Publish validated ICML reproduction

.gitattributes

@@ -1,35 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+source_paper.pdf filter=lfs diff=lfs merge=lfs -text
+source_archive.tar.gz filter=lfs diff=lfs merge=lfs -text

BUNDLE_SHA256SUMS.txt

@@ -0,0 +1,41 @@
+677530701aa216a5987b15675f80b19a3959bc3bc12ec5d402563c185db281b7  .gitattributes
+1f1a014c59964450011ac3e187ac0f9f79f7b7ad75f63c3b702a404ff6756047  README.md
+6988ca5673369a1c3ada117f208d0b11ec5b322201c34a7c07f53086c2a0d6ad  SOURCE_PIN.txt
+d1c28fc0a4e07f2688d013f576cf76ffc422d278d56a52a82989e0b93b3b3964  bucket-icon.svg
+ec6262d8225be045f94a7423fdc6fea0be9fe339954edcfae466eead45248e1d  build_manifest.py
+5abced67c2891fc0c79e07bbe682727b3d7de031966fe85a8f63a1a4e54f768e  index.html
+64e1de4358c79ec0d5f2697c56f98258c025e992c94ad7b3b7801739222ca41d  logbook.css
+69d73869184f936613668569980f31984be65229e77c4df4ba9604d3de70c02b  logbook.js
+3b16d33e6485aa8d700afad168fb0074c49ef6bde31ce454569303420473b239  logbook.json
+6cbc26962fda4eaae86c7393e551e976d455d5ab806a3cc6684537e52850f218  official_claims.json
+065038869ed78a46daad882a4d9e9550ac8933333aab830770ed56717dea5eec  outputs/depth_formula_audit.csv
+a0b720a0031dead0ee4d3bb9f21cdef929fccdf04f2d7d6be0058397db9465e8  outputs/gaussian_lower_bound_audit.csv
+ba22869657fc86ebb457d5ab5896860aa5dcbc25c2f27e774874136837c26bc8  outputs/network_protocol_audit.csv
+0060d0b025f6b7e884c91d68b3b283155149a96f9919bf665a8695bfb248c2e3  outputs/networked_information_audit.png
+fb7017c9b56bc94ec493654e8f95a6f5611903691e839fe683f8a7e0cbb3bc5a  outputs/orthogonality_decomposition_audit.csv
+dfd67823e0c042767c60a6bc1d1882baf0fd48bdcc691dc80b386383a7104459  outputs/results.json
+581d13ad9cff4a03bb448c381fc2de25f75790218355403df9cd96c45c7c4840  outputs/source_claim_audit.csv
+065038869ed78a46daad882a4d9e9550ac8933333aab830770ed56717dea5eec  packaged_replay/depth_formula_audit.csv
+a0b720a0031dead0ee4d3bb9f21cdef929fccdf04f2d7d6be0058397db9465e8  packaged_replay/gaussian_lower_bound_audit.csv
+ba22869657fc86ebb457d5ab5896860aa5dcbc25c2f27e774874136837c26bc8  packaged_replay/network_protocol_audit.csv
+0060d0b025f6b7e884c91d68b3b283155149a96f9919bf665a8695bfb248c2e3  packaged_replay/networked_information_audit.png
+fb7017c9b56bc94ec493654e8f95a6f5611903691e839fe683f8a7e0cbb3bc5a  packaged_replay/orthogonality_decomposition_audit.csv
+dfd67823e0c042767c60a6bc1d1882baf0fd48bdcc691dc80b386383a7104459  packaged_replay/results.json
+581d13ad9cff4a03bb448c381fc2de25f75790218355403df9cd96c45c7c4840  packaged_replay/source_claim_audit.csv
+b75d9f9a21173423cb649d0fc1f67f96c6e9cbf505fd1bc5e5a7b1e535f19f05  pages/claim-1-depth-upper-bound/page.md
+e71c0fed0816f3c192d4ca70ab6899b9b1212a79359db7859cf2ac11ba86981d  pages/claim-2-depth-lower-bound/page.md
+7a00be891a8eb501f6d2b31bb0e34864fba75d0c5a35cfa24c7926ecf82e2ab7  pages/claim-3-residual-orthogonality/page.md
+8c6e08fdd87c2dbaa04726e757dbbc51e47a1c852cfece651635ad4ac9fda39b  pages/claim-4-bce-kl-decomposition/page.md
+9251cf3ec639ab3392b5086b3da974bfad167976fbf5f685719385422ffc4ab6  pages/claim-5-logit-passing-protocol/page.md
+b58409359e7c02ddd738ad51233c13656eef5ecaf5822d08e1a5746d3c4ba6b9  pages/conclusion/page.md
+ac9fdde88c16c2a1159f6912c78e7845cb84e7983a24dfd6d4613c7615144145  pages/executive-summary/page.md
+9eec09a5f56662a7d42e8ff85999d02cd7ca90fa8a756556cbff91ec5813437c  pages/index.md
+82f8e039e63530d7126a319ff7bd89a6954cfe0d78d5a81bd735b886b8e5e704  paper.txt
+8cea42d58b1688a0b073719818de598db86f6eb1f4601b71f899bab7bd50f0b8  poster_embed.html
+2b25a6a28dc4e97547a294f28a74f01112ba66d9504e2dfc0240ba40e611bbbd  reproduce.py
+18d9327b4ec19517d71a96ac807565af43b11b8132569ddbf660aec191f7fa8d  requirements.txt
+d17612d6f31795fe581812dd7e20bf00ce5fabc7408e61411b439232b9917417  source_archive.tar.gz
+ca7263e8fd591b27cbd3f869d93ffe1818af27baaa439f278a27a5248ddd92b7  source_paper.pdf
+a6eb72253c0128ce79b526a86b7943eed37beec186b5f57ff6c1701d0e9ff596  trackio-logo-light.png
+3e3792061d4d095759da30d7cfe7f14b621901793cd4d677b61b2896f5bf472b  trackio-logo.png
+71da94795855710d214801eb9b9b7b8898e9a8757abac0e22966a0531bbb2f4f  trackio-wordmark-dark.png

README.md

@@ -1,10 +1,29 @@
 ---
-title: Repro Networked Information Aggregation For Binary Classification
-emoji: 😻
-colorFrom: gray
+title: Reproduction Networked Information Aggregation for Binary Classification
+emoji: 🎯
+colorFrom: purple
 colorTo: blue
 sdk: static
 pinned: false
+tags:
+- icml2026-repro
+- paper-mrtg4NmvAe
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Reproduction bundle
+
+This deterministic CPU-only Trackio logbook audits all five exact registered
+claims for OpenReview `mrtg4NmvAe` against arXiv `2605.01082v1`.
+
+Primary links: [OpenReview](https://openreview.net/forum?id=mrtg4NmvAe) and
+[arXiv v1](https://arxiv.org/abs/2605.01082v1).
+
+```bash
+PYTHONWARNINGS=error python reproduce.py --output replay
+python build_manifest.py --verify
+```
+
+Evidence includes exact nontrivial BCE projection identities, 48 sequential
+logit-passing panels, 56 deterministic Gaussian lower-bound cells, 72 depth-
+formula cells, and destructive non-optimal-reference and probability-passing
+controls. Source proofs and finite diagnostics remain explicitly distinct.

SOURCE_PIN.txt

@@ -0,0 +1,5 @@
+OpenReview: mrtg4NmvAe
+arXiv: 2605.01082v1
+paper PDF SHA-256: ca7263e8fd591b27cbd3f869d93ffe1818af27baaa439f278a27a5248ddd92b7
+source archive SHA-256: d17612d6f31795fe581812dd7e20bf00ce5fabc7408e61411b439232b9917417
+The included sole-revision PDF and TeX source preserve Theorems 3.7/4.5, Lemmas 3.1/3.3, Section 2, their assumptions, and the hard-instance construction audited by reproduce.py.

build_manifest.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+import argparse,hashlib
+from pathlib import Path
+ROOT=Path(__file__).resolve().parent;OUT=ROOT/"BUNDLE_SHA256SUMS.txt"
+def digest(path:Path)->str:
+ value=hashlib.sha256()
+ with path.open("rb") as handle:
+  for block in iter(lambda:handle.read(1<<20),b""):value.update(block)
+ return value.hexdigest()
+def rows()->list[str]:return [f"{digest(path)}  {path.relative_to(ROOT).as_posix()}" for path in sorted(ROOT.rglob("*")) if path.is_file() and path!=OUT and "__pycache__" not in path.parts]
+parser=argparse.ArgumentParser();parser.add_argument("--verify",action="store_true");args=parser.parse_args();rendered="\n".join(rows())+"\n"
+if args.verify:
+ if not OUT.exists() or OUT.read_text(encoding="utf-8")!=rendered:raise SystemExit("manifest mismatch")
+ print(f"verified {len(rows())} entries")
+else:OUT.write_text(rendered,encoding="utf-8");print(f"wrote {len(rows())} entries to {OUT.name}")

index.html

@@ -1,19 +1,54 @@
 <!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Reproduction: Networked Information Aggregation for Binary Classification</title>
+    <link rel="stylesheet" href="./logbook.css" />
+  </head>
+  <body>
+    <div id="app">
+      <aside id="sidebar">
+        <div id="book-head">
+          <img id="book-wordmark" src="./trackio-wordmark-dark.png" alt="" />
+          <div id="book-title" class="sr-only">Logbook</div>
+        </div>
+        <nav id="tree"></nav>
+        <div id="sidebar-foot" hidden>
+          <button id="connect-btn" type="button">
+            <span class="ico">ⓘ</span> Collaborate with your agent
+          </button>
+        </div>
+      </aside>
+      <main id="content">
+        <div id="page"></div>
+      </main>
+    </div>
+
+    <div id="modal" hidden>
+      <div class="modal-backdrop"></div>
+      <div class="modal-card" role="dialog" aria-modal="true">
+        <div class="modal-head">
+          <div class="modal-title">
+            <img class="modal-logo" src="./trackio-logo.png" alt="" />
+            Collaborate with your agent
+          </div>
+          <div class="modal-actions">
+            <button id="copy-agent" class="btn">Copy for agent</button>
+            <button id="modal-close" class="btn icon" aria-label="Close">×</button>
+          </div>
+        </div>
+        <div class="modal-body">
+          <p class="modal-intro">
+            Point your coding agent at this logbook. It reads a compact,
+            token-efficient version — and if you've given it write access to this
+            Space, it can add findings that sync back automatically.
+          </p>
+          <ol id="connect-steps"></ol>
+        </div>
+      </div>
+    </div>
+
+    <script src="./logbook.js"></script>
+  </body>
 </html>

logbook.css

@@ -0,0 +1,1602 @@
+:root {
+  --bg: #ffffff;
+  --paper: #fdfcf9;
+  --panel: #ffffff;
+  --ink: #1f2937;
+  --muted: #6b7280;
+  --line: #e5e7eb;
+  --accent: #f97316;
+  --accent-strong: #ea580c;
+  --accent-soft: #fff7ed;
+  --accent-line: rgba(249, 115, 22, 0.16);
+  --grid-line: rgba(31, 41, 55, 0.045);
+  --code-bg: #f3f4f6;
+  --radius: 12px;
+  --serif: ui-serif, "Iowan Old Style", "Palatino Linotype", Georgia, serif;
+  --sans: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial,
+    sans-serif;
+  --mono: "SFMono-Regular", "Cascadia Mono", "JetBrains Mono", Menlo, Consolas,
+    ui-monospace, monospace;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html,
+body {
+  margin: 0;
+  padding: 0;
+}
+
+html {
+  scroll-behavior: smooth;
+}
+
+body {
+  background: var(--bg);
+  color: var(--ink);
+  font-family: var(--sans);
+  font-size: 13px;
+  line-height: 1.65;
+  -webkit-font-smoothing: antialiased;
+}
+
+#app {
+  display: flex;
+  min-height: 100vh;
+}
+
+/* ---- sidebar (composition-book cover) ---- */
+#sidebar {
+  width: 280px;
+  flex: 0 0 280px;
+  background: #17181c;
+  color: #e7e7ea;
+  position: sticky;
+  top: 0;
+  height: 100vh;
+  overflow-y: auto;
+  padding: 22px 16px;
+  display: flex;
+  flex-direction: column;
+}
+
+#book-head {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 8px;
+  margin-bottom: 12px;
+  border-radius: 10px;
+  cursor: pointer;
+  transition: background 0.12s;
+}
+#book-head:hover {
+  background: rgba(255, 255, 255, 0.05);
+}
+#book-wordmark {
+  width: 154px;
+  height: auto;
+  object-fit: contain;
+}
+.sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+
+#tree {
+  flex: 1;
+  padding-top: 8px;
+}
+
+#tree a {
+  display: block;
+  padding: 6px 10px;
+  border-radius: 8px;
+  color: #c3c4cb;
+  text-decoration: none;
+  font-size: 14px;
+  transition: background 0.12s, color 0.12s;
+}
+
+#tree a:hover {
+  background: rgba(255, 255, 255, 0.06);
+  color: #ffffff;
+}
+
+#tree a.active {
+  background: rgba(249, 115, 22, 0.16);
+  color: #fdba74;
+  font-weight: 600;
+}
+
+#tree a .tree-mark {
+  color: #6b6d76;
+}
+
+#tree a:hover .tree-mark,
+#tree a.active .tree-mark {
+  color: inherit;
+  opacity: 0.6;
+}
+
+#tree .depth-1 {
+  padding-left: 22px;
+}
+#tree .depth-2 {
+  padding-left: 34px;
+}
+#tree .depth-3 {
+  padding-left: 46px;
+}
+
+
+/* ---- content ---- */
+#content {
+  flex: 1;
+  min-width: 0;
+  padding: 48px 40px 120px;
+  background-color: var(--paper);
+  background-image:
+    linear-gradient(var(--grid-line) 1px, transparent 1px),
+    linear-gradient(90deg, var(--grid-line) 1px, transparent 1px);
+  background-size: 26px 26px;
+  background-position: center top;
+}
+
+#page {
+  width: 100%;
+  min-width: 0;
+  max-width: 1052px;
+  margin: 0 auto;
+}
+
+.page-section {
+  scroll-margin-top: 40px;
+  padding: 0 0 35px;
+  margin: 0 0 32px;
+}
+
+.page-section:last-child {
+  margin-bottom: 0;
+}
+
+.page-layout {
+  display: grid;
+  grid-template-columns: minmax(0, 760px) 248px;
+  gap: 44px;
+  align-items: start;
+}
+
+.page-body {
+  min-width: 0;
+}
+
+.resource-anchor {
+  display: block;
+  height: 0;
+  overflow: hidden;
+}
+
+/* ---- pinned notes ---- */
+.pinned-notes {
+  margin: 30px 0 0;
+}
+.pinned-notes-list .cell {
+  margin: 0;
+  border-color: rgba(249, 115, 22, 0.55);
+}
+.pinned-notes-list .cell + .cell {
+  margin-top: 12px;
+}
+.cell.pinned-source {
+  border-color: rgba(249, 115, 22, 0.55);
+}
+.book-intro.has-pinned-notes {
+  border-bottom: none;
+  padding-bottom: 22px;
+  margin-bottom: 30px;
+}
+.book-intro.book-intro-tight {
+  border-bottom: none;
+  padding-bottom: 4px;
+  margin-bottom: 20px;
+}
+
+#page h1 {
+  font-family: var(--serif);
+  font-size: 34px;
+  line-height: 1.15;
+  letter-spacing: -0.02em;
+  margin: 0 0 8px;
+  overflow-wrap: anywhere;
+}
+
+#page .page-section:not(.book-intro) h1 {
+  font-size: 26px;
+}
+
+#page h2 {
+  font-family: var(--serif);
+  font-size: 24px;
+  margin: 36px 0 10px;
+}
+
+#page h3 {
+  font-size: 17px;
+  font-weight: 700;
+  margin: 26px 0 2px;
+  letter-spacing: -0.01em;
+}
+
+#page h3::before {
+  content: "";
+  display: inline-block;
+  width: 7px;
+  height: 7px;
+  border-radius: 2px;
+  background: var(--accent);
+  margin-right: 10px;
+  vertical-align: middle;
+  transform: translateY(-1px);
+}
+
+#page p {
+  margin: 10px 0;
+}
+
+#page blockquote {
+  margin: 14px 0;
+  padding: 2px 16px;
+  border-left: 3px solid #fdba74;
+  color: var(--muted);
+}
+
+#page hr {
+  display: none;
+}
+
+#page code {
+  font-family: var(--mono);
+  font-size: 0.86em;
+  background: var(--code-bg);
+  padding: 2px 6px;
+  border-radius: 6px;
+}
+
+#page pre {
+  max-width: 100%;
+  background: var(--code-bg);
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  padding: 14px 16px;
+  overflow-x: auto;
+}
+#page pre code {
+  background: none;
+  padding: 0;
+  font-size: 11.5px;
+}
+
+/* ---- code blocks + collapsible accordion ---- */
+#page pre.hl {
+  background: #17181c;
+  border: none;
+  color: #e7e7ea;
+  font-size: 13px;
+  line-height: 1.58;
+}
+#page pre.hl code {
+  color: inherit;
+  font-family: var(--mono);
+}
+.code-accordion {
+  border: 1px solid rgba(249, 115, 22, 0.2);
+  border-radius: 8px;
+  overflow: hidden;
+  margin: 12px 0;
+  background: #17181c;
+}
+.code-accordion summary {
+  list-style: none;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  gap: 9px;
+  padding: 9px 12px;
+  font-family: var(--mono);
+  font-size: 11.5px;
+  font-weight: 700;
+  color: #e7e7ea;
+  background: #1e2027;
+  user-select: none;
+  overflow-wrap: anywhere;
+}
+.code-accordion summary::-webkit-details-marker {
+  display: none;
+}
+.code-accordion summary::after {
+  content: "▸";
+  margin-left: auto;
+  color: var(--accent);
+  transition: transform 0.12s;
+  transform: rotate(180deg);
+}
+.code-accordion[open] summary::after {
+  transform: rotate(90deg);
+}
+.code-accordion .code-ico {
+  color: var(--accent);
+  font-weight: 700;
+}
+.code-accordion pre.hl {
+  margin: 0;
+  border-radius: 0;
+  border: none;
+  border-top: 1px solid rgba(249, 115, 22, 0.16);
+}
+.tok-comment {
+  color: #7a7d87;
+  font-style: italic;
+}
+.tok-string {
+  color: #a5d6a7;
+}
+.tok-keyword {
+  color: #fdba74;
+}
+.tok-number {
+  color: #7fd0e0;
+}
+
+#page a {
+  color: var(--accent);
+}
+
+#page ul {
+  padding-left: 20px;
+}
+
+.ts {
+  font-family: var(--mono);
+  font-size: 12px;
+  color: var(--muted);
+  background: none;
+  padding: 0;
+}
+
+/* ---- notebook-style cells ---- */
+.cell {
+  max-width: 100%;
+  border: 1px solid var(--line);
+  border-radius: 10px;
+  background: rgba(255, 255, 255, 0.86);
+  margin: 18px 0;
+  overflow: hidden;
+  box-shadow: 0 2px 10px rgba(31, 41, 55, 0.035);
+}
+.cell-head {
+  display: flex;
+  justify-content: space-between;
+  gap: 16px;
+  align-items: center;
+  padding: 14px 18px;
+  background: rgba(255, 255, 255, 0.92);
+  border-bottom: 1px solid var(--line);
+}
+.cell-head.no-title {
+  justify-content: flex-end;
+  padding-top: 10px;
+  padding-bottom: 10px;
+}
+.cell-title {
+  flex: 1;
+  min-width: 0;
+  font-size: 13px;
+  font-weight: 650;
+  color: var(--ink);
+  line-height: 1.35;
+  overflow-wrap: anywhere;
+}
+.cell-meta {
+  flex: 0 0 auto;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  font-family: var(--sans);
+  font-size: 13px;
+  color: var(--muted);
+}
+.cell-open {
+  flex: 0 0 auto;
+  font-family: var(--mono);
+  font-size: 12px;
+  color: var(--accent);
+  text-decoration: none;
+}
+.cell-open:hover {
+  color: var(--accent-strong);
+}
+.cell-body {
+  min-width: 0;
+  padding: 14px 18px 18px;
+}
+.cell.dashboard .cell-body {
+  padding: 0;
+}
+#page .cell-body h1,
+#page .cell-body h2 {
+  font-family: var(--sans);
+  font-size: 17px;
+  font-weight: 700;
+  letter-spacing: -0.01em;
+  line-height: 1.35;
+  margin: 22px 0 6px;
+}
+#page .cell-body > :first-child {
+  margin-top: 0;
+}
+#page .cell-body > :last-child {
+  margin-bottom: 0;
+}
+.cell.code .cell-head {
+  background: #fbfbfc;
+}
+.figure-fit {
+  position: relative;
+  overflow: hidden;
+  min-height: 160px;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  background: #fff;
+}
+.figure-fit[hidden] {
+  display: none;
+}
+.figure-fit:fullscreen,
+.figure-fit:-webkit-full-screen {
+  width: 100%;
+  height: 100%;
+  border: none;
+  border-radius: 0;
+}
+.figure-frame {
+  display: block;
+  width: 100%;
+  min-height: 160px;
+  border: none;
+  background: #fff;
+}
+.figure-frame[hidden],
+.figure-raw[hidden] {
+  display: none;
+}
+.fig-switch {
+  position: relative;
+  display: inline-flex;
+  flex: 0 0 auto;
+  border: 1px solid var(--line);
+  border-radius: 999px;
+  background: var(--code-bg);
+  padding: 2px;
+}
+.fig-switch button {
+  position: relative;
+  z-index: 1;
+  flex: 1;
+  min-width: 62px;
+  border: none;
+  background: none;
+  font-family: var(--sans);
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--muted);
+  padding: 3px 12px;
+  border-radius: 999px;
+  cursor: pointer;
+  transition: color 0.15s;
+}
+.fig-switch button.active {
+  color: var(--accent-strong);
+}
+.fig-switch-thumb {
+  position: absolute;
+  top: 2px;
+  bottom: 2px;
+  left: 2px;
+  width: calc(50% - 2px);
+  border-radius: 999px;
+  background: var(--panel);
+  border: 1px solid rgba(249, 115, 22, 0.35);
+  box-shadow: 0 1px 4px rgba(31, 41, 55, 0.08);
+  transition: transform 0.18s ease;
+}
+.fig-switch.raw .fig-switch-thumb {
+  transform: translateX(100%);
+}
+#page .figure-raw pre {
+  margin: 0;
+  max-height: 420px;
+  overflow: auto;
+  font-family: var(--mono);
+  font-size: 13px;
+  line-height: 1.55;
+  background: var(--code-bg);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  padding: 12px 14px;
+}
+/* ---- figure fullscreen ---- */
+.cell-fullscreen {
+  position: relative;
+  display: inline-flex;
+  flex: 0 0 auto;
+}
+.cell-fullscreen-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 26px;
+  height: 26px;
+  padding: 0;
+  border: 1px solid var(--line);
+  border-radius: 999px;
+  background: var(--code-bg);
+  color: var(--muted);
+  cursor: pointer;
+  transition: color 0.15s, border-color 0.15s, background 0.15s;
+}
+.cell-fullscreen-btn:hover {
+  color: var(--accent-strong);
+  border-color: rgba(249, 115, 22, 0.35);
+  background: var(--accent-soft);
+}
+.cell-fullscreen-btn svg {
+  width: 14px;
+  height: 14px;
+}
+/* ---- copyable snippets ---- */
+.snippet {
+  position: relative;
+}
+.copy-snippet {
+  position: absolute;
+  top: 7px;
+  right: 8px;
+  width: 24px;
+  height: 24px;
+  border: none;
+  border-radius: 6px;
+  background: rgba(255, 255, 255, 0.08);
+  color: #9a9da8;
+  font-size: 12px;
+  line-height: 1;
+  cursor: pointer;
+  opacity: 0;
+  transition: opacity 0.12s, color 0.12s, background 0.12s;
+}
+.snippet:hover .copy-snippet,
+.jp-out:hover .copy-snippet,
+.figure-raw:hover .copy-snippet,
+.code-accordion summary:hover .copy-snippet {
+  opacity: 1;
+}
+.copy-snippet:hover {
+  color: #ffffff;
+  background: rgba(255, 255, 255, 0.16);
+}
+.copy-snippet.copied {
+  color: #52d08a;
+  opacity: 1;
+}
+.code-accordion .code-name {
+  user-select: text;
+  cursor: text;
+}
+.jp-out,
+.figure-raw {
+  position: relative;
+}
+.jp-out .copy-snippet,
+.figure-raw .copy-snippet {
+  background: var(--code-bg);
+  color: var(--muted);
+  border: 1px solid var(--line);
+}
+.jp-out .copy-snippet:hover,
+.figure-raw .copy-snippet:hover {
+  color: var(--accent-strong);
+  background: var(--panel);
+}
+
+/* ---- jupyter-style code cells ---- */
+.jp {
+  border: 1px solid var(--line);
+  border-radius: 10px;
+  overflow: hidden;
+  margin: 12px 0;
+  background: var(--panel);
+}
+.jp-gutter {
+  flex: 0 0 46px;
+  padding: 13px 0 0 13px;
+  font-family: var(--mono);
+  font-size: 10.5px;
+  letter-spacing: 0.07em;
+  text-transform: uppercase;
+  font-weight: 600;
+  user-select: none;
+}
+.jp-in {
+  display: flex;
+  background: #17181c;
+}
+.jp-in .jp-gutter {
+  color: #6f727d;
+}
+.jp-in-body {
+  flex: 1;
+  min-width: 0;
+}
+#page .jp-in-body pre.hl {
+  margin: 0;
+  border: none;
+  border-radius: 0;
+  background: none;
+  padding: 12px 16px 12px 0;
+}
+.jp-in-body .code-accordion {
+  margin: 0;
+  border: none;
+  border-top: 1px solid rgba(255, 255, 255, 0.09);
+  border-radius: 0;
+  background: none;
+}
+.jp-in-body .code-accordion summary {
+  background: none;
+  padding: 9px 16px 9px 0;
+}
+.jp-in-body .code-accordion pre.hl {
+  border-top: 1px solid rgba(255, 255, 255, 0.09);
+}
+.jp-meta {
+  padding: 5px 14px;
+  font-family: var(--mono);
+  font-size: 11.5px;
+  color: var(--muted);
+  background: #fbfbfc;
+  border-top: 1px solid var(--line);
+}
+.jp-out {
+  display: flex;
+  border-top: 1px solid var(--line);
+  background: var(--panel);
+}
+.jp-out .jp-gutter {
+  color: var(--accent-strong);
+}
+.jp-out-body {
+  flex: 1;
+  min-width: 0;
+}
+#page .jp-out-pre {
+  min-width: 0;
+  margin: 0;
+  border: none;
+  border-radius: 0;
+  background: none;
+  color: var(--ink);
+  font-family: var(--mono);
+  font-size: 13px;
+  line-height: 1.55;
+  padding: 12px 16px 12px 0;
+  white-space: pre;
+  overflow-x: auto;
+  overflow-y: auto;
+  max-height: 26em;
+}
+.jp-artifacts {
+  display: flex;
+  flex-direction: column;
+}
+.jp-out-body .jp-out-pre + .jp-artifacts {
+  border-top: 1px solid var(--line);
+}
+.out-artifact {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  padding: 9px 16px 9px 0;
+  text-decoration: none;
+  color: inherit;
+}
+.out-artifact + .out-artifact {
+  border-top: 1px solid var(--line);
+}
+a.out-artifact:hover .out-artifact-name {
+  color: var(--accent-strong);
+}
+.out-artifact-ico {
+  flex: 0 0 auto;
+  font-size: 13px;
+}
+.out-artifact-name {
+  font-family: var(--mono);
+  font-size: 12.5px;
+  font-weight: 600;
+  color: var(--ink);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.out-artifact-meta {
+  flex: 0 0 auto;
+  margin-left: auto;
+  padding-left: 12px;
+  font-size: 12px;
+  color: var(--muted);
+  white-space: nowrap;
+}
+.out-artifact-state.open {
+  color: var(--accent);
+  font-weight: 600;
+}
+.trackio-embed {
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  overflow: hidden;
+  background: var(--panel);
+}
+.trackio-cell-meta {
+  display: flex;
+  gap: 6px;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+}
+
+/* ---- unfurl cards ---- */
+.unfurl {
+  display: block;
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  background: var(--panel);
+  margin: 12px 0;
+  overflow: hidden;
+  text-decoration: none;
+  color: inherit;
+  transition: border-color 0.14s, box-shadow 0.14s;
+}
+.unfurl:hover {
+  border-color: #cfcbe6;
+  box-shadow: 0 4px 18px rgba(30, 20, 80, 0.06);
+}
+
+.unfurl-body {
+  padding: 13px 16px;
+  display: flex;
+  gap: 12px;
+  align-items: flex-start;
+}
+
+.unfurl-ico {
+  font-size: 20px;
+  line-height: 1.3;
+  flex: 0 0 auto;
+}
+
+.unfurl-main {
+  min-width: 0;
+  flex: 1;
+}
+
+.unfurl-kind {
+  font-family: var(--mono);
+  font-size: 10.5px;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: var(--accent);
+  font-weight: 600;
+}
+
+.unfurl-title {
+  font-weight: 650;
+  font-size: 15px;
+  margin: 1px 0 2px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.unfurl-desc {
+  color: var(--muted);
+  font-size: 13.5px;
+  line-height: 1.45;
+}
+
+.unfurl-meta {
+  margin-top: 6px;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+
+.chip {
+  font-size: 11.5px;
+  background: var(--code-bg);
+  border-radius: 999px;
+  padding: 2px 9px;
+  color: var(--muted);
+  font-family: var(--mono);
+}
+
+.unfurl-raw {
+  font-family: var(--mono);
+  font-size: 11px;
+  color: var(--muted);
+  border-top: 1px solid var(--line);
+  padding: 7px 16px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.unfurl.embed {
+  padding: 0;
+  overflow: hidden;
+}
+.embed-head {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 10px 14px;
+  border-bottom: 1px solid var(--line);
+}
+.embed-head .unfurl-kind {
+  flex: 0 0 auto;
+}
+.embed-title {
+  flex: 1;
+  min-width: 0;
+  font-weight: 650;
+  font-size: 14px;
+  color: var(--ink);
+  text-decoration: none;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.embed-title:hover {
+  color: var(--accent);
+}
+.embed-open {
+  flex: 0 0 auto;
+  font-family: var(--mono);
+  font-size: 12px;
+  color: var(--accent);
+  text-decoration: none;
+}
+.embed-frame {
+  display: block;
+  width: 100%;
+  height: 560px;
+  border: 0;
+  background: var(--code-bg);
+}
+
+.dashboard-shell {
+  display: block;
+}
+.dashboard-shell .dashboard-frame {
+  display: block;
+  width: 100%;
+  height: 900px;
+  border: 0;
+  background: var(--code-bg);
+}
+
+.unfurl.image {
+  padding: 0;
+}
+.unfurl.image img {
+  display: block;
+  width: 100%;
+  height: auto;
+  max-height: 460px;
+  object-fit: contain;
+  background: var(--code-bg);
+}
+
+.artifact-chip {
+  border: 1px solid var(--line);
+  background: var(--panel);
+  border-radius: var(--radius);
+  padding: 10px 14px;
+  margin: 8px 0;
+  font-size: 14px;
+}
+.cell.dashboard .artifact-chip {
+  margin: 14px 18px 18px;
+}
+.artifact-chip code {
+  color: var(--accent);
+}
+
+/* ---- task board ---- */
+.board-wrap {
+  overflow-x: auto;
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  margin: 12px 0 20px;
+  background: var(--panel);
+}
+table.board {
+  border-collapse: collapse;
+  width: 100%;
+  font-size: 14px;
+}
+table.board th,
+table.board td {
+  text-align: left;
+  padding: 9px 14px;
+  border-bottom: 1px solid var(--line);
+  vertical-align: top;
+}
+table.board thead th {
+  background: var(--accent-soft);
+  font-size: 12px;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: #9a4a12;
+  font-weight: 600;
+  border-bottom: 1px solid var(--line);
+}
+table.board tbody tr:last-child td {
+  border-bottom: none;
+}
+table.board .col-check {
+  text-align: center;
+  width: 92px;
+  white-space: nowrap;
+}
+table.board tr.section-row td {
+  background: var(--accent-soft);
+  text-align: center;
+  font-weight: 700;
+  font-size: 13px;
+  color: var(--accent-strong);
+  padding: 7px 14px;
+  letter-spacing: 0.02em;
+}
+.box {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 18px;
+  height: 18px;
+  border: 1.5px solid #cfcbe0;
+  border-radius: 5px;
+  font-size: 12px;
+  color: #fff;
+  line-height: 1;
+}
+.box.on {
+  background: var(--accent);
+  border-color: var(--accent);
+}
+.who-chip {
+  display: inline-block;
+  padding: 3px 12px;
+  border-radius: 999px;
+  font-size: 12.5px;
+  font-weight: 600;
+  white-space: nowrap;
+}
+.who-chip.muted {
+  background: var(--code-bg);
+  color: var(--muted);
+  font-weight: 500;
+}
+
+/* ---- status badges + clickable rows ---- */
+table.board .col-status {
+  width: 130px;
+  white-space: nowrap;
+}
+.badge {
+  display: inline-block;
+  padding: 3px 11px;
+  border-radius: 999px;
+  font-size: 12px;
+  font-weight: 600;
+  letter-spacing: 0.01em;
+}
+.badge.gray {
+  background: var(--code-bg);
+  color: var(--muted);
+}
+.badge.amber {
+  background: var(--accent-soft);
+  color: #b45309;
+}
+.badge.green {
+  background: #e6f7ee;
+  color: #1a8a55;
+}
+.badge.red {
+  background: #fde8ec;
+  color: #c62a4b;
+}
+table.board tr.linked-row {
+  cursor: pointer;
+}
+table.board tr.linked-row:hover td {
+  background: var(--accent-soft);
+}
+table.board tr.linked-row a {
+  color: var(--ink);
+  font-weight: 600;
+  text-decoration: none;
+}
+table.board tr.linked-row:hover a {
+  color: var(--accent-strong);
+}
+
+/* ---- agent read hint ---- */
+.agent-hint {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin: 4px 0 22px;
+  font-size: 12.5px;
+  color: var(--muted);
+}
+#page .agent-hint code {
+  background: var(--code-bg);
+  padding: 2px 9px;
+  border-radius: 6px;
+  font-family: var(--mono);
+  font-size: 12px;
+  font-weight: 500;
+  color: var(--ink);
+}
+.agent-hint .copy {
+  flex: 0 0 auto;
+  background: none;
+  color: var(--muted);
+  border: 1px solid var(--line);
+  border-radius: 6px;
+  width: 22px;
+  height: 22px;
+  font-size: 11px;
+  line-height: 1;
+  cursor: pointer;
+  transition: color 0.12s, border-color 0.12s;
+}
+.agent-hint .copy:hover {
+  color: var(--accent-strong);
+  border-color: var(--accent);
+}
+.agent-hint .copy.copied {
+  color: #1a8a55;
+  border-color: #1a8a55;
+}
+.agent-hint-note {
+  margin-left: auto;
+  font-size: 12px;
+  color: var(--muted);
+}
+
+/* ---- logbook summary stats ---- */
+.logbook-stats {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 12px;
+  margin: 0 0 28px;
+}
+.stat-tile {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  gap: 11px;
+  border: 1px solid var(--line);
+  background: var(--panel);
+  border-radius: var(--radius);
+  padding: 12px 23px;
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+  transition: border-color 0.12s, box-shadow 0.12s;
+}
+.stat-tile:hover:not([disabled]) {
+  border-color: rgba(249, 115, 22, 0.45);
+  box-shadow: 0 3px 12px rgba(31, 41, 55, 0.06);
+}
+.stat-tile:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: 2px;
+}
+.stat-tile[disabled] {
+  cursor: default;
+  opacity: 0.7;
+}
+.stat-tile.open {
+  border-color: rgba(249, 115, 22, 0.6);
+  box-shadow: 0 3px 12px rgba(31, 41, 55, 0.08);
+}
+.stat-icon {
+  width: 24px;
+  height: 24px;
+  flex: 0 0 24px;
+  object-fit: contain;
+  align-self: center;
+}
+.stat-text {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  white-space: nowrap;
+  line-height: 1;
+}
+.stat-num {
+  font-family: var(--mono);
+  font-size: 20px;
+  font-weight: 600;
+  line-height: 1;
+  color: var(--accent-strong);
+}
+.stat-label {
+  font-size: 15px;
+  line-height: 1;
+  color: var(--muted);
+}
+.stat-caret {
+  margin-left: 2px;
+  font-size: 10px;
+  color: var(--muted);
+  align-self: center;
+  transition: transform 0.12s;
+}
+.stat-tile.open .stat-caret {
+  transform: rotate(180deg);
+}
+.stat-popover {
+  position: absolute;
+  top: 100%;
+  left: 0;
+  margin-top: 6px;
+  min-width: 300px;
+  max-width: min(460px, 92vw);
+  max-height: 340px;
+  overflow-y: auto;
+  z-index: 20;
+  background: var(--panel);
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  box-shadow: 0 8px 28px rgba(31, 41, 55, 0.12);
+  padding: 6px;
+}
+.stat-popover[hidden] {
+  display: none;
+}
+.stat-pop-head {
+  padding: 6px 10px 8px;
+  font-size: 11.5px;
+  font-weight: 700;
+  letter-spacing: 0.03em;
+  text-transform: uppercase;
+  color: var(--muted);
+}
+.stat-row {
+  display: flex;
+  align-items: flex-start;
+  gap: 10px;
+  padding: 9px 11px;
+  border-radius: 9px;
+  border: 1px solid transparent;
+  text-decoration: none;
+  color: inherit;
+  cursor: pointer;
+}
+.stat-row:hover {
+  border-color: rgba(249, 115, 22, 0.4);
+  background: var(--accent-soft);
+}
+.stat-row-ico {
+  font-size: 15px;
+  line-height: 1.3;
+  flex: 0 0 auto;
+}
+.stat-row-main {
+  min-width: 0;
+  flex: 1;
+}
+.stat-row-title {
+  font-family: var(--mono);
+  font-size: 12.5px;
+  font-weight: 600;
+  color: var(--ink);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.stat-row-meta {
+  margin-top: 2px;
+  font-size: 12px;
+  color: var(--muted);
+}
+.stat-row-state.open {
+  color: var(--accent);
+  font-weight: 600;
+  border-radius: 5px;
+  padding: 1px 5px;
+  margin: -1px -2px;
+}
+.stat-row-state.open:hover {
+  background: rgba(249, 115, 22, 0.14);
+  text-decoration: underline;
+}
+.art-ico {
+  width: 1em;
+  height: 1em;
+  object-fit: contain;
+  vertical-align: -0.15em;
+}
+
+/* ---- scroll-to-resource highlight ---- */
+.res-flash {
+  animation: res-flash 1.5s ease;
+  border-radius: 8px;
+}
+@keyframes res-flash {
+  0%,
+  25% {
+    box-shadow: 0 0 0 3px var(--accent);
+  }
+  100% {
+    box-shadow: 0 0 0 3px rgba(249, 115, 22, 0);
+  }
+}
+
+/* ---- inline resource chips ---- */
+#page .res-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  max-width: 100%;
+  padding: 0 9px 0 6px;
+  margin: 0 1px;
+  border: 1px solid var(--line);
+  border-radius: 999px;
+  background: var(--panel);
+  font-family: var(--mono);
+  font-size: 0.78em;
+  font-weight: 600;
+  color: var(--ink);
+  text-decoration: none;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  vertical-align: middle;
+  line-height: 1.65;
+  transform: translateY(-0.08em);
+  transition: border-color 0.12s, background 0.12s, color 0.12s;
+}
+.res-chip-ico {
+  font-size: 1.05em;
+  line-height: 1;
+}
+#page .res-chip:hover,
+#page .res-chip.res-hl {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+  color: var(--accent-strong);
+}
+#page a.res-link.res-hl {
+  background: var(--accent-soft);
+  border-radius: 4px;
+}
+.rail-item.res-hl {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+  box-shadow: 0 3px 12px rgba(249, 115, 22, 0.14);
+}
+.rail-item.res-hl .rail-title {
+  color: var(--accent-strong);
+}
+.rail-item.rail-local {
+  cursor: default;
+}
+.artifact-chip.res-hl {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+}
+
+/* ---- contextual resources rail ---- */
+.context-rail {
+  position: relative;
+  width: 248px;
+}
+.context-rail[hidden] {
+  display: none;
+}
+.rail-kind {
+  display: flex;
+  align-items: center;
+  gap: 5px;
+  font-family: var(--mono);
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  font-weight: 600;
+  color: var(--accent);
+  margin-bottom: 4px;
+}
+.rail-item {
+  position: absolute;
+  left: 0;
+  right: 0;
+  display: block;
+  border: 1px solid var(--line);
+  border-radius: 10px;
+  background: var(--panel);
+  padding: 9px 12px;
+  margin-bottom: 8px;
+  text-decoration: none;
+  color: inherit;
+  transition: border-color 0.14s, box-shadow 0.14s;
+}
+.rail-item:hover {
+  border-color: rgba(249, 115, 22, 0.45);
+  box-shadow: 0 3px 12px rgba(31, 41, 55, 0.06);
+}
+.rail-title {
+  font-family: var(--mono);
+  font-size: 12.5px;
+  font-weight: 600;
+  color: var(--ink);
+  overflow-wrap: anywhere;
+  line-height: 1.4;
+}
+.rail-item:hover .rail-title {
+  color: var(--accent-strong);
+}
+.rail-meta {
+  font-size: 11.5px;
+  color: var(--muted);
+  margin-top: 2px;
+}
+
+@media (max-width: 1400px) {
+  .page-layout {
+    display: block;
+  }
+  .context-rail {
+    width: 100%;
+    margin-top: 28px;
+    position: static;
+    min-height: 0 !important;
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+    gap: 10px;
+  }
+  .context-rail[hidden] {
+    display: none;
+  }
+  .context-rail .rail-item {
+    position: static;
+    margin-bottom: 0;
+  }
+}
+
+/* ---- connect footer + modal ---- */
+#sidebar-foot {
+  margin-top: auto;
+  padding-top: 14px;
+  border-top: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+#connect-btn {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  background: rgba(255, 255, 255, 0.05);
+  color: #c3c4cb;
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  border-radius: 9px;
+  padding: 9px 12px;
+  font-size: 13.5px;
+  font-family: var(--sans);
+  cursor: pointer;
+  transition: background 0.12s, color 0.12s, border-color 0.12s;
+}
+#connect-btn:hover {
+  background: rgba(249, 115, 22, 0.14);
+  border-color: rgba(249, 115, 22, 0.4);
+  color: #fdba74;
+}
+#connect-btn .ico {
+  font-size: 15px;
+}
+
+#modal[hidden] {
+  display: none;
+}
+#modal {
+  position: fixed;
+  inset: 0;
+  z-index: 100;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 24px;
+}
+.modal-backdrop {
+  position: absolute;
+  inset: 0;
+  background: rgba(20, 18, 30, 0.5);
+  backdrop-filter: blur(2px);
+}
+.modal-card {
+  position: relative;
+  background: var(--panel);
+  border-radius: 16px;
+  width: 100%;
+  max-width: 620px;
+  max-height: 85vh;
+  overflow-y: auto;
+  box-shadow: 0 24px 70px rgba(20, 15, 50, 0.28);
+}
+.modal-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 18px 22px;
+  border-bottom: 1px solid var(--line);
+  position: sticky;
+  top: 0;
+  background: var(--panel);
+}
+.modal-title {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  font-family: var(--serif);
+  font-size: 21px;
+  letter-spacing: -0.01em;
+}
+.modal-logo {
+  width: 26px;
+  height: 26px;
+  object-fit: contain;
+}
+.modal-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.btn {
+  font-family: var(--sans);
+  font-size: 13.5px;
+  font-weight: 600;
+  border: 1px solid var(--line);
+  background: var(--panel);
+  color: var(--ink);
+  border-radius: 9px;
+  padding: 8px 13px;
+  cursor: pointer;
+  transition: background 0.12s, border-color 0.12s, color 0.12s;
+}
+.btn:hover {
+  border-color: var(--accent);
+  color: var(--accent-strong);
+}
+.btn.copied {
+  border-color: #1a8a55;
+  color: #1a8a55;
+}
+.btn.icon {
+  font-size: 18px;
+  line-height: 1;
+  padding: 6px 11px;
+  font-weight: 400;
+}
+.modal-body {
+  padding: 20px 22px 26px;
+}
+.modal-intro {
+  margin: 0 0 20px;
+  color: var(--muted);
+  line-height: 1.55;
+}
+#connect-steps {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+#connect-steps li {
+  margin-bottom: 18px;
+}
+.step-title {
+  font-weight: 600;
+  font-size: 14.5px;
+  margin-bottom: 8px;
+}
+.codeblock {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  background: #17181c;
+  border-radius: 10px;
+  padding: 11px 12px 11px 15px;
+}
+.codeblock code {
+  flex: 1;
+  min-width: 0;
+  overflow-x: auto;
+  white-space: nowrap;
+  font-family: var(--mono);
+  font-size: 13px;
+  color: #f0efff;
+  background: none;
+  padding: 0;
+}
+.codeblock .copy {
+  flex: 0 0 auto;
+  background: rgba(255, 255, 255, 0.08);
+  color: #c3c4cb;
+  border: 1px solid rgba(255, 255, 255, 0.14);
+  border-radius: 7px;
+  width: 30px;
+  height: 30px;
+  font-size: 14px;
+  cursor: pointer;
+  transition: background 0.12s, color 0.12s;
+}
+.codeblock .copy:hover {
+  background: rgba(249, 115, 22, 0.2);
+  color: #fdba74;
+}
+.codeblock .copy.copied {
+  color: #52d08a;
+}
+
+@media (max-width: 720px) {
+  #app {
+    flex-direction: column;
+  }
+  #sidebar {
+    width: 100%;
+    flex: none;
+    height: auto;
+    position: static;
+  }
+  #content {
+    display: block;
+    width: 100%;
+    padding: 28px 20px 80px;
+    overflow-x: hidden;
+  }
+  #page {
+    width: 100%;
+    max-width: 100%;
+  }
+  #page h1 {
+    font-size: 30px;
+  }
+  .cell-head {
+    align-items: flex-start;
+    flex-direction: column;
+    gap: 4px;
+  }
+}

logbook.js

@@ -0,0 +1,2275 @@
+(function () {
+  "use strict";
+
+  let MANIFEST = null;
+  const PAGE_CACHE = {};
+  const UNFURL_CACHE = {};
+  const LIVE_RELOAD_MS = 1500;
+  const FIGURE_FRAME_WINDOWS = new Set();
+  let FIGURE_NAVIGATION_READY = false;
+
+  function esc(s) {
+    return String(s)
+      .replace(/&/g, "&")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;")
+      .replace(/'/g, "&#39;");
+  }
+
+  function flattenTree(node, depth, acc) {
+    acc.push({ node: node, depth: depth });
+    (node.children || []).forEach((c) => flattenTree(c, depth + 1, acc));
+    return acc;
+  }
+
+  function findNode(node, slug) {
+    if (node.slug === slug) return node;
+    for (const c of node.children || []) {
+      const hit = findNode(c, slug);
+      if (hit) return hit;
+    }
+    return null;
+  }
+
+  /* -------------------- minimal markdown -------------------- */
+
+  function inline(text) {
+    let t = esc(text);
+    t = t.replace(/`([^`]+)`/g, (_, c) => `<code>${c}</code>`);
+    t = t.replace(/\*\*([^*]+)\*\*/g, (_, c) => `<strong>${c}</strong>`);
+    t = t.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, txt, url) => {
+      const safe = esc(url);
+      const attrs = /^https?:/.test(url) ? ' target="_blank" rel="noopener"' : "";
+      const item = /^https?:/.test(url) ? classifyResource(url) : null;
+      const data = item
+        ? ` class="res-link" data-res-url="${esc(item.url)}"`
+        : "";
+      return `<a href="${safe}"${attrs}${data}>${txt}</a>`;
+    });
+    t = t.replace(/(^|[\s(])(https?:\/\/[^\s<>)"'`]+)/g, (m, pre, url) => {
+      let rest = "";
+      const cut = url.search(/&quot;|&#39;|&lt;|&gt;/);
+      if (cut !== -1) {
+        rest = url.slice(cut);
+        url = url.slice(0, cut);
+      }
+      const trailing = (url.match(/[.,;:!?`]+$/) || [""])[0];
+      const clean = trailing ? url.slice(0, -trailing.length) : url;
+      if (!clean) return m;
+      const item = classifyResource(clean);
+      if (item) return `${pre}${resChipHtml(item)}${trailing}${rest}`;
+      return `${pre}<a href="${clean}" target="_blank" rel="noopener">${clean}</a>${trailing}${rest}`;
+    });
+    return t;
+  }
+
+  function resChipHtml(item) {
+    return (
+      `<a class="res-chip" href="${esc(item.url)}" target="_blank" ` +
+      `rel="noopener" data-res-url="${esc(item.url)}">` +
+      `<span class="res-chip-ico">${RESOURCE_ICONS[item.kind]}</span>` +
+      `${esc(item.id)}</a>`
+    );
+  }
+
+  const URL_ONLY = /^(https?:\/\/[^\s]+)$/;
+  const DETECTED_URL =
+    /(https?:\/\/[^\s<>)\]"'`]+|trackio-local-dashboard:\/\/[^\s<>)\]"'`]+|trackio-artifact:\/\/[^\s<>)\]"'`]+|trackio-local-path:\/\/[^\s<>)\]"'`]+)/g;
+
+  function renderMarkdown(md, container) {
+    const cellRe = /(^|\n)---\n<!-- trackio-cell\n([\s\S]*?)\n-->\n([\s\S]*?)(?=\n---\n<!-- trackio-cell\n|\s*$)/g;
+    const tokens = [];
+    let pos = 0;
+    let found = false;
+    let match;
+    while ((match = cellRe.exec(md))) {
+      found = true;
+      tokens.push({
+        kind: "md",
+        text: md.slice(pos, match.index + match[1].length),
+      });
+      tokens.push({
+        kind: "cell",
+        meta: parseCellMeta(match[2]),
+        body: match[3],
+      });
+      pos = match.index + match[0].length;
+    }
+    tokens.push({ kind: "md", text: found ? md.slice(pos) : md });
+
+    for (let i = 0; i < tokens.length; i++) {
+      const t = tokens[i];
+      if (t.kind === "md") {
+        renderMarkdownPlain(t.text, container);
+        continue;
+      }
+      if (t.consumed) continue;
+      if (t.meta.type === "code") {
+        const arts = [];
+        for (let j = i + 1; j < tokens.length; j++) {
+          const n = tokens[j];
+          if (n.kind === "md") {
+            if (n.text.trim() === "") continue;
+            break;
+          }
+          if (n.meta.type === "artifact") {
+            arts.push(n);
+            n.consumed = true;
+            continue;
+          }
+          break;
+        }
+        renderCell(t.meta, t.body, container, arts);
+      } else {
+        renderCell(t.meta, t.body, container);
+      }
+    }
+  }
+
+  function parseCellMeta(raw) {
+    try {
+      return JSON.parse(raw);
+    } catch (e) {
+      return { type: "markdown", title: "Note" };
+    }
+  }
+
+  function renderMarkdownPlain(md, container) {
+    const lines = md.replace(/<!--[\s\S]*?-->/g, "").split("\n");
+    let i = 0;
+    let para = [];
+
+    function flushPara() {
+      if (!para.length) return;
+      const joined = para.join(" ").trim();
+      para = [];
+      if (!joined) return;
+      if (/^trackio-artifact:\/\/\S+$/.test(joined)) return;
+      if (/^trackio-local-path:\/\/\S+$/.test(joined)) return;
+      if (joined.indexOf("📦 Artifact") !== -1) {
+        const div = document.createElement("div");
+        div.className = "artifact-chip";
+        div.innerHTML = ARTIFACT_ICON_IMG + inline(joined.replace(/📦\s*/, ""));
+        container.appendChild(div);
+        return;
+      }
+      if (URL_ONLY.test(joined) || IMG_PATH.test(joined)) {
+        const el = renderStandaloneUrl(joined);
+        if (el) container.appendChild(el);
+        return;
+      }
+      const p = document.createElement("p");
+      p.innerHTML = inline(joined);
+      container.appendChild(p);
+    }
+
+    while (i < lines.length) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      if (trimmed === "") {
+        flushPara();
+        i++;
+        continue;
+      }
+      const fence = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
+      if (fence) {
+        flushPara();
+        const marker = fence[1][0];
+        const closeRe = new RegExp("^" + marker + "{" + fence[1].length + ",}\\s*$");
+        const info = fence[2].trim();
+        const buf = [];
+        i++;
+        while (i < lines.length && !closeRe.test(lines[i].trim())) {
+          buf.push(lines[i]);
+          i++;
+        }
+        i++;
+        const lang = (info.split(/\s+/)[0] || "").toLowerCase();
+        const tm = info.match(/title=(\S+)/);
+        container.appendChild(
+          renderCode(buf.join("\n"), lang, tm ? tm[1] : null)
+        );
+        continue;
+      }
+      if (trimmed === "---") {
+        flushPara();
+        container.appendChild(document.createElement("hr"));
+        i++;
+        continue;
+      }
+      const h = trimmed.match(/^(#{1,4})\s+(.*)$/);
+      if (h) {
+        flushPara();
+        const el = document.createElement("h" + h[1].length);
+        el.innerHTML = inline(h[2]);
+        container.appendChild(el);
+        i++;
+        continue;
+      }
+      if (
+        trimmed.startsWith("|") &&
+        i + 1 < lines.length &&
+        /^\|?[\s:|-]*-{2,}[\s:|-]*\|?$/.test(lines[i + 1].trim())
+      ) {
+        flushPara();
+        const rows = [];
+        while (i < lines.length && lines[i].trim().startsWith("|")) {
+          rows.push(parseRow(lines[i].trim()));
+          i++;
+        }
+        renderTable(rows, container);
+        continue;
+      }
+      if (trimmed.startsWith("> ")) {
+        flushPara();
+        const bq = document.createElement("blockquote");
+        bq.innerHTML = inline(trimmed.slice(2));
+        container.appendChild(bq);
+        i++;
+        continue;
+      }
+      if (/^`[^`]+`$/.test(trimmed)) {
+        flushPara();
+        const el = document.createElement("div");
+        el.className = "ts";
+        el.textContent = trimmed.replace(/`/g, "");
+        container.appendChild(el);
+        i++;
+        continue;
+      }
+      if (trimmed.startsWith("- ")) {
+        flushPara();
+        const items = [];
+        while (i < lines.length && lines[i].trim().startsWith("- ")) {
+          items.push(lines[i].trim().slice(2).trim());
+          i++;
+        }
+        renderList(items, container);
+        continue;
+      }
+      para.push(trimmed);
+      i++;
+    }
+    flushPara();
+  }
+
+  function renderCell(meta, body, container, artifacts) {
+    const cell = document.createElement("section");
+    cell.className = `cell ${meta.type || "markdown"}`;
+    if (meta.id) cell.dataset.cellId = meta.id;
+    if (isPinned(meta)) cell.classList.add("pinned-source");
+
+    const head = document.createElement("div");
+    head.className = "cell-head";
+    const rawTitle = (meta.title || "").trim();
+    const title = rawTitle && rawTitle.toLowerCase() !== "untitled" ? esc(rawTitle) : "";
+    const when = meta.created_at ? `<span>${esc(formatTime(meta.created_at))}</span>` : "";
+    head.innerHTML =
+      (title ? `<div class="cell-title">${title}</div>` : "") +
+      `<div class="cell-meta">${when}</div>`;
+    if (!title) head.classList.add("no-title");
+    cell.appendChild(head);
+
+    const bodyEl = document.createElement("div");
+    bodyEl.className = "cell-body";
+    if (meta.type === "code") {
+      renderCodeCell(body, bodyEl, artifacts);
+    } else if (meta.type === "figure") {
+      cell.dataset.resUrl = `trackio-figure://${(meta.title || "Figure").trim()}`;
+      renderFigureCell(body, bodyEl, head);
+    } else if (meta.type === "artifact") {
+      renderMarkdownPlain(body, bodyEl);
+      const chip = bodyEl.querySelector(".artifact-chip");
+      const uri = body.match(
+        /(trackio-artifact:\/\/\S+|trackio-local-path:\/\/\S+|https:\/\/huggingface\.co\/buckets\/[^\s<)]+#\S+)/
+      );
+      if (chip && uri) chip.dataset.resUrl = uri[1];
+    } else if (meta.type === "dashboard") {
+      const sp = body.match(/https:\/\/huggingface\.co\/spaces\/[^\s<>)"'`]+/);
+      cell.dataset.resUrl = sp
+        ? sp[0]
+        : `trackio-local-dashboard://${(meta.dashboard_project || "").trim()}`;
+      renderDashboardCell(meta, body, bodyEl, head);
+    } else {
+      const cleaned = stripDuplicateTitle(body, meta.title);
+      renderMarkdownPlain(cleaned, bodyEl);
+      renderDetectedEmbeds(cleaned, bodyEl);
+    }
+    cell.appendChild(bodyEl);
+    container.appendChild(cell);
+    return cell;
+  }
+
+  function isPinned(meta) {
+    return Boolean(meta && (meta.pinned === true || meta.pinned === "true"));
+  }
+
+  function stripDuplicateTitle(body, title) {
+    if (!title) return body;
+    const m = body.match(/^\s*#{1,6}\s+([^\n]+)\n?/);
+    if (!m) return body;
+    const norm = (s) =>
+      s
+        .toLowerCase()
+        .replace(/[*_`#]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    return norm(m[1]) === norm(title) ? body.slice(m[0].length) : body;
+  }
+
+  function formatTime(iso) {
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime())) return iso;
+    return d.toLocaleString(undefined, {
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+    });
+  }
+
+  function parseFences(text) {
+    const fenceRe = /(`{3,4}|~{3,4})([^\n]*)\n([\s\S]*?)\n\1/g;
+    const parts = [];
+    let pos = 0;
+    let match;
+    while ((match = fenceRe.exec(text))) {
+      if (match.index > pos) {
+        parts.push({ kind: "text", text: text.slice(pos, match.index) });
+      }
+      const info = match[2].trim();
+      const lang = (info.split(/\s+/)[0] || "").toLowerCase();
+      const titleMatch = info.match(/title=(\S+)/);
+      parts.push({
+        kind: lang === "result" || lang === "output" ? "output" : "code",
+        lang,
+        title: titleMatch ? titleMatch[1] : null,
+        text: match[3],
+      });
+      pos = match.index + match[0].length;
+    }
+    if (pos < text.length) parts.push({ kind: "text", text: text.slice(pos) });
+    return parts;
+  }
+
+  function fitFigureFrame(frame, wrap) {
+    let doc;
+    try {
+      doc = frame.contentDocument;
+    } catch (e) {
+      return;
+    }
+    if (!doc || !doc.body) return;
+    frame.style.transform = "none";
+    frame.style.width = "100%";
+    frame.style.height = "auto";
+    frame.style.position = "";
+    frame.style.left = "";
+    frame.style.top = "";
+    const avail = wrap.clientWidth;
+    const isFullscreen =
+      document.fullscreenElement === wrap ||
+      document.webkitFullscreenElement === wrap;
+    const availHeight = isFullscreen ? wrap.clientHeight : Infinity;
+    const cw = Math.max(doc.body.scrollWidth, doc.documentElement.scrollWidth, 1);
+    const ch = Math.max(doc.body.scrollHeight, doc.documentElement.scrollHeight, 1);
+    const scale = Math.min(avail / cw, availHeight / ch);
+    if (avail && scale < 1 - 1e-3) {
+      frame.style.width = `${cw}px`;
+      frame.style.height = `${ch}px`;
+      frame.style.transformOrigin = "top left";
+      frame.style.transform = `scale(${scale})`;
+      if (isFullscreen) {
+        frame.style.position = "absolute";
+        frame.style.left = `${Math.max(0, (avail - cw * scale) / 2)}px`;
+        frame.style.top = `${Math.max(0, (availHeight - ch * scale) / 2)}px`;
+        wrap.style.height = "100%";
+      } else {
+        wrap.style.height = `${Math.ceil(ch * scale)}px`;
+      }
+    } else {
+      frame.style.width = "100%";
+      frame.style.height = `${ch}px`;
+      wrap.style.height = isFullscreen ? "100%" : `${ch}px`;
+    }
+  }
+
+  function attachFigureFit(frame, wrap) {
+    const refit = () => fitFigureFrame(frame, wrap);
+    frame.addEventListener("load", refit);
+    if (window.ResizeObserver) {
+      const ro = new ResizeObserver(() => refit());
+      ro.observe(wrap);
+    }
+  }
+
+  function renderFigureCell(text, container, head) {
+    const parts = parseFences(text);
+    const htmlPart = parts.find((part) => part.lang === "html");
+    const rawPart = parts.find((part) => part.lang === "raw");
+    if (!htmlPart || !htmlPart.text.trim()) {
+      const empty = document.createElement("p");
+      empty.className = "muted";
+      empty.textContent = "No figure HTML.";
+      container.appendChild(empty);
+      return;
+    }
+    const frame = document.createElement("iframe");
+    frame.className = "figure-frame";
+    frame.sandbox = "allow-scripts allow-same-origin";
+    frame.loading = "lazy";
+    frame.srcdoc = htmlPart.text;
+    registerFigureNavigation(frame);
+    const figWrap = document.createElement("div");
+    figWrap.className = "figure-fit";
+    figWrap.appendChild(frame);
+    attachFigureFit(frame, figWrap);
+    if (head) {
+      const metaEl = head.querySelector(".cell-meta");
+      if (metaEl)
+        metaEl.insertBefore(buildFullscreenControl(figWrap, frame), metaEl.firstChild);
+    }
+    if (!rawPart || !rawPart.text.trim()) {
+      container.appendChild(figWrap);
+      return;
+    }
+    const sw = document.createElement("div");
+    sw.className = "fig-switch";
+    const thumb = document.createElement("span");
+    thumb.className = "fig-switch-thumb";
+    const figBtn = document.createElement("button");
+    figBtn.type = "button";
+    figBtn.className = "active";
+    figBtn.textContent = "Figure";
+    const rawBtn = document.createElement("button");
+    rawBtn.type = "button";
+    rawBtn.textContent = "Raw";
+    sw.appendChild(thumb);
+    sw.appendChild(figBtn);
+    sw.appendChild(rawBtn);
+    const rawView = document.createElement("div");
+    rawView.className = "figure-raw";
+    rawView.hidden = true;
+    const pre = document.createElement("pre");
+    const code = document.createElement("code");
+    code.textContent = rawPart.text;
+    pre.appendChild(code);
+    rawView.appendChild(pre);
+    rawView.appendChild(copySnippetBtn(rawPart.text));
+    const select = (showRaw) => {
+      sw.classList.toggle("raw", showRaw);
+      figBtn.classList.toggle("active", !showRaw);
+      rawBtn.classList.toggle("active", showRaw);
+      figWrap.hidden = showRaw;
+      rawView.hidden = !showRaw;
+    };
+    figBtn.addEventListener("click", () => select(false));
+    rawBtn.addEventListener("click", () => select(true));
+    if (head) {
+      head.insertBefore(sw, head.querySelector(".cell-meta"));
+    } else {
+      container.appendChild(sw);
+    }
+    container.appendChild(figWrap);
+    container.appendChild(rawView);
+  }
+
+  // Poster embeds can send `{ type: "trackio-logbook:navigate", target: "..." }`
+  // from their iframe. Only accept messages from figure frames we created, and
+  // only route to pages that are present in this logbook's manifest.
+  function registerFigureNavigation(frame) {
+    const registerFrameWindow = () => {
+      if (frame.contentWindow) FIGURE_FRAME_WINDOWS.add(frame.contentWindow);
+    };
+    // `srcdoc` replaces the initial about:blank document. Register after that
+    // navigation as well, so messages come from the live figure document.
+    frame.addEventListener("load", registerFrameWindow);
+    registerFrameWindow();
+    if (FIGURE_NAVIGATION_READY) return;
+    FIGURE_NAVIGATION_READY = true;
+    window.addEventListener("message", (event) => {
+      if (!FIGURE_FRAME_WINDOWS.has(event.source)) return;
+      const message = event.data;
+      if (!message || message.type !== "trackio-logbook:navigate") return;
+      const target = String(message.target || "").replace(/^#?\//, "");
+      if (!target || !MANIFEST || !findNode(MANIFEST.root, target)) return;
+      const hash = "#/" + target;
+      if (location.hash === hash) scrollToHash();
+      else location.hash = hash;
+    });
+  }
+
+  const FULLSCREEN_ICON =
+    '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" ' +
+    'stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">' +
+    '<path d="M8 3H3v5M16 3h5v5M21 16v5h-5M3 16v5h5"/>' +
+    '<path d="M3 8 8 3M16 3l5 5M21 16l-5 5M8 21l-5-5"/></svg>';
+
+  // Figures are rendered in same-origin iframes, so fullscreen the fitted
+  // wrapper rather than the iframe document. This uses the browser's native
+  // fullscreen UI and preserves the figure's existing responsive sizing.
+  function buildFullscreenControl(figWrap, frame) {
+    const wrap = document.createElement("span");
+    wrap.className = "cell-fullscreen";
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "cell-fullscreen-btn";
+    btn.setAttribute("aria-label", "Open figure in fullscreen");
+    btn.title = "Open figure in fullscreen";
+    btn.innerHTML = FULLSCREEN_ICON;
+    wrap.appendChild(btn);
+
+    btn.addEventListener("click", async () => {
+      const request = figWrap.requestFullscreen || figWrap.webkitRequestFullscreen;
+      if (!request) return;
+      try {
+        await request.call(figWrap);
+      } catch (_) {
+        // Fullscreen can be disabled by the embedding browser or policy.
+      }
+    });
+    document.addEventListener("fullscreenchange", () => {
+      if (document.fullscreenElement === figWrap) fitFigureFrame(frame, figWrap);
+    });
+    return wrap;
+  }
+
+  function extractUrls(text) {
+    const seen = new Set();
+    const urls = [];
+    let match;
+    while ((match = DETECTED_URL.exec(text))) {
+      const url = match[1].replace(/[.,;:!?'"`]+$/, "");
+      if (!seen.has(url)) {
+        seen.add(url);
+        urls.push(url);
+      }
+    }
+    DETECTED_URL.lastIndex = 0;
+    return urls;
+  }
+
+  const IMG_URL = /(\.(png|jpe?g|gif|svg|webp)(\?|$)|\/artifact_blob\/)/i;
+
+  function renderDetectedEmbeds(text, container) {
+    extractUrls(text).forEach((url) => {
+      if (url.startsWith("trackio-local-dashboard://")) {
+        const div = document.createElement("div");
+        div.className = "artifact-chip";
+        div.dataset.resUrl = url;
+        div.innerHTML =
+          "🎯 <strong>Local Trackio dashboard</strong> — publish the logbook to share it";
+        container.appendChild(div);
+      } else if (IMG_URL.test(url)) {
+        container.appendChild(renderImage(url));
+      } else if (/huggingface\.co\/spaces\//.test(url)) {
+        maybeEmbedTrackioSpace(url, container);
+      }
+    });
+  }
+
+  function renderStandaloneUrl(url) {
+    if (IMG_URL.test(url) || IMG_PATH.test(url)) return renderImage(url);
+    const item = classifyResource(url);
+    if (item) {
+      const marker = document.createElement("span");
+      marker.className = "resource-anchor";
+      marker.dataset.resUrl = item.url;
+      marker.setAttribute("aria-hidden", "true");
+      return marker;
+    }
+    const p = document.createElement("p");
+    p.innerHTML = inline(url);
+    return p;
+  }
+
+  function renderImage(url) {
+    const a = document.createElement("a");
+    a.className = "unfurl image";
+    a.href = url;
+    a.target = "_blank";
+    a.rel = "noopener";
+    const img = document.createElement("img");
+    img.loading = "lazy";
+    img.src = url;
+    img.alt = "artifact image";
+    a.appendChild(img);
+    return a;
+  }
+
+  function maybeEmbedTrackioSpace(url, container) {
+    const id = url.split("/spaces/")[1].split(/[?#]/)[0].replace(/\/$/, "");
+    const holder = document.createElement("div");
+    container.appendChild(holder);
+    getJSON(`https://huggingface.co/api/spaces/${id}`).then((d) => {
+      const tags = (d && d.tags) || [];
+      if (tags.some((t) => String(t).toLowerCase() === "trackio")) {
+        renderTrackioSpaceEmbed(holder, url, id);
+      } else {
+        holder.remove();
+      }
+    });
+  }
+
+  function jpGutter(label) {
+    const g = document.createElement("div");
+    g.className = "jp-gutter";
+    g.textContent = label;
+    return g;
+  }
+
+  function renderOutArtifact(info) {
+    const remote = !info.local && !!info.url;
+    const el = document.createElement(remote ? "a" : "div");
+    el.className = "out-artifact";
+    if (remote) {
+      el.href = info.url;
+      el.target = "_blank";
+      el.rel = "noopener";
+    }
+    el.dataset.resUrl = info.resUrl;
+    const parts = [info.type, info.size].filter(Boolean).map(esc);
+    const state = remote
+      ? `<span class="out-artifact-state open">Open ↗</span>`
+      : `<span class="out-artifact-state">publish to share</span>`;
+    const meta = parts.length ? `${parts.join(" · ")} · ${state}` : state;
+    el.innerHTML =
+      `<span class="out-artifact-ico">${ARTIFACT_ICON_IMG}</span>` +
+      `<span class="out-artifact-name">${esc(info.name)}</span>` +
+      `<span class="out-artifact-meta">${meta}</span>`;
+    return el;
+  }
+
+  function renderCodeCell(body, container, artifacts) {
+    const parts = parseFences(body);
+    const block = document.createElement("div");
+    block.className = "jp";
+    const input = document.createElement("div");
+    input.className = "jp-in";
+    const inputBody = document.createElement("div");
+    inputBody.className = "jp-in-body";
+    input.appendChild(jpGutter("In"));
+    input.appendChild(inputBody);
+    let metaEl = null;
+    let outputEl = null;
+    let outBody = null;
+    const ensureOut = () => {
+      if (outputEl) return;
+      outputEl = document.createElement("div");
+      outputEl.className = "jp-out";
+      outputEl.appendChild(jpGutter("Out"));
+      outBody = document.createElement("div");
+      outBody.className = "jp-out-body";
+      outputEl.appendChild(outBody);
+    };
+    const embedTexts = [];
+    parts.forEach((part) => {
+      if (part.kind === "text") {
+        const text = part.text.trim();
+        if (!text) return;
+        if (/^exit\s+\S+(\s|·)/.test(text)) {
+          metaEl = document.createElement("div");
+          metaEl.className = "jp-meta";
+          metaEl.textContent = text.replace(
+            /\s*·\s*[A-Z][a-z]{2} \d{1,2}, \d{4}.*$/,
+            ""
+          );
+        } else {
+          renderMarkdownPlain(text, container);
+          embedTexts.push(text);
+        }
+        return;
+      }
+      if (part.kind === "output") {
+        ensureOut();
+        const pre = document.createElement("pre");
+        pre.className = "jp-out-pre";
+        const c = document.createElement("code");
+        c.textContent = part.text;
+        pre.appendChild(c);
+        outBody.appendChild(pre);
+        outputEl.appendChild(copySnippetBtn(part.text));
+        embedTexts.push(part.text);
+        return;
+      }
+      inputBody.appendChild(renderCode(part.text, part.lang, part.title));
+    });
+    if (artifacts && artifacts.length) {
+      ensureOut();
+      const artWrap = document.createElement("div");
+      artWrap.className = "jp-artifacts";
+      artifacts.forEach((a) => {
+        artWrap.appendChild(
+          renderOutArtifact(artifactInfoFromCell(a.meta, a.body))
+        );
+      });
+      outBody.appendChild(artWrap);
+    }
+    if (inputBody.childNodes.length > 0) block.appendChild(input);
+    if (metaEl) block.appendChild(metaEl);
+    if (outputEl) block.appendChild(outputEl);
+    if (block.childNodes.length) container.appendChild(block);
+    embedTexts.forEach((text) => renderDetectedEmbeds(text, container));
+  }
+
+  function parseRow(line) {
+    let s = line.trim();
+    if (s.startsWith("|")) s = s.slice(1);
+    if (s.endsWith("|")) s = s.slice(0, -1);
+    return s.split(/(?<!\\)\|/).map((c) => c.replace(/\\\|/g, "|").trim());
+  }
+
+  const TRUTHY = ["x", "✓", "✔", "yes", "done", "true", "[x]"];
+  const CHIP_COLORS = [
+    ["#e7f0ff", "#2158d0"],
+    ["#fde8ec", "#c62a4b"],
+    ["#e6f7ee", "#1a8a55"],
+    ["#fdf0e0", "#b26a12"],
+    ["#efe9ff", "#5b3bd6"],
+    ["#e6f6f8", "#127b88"],
+  ];
+
+  function chipColor(name) {
+    let h = 0;
+    for (let i = 0; i < name.length; i++) h = (h * 31 + name.charCodeAt(i)) >>> 0;
+    return CHIP_COLORS[h % CHIP_COLORS.length];
+  }
+
+  const STATUS_MAP = {
+    "": ["Planned", "gray"],
+    planned: ["Planned", "gray"],
+    todo: ["Planned", "gray"],
+    "to do": ["Planned", "gray"],
+    backlog: ["Planned", "gray"],
+    "in progress": ["In progress", "amber"],
+    "in-progress": ["In progress", "amber"],
+    wip: ["In progress", "amber"],
+    running: ["In progress", "amber"],
+    active: ["In progress", "amber"],
+    done: ["Done", "green"],
+    complete: ["Done", "green"],
+    completed: ["Done", "green"],
+    blocked: ["Blocked", "red"],
+    failed: ["Failed", "red"],
+    abandoned: ["Abandoned", "gray"],
+  };
+
+  function statusBadge(val) {
+    const [label, tone] = STATUS_MAP[val.toLowerCase()] || [val || "—", "gray"];
+    return `<span class="badge ${tone}">${esc(label)}</span>`;
+  }
+
+  function renderTable(rows, container) {
+    if (rows.length < 2) return;
+    const header = rows[0];
+    const body = rows.slice(2);
+    const roles = header.map((h) => {
+      const t = h.toLowerCase();
+      if (t.includes("status") || t.includes("state")) return "status";
+      if (t.includes("progress") || t.includes("complete") || t.includes("done"))
+        return "check";
+      if (t === "who" || t.includes("assign") || t.includes("owner")) return "who";
+      return "text";
+    });
+    const table = document.createElement("table");
+    table.className = "board";
+    const thead = document.createElement("thead");
+    const htr = document.createElement("tr");
+    header.forEach((h, c) => {
+      const th = document.createElement("th");
+      th.textContent = h;
+      if (roles[c] === "check") th.className = "col-check";
+      htr.appendChild(th);
+    });
+    thead.appendChild(htr);
+    table.appendChild(thead);
+    const tbody = document.createElement("tbody");
+    body.forEach((cells) => {
+      const nonEmpty = cells.filter((x) => x !== "").length;
+      if (header.length > 1 && nonEmpty === 1 && cells[0]) {
+        const tr = document.createElement("tr");
+        tr.className = "section-row";
+        const td = document.createElement("td");
+        td.colSpan = header.length;
+        td.innerHTML = inline(cells[0]);
+        tr.appendChild(td);
+        tbody.appendChild(tr);
+        return;
+      }
+      const tr = document.createElement("tr");
+      header.forEach((_, c) => {
+        const td = document.createElement("td");
+        const val = (cells[c] || "").trim();
+        if (roles[c] === "status") {
+          td.className = "col-status";
+          td.innerHTML = statusBadge(val);
+        } else if (roles[c] === "check") {
+          td.className = "col-check";
+          const on = TRUTHY.indexOf(val.toLowerCase()) !== -1;
+          td.innerHTML = `<span class="box ${on ? "on" : ""}">${on ? "✓" : ""}</span>`;
+        } else if (roles[c] === "who") {
+          if (!val || /^to assign$/i.test(val)) {
+            td.innerHTML = `<span class="who-chip muted">${esc(val || "—")}</span>`;
+          } else {
+            const [bg, fg] = chipColor(val);
+            td.innerHTML = `<span class="who-chip" style="background:${bg};color:${fg}">${esc(val)}</span>`;
+          }
+        } else {
+          td.innerHTML = inline(val);
+        }
+        tr.appendChild(td);
+      });
+      const link = tr.querySelector('a[href^="#/"]');
+      if (link) {
+        tr.classList.add("linked-row");
+        tr.addEventListener("click", (e) => {
+          if (e.target.tagName !== "A") location.hash = link.getAttribute("href");
+        });
+      }
+      tbody.appendChild(tr);
+    });
+    table.appendChild(tbody);
+    const wrap = document.createElement("div");
+    wrap.className = "board-wrap";
+    wrap.appendChild(table);
+    container.appendChild(wrap);
+  }
+
+  const HL_RULES = {
+    python: [
+      ["comment", /#[^\n]*/],
+      ["string", /'''[\s\S]*?'''|"""[\s\S]*?"""|'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"/],
+      [
+        "keyword",
+        /\b(?:def|class|return|if|elif|else|for|while|import|from|as|with|try|except|finally|raise|in|not|and|or|is|None|True|False|lambda|yield|global|nonlocal|assert|pass|break|continue|async|await|print)\b/,
+      ],
+      ["number", /\b\d[\d_.eE+-]*\b/],
+    ],
+    bash: [
+      ["comment", /#[^\n]*/],
+      ["string", /'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"/],
+      ["keyword", /\b(?:if|then|else|fi|for|in|do|done|while|case|esac|function|export|source|echo|cd|return|local)\b/],
+      ["number", /(?<=\s)-{1,2}[a-zA-Z][\w-]*/],
+    ],
+    json: [
+      ["string", /"(?:\\.|[^"\\])*"/],
+      ["keyword", /\b(?:true|false|null)\b/],
+      ["number", /-?\b\d[\d.eE+-]*\b/],
+    ],
+    yaml: [
+      ["comment", /#[^\n]*/],
+      ["string", /'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"/],
+      ["keyword", /\b(?:true|false|null|yes|no)\b/],
+      ["number", /-?\b\d[\d.eE+-]*\b/],
+    ],
+  };
+  HL_RULES.javascript = HL_RULES.python;
+  HL_RULES.typescript = HL_RULES.python;
+  HL_RULES.sql = [
+    ["comment", /--[^\n]*/],
+    ["string", /'(?:\\.|[^'\\])*'/],
+    [
+      "keyword",
+      /\b(?:SELECT|FROM|WHERE|JOIN|LEFT|RIGHT|INNER|OUTER|ON|GROUP|BY|ORDER|LIMIT|INSERT|INTO|VALUES|UPDATE|SET|DELETE|CREATE|TABLE|AS|AND|OR|NOT|NULL|COUNT|DISTINCT|IN)\b/i,
+    ],
+    ["number", /\b\d[\d.]*\b/],
+  ];
+
+  function highlightCode(code, lang) {
+    const rules = HL_RULES[lang];
+    if (!rules) return esc(code);
+    const combined = new RegExp(rules.map((r) => "(" + r[1].source + ")").join("|"), "g");
+    let out = "";
+    let last = 0;
+    let m;
+    while ((m = combined.exec(code))) {
+      if (m[0] === "") {
+        combined.lastIndex++;
+        continue;
+      }
+      out += esc(code.slice(last, m.index));
+      let gi = 1;
+      while (gi < m.length && m[gi] === undefined) gi++;
+      out += `<span class="tok-${rules[gi - 1][0]}">${esc(m[0])}</span>`;
+      last = m.index + m[0].length;
+    }
+    out += esc(code.slice(last));
+    return out;
+  }
+
+  function copySnippetBtn(text) {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "copy-snippet";
+    btn.title = "Copy";
+    btn.textContent = "⧉";
+    btn.addEventListener("click", (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      copyText(text, btn, "⧉");
+    });
+    return btn;
+  }
+
+  function renderCode(code, lang, title) {
+    const pre = document.createElement("pre");
+    pre.className = "hl";
+    const c = document.createElement("code");
+    c.innerHTML = highlightCode(code, lang);
+    pre.appendChild(c);
+    if (!title) {
+      const wrap = document.createElement("div");
+      wrap.className = "snippet";
+      wrap.appendChild(pre);
+      wrap.appendChild(copySnippetBtn(code));
+      return wrap;
+    }
+    const det = document.createElement("details");
+    det.className = "code-accordion";
+    det.dataset.resUrl = `trackio-script://${title}`;
+    const sum = document.createElement("summary");
+    sum.innerHTML =
+      `<span class="code-ico">&lt;/&gt;</span>` +
+      `<span class="code-name">${esc(title)}</span>`;
+    sum
+      .querySelector(".code-name")
+      .addEventListener("click", (e) => e.preventDefault());
+    det.appendChild(sum);
+    const wrap = document.createElement("div");
+    wrap.className = "snippet";
+    wrap.appendChild(pre);
+    wrap.appendChild(copySnippetBtn(code));
+    det.appendChild(wrap);
+    return det;
+  }
+
+  const IMG_PATH = /^[^\s]+\.(png|jpe?g|gif|svg|webp)$/i;
+
+  function renderList(items, container) {
+    let ul = null;
+    items.forEach((item) => {
+      if (URL_ONLY.test(item) || IMG_PATH.test(item)) {
+        const el = renderStandaloneUrl(item);
+        if (el) {
+          ul = null;
+          container.appendChild(el);
+        }
+      } else if (item.indexOf("📦 Artifact") !== -1) {
+        ul = null;
+        const div = document.createElement("div");
+        div.className = "artifact-chip";
+        div.innerHTML = inline(item.replace("📦", "🪣"));
+        container.appendChild(div);
+      } else if (item.indexOf("trackio-local-dashboard://") !== -1) {
+        ul = null;
+        const uri = item.match(/trackio-local-dashboard:\/\/\S+/)?.[0] || "";
+        const div = document.createElement("div");
+        div.className = "artifact-chip";
+        if (uri) div.dataset.resUrl = uri;
+        div.innerHTML =
+          "🎯 <strong>Local dashboard</strong> — publish the logbook to share it";
+        container.appendChild(div);
+      } else {
+        if (!ul) {
+          ul = document.createElement("ul");
+          container.appendChild(ul);
+        }
+        const li = document.createElement("li");
+        li.innerHTML = inline(item);
+        ul.appendChild(li);
+      }
+    });
+  }
+
+  /* -------------------- resources rail -------------------- */
+
+  function fmt(n) {
+    if (n == null) return null;
+    if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
+    if (n >= 1e3) return (n / 1e3).toFixed(1) + "k";
+    return String(n);
+  }
+
+  const RESOURCE_SECTIONS = [
+    ["dashboard", "Dashboards", "🎯"],
+    ["model", "Models", "🤗"],
+    ["dataset", "Datasets", "📊"],
+    ["space", "Spaces", "🚀"],
+    ["artifact", "Artifacts", "🪣"],
+    ["paper", "Papers", "📄"],
+    ["repo", "Code", "🐙"],
+    ["job", "Jobs", "⚙️"],
+    ["bucket", "Buckets", "🪣"],
+  ];
+
+  const RESOURCE_ICONS = Object.fromEntries(
+    RESOURCE_SECTIONS.map(([kind, , icon]) => [kind, icon])
+  );
+
+  const ARTIFACT_ICON_IMG = `<img class="art-ico" src="./bucket-icon.svg" alt="" />`;
+  const DASHBOARD_ICON_IMG = `<img class="art-ico" src="./trackio-logo-light.png" alt="" />`;
+
+  const RESOURCE_DESC = {
+    dashboard: "Dashboard",
+    model: "Model",
+    dataset: "Dataset",
+    space: "Space",
+    artifact: "Artifact — in Bucket",
+    paper: "Paper",
+    repo: "Repository",
+    job: "Job — status & logs",
+    bucket: "Bucket — artifacts & data",
+  };
+
+  const HF_NON_MODEL_PREFIX =
+    /^(datasets|spaces|jobs|buckets|papers|blog|docs|api|posts|collections|organizations|settings|new|join|login|pricing|tasks|learn|chat|models)(\/|$)/;
+
+  function hfId(url, marker) {
+    return url.split(marker)[1].split(/[?#]/)[0].replace(/\/$/, "");
+  }
+
+  function classifyResource(url) {
+    if (IMG_URL.test(url)) {
+      return null;
+    }
+    let m;
+    if (url.startsWith("trackio-local-dashboard://")) {
+      return {
+        kind: "dashboard",
+        id: url.slice("trackio-local-dashboard://".length),
+        url,
+        local: true,
+      };
+    }
+    if (url.startsWith("trackio-artifact://")) {
+      return {
+        kind: "artifact",
+        id: url.slice("trackio-artifact://".length),
+        url,
+        local: true,
+      };
+    }
+    if (url.startsWith("trackio-local-path://")) {
+      return {
+        kind: "artifact",
+        id: url.slice("trackio-local-path://".length),
+        url,
+        local: true,
+      };
+    }
+    if ((m = url.match(/huggingface\.co\/buckets\/[^#\s]+#(.+)/))) {
+      return { kind: "artifact", id: decodeURIComponent(m[1]), url };
+    }
+    if (/huggingface\.co\/datasets\/[^/]+\/[^/]+/.test(url)) {
+      return { kind: "dataset", id: hfId(url, "/datasets/"), url };
+    }
+    if (/huggingface\.co\/spaces\/[^/]+\/[^/]+/.test(url)) {
+      return { kind: "space", id: hfId(url, "/spaces/"), url };
+    }
+    if (/huggingface\.co\/jobs\//.test(url)) {
+      const parts = hfId(url, "/jobs/").split("/");
+      const jid = parts[1] || "";
+      return {
+        kind: "job",
+        id: parts[0] + (jid ? ` · ${jid.slice(0, 12)}${jid.length > 12 ? "…" : ""}` : ""),
+        url,
+      };
+    }
+    if (/huggingface\.co\/buckets\//.test(url)) {
+      return { kind: "bucket", id: hfId(url, "/buckets/"), url };
+    }
+    if (/huggingface\.co\/papers\//.test(url)) {
+      return { kind: "paper", id: `Paper ${hfId(url, "/papers/")}`, url };
+    }
+    if ((m = url.match(/arxiv\.org\/(?:abs|pdf)\/([^?#\s]+)/))) {
+      return { kind: "paper", id: `arXiv:${m[1].replace(/\.pdf$/, "")}`, url };
+    }
+    if ((m = url.match(/github\.com\/([^/?#]+\/[^/?#]+)/))) {
+      return { kind: "repo", id: m[1], url };
+    }
+    if ((m = url.match(/huggingface\.co\/([^?#]+)/))) {
+      const rest = m[1].replace(/\/$/, "");
+      if (/^[^/]+\/[^/]+$/.test(rest) && !HF_NON_MODEL_PREFIX.test(rest)) {
+        return { kind: "model", id: rest, url };
+      }
+    }
+    return null;
+  }
+
+  async function fillRailMeta(item, el) {
+    if (item.local) return;
+    const meta = el.querySelector(".rail-meta");
+    const set = (parts) => {
+      const text = parts.filter(Boolean).join(" · ");
+      if (text) meta.textContent = text;
+    };
+    if (item.kind === "model") {
+      const d = await getJSON(`https://huggingface.co/api/models/${item.id}`);
+      if (d) set([d.pipeline_tag, `↓ ${fmt(d.downloads)}`, `♥ ${fmt(d.likes)}`]);
+    } else if (item.kind === "dataset") {
+      const d = await getJSON(`https://huggingface.co/api/datasets/${item.id}`);
+      if (d) set([`↓ ${fmt(d.downloads)}`, `♥ ${fmt(d.likes)}`]);
+    } else if (item.kind === "space" || item.kind === "dashboard") {
+      const d = await getJSON(`https://huggingface.co/api/spaces/${item.id}`);
+      if (d) set([d.sdk, `♥ ${fmt(d.likes)}`]);
+    } else if (item.kind === "repo") {
+      const d = await getJSON(`https://api.github.com/repos/${item.id}`);
+      if (d) set([`★ ${fmt(d.stargazers_count)}`, d.language]);
+    } else if (item.kind === "paper") {
+      const m = item.id.match(/^(?:arXiv:|Paper )(.+)$/);
+      if (!m) return;
+      const arxivId = m[1].replace(/v\d+$/, "");
+      const d = await getJSON(`https://huggingface.co/api/papers/${arxivId}`);
+      if (d && d.id) {
+        if (el.href) el.href = `https://huggingface.co/papers/${d.id}`;
+        const title =
+          d.title && d.title.length > 70 ? `${d.title.slice(0, 69)}…` : d.title;
+        set([title, d.upvotes ? `▲ ${fmt(d.upvotes)}` : null]);
+      }
+    }
+  }
+
+  const BARE_ID_SKIP_DIRS = new Set([
+    "scripts",
+    "configs",
+    "config",
+    "results",
+    "figures",
+    "data",
+    "datasets",
+    "src",
+    "tests",
+    "test",
+    "examples",
+    "pages",
+    "assets",
+    "docs",
+    "outputs",
+    "output",
+    "checkpoints",
+    "models",
+    "utils",
+    "lib",
+    "bin",
+    "tmp",
+    "node_modules",
+    "dist",
+    "build",
+  ]);
+  const FILE_EXT_RE =
+    /\.(py|pyc|js|ts|jsx|tsx|json|jsonl|yaml|yml|csv|tsv|md|txt|sh|bash|html|css|png|jpe?g|svg|gif|webp|ipynb|toml|cfg|ini|lock|pdf|whl|gz|zip|tar|pt|pth|bin|safetensors|db|sqlite)$/i;
+
+  async function detectBareModelIds(text, groups) {
+    const stripped = text.replace(DETECTED_URL, " ");
+    DETECTED_URL.lastIndex = 0;
+    const seen = new Set();
+    const candidates = [];
+    const re = /(^|[\s"'`(=[])([A-Za-z0-9][\w.-]*\/[A-Za-z0-9][\w.-]*)/g;
+    let m;
+    while ((m = re.exec(stripped)) && candidates.length < 15) {
+      const id = m[2].replace(/[.:,]+$/, "");
+      if (seen.has(id)) continue;
+      seen.add(id);
+      if (FILE_EXT_RE.test(id)) continue;
+      if (BARE_ID_SKIP_DIRS.has(id.split("/")[0].toLowerCase())) continue;
+      candidates.push(id);
+    }
+    const results = await Promise.all(
+      candidates.map((id) => getJSON(`https://huggingface.co/api/models/${id}`))
+    );
+    let added = false;
+    const confirmed = [];
+    results.forEach((d, i) => {
+      if (!d || !d.id) return;
+      const id = candidates[i];
+      confirmed.push(id);
+      const url = `https://huggingface.co/${id}`;
+      if (!groups.has("model")) groups.set("model", new Map());
+      if (!groups.get("model").has(url)) {
+        groups.get("model").set(url, { kind: "model", id, url });
+        added = true;
+      }
+    });
+    return { added, confirmed };
+  }
+
+  function chipifyBareIds(ids, container) {
+    if (!ids.length) return;
+    const escaped = ids.map((id) => id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    const pattern = new RegExp("(" + escaped.join("|") + ")");
+    const splitter = new RegExp(pattern.source, "g");
+    container
+      .querySelectorAll(".cell.markdown .cell-body")
+      .forEach((body) => {
+        const walker = document.createTreeWalker(body, NodeFilter.SHOW_TEXT, {
+          acceptNode(node) {
+            if (!pattern.test(node.nodeValue)) return NodeFilter.FILTER_REJECT;
+            for (
+              let el = node.parentElement;
+              el && el !== body;
+              el = el.parentElement
+            ) {
+              if (["A", "CODE", "PRE", "BUTTON"].indexOf(el.tagName) !== -1) {
+                return NodeFilter.FILTER_REJECT;
+              }
+            }
+            return NodeFilter.FILTER_ACCEPT;
+          },
+        });
+        const nodes = [];
+        while (walker.nextNode()) nodes.push(walker.currentNode);
+        nodes.forEach((node) => {
+          const frag = document.createDocumentFragment();
+          node.nodeValue.split(splitter).forEach((part) => {
+            if (ids.indexOf(part) !== -1) {
+              const holder = document.createElement("span");
+              holder.innerHTML = resChipHtml({
+                kind: "model",
+                id: part,
+                url: `https://huggingface.co/${part}`,
+              });
+              frag.appendChild(holder.firstChild);
+            } else if (part) {
+              frag.appendChild(document.createTextNode(part));
+            }
+          });
+          node.parentNode.replaceChild(frag, node);
+        });
+      });
+  }
+
+  let RAIL_TOKEN = 0;
+  const RAIL_EXCLUDE_KINDS = new Set(["paper", "repo", "artifact", "dashboard"]);
+
+  function railDashboardItem(it) {
+    return {
+      kind: "dashboard",
+      id: it.id,
+      url: it.local ? it.resUrl : it.url || it.resUrl,
+      local: it.local,
+      railLabel: "Dashboard",
+    };
+  }
+
+  function promoteTrackioSpacesInRail(groups, dashResUrls, body, rail, token) {
+    const spaceGroup = groups.get("space");
+    if (!spaceGroup || !spaceGroup.size) return;
+    spaceGroup.forEach((item, url) => {
+      getJSON(`https://huggingface.co/api/spaces/${item.id}`)
+        .then((d) => {
+          if (rail.dataset.renderToken !== token) return;
+          const tags = (d && d.tags) || [];
+          if (!tags.some((t) => String(t).toLowerCase() === "trackio")) return;
+          if (dashResUrls.has(url)) return;
+          spaceGroup.delete(url);
+          if (!spaceGroup.size) groups.delete("space");
+          if (!groups.has("dashboard")) groups.set("dashboard", new Map());
+          groups.get("dashboard").set(url, {
+            kind: "dashboard",
+            id: item.id,
+            url: item.url,
+            local: false,
+            railLabel: "Dashboard",
+          });
+          dashResUrls.add(url);
+          paintRail(groups, body, rail);
+        })
+        .catch(() => {});
+    });
+  }
+
+  function renderRail(md, body, rail) {
+    const token = String(++RAIL_TOKEN);
+    rail.dataset.renderToken = token;
+    const scanText = md.replace(
+      /(`{3,4}|~{3,4})(html|raw)[^\n]*\n[\s\S]*?\n\1/g,
+      " "
+    );
+    const groups = new Map();
+    const dashMap = new Map();
+    const dashResUrls = new Set();
+    cellDashboardItems(md).forEach((it) => {
+      if (dashMap.has(it.resUrl)) return;
+      dashMap.set(it.resUrl, railDashboardItem(it));
+      dashResUrls.add(it.resUrl);
+    });
+    if (dashMap.size) groups.set("dashboard", dashMap);
+    extractUrls(scanText).forEach((url) => {
+      const item = classifyResource(url);
+      if (!item) return;
+      if (RAIL_EXCLUDE_KINDS.has(item.kind)) return;
+      if (dashResUrls.has(url)) return;
+      if (!groups.has(item.kind)) groups.set(item.kind, new Map());
+      groups.get(item.kind).set(item.url, item);
+    });
+    const artMap = new Map();
+    cellArtifactItems(md).forEach((it) => {
+      if (artMap.has(it.resUrl)) return;
+      const label = it.type
+        ? it.type.charAt(0).toUpperCase() + it.type.slice(1)
+        : "Artifact";
+      artMap.set(it.resUrl, {
+        kind: "artifact",
+        id: it.name,
+        url: it.local ? it.resUrl : it.url || it.resUrl,
+        local: it.local,
+        railLabel: label,
+        size: it.size,
+      });
+    });
+    if (artMap.size) groups.set("artifact", artMap);
+    paintRail(groups, body, rail);
+    promoteTrackioSpacesInRail(groups, dashResUrls, body, rail, token);
+    detectBareModelIds(scanText, groups)
+      .then((result) => {
+        if (rail.dataset.renderToken !== token) return;
+        chipifyBareIds(result.confirmed, body);
+        if (result.added) paintRail(groups, body, rail);
+      })
+      .catch(() => {});
+  }
+
+  function paintRail(groups, body, rail) {
+    rail.innerHTML = "";
+    RESOURCE_SECTIONS.forEach(([kind, label, icon]) => {
+      const group = groups.get(kind);
+      if (!group || !group.size) return;
+      group.forEach((item) => {
+        const el = document.createElement(item.local ? "div" : "a");
+        el.className = item.local ? "rail-item rail-local" : "rail-item";
+        if (!item.local) {
+          el.href = item.url;
+          el.target = "_blank";
+          el.rel = "noopener";
+        }
+        el.dataset.resUrl = item.url;
+        let desc;
+        if (kind === "artifact") {
+          const state = item.local ? "publish to share" : "Open ↗";
+          desc = item.size ? `${item.size} · ${state}` : state;
+        } else if (kind === "dashboard") {
+          desc = item.local ? "publish to share" : "Open ↗";
+        } else {
+          desc = item.local ? "publish to share" : RESOURCE_DESC[kind];
+        }
+        const kindLabel = item.railLabel || label.replace(/s$/, "");
+        const iconHtml =
+          kind === "artifact"
+            ? ARTIFACT_ICON_IMG
+            : kind === "dashboard"
+              ? DASHBOARD_ICON_IMG
+              : `<span>${icon}</span>`;
+        el.innerHTML =
+          `<div class="rail-kind">${iconHtml}${esc(kindLabel)}</div>` +
+          `<div class="rail-title">${esc(item.id)}</div>` +
+          `<div class="rail-meta">${esc(desc)}</div>`;
+        rail.appendChild(el);
+        fillRailMeta(item, el)
+          .catch(() => {})
+          .finally(() => scheduleRailPosition(body, rail));
+      });
+    });
+    rail.hidden = !rail.childElementCount;
+    scheduleRailPosition(body, rail);
+  }
+
+  function resourceAnchor(body, url) {
+    return body.querySelector(`[data-res-url="${CSS.escape(url)}"]`);
+  }
+
+  function positionRail(body, rail) {
+    if (rail.hidden || !rail.isConnected) return;
+    const bodyRect = body.getBoundingClientRect();
+    const items = Array.from(rail.querySelectorAll(".rail-item")).map((el, index) => {
+      const anchor = resourceAnchor(body, el.dataset.resUrl);
+      return {
+        el,
+        index,
+        desired: anchor
+          ? Math.max(0, anchor.getBoundingClientRect().top - bodyRect.top)
+          : 0,
+      };
+    });
+    items.sort((a, b) => a.desired - b.desired || a.index - b.index);
+    let cursor = 0;
+    items.forEach(({ el, desired }) => {
+      const top = Math.max(desired, cursor);
+      el.style.top = `${top}px`;
+      cursor = top + el.offsetHeight + 10;
+    });
+    rail.style.minHeight = `${Math.max(body.offsetHeight, cursor)}px`;
+  }
+
+  function scheduleRailPosition(body, rail) {
+    cancelAnimationFrame(Number(rail.dataset.positionFrame || 0));
+    rail.dataset.positionFrame = String(
+      requestAnimationFrame(() => positionRail(body, rail))
+    );
+  }
+
+  function dashboardSubdomainFromUrl(url) {
+    return spaceIdFromUrl(url).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  }
+
+  function dashboardOpenLink(head, url) {
+    if (!head || !url) return;
+    const meta = head.querySelector(".cell-meta");
+    if (!meta) return;
+    let link = meta.querySelector(".cell-open");
+    if (!link) {
+      link = document.createElement("a");
+      link.className = "cell-open";
+      link.target = "_blank";
+      link.rel = "noopener";
+      meta.insertBefore(link, meta.firstChild);
+    }
+    link.href = url;
+    link.textContent = "Open ↗";
+  }
+
+  function dashboardFrame(src) {
+    const iframe = document.createElement("iframe");
+    iframe.className = "dashboard-frame";
+    iframe.src = src;
+    iframe.loading = "lazy";
+    iframe.allow = "clipboard-read; clipboard-write; fullscreen";
+    return iframe;
+  }
+
+  function renderDashboardCell(meta, body, container, head) {
+    const project = meta.dashboard_project || "";
+    const holder = document.createElement("div");
+    holder.className = "dashboard-shell";
+    container.appendChild(holder);
+    const space = body.match(/https:\/\/huggingface\.co\/spaces\/[^\s<>)"'`]+/);
+    if (space) {
+      const url = space[0];
+      dashboardOpenLink(head, url);
+      holder.appendChild(
+        dashboardFrame(
+          `https://${dashboardSubdomainFromUrl(url)}.hf.space/?sidebar=hidden&hide_empty_tabs=true`
+        )
+      );
+      return;
+    }
+    if (!isLocalPreview()) {
+      holder.className = "artifact-chip";
+      holder.dataset.resUrl = `trackio-local-dashboard://${project}`;
+      holder.innerHTML =
+        "🎯 <strong>Local Trackio dashboard</strong> — publish the logbook to share it";
+      return;
+    }
+    const open = "/dashboard/?project=" + encodeURIComponent(project);
+    dashboardOpenLink(head, open);
+    holder.appendChild(
+      dashboardFrame(open + "&sidebar=hidden&hide_empty_tabs=true"),
+    );
+  }
+
+  const CACHE_PREFIX = "trackio-logbook:";
+  const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+  const CACHE_MISS_TTL_MS = 60 * 60 * 1000;
+
+  function cacheGet(url) {
+    try {
+      const raw = localStorage.getItem(CACHE_PREFIX + url);
+      if (!raw) return undefined;
+      const entry = JSON.parse(raw);
+      const ttl = entry.d === null ? CACHE_MISS_TTL_MS : CACHE_TTL_MS;
+      if (Date.now() - entry.t > ttl) {
+        localStorage.removeItem(CACHE_PREFIX + url);
+        return undefined;
+      }
+      return entry.d;
+    } catch (e) {
+      return undefined;
+    }
+  }
+
+  function cacheSet(url, data) {
+    try {
+      localStorage.setItem(
+        CACHE_PREFIX + url,
+        JSON.stringify({ t: Date.now(), d: data })
+      );
+    } catch (e) {}
+  }
+
+  async function getJSON(url) {
+    if (UNFURL_CACHE[url] !== undefined) return UNFURL_CACHE[url];
+    const cached = cacheGet(url);
+    if (cached !== undefined) {
+      UNFURL_CACHE[url] = cached;
+      return cached;
+    }
+    try {
+      const r = await fetch(url);
+      if (!r.ok) throw new Error(r.status);
+      const j = await r.json();
+      UNFURL_CACHE[url] = j;
+      cacheSet(url, j);
+      return j;
+    } catch (e) {
+      UNFURL_CACHE[url] = null;
+      cacheSet(url, null);
+      return null;
+    }
+  }
+
+  /* -------------------- routing / render -------------------- */
+
+  function buildTree() {
+    const tree = document.getElementById("tree");
+    tree.innerHTML = "";
+    const nodes = [];
+    (MANIFEST.root.children || []).forEach((c) => flattenTree(c, 0, nodes));
+    nodes.forEach(({ node, depth }) => {
+      const a = document.createElement("a");
+      a.href = "#/" + node.slug;
+      a.className = "depth-" + depth;
+      a.dataset.slug = node.slug;
+      const mark = document.createElement("span");
+      mark.className = "tree-mark";
+      mark.textContent = "§";
+      a.appendChild(mark);
+      a.appendChild(document.createTextNode(" " + node.title));
+      tree.appendChild(a);
+    });
+  }
+
+  function highlight(slug) {
+    document
+      .querySelectorAll("#tree a")
+      .forEach((a) => a.classList.toggle("active", a.dataset.slug === slug));
+    document
+      .getElementById("book-head")
+      .classList.toggle("active", slug === MANIFEST.root.slug);
+  }
+
+  function clearPageCache() {
+    Object.keys(PAGE_CACHE).forEach((key) => {
+      delete PAGE_CACHE[key];
+    });
+  }
+
+  function isLocalPreview() {
+    return ["localhost", "127.0.0.1", "::1"].includes(location.hostname);
+  }
+
+  async function fetchManifest() {
+    const suffix = isLocalPreview() ? `?t=${Date.now()}` : "";
+    return await (await fetch("./logbook.json" + suffix, { cache: "no-store" })).json();
+  }
+
+  async function fetchPage(node) {
+    if (PAGE_CACHE[node.file]) return PAGE_CACHE[node.file];
+    try {
+      const suffix = isLocalPreview()
+        ? `?rev=${encodeURIComponent(MANIFEST.revision || "")}`
+        : "";
+      const r = await fetch("./" + node.file + suffix, { cache: "no-store" });
+      PAGE_CACHE[node.file] = await r.text();
+    } catch (e) {
+      PAGE_CACHE[node.file] = "# " + node.title + "\n\n_Could not load section._";
+    }
+    return PAGE_CACHE[node.file];
+  }
+
+  function allNodes() {
+    const nodes = [];
+    flattenTree(MANIFEST.root, 0, nodes);
+    return nodes.map(({ node }) => node);
+  }
+
+  function collectPinnedCells(markdown, nodes) {
+    const cells = [];
+    markdown.forEach((text, index) => {
+      const cellRe = /(^|\n)---\n<!-- trackio-cell\n([\s\S]*?)\n-->\n([\s\S]*?)(?=\n---\n<!-- trackio-cell\n|\s*$)/g;
+      let match;
+      let cellIndex = 0;
+      while ((match = cellRe.exec(text))) {
+        const meta = parseCellMeta(match[2]);
+        if (isPinned(meta)) {
+          cells.push({
+            meta,
+            body: match[3],
+            node: nodes[index],
+            index: cells.length,
+            order: meta.pinned_at || meta.created_at || "",
+            cellIndex,
+          });
+        }
+        cellIndex++;
+      }
+    });
+    return cells.sort(
+      (a, b) =>
+        a.order.localeCompare(b.order) ||
+        a.index - b.index ||
+        a.cellIndex - b.cellIndex
+    );
+  }
+
+  function renderPinnedNotes(cells, container) {
+    if (!cells.length) return;
+    const deck = document.createElement("section");
+    deck.className = "pinned-notes";
+    const list = document.createElement("div");
+    list.className = "pinned-notes-list";
+    cells.forEach(({ meta, body }) => {
+      const cell = renderCell(meta, body, list);
+      cell.classList.add("pinned-copy");
+    });
+    deck.appendChild(list);
+    const anchor =
+      container.querySelector(".logbook-stats") ||
+      container.querySelector(".agent-hint");
+    container.insertBefore(deck, anchor ? anchor.nextSibling : container.firstChild);
+    container.closest(".book-intro").classList.add("has-pinned-notes");
+  }
+
+  function removeIndexProse(body) {
+    const h1 = Array.from(body.children).find((el) => el.tagName === "H1");
+    if (!h1) return;
+    let current = h1.nextElementSibling;
+    while (current && current.tagName !== "H2") {
+      const next = current.nextElementSibling;
+      current.remove();
+      current = next;
+    }
+  }
+
+  function removePageDirectory(body) {
+    const heading = Array.from(body.children).find(
+      (el) => el.tagName === "H2" && el.textContent.trim().toLowerCase() === "pages"
+    );
+    if (!heading) return;
+    let current = heading;
+    while (current) {
+      const next = current.nextElementSibling;
+      current.remove();
+      if (next && ["H1", "H2"].includes(next.tagName)) break;
+      current = next;
+    }
+  }
+
+  const RAIL_OBSERVERS = [];
+
+  async function renderLogbook(opts = {}) {
+    const scrollY = window.scrollY;
+    const page = document.getElementById("page");
+    RAIL_OBSERVERS.splice(0).forEach((observer) => observer.disconnect());
+    page.innerHTML = "";
+    const nodes = allNodes();
+    const markdown = await Promise.all(nodes.map(fetchPage));
+    const pinnedCells = collectPinnedCells(markdown, nodes);
+    let bookIntroBody = null;
+    nodes.forEach((node, index) => {
+      const section = document.createElement("section");
+      section.className = "page-section";
+      section.id = "/" + node.slug;
+      section.dataset.slug = node.slug;
+
+      const layout = document.createElement("div");
+      layout.className = "page-layout";
+      const body = document.createElement("div");
+      body.className = "page-body";
+      const rail = document.createElement("aside");
+      rail.className = "context-rail";
+      rail.setAttribute("aria-label", `Resources for ${node.title}`);
+
+      renderMarkdown(markdown[index], body);
+      if (node.slug === MANIFEST.root.slug) {
+        section.classList.add("book-intro");
+        removeIndexProse(body);
+        removePageDirectory(body);
+        const hint = buildAgentHint();
+        const h1 = body.querySelector("h1");
+        if (h1 && h1.parentNode === body) {
+          body.insertBefore(hint, h1.nextSibling);
+        } else {
+          body.prepend(hint);
+        }
+        hint.after(buildLogbookStats(markdown));
+        bookIntroBody = body;
+      }
+      layout.appendChild(body);
+      layout.appendChild(rail);
+      section.appendChild(layout);
+      page.appendChild(section);
+      renderRail(markdown[index], body, rail);
+      if (window.ResizeObserver) {
+        const observer = new ResizeObserver(() => scheduleRailPosition(body, rail));
+        observer.observe(body);
+        observer.observe(rail);
+        RAIL_OBSERVERS.push(observer);
+      }
+    });
+    if (bookIntroBody) renderPinnedNotes(pinnedCells, bookIntroBody);
+    if (bookIntroBody) {
+      const section = bookIntroBody.closest(".book-intro");
+      const hasExtra = Array.from(bookIntroBody.children).some(
+        (el) =>
+          el.tagName !== "H1" &&
+          !el.classList.contains("agent-hint") &&
+          !el.classList.contains("logbook-stats") &&
+          !el.classList.contains("pinned-notes")
+      );
+      if (section && !section.classList.contains("has-pinned-notes") && !hasExtra) {
+        section.classList.add("book-intro-tight");
+      }
+    }
+    requestAnimationFrame(() => {
+      if (opts.preserveScroll) {
+        window.scrollTo(0, scrollY);
+      } else {
+        scrollToHash({ behavior: "auto" });
+      }
+      updateActiveSection();
+    });
+  }
+
+  function setupResourceHover() {
+    document.addEventListener("mouseover", (e) => {
+      const el = e.target.closest && e.target.closest("[data-res-url]");
+      if (!el || el.classList.contains("rail-item")) return;
+      const url = el.getAttribute("data-res-url");
+      const section = el.closest(".page-section");
+      const scope = section || document;
+      scope.querySelectorAll(".context-rail [data-res-url]").forEach((n) => {
+        n.classList.toggle("res-hl", n.getAttribute("data-res-url") === url);
+      });
+    });
+    document.addEventListener("mouseout", (e) => {
+      const el = e.target.closest && e.target.closest("[data-res-url]");
+      if (!el || el.classList.contains("rail-item")) return;
+      document.querySelectorAll(".context-rail .res-hl").forEach((n) => {
+        n.classList.remove("res-hl");
+      });
+    });
+  }
+
+  let STATS_TOKEN = 0;
+  let STATS_LISTENERS = false;
+
+  function fmtBytes(n) {
+    if (n == null || isNaN(n)) return null;
+    if (n < 1000) return `${n} B`;
+    const units = ["kB", "MB", "GB", "TB"];
+    let v = n;
+    let i = -1;
+    do {
+      v /= 1000;
+      i++;
+    } while (v >= 1000 && i < units.length - 1);
+    return `${v.toFixed(v < 10 ? 1 : 0)} ${units[i]}`;
+  }
+
+  function spaceIdFromUrl(url) {
+    return url.split("/spaces/")[1].split(/[?#]/)[0].replace(/\/$/, "");
+  }
+
+  const LB_CELL_RE = /(^|\n)---\n<!-- trackio-cell\n([\s\S]*?)\n-->\n([\s\S]*?)(?=\n---\n<!-- trackio-cell\n|\s*$)/g;
+
+  function cellDashboardItems(md) {
+    const re = new RegExp(LB_CELL_RE.source, "g");
+    const items = [];
+    let m;
+    while ((m = re.exec(md))) {
+      const meta = parseCellMeta(m[2]);
+      if (meta.type !== "dashboard") continue;
+      const body = m[3];
+      const project = meta.dashboard_project || "";
+      const sp = body.match(/https:\/\/huggingface\.co\/spaces\/[^\s<>)"'`]+/);
+      const local = !sp;
+      const url = sp ? sp[0] : "";
+      const resUrl = local ? `trackio-local-dashboard://${project}` : url;
+      items.push({
+        id: local ? project : spaceIdFromUrl(url),
+        local,
+        url,
+        resUrl,
+      });
+    }
+    return items;
+  }
+
+  function artifactInfoFromCell(meta, body) {
+    const name = meta.artifact || meta.path || "";
+    let size = null;
+    const sm = body.match(/·\s*([\d.]+\s*[kMGT]?B)\b/);
+    if (sm) size = sm[1].trim();
+    if (!size && meta.size != null) size = fmtBytes(meta.size);
+    const bucket = body.match(/https:\/\/huggingface\.co\/buckets\/[^\s<>)"'`]+/);
+    const artUri = body.match(/trackio-artifact:\/\/\S+/);
+    const pathUri = body.match(/trackio-local-path:\/\/\S+/);
+    const url = bucket ? bucket[0] : "";
+    const local = !bucket;
+    const resUrl =
+      url || (artUri ? artUri[0] : pathUri ? pathUri[0] : `trackio-artifact://${name}`);
+    return {
+      name,
+      type: meta.artifact_type || "",
+      size,
+      local,
+      isPathRef: !!meta.path,
+      url,
+      resUrl,
+    };
+  }
+
+  function cellArtifactItems(md) {
+    const re = new RegExp(LB_CELL_RE.source, "g");
+    const items = [];
+    let m;
+    while ((m = re.exec(md))) {
+      const meta = parseCellMeta(m[2]);
+      const body = m[3];
+      const order = meta.created_at || "";
+      if (meta.type === "artifact") {
+        const info = artifactInfoFromCell(meta, body);
+        if (info.name) items.push({ ...info, order });
+      }
+    }
+    return items;
+  }
+
+  function collectLogbookResources(markdownList) {
+    const re = new RegExp(LB_CELL_RE.source, "g");
+    const dashboards = new Map();
+    markdownList.forEach((md) => {
+      let m;
+      while ((m = re.exec(md))) {
+        const meta = parseCellMeta(m[2]);
+        const body = m[3];
+        if (meta.type !== "dashboard") continue;
+        const project = meta.dashboard_project || "";
+        const space = body.match(/https:\/\/huggingface\.co\/spaces\/[^\s<>)"'`]+/);
+        const local = !space;
+        const url = space ? space[0] : "";
+        const key = local ? `local:${project}` : `space:${spaceIdFromUrl(url)}`;
+        const resUrl = local ? `trackio-local-dashboard://${project}` : url;
+        if (!dashboards.has(key))
+          dashboards.set(key, { project, local, url, resUrl });
+      }
+    });
+    const artifacts = new Map();
+    markdownList.forEach((md) => {
+      cellArtifactItems(md).forEach((it) => {
+        const key = `${it.type}:${it.name}`;
+        const prev = artifacts.get(key);
+        if (!prev || it.order >= prev.order) artifacts.set(key, it);
+      });
+    });
+    return {
+      dashboards: Array.from(dashboards.values()).sort((a, b) =>
+        a.project.localeCompare(b.project)
+      ),
+      artifacts: Array.from(artifacts.values()).sort((a, b) =>
+        a.name.localeCompare(b.name)
+      ),
+    };
+  }
+
+  function closeStatPopovers() {
+    document
+      .querySelectorAll(".stat-popover")
+      .forEach((p) => (p.hidden = true));
+    document
+      .querySelectorAll(".stat-tile.open")
+      .forEach((t) => t.classList.remove("open"));
+  }
+
+  function ensureStatListeners() {
+    if (STATS_LISTENERS) return;
+    STATS_LISTENERS = true;
+    document.addEventListener("click", closeStatPopovers);
+    document.addEventListener("keydown", (e) => {
+      if (e.key === "Escape") closeStatPopovers();
+    });
+  }
+
+  function stateHtml(remote, url) {
+    return remote
+      ? `<a class="stat-row-state open" href="${esc(url)}" target="_blank" rel="noopener" title="Open in a new tab">Open ↗</a>`
+      : `<span class="stat-row-state">publish to share</span>`;
+  }
+
+  function scrollToResource(resUrl) {
+    closeStatPopovers();
+    if (!resUrl) return;
+    const el = document.querySelector(
+      `#page .page-body [data-res-url="${CSS.escape(resUrl)}"]:not(.stat-row)`
+    );
+    if (!el) return;
+    el.scrollIntoView({ behavior: "smooth", block: "center" });
+    el.classList.add("res-flash");
+    setTimeout(() => el.classList.remove("res-flash"), 1500);
+  }
+
+  function dashRowHtml(d) {
+    const inner =
+      `<span class="stat-row-ico">${DASHBOARD_ICON_IMG}</span>` +
+      `<div class="stat-row-main"><div class="stat-row-title">${esc(d.project)}</div>` +
+      `<div class="stat-row-meta">${stateHtml(!d.local, d.url)}</div></div>`;
+    return `<div class="stat-row" data-res-url="${esc(d.resUrl)}" title="Jump to it in the logbook">${inner}</div>`;
+  }
+
+  function artRowHtml(a) {
+    const remote = !a.local && !!a.url;
+    const parts = [a.type, a.size].filter(Boolean).map(esc);
+    const meta = parts.length
+      ? `${parts.join(" · ")} · ${stateHtml(remote, a.url)}`
+      : stateHtml(remote, a.url);
+    const inner =
+      `<span class="stat-row-ico">${ARTIFACT_ICON_IMG}</span>` +
+      `<div class="stat-row-main"><div class="stat-row-title">${esc(a.name)}</div>` +
+      `<div class="stat-row-meta">${meta}</div></div>`;
+    return `<div class="stat-row" data-res-url="${esc(a.resUrl)}" title="Jump to it in the logbook">${inner}</div>`;
+  }
+
+  function statTile(icon, alt, singular, plural, head, rowFn) {
+    const tile = document.createElement("button");
+    tile.type = "button";
+    tile.className = "stat-tile";
+    const render = (items) => {
+      const count = items.length;
+      const label = count === 1 ? singular : plural;
+      const caret = count > 0 ? `<span class="stat-caret">▾</span>` : "";
+      tile.innerHTML =
+        `<img class="stat-icon" src="${icon}" alt="${esc(alt)}" />` +
+        `<div class="stat-text"><div class="stat-num">${count}</div>` +
+        `<div class="stat-label">${esc(label)}</div></div>` +
+        caret;
+      tile.disabled = count === 0;
+      if (count > 0) {
+        const pop = document.createElement("div");
+        pop.className = "stat-popover";
+        pop.hidden = true;
+        pop.innerHTML =
+          `<div class="stat-pop-head">${esc(head)}</div>` +
+          items.map(rowFn).join("");
+        pop.addEventListener("click", (e) => {
+          if (e.target.closest("a.stat-row-state")) {
+            e.stopPropagation();
+            return;
+          }
+          e.stopPropagation();
+          const row = e.target.closest(".stat-row");
+          if (row) scrollToResource(row.dataset.resUrl);
+        });
+        tile.appendChild(pop);
+      }
+    };
+    tile.addEventListener("click", (e) => {
+      if (tile.disabled) return;
+      e.stopPropagation();
+      const pop = tile.querySelector(".stat-popover");
+      if (!pop) return;
+      const isOpen = !pop.hidden;
+      closeStatPopovers();
+      if (!isOpen) {
+        pop.hidden = false;
+        tile.classList.add("open");
+      }
+    });
+    return { tile, render };
+  }
+
+  function buildLogbookStats(markdownList) {
+    const token = ++STATS_TOKEN;
+    ensureStatListeners();
+    const { dashboards, artifacts } = collectLogbookResources(markdownList);
+
+    const el = document.createElement("div");
+    el.className = "logbook-stats";
+    const dash = statTile(
+      "./trackio-logo-light.png",
+      "Trackio",
+      "Trackio Dashboard",
+      "Trackio Dashboards",
+      "Dashboards created in this logbook",
+      dashRowHtml
+    );
+    const art = statTile(
+      "./bucket-icon.svg",
+      "Bucket",
+      "Artifact",
+      "Artifacts",
+      "Artifacts created in this logbook",
+      artRowHtml
+    );
+    dash.render(dashboards);
+    art.render(artifacts);
+    el.appendChild(dash.tile);
+    el.appendChild(art.tile);
+
+    const scanText = markdownList
+      .map((md) =>
+        md.replace(/(`{3,4}|~{3,4})(html|raw)[^\n]*\n[\s\S]*?\n\1/g, " ")
+      )
+      .join("\n");
+    const seen = new Set(
+      dashboards.map((d) =>
+        d.local ? `local:${d.project}` : `space:${spaceIdFromUrl(d.url)}`
+      )
+    );
+    const remoteSpaces = new Map();
+    extractUrls(scanText).forEach((url) => {
+      const item = classifyResource(url);
+      if (item && item.kind === "space" && !item.local) {
+        remoteSpaces.set(item.url, item);
+      }
+    });
+    remoteSpaces.forEach((s) => {
+      const key = `space:${s.id}`;
+      if (seen.has(key)) return;
+      getJSON(`https://huggingface.co/api/spaces/${s.id}`)
+        .then((d) => {
+          if (STATS_TOKEN !== token) return;
+          const tags = (d && d.tags) || [];
+          if (
+            !seen.has(key) &&
+            tags.some((t) => String(t).toLowerCase() === "trackio")
+          ) {
+            seen.add(key);
+            dashboards.push({
+              project: s.id,
+              local: false,
+              url: s.url,
+              resUrl: s.url,
+            });
+            dashboards.sort((a, b) => a.project.localeCompare(b.project));
+            dash.render(dashboards);
+          }
+        })
+        .catch(() => {});
+    });
+    return el;
+  }
+
+  function buildAgentHint() {
+    const onSpaces =
+      /\.hf\.space$/.test(location.hostname) ||
+      /(^|\.)huggingface\.co$/.test(location.hostname);
+    let source = "";
+    if (onSpaces && MANIFEST.space_id) {
+      source = ` ${MANIFEST.space_id}`;
+    } else if (/^https?:$/.test(location.protocol)) {
+      source = ` ${location.origin}/`;
+    }
+    const command = `trackio logbook read${source}`;
+    const tokens = MANIFEST.agent_view_tokens;
+    const div = document.createElement("div");
+    div.className = "agent-hint";
+    const label = document.createElement("span");
+    label.className = "agent-hint-label";
+    label.textContent = "Read from the CLI:";
+    const code = document.createElement("code");
+    code.textContent = command;
+    const copy = document.createElement("button");
+    copy.className = "copy";
+    copy.type = "button";
+    copy.title = "Copy";
+    copy.textContent = "⧉";
+    copy.addEventListener("click", () => copyText(command, copy, "⧉"));
+    const note = document.createElement("span");
+    note.className = "agent-hint-note";
+    note.textContent =
+      "compact view for agents" + (tokens ? ` · ~${fmt(tokens)} tokens` : "");
+    div.appendChild(label);
+    div.appendChild(code);
+    div.appendChild(copy);
+    div.appendChild(note);
+    return div;
+  }
+
+  function currentSlug() {
+    const slug = (location.hash || "").replace(/^#\//, "") || MANIFEST.root.slug;
+    return findNode(MANIFEST.root, slug) ? slug : MANIFEST.root.slug;
+  }
+
+  function scrollToHash(opts = {}) {
+    const slug = currentSlug();
+    if (!location.hash) {
+      window.scrollTo({ top: 0, behavior: opts.behavior || "auto" });
+      highlight(slug);
+      return;
+    }
+    const section = document.getElementById("/" + slug);
+    if (section) section.scrollIntoView({ behavior: opts.behavior || "smooth" });
+    highlight(slug);
+  }
+
+  function navigateToLogbookSlug(target) {
+    const slug = String(target || "").replace(/^#?\//, "").trim();
+    if (!slug || !findNode(MANIFEST.root, slug)) return;
+    const hash = "#/" + slug;
+    if (location.hash === hash) {
+      scrollToHash({ behavior: "smooth" });
+    } else {
+      location.hash = hash;
+    }
+  }
+
+  function setupFigureNavigation() {
+    window.addEventListener("message", (event) => {
+      const data = event.data;
+      if (!data || data.type !== "trackio-logbook:navigate") return;
+      // Only accept messages from one of this logbook's sandboxed figure
+      // iframes, rather than from an arbitrary same-origin page.
+      const isFigureFrame = Array.from(
+        document.querySelectorAll("iframe.figure-frame")
+      ).some((frame) => frame.contentWindow === event.source);
+      if (!isFigureFrame) return;
+      navigateToLogbookSlug(data.target);
+    });
+  }
+
+  let SCROLL_FRAME = 0;
+  function updateActiveSection() {
+    cancelAnimationFrame(SCROLL_FRAME);
+    SCROLL_FRAME = requestAnimationFrame(() => {
+      const sections = Array.from(document.querySelectorAll(".page-section"));
+      if (!sections.length) return;
+      const marker = Math.min(window.innerHeight * 0.28, 180);
+      let active = sections[0];
+      sections.forEach((section) => {
+        if (section.getBoundingClientRect().top <= marker) active = section;
+      });
+      if (
+        window.innerHeight + window.scrollY >=
+        document.documentElement.scrollHeight - 2
+      ) {
+        active = sections[sections.length - 1];
+      }
+      highlight(active.dataset.slug);
+    });
+  }
+
+  function startLiveReload() {
+    if (!isLocalPreview()) return;
+    setInterval(async () => {
+      try {
+        const next = await fetchManifest();
+        if (!next || next.revision === MANIFEST.revision) return;
+        MANIFEST = next;
+        clearPageCache();
+        document.title = MANIFEST.title + " · Trackio Logbook";
+        document.getElementById("book-title").textContent = MANIFEST.title;
+        document.getElementById("book-head").setAttribute("aria-label", MANIFEST.title);
+        buildTree();
+        renderLogbook({ preserveScroll: true });
+      } catch (e) {}
+    }, LIVE_RELOAD_MS);
+  }
+
+  function setupConnect() {
+    const space = MANIFEST.space_id;
+    if (!space) return;
+    const steps = [
+      { t: "Install Trackio, if you don't have it yet.", c: "uv tool install trackio" },
+      { t: "Add the Trackio skill for your agent, then reload it.", c: "trackio skills add" },
+      { t: "Connect to this logbook.", c: `trackio logbook open ${space}` },
+    ];
+    const ol = document.getElementById("connect-steps");
+    steps.forEach((s, i) => {
+      const li = document.createElement("li");
+      const title = document.createElement("div");
+      title.className = "step-title";
+      title.textContent = `${i + 1}. ${s.t}`;
+      const block = document.createElement("div");
+      block.className = "codeblock";
+      const code = document.createElement("code");
+      code.textContent = s.c;
+      const copy = document.createElement("button");
+      copy.className = "copy";
+      copy.type = "button";
+      copy.title = "Copy";
+      copy.textContent = "⧉";
+      copy.addEventListener("click", () => copyText(s.c, copy, "⧉"));
+      block.appendChild(code);
+      block.appendChild(copy);
+      li.appendChild(title);
+      li.appendChild(block);
+      ol.appendChild(li);
+    });
+
+    const agentPrompt =
+      `Read and help maintain this Trackio experiment logbook ("${MANIFEST.title}").\n\n` +
+      "1. If you don't have Trackio, install it:  uv tool install trackio\n" +
+      "2. Add the Trackio skill for your agent:   trackio skills add   (then reload)\n" +
+      `3. Connect to this logbook:                trackio logbook open ${space}\n\n` +
+      "Start with `trackio logbook read`; use `trackio logbook read page \"...\"` " +
+      "for a page-level view, then fetch relevant details with " +
+      "`trackio logbook read cell cell_<id>`. If I've given you " +
+      'write access to the Space, add findings with `trackio logbook cell markdown "..." ' +
+      '--page "..."` and they will sync back automatically.';
+
+    const foot = document.getElementById("sidebar-foot");
+    foot.hidden = false;
+    const modal = document.getElementById("modal");
+    const open = () => (modal.hidden = false);
+    const close = () => (modal.hidden = true);
+    document.getElementById("connect-btn").addEventListener("click", open);
+    document.getElementById("modal-close").addEventListener("click", close);
+    modal.querySelector(".modal-backdrop").addEventListener("click", close);
+    document.addEventListener("keydown", (e) => {
+      if (e.key === "Escape") close();
+    });
+    const agentBtn = document.getElementById("copy-agent");
+    agentBtn.addEventListener("click", () =>
+      copyText(agentPrompt, agentBtn, "Copy for agent")
+    );
+  }
+
+  function copyText(text, btn, restore) {
+    const done = () => {
+      const prev = btn.textContent;
+      btn.textContent = restore === "⧉" ? "✓" : "Copied!";
+      btn.classList.add("copied");
+      setTimeout(() => {
+        btn.textContent = restore;
+        btn.classList.remove("copied");
+      }, 1400);
+      void prev;
+    };
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+      navigator.clipboard.writeText(text).then(done, done);
+    } else {
+      const ta = document.createElement("textarea");
+      ta.value = text;
+      document.body.appendChild(ta);
+      ta.select();
+      try {
+        document.execCommand("copy");
+      } catch (e) {}
+      document.body.removeChild(ta);
+      done();
+    }
+  }
+
+  async function init() {
+    MANIFEST = await fetchManifest();
+    document.title = MANIFEST.title + " · Trackio Logbook";
+    document.getElementById("book-title").textContent = MANIFEST.title;
+    document.getElementById("book-head").setAttribute("aria-label", MANIFEST.title);
+    document.getElementById("book-head").addEventListener("click", () => {
+      const target = "#/" + MANIFEST.root.slug;
+      if (location.hash === target) scrollToHash();
+      else location.hash = target;
+    });
+    buildTree();
+    setupConnect();
+    setupResourceHover();
+    setupFigureNavigation();
+    window.addEventListener("hashchange", () => scrollToHash());
+    window.addEventListener("scroll", updateActiveSection, { passive: true });
+    await renderLogbook();
+    startLiveReload();
+  }
+
+  init();
+})();

logbook.json

@@ -0,0 +1,65 @@
+{
+  "schema_version": 1,
+  "title": "Reproduction: Networked Information Aggregation for Binary Classification",
+  "emoji": "🎯",
+  "space_id": "ProCreations/repro-networked-information-aggregation-for-binary-classification",
+  "paper": {
+    "arxiv_id": "2605.01082"
+  },
+  "tags": [
+    "icml2026-repro",
+    "paper-mrtg4NmvAe"
+  ],
+  "updated_at": "2026-07-22T10:28:07+00:00",
+  "root": {
+    "slug": "index",
+    "title": "Reproduction: Networked Information Aggregation for Binary Classification",
+    "file": "pages/index.md",
+    "children": [
+      {
+        "slug": "executive-summary",
+        "title": "Executive summary",
+        "file": "pages/executive-summary/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-1-depth-upper-bound",
+        "title": "Claim 1: Depth upper bound",
+        "file": "pages/claim-1-depth-upper-bound/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-2-depth-lower-bound",
+        "title": "Claim 2: Depth lower bound",
+        "file": "pages/claim-2-depth-lower-bound/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-3-residual-orthogonality",
+        "title": "Claim 3: Residual orthogonality",
+        "file": "pages/claim-3-residual-orthogonality/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-4-bce-kl-decomposition",
+        "title": "Claim 4: BCE/KL decomposition",
+        "file": "pages/claim-4-bce-kl-decomposition/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-5-logit-passing-protocol",
+        "title": "Claim 5: Logit-passing protocol",
+        "file": "pages/claim-5-logit-passing-protocol/page.md",
+        "children": []
+      },
+      {
+        "slug": "conclusion",
+        "title": "Conclusion",
+        "file": "pages/conclusion/page.md",
+        "children": []
+      }
+    ]
+  },
+  "agent_view_tokens": 1400,
+  "revision": "1784716087001863000"
+}

official_claims.json

@@ -0,0 +1,7 @@
+[
+  "Theorem 3.7 proves an upper bound on excess risk of B_p* * B_X * M/sqrt(D) under an M-coverage condition on depth-D DAGs, extending networked information aggregation from squared loss to Binary Cross-Entropy-based binary classification (Theorem 3.7).",
+  "Theorem 4.5 proves a matching lower bound showing instances with excess loss of at least Omega(k/D), where k is feature dimension and D is path depth, establishing network depth as a necessary bottleneck (Theorem 4.5).",
+  "Lemma 3.1 establishes an orthogonality property of Binary Cross-Entropy residuals, E[x(p*(x)-y)] = 0, replacing the variance-decomposition tools used in prior squared-loss analyses (Lemma 3.1).",
+  "Lemma 3.3 provides a KL/Bregman-type loss decomposition L(q) = L(p*) + D(p*||q), used with Pinsker-style bounds to connect BCE progress to prediction error (Lemma 3.3).",
+  "The protocol models a sequential DAG in which each agent observes only a subset of features, receives parent logits (not probabilities), and locally minimizes Binary Cross-Entropy before passing its own logits downstream (Section 2)."
+]

outputs/depth_formula_audit.csv

@@ -0,0 +1,73 @@
+B_p_star,B_X,M,D,upper_bound,D_times_four_bound_ratio
+0.5,0.5,2,4,0.25,0.5
+0.5,0.5,2,16,0.125,0.5
+0.5,0.5,2,64,0.0625,0.5
+0.5,0.5,2,256,0.03125,0.5
+0.5,0.5,4,16,0.25,0.5
+0.5,0.5,4,64,0.125,0.5
+0.5,0.5,4,256,0.0625,0.5
+0.5,0.5,4,1024,0.03125,0.5
+0.5,0.5,8,64,0.25,0.5
+0.5,0.5,8,256,0.125,0.5
+0.5,0.5,8,1024,0.0625,0.5
+0.5,0.5,8,4096,0.03125,0.5
+0.5,1.5,2,4,0.75,0.5
+0.5,1.5,2,16,0.375,0.5
+0.5,1.5,2,64,0.1875,0.5
+0.5,1.5,2,256,0.09375,0.5
+0.5,1.5,4,16,0.75,0.5
+0.5,1.5,4,64,0.375,0.5
+0.5,1.5,4,256,0.1875,0.5
+0.5,1.5,4,1024,0.09375,0.5
+0.5,1.5,8,64,0.75,0.5
+0.5,1.5,8,256,0.375,0.5
+0.5,1.5,8,1024,0.1875,0.5
+0.5,1.5,8,4096,0.09375,0.5
+1.0,0.5,2,4,0.5,0.5
+1.0,0.5,2,16,0.25,0.5
+1.0,0.5,2,64,0.125,0.5
+1.0,0.5,2,256,0.0625,0.5
+1.0,0.5,4,16,0.5,0.5
+1.0,0.5,4,64,0.25,0.5
+1.0,0.5,4,256,0.125,0.5
+1.0,0.5,4,1024,0.0625,0.5
+1.0,0.5,8,64,0.5,0.5
+1.0,0.5,8,256,0.25,0.5
+1.0,0.5,8,1024,0.125,0.5
+1.0,0.5,8,4096,0.0625,0.5
+1.0,1.5,2,4,1.5,0.5
+1.0,1.5,2,16,0.75,0.5
+1.0,1.5,2,64,0.375,0.5
+1.0,1.5,2,256,0.1875,0.5
+1.0,1.5,4,16,1.5,0.5
+1.0,1.5,4,64,0.75,0.5
+1.0,1.5,4,256,0.375,0.5
+1.0,1.5,4,1024,0.1875,0.5
+1.0,1.5,8,64,1.5,0.5
+1.0,1.5,8,256,0.75,0.5
+1.0,1.5,8,1024,0.375,0.5
+1.0,1.5,8,4096,0.1875,0.5
+2.0,0.5,2,4,1.0,0.5
+2.0,0.5,2,16,0.5,0.5
+2.0,0.5,2,64,0.25,0.5
+2.0,0.5,2,256,0.125,0.5
+2.0,0.5,4,16,1.0,0.5
+2.0,0.5,4,64,0.5,0.5
+2.0,0.5,4,256,0.25,0.5
+2.0,0.5,4,1024,0.125,0.5
+2.0,0.5,8,64,1.0,0.5
+2.0,0.5,8,256,0.5,0.5
+2.0,0.5,8,1024,0.25,0.5
+2.0,0.5,8,4096,0.125,0.5
+2.0,1.5,2,4,3.0,0.5
+2.0,1.5,2,16,1.5,0.5
+2.0,1.5,2,64,0.75,0.5
+2.0,1.5,2,256,0.375,0.5
+2.0,1.5,4,16,3.0,0.5
+2.0,1.5,4,64,1.5,0.5
+2.0,1.5,4,256,0.75,0.5
+2.0,1.5,4,1024,0.375,0.5
+2.0,1.5,8,64,3.0,0.5
+2.0,1.5,8,256,1.5,0.5
+2.0,1.5,8,1024,0.75,0.5
+2.0,1.5,8,4096,0.375,0.5

outputs/gaussian_lower_bound_audit.csv

@@ -0,0 +1,57 @@
+k,passes_p,D,optimal_coefficient_c,excess_bce,k_over_D,scaled_excess_D_over_k,zero_noise_control_excess,coefficient_in_open_unit_interval
+4,1,4,0.452001306649,0.049078635566,1.0,0.049078635566,0.0,True
+4,2,8,0.622369338629,0.033261836901,0.5,0.066523673802,0.0,True
+4,3,12,0.711885741399,0.025157840993,0.333333333333,0.075473522978,0.0,True
+8,1,8,0.452001306649,0.049078635566,1.0,0.049078635566,0.0,True
+8,2,16,0.622369338629,0.033261836901,0.5,0.066523673802,0.0,True
+8,3,24,0.711885741399,0.025157840993,0.333333333333,0.075473522978,0.0,True
+8,4,32,0.767082976873,0.020229940119,0.25,0.080919760476,0.0,True
+8,5,40,0.804526570071,0.016916655917,0.2,0.084583279584,0.0,True
+8,6,48,0.831596672169,0.014536064145,0.166666666667,0.087216384871,0.0,True
+8,7,56,0.852080201043,0.012742892325,0.142857142857,0.089200246272,0.0,True
+16,1,16,0.452001306649,0.049078635566,1.0,0.049078635566,0.0,True
+16,2,32,0.622369338629,0.033261836901,0.5,0.066523673802,0.0,True
+16,3,48,0.711885741399,0.025157840993,0.333333333333,0.075473522978,0.0,True
+16,4,64,0.767082976873,0.020229940119,0.25,0.080919760476,0.0,True
+16,5,80,0.804526570071,0.016916655917,0.2,0.084583279584,0.0,True
+16,6,96,0.831596672169,0.014536064145,0.166666666667,0.087216384871,0.0,True
+16,7,112,0.852080201043,0.012742892325,0.142857142857,0.089200246272,0.0,True
+16,8,128,0.868120595068,0.011343581712,0.125,0.090748653698,0.0,True
+16,9,144,0.881022187615,0.010221201075,0.111111111111,0.091990809671,0.0,True
+16,10,160,0.891624244283,0.009300940043,0.1,0.093009400432,0.0,True
+16,11,176,0.90049128941,0.008532709285,0.090909090909,0.093859802136,0.0,True
+16,12,192,0.908017031089,0.007881708039,0.083333333333,0.094580496464,0.0,True
+16,13,208,0.914484428413,0.007323004392,0.076923076923,0.095199057091,0.0,True
+16,14,224,0.920102076166,0.006838268501,0.071428571429,0.095735759013,0.0,True
+16,15,240,0.925027129125,0.00641372291,0.066666666667,0.096205843647,0.0,True
+32,1,32,0.452001306649,0.049078635566,1.0,0.049078635566,0.0,True
+32,2,64,0.622369338629,0.033261836901,0.5,0.066523673802,0.0,True
+32,3,96,0.711885741399,0.025157840993,0.333333333333,0.075473522978,0.0,True
+32,4,128,0.767082976873,0.020229940119,0.25,0.080919760476,0.0,True
+32,5,160,0.804526570071,0.016916655917,0.2,0.084583279584,0.0,True
+32,6,192,0.831596672169,0.014536064145,0.166666666667,0.087216384871,0.0,True
+32,7,224,0.852080201043,0.012742892325,0.142857142857,0.089200246272,0.0,True
+32,8,256,0.868120595068,0.011343581712,0.125,0.090748653698,0.0,True
+32,9,288,0.881022187615,0.010221201075,0.111111111111,0.091990809671,0.0,True
+32,10,320,0.891624244283,0.009300940043,0.1,0.093009400432,0.0,True
+32,11,352,0.90049128941,0.008532709285,0.090909090909,0.093859802136,0.0,True
+32,12,384,0.908017031089,0.007881708039,0.083333333333,0.094580496464,0.0,True
+32,13,416,0.914484428413,0.007323004392,0.076923076923,0.095199057091,0.0,True
+32,14,448,0.920102076166,0.006838268501,0.071428571429,0.095735759013,0.0,True
+32,15,480,0.925027129125,0.00641372291,0.066666666667,0.096205843647,0.0,True
+32,16,512,0.929380238317,0.006038811854,0.0625,0.096620989667,0.0,True
+32,17,544,0.933255568448,0.005705311562,0.058823529412,0.096990296549,0.0,True
+32,18,576,0.936727688079,0.005406719964,0.055555555556,0.097320959347,0.0,True
+32,19,608,0.939856415222,0.005137828534,0.052631578947,0.097618742145,0.0,True
+32,20,640,0.942690292843,0.004894415848,0.05,0.097888316958,0.0,True
+32,21,672,0.945269125894,0.004673024317,0.047619047619,0.098133510667,0.0,True
+32,22,704,0.947625862799,0.004470794903,0.045454545455,0.098357487857,0.0,True
+32,23,736,0.949788010849,0.004285342963,0.04347826087,0.098562888146,0.0,True
+32,24,768,0.951778714879,0.00411466378,0.041666666667,0.098751930715,0.0,True
+32,25,800,0.953617589118,0.003957059792,0.04,0.098926494804,0.0,True
+32,26,832,0.955321365682,0.003811083939,0.038461538462,0.099088182411,0.0,True
+32,27,864,0.956904405197,0.003675495096,0.037037037037,0.099238367596,0.0,True
+32,28,896,0.95837910257,0.003549222701,0.035714285714,0.099378235629,0.0,True
+32,29,928,0.959756212207,0.003431338426,0.034482758621,0.09950881434,0.0,True
+32,30,960,0.961045110731,0.003321033314,0.033333333333,0.099630999417,0.0,True
+32,31,992,0.962254010773,0.003217599193,0.032258064516,0.099745574981,0.0,True

outputs/network_protocol_audit.csv

@@ -0,0 +1,49 @@
+dimension,trial,D,M,M_coverage,B_p_star,B_X,theorem_upper_bound,logit_final_excess_bce,probability_control_excess_bce,all_logit_losses_nonincreasing,upper_bound_certificate,probability_control_worse
+3,0,3,3,True,1.091460616837,1.0,1.890465242823,5.26e-10,7.2951e-08,True,True,True
+3,0,6,3,True,1.091460616837,1.0,1.336760792797,3e-12,0.000341074969,True,True,True
+3,0,12,3,True,1.091460616837,1.0,0.945232621411,0.0,0.001660024026,True,True,True
+3,0,24,3,True,1.091460616837,1.0,0.668380396399,0.0,0.00232631364,True,True,True
+3,1,3,3,True,1.829920095331,1.0,3.169514578905,5.96764e-07,1.5892294e-05,True,True,True
+3,1,6,3,True,1.829920095331,1.0,2.241185251813,3.889e-09,0.003702241885,True,True,True
+3,1,12,3,True,1.829920095331,1.0,1.584757289452,0.0,0.00798032755,True,True,True
+3,1,24,3,True,1.829920095331,1.0,1.120592625907,0.0,0.008256585251,True,True,True
+3,2,3,3,True,1.823094348708,1.0,3.157692038954,4.95634e-07,2.9569555e-05,True,True,True
+3,2,6,3,True,1.823094348708,1.0,2.232825453643,4.229e-09,0.003911454119,True,True,True
+3,2,12,3,True,1.823094348708,1.0,1.578846019477,0.0,0.00818085715,True,True,True
+3,2,24,3,True,1.823094348708,1.0,1.116412726821,-0.0,0.00842462407,True,True,True
+3,3,3,3,True,1.557006316775,1.0,2.696814048359,7.225e-09,1.13947e-07,True,True,True
+3,3,6,3,True,1.557006316775,1.0,1.906935501194,3e-11,0.001688292841,True,True,True
+3,3,12,3,True,1.557006316775,1.0,1.34840702418,0.0,0.004726584127,True,True,True
+3,3,24,3,True,1.557006316775,1.0,0.953467750597,0.0,0.005092186189,True,True,True
+4,0,4,4,True,1.640918196777,1.0,3.281836393554,5.6234e-08,5.4057222e-05,True,True,True
+4,0,8,4,True,1.640918196777,1.0,2.320608768627,3.98e-10,0.002351889291,True,True,True
+4,0,16,4,True,1.640918196777,1.0,1.640918196777,0.0,0.005586105956,True,True,True
+4,0,32,4,True,1.640918196777,1.0,1.160304384313,0.0,0.00612815868,True,True,True
+4,1,4,4,True,1.847447387351,1.0,3.694894774703,6.077e-08,8.593969e-05,True,True,True
+4,1,8,4,True,1.847447387351,1.0,2.612685150963,4.74e-10,0.003880201214,True,True,True
+4,1,16,4,True,1.847447387351,1.0,1.847447387351,0.0,0.007786960967,True,True,True
+4,1,32,4,True,1.847447387351,1.0,1.306342575482,-0.0,0.008377402037,True,True,True
+4,2,4,4,True,2.112896501672,1.0,4.225793003344,1.6385e-08,0.000539786466,True,True,True
+4,2,8,4,True,2.112896501672,1.0,2.988086888555,9.3e-11,0.00686662151,True,True,True
+4,2,16,4,True,2.112896501672,1.0,2.112896501672,0.0,0.01045679728,True,True,True
+4,2,32,4,True,2.112896501672,1.0,1.494043444277,0.0,0.010657526658,True,True,True
+4,3,4,4,True,1.670857371186,1.0,3.341714742372,4.442e-09,0.00021303184,True,True,True
+4,3,8,4,True,1.670857371186,1.0,2.362949155122,1.5e-11,0.003423698247,True,True,True
+4,3,16,4,True,1.670857371186,1.0,1.670857371186,0.0,0.006769257264,True,True,True
+4,3,32,4,True,1.670857371186,1.0,1.181474577561,0.0,0.007137793931,True,True,True
+5,0,5,5,True,3.114374171952,1.0,6.963952355853,2.8756e-07,0.001384474922,True,True,True
+5,0,10,5,True,3.114374171952,1.0,4.924257934684,2.282e-09,0.014557023823,True,True,True
+5,0,20,5,True,3.114374171952,1.0,3.481976177927,0.0,0.020981078283,True,True,True
+5,0,40,5,True,3.114374171952,1.0,2.462128967342,0.0,0.021473439098,True,True,True
+5,1,5,5,True,2.045531556852,1.0,4.573947611242,1.15401e-07,0.000362650185,True,True,True
+5,1,10,5,True,2.045531556852,1.0,3.234269372701,9.28e-10,0.005443489233,True,True,True
+5,1,20,5,True,2.045531556852,1.0,2.286973805621,0.0,0.010457249607,True,True,True
+5,1,40,5,True,2.045531556852,1.0,1.617134686351,0.0,0.011420451294,True,True,True
+5,2,5,5,True,2.455590106114,1.0,5.490866402146,1.1162e-08,0.00072522127,True,True,True
+5,2,10,5,True,2.455590106114,1.0,3.882628867547,1.34e-10,0.009158279431,True,True,True
+5,2,20,5,True,2.455590106114,1.0,2.745433201073,0.0,0.014243461527,True,True,True
+5,2,40,5,True,2.455590106114,1.0,1.941314433773,0.0,0.014496013881,True,True,True
+5,3,5,5,True,2.323175338576,1.0,5.194777980708,1.70576e-07,0.000606720343,True,True,True
+5,3,10,5,True,2.323175338576,1.0,3.673262736917,1.207e-09,0.006959411103,True,True,True
+5,3,20,5,True,2.323175338576,1.0,2.597388990354,0.0,0.013097454948,True,True,True
+5,3,40,5,True,2.323175338576,1.0,1.836631368458,0.0,0.014732879402,True,True,True

outputs/orthogonality_decomposition_audit.csv

@@ -0,0 +1,25 @@
+seed,dimension,used_features,support_points,maximum_orthogonality_residual,loss_star,loss_q,kl_pstar_q,decomposition_gap,pinsker_rhs,pinsker_certificate,nonoptimal_reference_control_gap
+0,3,2,8,0.0,0.686473298406,0.783695922155,0.09722262375,-0.0,0.078553220216,True,0.043499052401
+1,4,3,16,0.0,0.598417320382,0.645270541438,0.046853221056,-0.0,0.037869368551,True,0.012030249774
+2,5,4,32,0.0,0.65719040498,0.732528348289,0.075337943309,-0.0,0.050318641751,True,0.030823019361
+3,6,5,64,0.0,0.642820613088,0.751737913087,0.108917299999,0.0,0.089207272944,True,0.02994685481
+4,3,2,8,0.0,0.666305076982,0.785501514963,0.11919643798,0.0,0.103716252989,True,0.039576315056
+5,4,4,16,0.0,0.572899722887,0.670614857037,0.09771513415,-0.0,0.085777279588,True,0.028243904413
+6,5,4,32,0.0,0.628625482902,0.698615804061,0.069990321159,-0.0,0.04965387929,True,0.022381623143
+7,6,4,64,0.0,0.545986204592,0.565500817676,0.019514613084,-0.0,0.015842513809,True,-0.00260924578
+8,3,2,8,0.0,0.620964234687,0.649458834726,0.028494600039,0.0,0.018734196272,True,0.010040348448
+9,4,2,16,0.0,0.655565825095,0.666111830149,0.010546005054,-0.0,0.010155075049,True,-0.00514674705
+10,5,4,32,0.0,0.584812151693,0.614510101767,0.029697950074,-0.0,0.024764631512,True,-0.003567374242
+11,6,3,64,0.0,0.66200766098,0.698189146123,0.036181485143,-0.0,0.031915339102,True,0.000971076055
+12,3,2,8,0.0,0.602723978336,0.721271512227,0.118547533891,0.0,0.066592620766,True,0.051776915525
+13,4,3,16,0.0,0.65107027566,0.673356766475,0.022286490815,-0.0,0.019903551755,True,0.003404751896
+14,5,4,32,0.0,0.525472849344,0.551553308477,0.026080459133,-0.0,0.021018260354,True,0.0032901328
+15,6,2,64,0.0,0.668516307378,0.671535464329,0.003019156951,0.0,0.002597076841,True,-0.012991449925
+16,3,2,8,0.0,0.637714405232,0.678704225479,0.040989820247,-0.0,0.031358671887,True,0.015777164811
+17,4,4,16,0.0,0.633729576273,0.642950329009,0.009220752736,-0.0,0.008175981856,True,-0.019199584657
+18,5,4,32,0.0,0.673727994983,0.876445857306,0.202717862323,0.0,0.136648306688,True,0.072911731861
+19,6,6,64,0.0,0.504767024972,0.565232093929,0.060465068957,0.0,0.047165181757,True,0.013421062862
+20,3,2,8,0.0,0.664723092217,0.713317519622,0.048594427405,0.0,0.038634049595,True,0.010233294903
+21,4,2,16,0.0,0.619462297857,0.62298409835,0.003521800494,0.0,0.003279155634,True,-0.024450730295
+22,5,4,32,0.0,0.632812381238,0.652679684102,0.019867302864,0.0,0.019213874869,True,-0.01243895153
+23,6,5,64,0.0,0.630455413033,0.65939460964,0.028939196608,0.0,0.02272574564,True,-0.005756255758

outputs/results.json

@@ -0,0 +1,75 @@
+{
+  "claims": [
+    "Theorem 3.7 proves an upper bound on excess risk of B_p* * B_X * M/sqrt(D) under an M-coverage condition on depth-D DAGs, extending networked information aggregation from squared loss to Binary Cross-Entropy-based binary classification (Theorem 3.7).",
+    "Theorem 4.5 proves a matching lower bound showing instances with excess loss of at least Omega(k/D), where k is feature dimension and D is path depth, establishing network depth as a necessary bottleneck (Theorem 4.5).",
+    "Lemma 3.1 establishes an orthogonality property of Binary Cross-Entropy residuals, E[x(p*(x)-y)] = 0, replacing the variance-decomposition tools used in prior squared-loss analyses (Lemma 3.1).",
+    "Lemma 3.3 provides a KL/Bregman-type loss decomposition L(q) = L(p*) + D(p*||q), used with Pinsker-style bounds to connect BCE progress to prediction error (Lemma 3.3).",
+    "The protocol models a sequential DAG in which each agent observes only a subset of features, receives parent logits (not probabilities), and locally minimizes Binary Cross-Entropy before passing its own logits downstream (Section 2)."
+  ],
+  "formula_summary": {
+    "all_positive": true,
+    "cells": 72,
+    "depth_exponent_minus_one_half": true
+  },
+  "gates": {
+    "all_logit_losses_nonincreasing": true,
+    "all_m_coverage": true,
+    "all_pinsker_certificates": true,
+    "all_upper_bound_certificates": true,
+    "bce_kl_decomposition_exact": true,
+    "five_exact_claims_present": true,
+    "formula_bounds_positive": true,
+    "formula_panel_complete": true,
+    "lower_bound_coefficients_valid": true,
+    "lower_bound_excess_positive": true,
+    "lower_bound_panel_complete": true,
+    "lower_bound_scaled_constant_positive": true,
+    "nonoptimal_reference_control_fails": true,
+    "orthogonality_panel_complete": true,
+    "orthogonality_residual_small": true,
+    "positive_probability_control_gap": true,
+    "probability_passing_control_worse": true,
+    "protocol_panel_complete": true,
+    "source_archive_pin": true,
+    "source_pdf_pin": true,
+    "source_scope_rows_complete": true,
+    "upper_depth_exponent_minus_one_half": true
+  },
+  "lower_bound_summary": {
+    "all_coefficients_in_open_unit_interval": true,
+    "all_excess_positive": true,
+    "cells": 56,
+    "maximum_scaled_excess_D_over_k": 0.099745574981,
+    "minimum_scaled_excess_D_over_k": 0.049078635566
+  },
+  "orthogonality_summary": {
+    "all_pinsker_certificates": true,
+    "cells": 24,
+    "maximum_absolute_decomposition_gap": 0.0,
+    "maximum_orthogonality_residual": 0.0,
+    "nonoptimal_reference_counterexamples": 24
+  },
+  "paper": {
+    "arxiv": "2605.01082v1",
+    "openreview_id": "mrtg4NmvAe",
+    "title": "Networked Information Aggregation for Binary Classification"
+  },
+  "passed": true,
+  "protocol_summary": {
+    "all_logit_losses_nonincreasing": true,
+    "all_m_coverage": true,
+    "all_upper_bound_certificates": true,
+    "cells": 48,
+    "mean_probability_control_excess_gap": 0.00618226885,
+    "probability_control_worse_cells": 48
+  },
+  "scientific_scope": {
+    "decomposition": "The BCE/KL identity requires the optimal same-feature-space logistic reference.",
+    "matching": "The source uses matching for the depth bottleneck; upper and lower exponents are not identical.",
+    "protocol": "The source transmits logits rather than probabilities."
+  },
+  "source_checks": {
+    "pdf_sha256": "ca7263e8fd591b27cbd3f869d93ffe1818af27baaa439f278a27a5248ddd92b7",
+    "source_sha256": "d17612d6f31795fe581812dd7e20bf00ce5fabc7408e61411b439232b9917417"
+  }
+}

outputs/source_claim_audit.csv

@@ -0,0 +1,6 @@
+claim,anchor,verdict,scope
+1,Theorem 3.7 / thm:convergence,supported_with_assumptions,"Requires a depth-D path satisfying M-coverage, bounded second moments, and bounded global-logit l1 coefficients."
+2,Theorem 4.5 / Lower Bound on Convergence,supported_with_scope,"The construction has D=kp and p<=k-1; matching refers to the network-depth bottleneck, not identical upper/lower exponents."
+3,Lemma 3.1 / lem:orthogonality,supported,First-order optimality for the optimal logistic predictor on its feature space.
+4,Lemma 3.3 / lem:pythagorean,supported_with_scope,Both p* and q are logistic predictors on the same feature set and p* is the optimizer.
+5,Section 2 / Sequential Learning Protocol,supported,"Agents pass logits, not probabilities, in a topological order."

packaged_replay/depth_formula_audit.csv

@@ -0,0 +1,73 @@
+B_p_star,B_X,M,D,upper_bound,D_times_four_bound_ratio
+0.5,0.5,2,4,0.25,0.5
+0.5,0.5,2,16,0.125,0.5
+0.5,0.5,2,64,0.0625,0.5
+0.5,0.5,2,256,0.03125,0.5
+0.5,0.5,4,16,0.25,0.5
+0.5,0.5,4,64,0.125,0.5
+0.5,0.5,4,256,0.0625,0.5
+0.5,0.5,4,1024,0.03125,0.5
+0.5,0.5,8,64,0.25,0.5
+0.5,0.5,8,256,0.125,0.5
+0.5,0.5,8,1024,0.0625,0.5
+0.5,0.5,8,4096,0.03125,0.5
+0.5,1.5,2,4,0.75,0.5
+0.5,1.5,2,16,0.375,0.5
+0.5,1.5,2,64,0.1875,0.5
+0.5,1.5,2,256,0.09375,0.5
+0.5,1.5,4,16,0.75,0.5
+0.5,1.5,4,64,0.375,0.5
+0.5,1.5,4,256,0.1875,0.5
+0.5,1.5,4,1024,0.09375,0.5
+0.5,1.5,8,64,0.75,0.5
+0.5,1.5,8,256,0.375,0.5
+0.5,1.5,8,1024,0.1875,0.5
+0.5,1.5,8,4096,0.09375,0.5
+1.0,0.5,2,4,0.5,0.5
+1.0,0.5,2,16,0.25,0.5
+1.0,0.5,2,64,0.125,0.5
+1.0,0.5,2,256,0.0625,0.5
+1.0,0.5,4,16,0.5,0.5
+1.0,0.5,4,64,0.25,0.5
+1.0,0.5,4,256,0.125,0.5
+1.0,0.5,4,1024,0.0625,0.5
+1.0,0.5,8,64,0.5,0.5
+1.0,0.5,8,256,0.25,0.5
+1.0,0.5,8,1024,0.125,0.5
+1.0,0.5,8,4096,0.0625,0.5
+1.0,1.5,2,4,1.5,0.5
+1.0,1.5,2,16,0.75,0.5
+1.0,1.5,2,64,0.375,0.5
+1.0,1.5,2,256,0.1875,0.5
+1.0,1.5,4,16,1.5,0.5
+1.0,1.5,4,64,0.75,0.5
+1.0,1.5,4,256,0.375,0.5
+1.0,1.5,4,1024,0.1875,0.5
+1.0,1.5,8,64,1.5,0.5
+1.0,1.5,8,256,0.75,0.5
+1.0,1.5,8,1024,0.375,0.5
+1.0,1.5,8,4096,0.1875,0.5
+2.0,0.5,2,4,1.0,0.5
+2.0,0.5,2,16,0.5,0.5
+2.0,0.5,2,64,0.25,0.5
+2.0,0.5,2,256,0.125,0.5
+2.0,0.5,4,16,1.0,0.5
+2.0,0.5,4,64,0.5,0.5
+2.0,0.5,4,256,0.25,0.5
+2.0,0.5,4,1024,0.125,0.5
+2.0,0.5,8,64,1.0,0.5
+2.0,0.5,8,256,0.5,0.5
+2.0,0.5,8,1024,0.25,0.5
+2.0,0.5,8,4096,0.125,0.5
+2.0,1.5,2,4,3.0,0.5
+2.0,1.5,2,16,1.5,0.5
+2.0,1.5,2,64,0.75,0.5
+2.0,1.5,2,256,0.375,0.5
+2.0,1.5,4,16,3.0,0.5
+2.0,1.5,4,64,1.5,0.5
+2.0,1.5,4,256,0.75,0.5
+2.0,1.5,4,1024,0.375,0.5
+2.0,1.5,8,64,3.0,0.5
+2.0,1.5,8,256,1.5,0.5
+2.0,1.5,8,1024,0.75,0.5
+2.0,1.5,8,4096,0.375,0.5

packaged_replay/gaussian_lower_bound_audit.csv

@@ -0,0 +1,57 @@
+k,passes_p,D,optimal_coefficient_c,excess_bce,k_over_D,scaled_excess_D_over_k,zero_noise_control_excess,coefficient_in_open_unit_interval
+4,1,4,0.452001306649,0.049078635566,1.0,0.049078635566,0.0,True
+4,2,8,0.622369338629,0.033261836901,0.5,0.066523673802,0.0,True
+4,3,12,0.711885741399,0.025157840993,0.333333333333,0.075473522978,0.0,True
+8,1,8,0.452001306649,0.049078635566,1.0,0.049078635566,0.0,True
+8,2,16,0.622369338629,0.033261836901,0.5,0.066523673802,0.0,True
+8,3,24,0.711885741399,0.025157840993,0.333333333333,0.075473522978,0.0,True
+8,4,32,0.767082976873,0.020229940119,0.25,0.080919760476,0.0,True
+8,5,40,0.804526570071,0.016916655917,0.2,0.084583279584,0.0,True
+8,6,48,0.831596672169,0.014536064145,0.166666666667,0.087216384871,0.0,True
+8,7,56,0.852080201043,0.012742892325,0.142857142857,0.089200246272,0.0,True
+16,1,16,0.452001306649,0.049078635566,1.0,0.049078635566,0.0,True
+16,2,32,0.622369338629,0.033261836901,0.5,0.066523673802,0.0,True
+16,3,48,0.711885741399,0.025157840993,0.333333333333,0.075473522978,0.0,True
+16,4,64,0.767082976873,0.020229940119,0.25,0.080919760476,0.0,True
+16,5,80,0.804526570071,0.016916655917,0.2,0.084583279584,0.0,True
+16,6,96,0.831596672169,0.014536064145,0.166666666667,0.087216384871,0.0,True
+16,7,112,0.852080201043,0.012742892325,0.142857142857,0.089200246272,0.0,True
+16,8,128,0.868120595068,0.011343581712,0.125,0.090748653698,0.0,True
+16,9,144,0.881022187615,0.010221201075,0.111111111111,0.091990809671,0.0,True
+16,10,160,0.891624244283,0.009300940043,0.1,0.093009400432,0.0,True
+16,11,176,0.90049128941,0.008532709285,0.090909090909,0.093859802136,0.0,True
+16,12,192,0.908017031089,0.007881708039,0.083333333333,0.094580496464,0.0,True
+16,13,208,0.914484428413,0.007323004392,0.076923076923,0.095199057091,0.0,True
+16,14,224,0.920102076166,0.006838268501,0.071428571429,0.095735759013,0.0,True
+16,15,240,0.925027129125,0.00641372291,0.066666666667,0.096205843647,0.0,True
+32,1,32,0.452001306649,0.049078635566,1.0,0.049078635566,0.0,True
+32,2,64,0.622369338629,0.033261836901,0.5,0.066523673802,0.0,True
+32,3,96,0.711885741399,0.025157840993,0.333333333333,0.075473522978,0.0,True
+32,4,128,0.767082976873,0.020229940119,0.25,0.080919760476,0.0,True
+32,5,160,0.804526570071,0.016916655917,0.2,0.084583279584,0.0,True
+32,6,192,0.831596672169,0.014536064145,0.166666666667,0.087216384871,0.0,True
+32,7,224,0.852080201043,0.012742892325,0.142857142857,0.089200246272,0.0,True
+32,8,256,0.868120595068,0.011343581712,0.125,0.090748653698,0.0,True
+32,9,288,0.881022187615,0.010221201075,0.111111111111,0.091990809671,0.0,True
+32,10,320,0.891624244283,0.009300940043,0.1,0.093009400432,0.0,True
+32,11,352,0.90049128941,0.008532709285,0.090909090909,0.093859802136,0.0,True
+32,12,384,0.908017031089,0.007881708039,0.083333333333,0.094580496464,0.0,True
+32,13,416,0.914484428413,0.007323004392,0.076923076923,0.095199057091,0.0,True
+32,14,448,0.920102076166,0.006838268501,0.071428571429,0.095735759013,0.0,True
+32,15,480,0.925027129125,0.00641372291,0.066666666667,0.096205843647,0.0,True
+32,16,512,0.929380238317,0.006038811854,0.0625,0.096620989667,0.0,True
+32,17,544,0.933255568448,0.005705311562,0.058823529412,0.096990296549,0.0,True
+32,18,576,0.936727688079,0.005406719964,0.055555555556,0.097320959347,0.0,True
+32,19,608,0.939856415222,0.005137828534,0.052631578947,0.097618742145,0.0,True
+32,20,640,0.942690292843,0.004894415848,0.05,0.097888316958,0.0,True
+32,21,672,0.945269125894,0.004673024317,0.047619047619,0.098133510667,0.0,True
+32,22,704,0.947625862799,0.004470794903,0.045454545455,0.098357487857,0.0,True
+32,23,736,0.949788010849,0.004285342963,0.04347826087,0.098562888146,0.0,True
+32,24,768,0.951778714879,0.00411466378,0.041666666667,0.098751930715,0.0,True
+32,25,800,0.953617589118,0.003957059792,0.04,0.098926494804,0.0,True
+32,26,832,0.955321365682,0.003811083939,0.038461538462,0.099088182411,0.0,True
+32,27,864,0.956904405197,0.003675495096,0.037037037037,0.099238367596,0.0,True
+32,28,896,0.95837910257,0.003549222701,0.035714285714,0.099378235629,0.0,True
+32,29,928,0.959756212207,0.003431338426,0.034482758621,0.09950881434,0.0,True
+32,30,960,0.961045110731,0.003321033314,0.033333333333,0.099630999417,0.0,True
+32,31,992,0.962254010773,0.003217599193,0.032258064516,0.099745574981,0.0,True

packaged_replay/network_protocol_audit.csv

@@ -0,0 +1,49 @@
+dimension,trial,D,M,M_coverage,B_p_star,B_X,theorem_upper_bound,logit_final_excess_bce,probability_control_excess_bce,all_logit_losses_nonincreasing,upper_bound_certificate,probability_control_worse
+3,0,3,3,True,1.091460616837,1.0,1.890465242823,5.26e-10,7.2951e-08,True,True,True
+3,0,6,3,True,1.091460616837,1.0,1.336760792797,3e-12,0.000341074969,True,True,True
+3,0,12,3,True,1.091460616837,1.0,0.945232621411,0.0,0.001660024026,True,True,True
+3,0,24,3,True,1.091460616837,1.0,0.668380396399,0.0,0.00232631364,True,True,True
+3,1,3,3,True,1.829920095331,1.0,3.169514578905,5.96764e-07,1.5892294e-05,True,True,True
+3,1,6,3,True,1.829920095331,1.0,2.241185251813,3.889e-09,0.003702241885,True,True,True
+3,1,12,3,True,1.829920095331,1.0,1.584757289452,0.0,0.00798032755,True,True,True
+3,1,24,3,True,1.829920095331,1.0,1.120592625907,0.0,0.008256585251,True,True,True
+3,2,3,3,True,1.823094348708,1.0,3.157692038954,4.95634e-07,2.9569555e-05,True,True,True
+3,2,6,3,True,1.823094348708,1.0,2.232825453643,4.229e-09,0.003911454119,True,True,True
+3,2,12,3,True,1.823094348708,1.0,1.578846019477,0.0,0.00818085715,True,True,True
+3,2,24,3,True,1.823094348708,1.0,1.116412726821,-0.0,0.00842462407,True,True,True
+3,3,3,3,True,1.557006316775,1.0,2.696814048359,7.225e-09,1.13947e-07,True,True,True
+3,3,6,3,True,1.557006316775,1.0,1.906935501194,3e-11,0.001688292841,True,True,True
+3,3,12,3,True,1.557006316775,1.0,1.34840702418,0.0,0.004726584127,True,True,True
+3,3,24,3,True,1.557006316775,1.0,0.953467750597,0.0,0.005092186189,True,True,True
+4,0,4,4,True,1.640918196777,1.0,3.281836393554,5.6234e-08,5.4057222e-05,True,True,True
+4,0,8,4,True,1.640918196777,1.0,2.320608768627,3.98e-10,0.002351889291,True,True,True
+4,0,16,4,True,1.640918196777,1.0,1.640918196777,0.0,0.005586105956,True,True,True
+4,0,32,4,True,1.640918196777,1.0,1.160304384313,0.0,0.00612815868,True,True,True
+4,1,4,4,True,1.847447387351,1.0,3.694894774703,6.077e-08,8.593969e-05,True,True,True
+4,1,8,4,True,1.847447387351,1.0,2.612685150963,4.74e-10,0.003880201214,True,True,True
+4,1,16,4,True,1.847447387351,1.0,1.847447387351,0.0,0.007786960967,True,True,True
+4,1,32,4,True,1.847447387351,1.0,1.306342575482,-0.0,0.008377402037,True,True,True
+4,2,4,4,True,2.112896501672,1.0,4.225793003344,1.6385e-08,0.000539786466,True,True,True
+4,2,8,4,True,2.112896501672,1.0,2.988086888555,9.3e-11,0.00686662151,True,True,True
+4,2,16,4,True,2.112896501672,1.0,2.112896501672,0.0,0.01045679728,True,True,True
+4,2,32,4,True,2.112896501672,1.0,1.494043444277,0.0,0.010657526658,True,True,True
+4,3,4,4,True,1.670857371186,1.0,3.341714742372,4.442e-09,0.00021303184,True,True,True
+4,3,8,4,True,1.670857371186,1.0,2.362949155122,1.5e-11,0.003423698247,True,True,True
+4,3,16,4,True,1.670857371186,1.0,1.670857371186,0.0,0.006769257264,True,True,True
+4,3,32,4,True,1.670857371186,1.0,1.181474577561,0.0,0.007137793931,True,True,True
+5,0,5,5,True,3.114374171952,1.0,6.963952355853,2.8756e-07,0.001384474922,True,True,True
+5,0,10,5,True,3.114374171952,1.0,4.924257934684,2.282e-09,0.014557023823,True,True,True
+5,0,20,5,True,3.114374171952,1.0,3.481976177927,0.0,0.020981078283,True,True,True
+5,0,40,5,True,3.114374171952,1.0,2.462128967342,0.0,0.021473439098,True,True,True
+5,1,5,5,True,2.045531556852,1.0,4.573947611242,1.15401e-07,0.000362650185,True,True,True
+5,1,10,5,True,2.045531556852,1.0,3.234269372701,9.28e-10,0.005443489233,True,True,True
+5,1,20,5,True,2.045531556852,1.0,2.286973805621,0.0,0.010457249607,True,True,True
+5,1,40,5,True,2.045531556852,1.0,1.617134686351,0.0,0.011420451294,True,True,True
+5,2,5,5,True,2.455590106114,1.0,5.490866402146,1.1162e-08,0.00072522127,True,True,True
+5,2,10,5,True,2.455590106114,1.0,3.882628867547,1.34e-10,0.009158279431,True,True,True
+5,2,20,5,True,2.455590106114,1.0,2.745433201073,0.0,0.014243461527,True,True,True
+5,2,40,5,True,2.455590106114,1.0,1.941314433773,0.0,0.014496013881,True,True,True
+5,3,5,5,True,2.323175338576,1.0,5.194777980708,1.70576e-07,0.000606720343,True,True,True
+5,3,10,5,True,2.323175338576,1.0,3.673262736917,1.207e-09,0.006959411103,True,True,True
+5,3,20,5,True,2.323175338576,1.0,2.597388990354,0.0,0.013097454948,True,True,True
+5,3,40,5,True,2.323175338576,1.0,1.836631368458,0.0,0.014732879402,True,True,True

packaged_replay/orthogonality_decomposition_audit.csv

@@ -0,0 +1,25 @@
+seed,dimension,used_features,support_points,maximum_orthogonality_residual,loss_star,loss_q,kl_pstar_q,decomposition_gap,pinsker_rhs,pinsker_certificate,nonoptimal_reference_control_gap
+0,3,2,8,0.0,0.686473298406,0.783695922155,0.09722262375,-0.0,0.078553220216,True,0.043499052401
+1,4,3,16,0.0,0.598417320382,0.645270541438,0.046853221056,-0.0,0.037869368551,True,0.012030249774
+2,5,4,32,0.0,0.65719040498,0.732528348289,0.075337943309,-0.0,0.050318641751,True,0.030823019361
+3,6,5,64,0.0,0.642820613088,0.751737913087,0.108917299999,0.0,0.089207272944,True,0.02994685481
+4,3,2,8,0.0,0.666305076982,0.785501514963,0.11919643798,0.0,0.103716252989,True,0.039576315056
+5,4,4,16,0.0,0.572899722887,0.670614857037,0.09771513415,-0.0,0.085777279588,True,0.028243904413
+6,5,4,32,0.0,0.628625482902,0.698615804061,0.069990321159,-0.0,0.04965387929,True,0.022381623143
+7,6,4,64,0.0,0.545986204592,0.565500817676,0.019514613084,-0.0,0.015842513809,True,-0.00260924578
+8,3,2,8,0.0,0.620964234687,0.649458834726,0.028494600039,0.0,0.018734196272,True,0.010040348448
+9,4,2,16,0.0,0.655565825095,0.666111830149,0.010546005054,-0.0,0.010155075049,True,-0.00514674705
+10,5,4,32,0.0,0.584812151693,0.614510101767,0.029697950074,-0.0,0.024764631512,True,-0.003567374242
+11,6,3,64,0.0,0.66200766098,0.698189146123,0.036181485143,-0.0,0.031915339102,True,0.000971076055
+12,3,2,8,0.0,0.602723978336,0.721271512227,0.118547533891,0.0,0.066592620766,True,0.051776915525
+13,4,3,16,0.0,0.65107027566,0.673356766475,0.022286490815,-0.0,0.019903551755,True,0.003404751896
+14,5,4,32,0.0,0.525472849344,0.551553308477,0.026080459133,-0.0,0.021018260354,True,0.0032901328
+15,6,2,64,0.0,0.668516307378,0.671535464329,0.003019156951,0.0,0.002597076841,True,-0.012991449925
+16,3,2,8,0.0,0.637714405232,0.678704225479,0.040989820247,-0.0,0.031358671887,True,0.015777164811
+17,4,4,16,0.0,0.633729576273,0.642950329009,0.009220752736,-0.0,0.008175981856,True,-0.019199584657
+18,5,4,32,0.0,0.673727994983,0.876445857306,0.202717862323,0.0,0.136648306688,True,0.072911731861
+19,6,6,64,0.0,0.504767024972,0.565232093929,0.060465068957,0.0,0.047165181757,True,0.013421062862
+20,3,2,8,0.0,0.664723092217,0.713317519622,0.048594427405,0.0,0.038634049595,True,0.010233294903
+21,4,2,16,0.0,0.619462297857,0.62298409835,0.003521800494,0.0,0.003279155634,True,-0.024450730295
+22,5,4,32,0.0,0.632812381238,0.652679684102,0.019867302864,0.0,0.019213874869,True,-0.01243895153
+23,6,5,64,0.0,0.630455413033,0.65939460964,0.028939196608,0.0,0.02272574564,True,-0.005756255758

packaged_replay/results.json

@@ -0,0 +1,75 @@
+{
+  "claims": [
+    "Theorem 3.7 proves an upper bound on excess risk of B_p* * B_X * M/sqrt(D) under an M-coverage condition on depth-D DAGs, extending networked information aggregation from squared loss to Binary Cross-Entropy-based binary classification (Theorem 3.7).",
+    "Theorem 4.5 proves a matching lower bound showing instances with excess loss of at least Omega(k/D), where k is feature dimension and D is path depth, establishing network depth as a necessary bottleneck (Theorem 4.5).",
+    "Lemma 3.1 establishes an orthogonality property of Binary Cross-Entropy residuals, E[x(p*(x)-y)] = 0, replacing the variance-decomposition tools used in prior squared-loss analyses (Lemma 3.1).",
+    "Lemma 3.3 provides a KL/Bregman-type loss decomposition L(q) = L(p*) + D(p*||q), used with Pinsker-style bounds to connect BCE progress to prediction error (Lemma 3.3).",
+    "The protocol models a sequential DAG in which each agent observes only a subset of features, receives parent logits (not probabilities), and locally minimizes Binary Cross-Entropy before passing its own logits downstream (Section 2)."
+  ],
+  "formula_summary": {
+    "all_positive": true,
+    "cells": 72,
+    "depth_exponent_minus_one_half": true
+  },
+  "gates": {
+    "all_logit_losses_nonincreasing": true,
+    "all_m_coverage": true,
+    "all_pinsker_certificates": true,
+    "all_upper_bound_certificates": true,
+    "bce_kl_decomposition_exact": true,
+    "five_exact_claims_present": true,
+    "formula_bounds_positive": true,
+    "formula_panel_complete": true,
+    "lower_bound_coefficients_valid": true,
+    "lower_bound_excess_positive": true,
+    "lower_bound_panel_complete": true,
+    "lower_bound_scaled_constant_positive": true,
+    "nonoptimal_reference_control_fails": true,
+    "orthogonality_panel_complete": true,
+    "orthogonality_residual_small": true,
+    "positive_probability_control_gap": true,
+    "probability_passing_control_worse": true,
+    "protocol_panel_complete": true,
+    "source_archive_pin": true,
+    "source_pdf_pin": true,
+    "source_scope_rows_complete": true,
+    "upper_depth_exponent_minus_one_half": true
+  },
+  "lower_bound_summary": {
+    "all_coefficients_in_open_unit_interval": true,
+    "all_excess_positive": true,
+    "cells": 56,
+    "maximum_scaled_excess_D_over_k": 0.099745574981,
+    "minimum_scaled_excess_D_over_k": 0.049078635566
+  },
+  "orthogonality_summary": {
+    "all_pinsker_certificates": true,
+    "cells": 24,
+    "maximum_absolute_decomposition_gap": 0.0,
+    "maximum_orthogonality_residual": 0.0,
+    "nonoptimal_reference_counterexamples": 24
+  },
+  "paper": {
+    "arxiv": "2605.01082v1",
+    "openreview_id": "mrtg4NmvAe",
+    "title": "Networked Information Aggregation for Binary Classification"
+  },
+  "passed": true,
+  "protocol_summary": {
+    "all_logit_losses_nonincreasing": true,
+    "all_m_coverage": true,
+    "all_upper_bound_certificates": true,
+    "cells": 48,
+    "mean_probability_control_excess_gap": 0.00618226885,
+    "probability_control_worse_cells": 48
+  },
+  "scientific_scope": {
+    "decomposition": "The BCE/KL identity requires the optimal same-feature-space logistic reference.",
+    "matching": "The source uses matching for the depth bottleneck; upper and lower exponents are not identical.",
+    "protocol": "The source transmits logits rather than probabilities."
+  },
+  "source_checks": {
+    "pdf_sha256": "ca7263e8fd591b27cbd3f869d93ffe1818af27baaa439f278a27a5248ddd92b7",
+    "source_sha256": "d17612d6f31795fe581812dd7e20bf00ce5fabc7408e61411b439232b9917417"
+  }
+}

packaged_replay/source_claim_audit.csv

@@ -0,0 +1,6 @@
+claim,anchor,verdict,scope
+1,Theorem 3.7 / thm:convergence,supported_with_assumptions,"Requires a depth-D path satisfying M-coverage, bounded second moments, and bounded global-logit l1 coefficients."
+2,Theorem 4.5 / Lower Bound on Convergence,supported_with_scope,"The construction has D=kp and p<=k-1; matching refers to the network-depth bottleneck, not identical upper/lower exponents."
+3,Lemma 3.1 / lem:orthogonality,supported,First-order optimality for the optimal logistic predictor on its feature space.
+4,Lemma 3.3 / lem:pythagorean,supported_with_scope,Both p* and q are logistic predictors on the same feature set and p* is the optimizer.
+5,Section 2 / Sequential Learning Protocol,supported,"Agents pass logits, not probabilities, in a topological order."

pages/claim-1-depth-upper-bound/page.md

@@ -0,0 +1,17 @@
+# Claim 1: Theorem 3.7 proves an upper bound on excess risk of B_p* * B_X * M/sqrt(D) under an M-coverage condition on depth-D DAGs, extending networked information aggregation from squared loss to Binary Cross-Entropy-based binary classification (Theorem 3.7).
+
+
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_446cad9dbeff", "created_at": "2026-07-22T10:28:06+00:00", "title": "Claim 1: Theorem 3.7 proves an upper bound on excess risk of B_p* * B_X * M/sqrt(D) under an M-coverage condition on depth-D DAGs, extending networked information aggregation from squared loss to Binary Cross-Entropy-based binary classification (Theorem 3.7)."}
+-->
+> Theorem 3.7 proves an upper bound on excess risk of B_p* * B_X * M/sqrt(D) under an M-coverage condition on depth-D DAGs, extending networked information aggregation from squared loss to Binary Cross-Entropy-based binary classification (Theorem 3.7).
+
+**Outcome: source-supported under explicit assumptions.** The theorem concerns
+a depth-`D` path within the DAG, `M`-coverage, bounded feature second moments,
+and bounded `l1` coefficients for the global optimum. All 48 cyclic-path
+diagnostics satisfy coverage, non-increasing BCE, and the stated bound. The
+72-cell exact formula grid recovers the `D^(-1/2)` dependence.
+
+Artifacts: `outputs/network_protocol_audit.csv` and
+`outputs/depth_formula_audit.csv`.

pages/claim-2-depth-lower-bound/page.md

@@ -0,0 +1,17 @@
+# Claim 2: Theorem 4.5 proves a matching lower bound showing instances with excess loss of at least Omega(k/D), where k is feature dimension and D is path depth, establishing network depth as a necessary bottleneck (Theorem 4.5).
+
+
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_57edd560ccd9", "created_at": "2026-07-22T10:28:06+00:00", "title": "Claim 2: Theorem 4.5 proves a matching lower bound showing instances with excess loss of at least Omega(k/D), where k is feature dimension and D is path depth, establishing network depth as a necessary bottleneck (Theorem 4.5)."}
+-->
+> Theorem 4.5 proves a matching lower bound showing instances with excess loss of at least Omega(k/D), where k is feature dimension and D is path depth, establishing network depth as a necessary bottleneck (Theorem 4.5).
+
+**Outcome: source-supported with construction scope.** The hard instance uses
+`D=kp`, cyclic one-feature agents, and `p≤k-1`. “Matching” is preserved only in
+the source's network-depth-bottleneck sense; the upper and lower exponents are
+not identical. Deterministic 64-node two-dimensional Gauss-Hermite quadrature
+across 56 `k,p` cells finds every excess positive and keeps
+`excess·D/k` in `[0.049078635566, 0.099745574981]`.
+
+Artifact: `outputs/gaussian_lower_bound_audit.csv`.

pages/claim-3-residual-orthogonality/page.md

@@ -0,0 +1,16 @@
+# Claim 3: Lemma 3.1 establishes an orthogonality property of Binary Cross-Entropy residuals, E[x(p*(x)-y)] = 0, replacing the variance-decomposition tools used in prior squared-loss analyses (Lemma 3.1).
+
+
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_f1813dcb767c", "created_at": "2026-07-22T10:28:06+00:00", "title": "Claim 3: Lemma 3.1 establishes an orthogonality property of Binary Cross-Entropy residuals, E[x(p*(x)-y)] = 0, replacing the variance-decomposition tools used in prior squared-loss analyses (Lemma 3.1)."}
+-->
+> Lemma 3.1 establishes an orthogonality property of Binary Cross-Entropy residuals, E[x(p*(x)-y)] = 0, replacing the variance-decomposition tools used in prior squared-loss analyses (Lemma 3.1).
+
+**Outcome: source-supported.** The identity is the first-order condition for
+the optimal logistic predictor on its feature space. Twenty-four deliberately
+misspecified finite conditional-label models yield nonzero pointwise residuals
+but a maximum weighted feature-moment residual below displayed `1e-12`; this
+is stronger than a correctly specified tautological test.
+
+Artifact: `outputs/orthogonality_decomposition_audit.csv`.

pages/claim-4-bce-kl-decomposition/page.md

@@ -0,0 +1,16 @@
+# Claim 4: Lemma 3.3 provides a KL/Bregman-type loss decomposition L(q) = L(p*) + D(p*||q), used with Pinsker-style bounds to connect BCE progress to prediction error (Lemma 3.3).
+
+
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_f3bd879d54f5", "created_at": "2026-07-22T10:28:06+00:00", "title": "Claim 4: Lemma 3.3 provides a KL/Bregman-type loss decomposition L(q) = L(p*) + D(p*||q), used with Pinsker-style bounds to connect BCE progress to prediction error (Lemma 3.3)."}
+-->
+> Lemma 3.3 provides a KL/Bregman-type loss decomposition L(q) = L(p*) + D(p*||q), used with Pinsker-style bounds to connect BCE progress to prediction error (Lemma 3.3).
+
+**Outcome: source-supported with optimizer scope.** The identity requires
+`p*` to be the optimal logistic predictor and `q` to use the same feature
+space. All 24 nontrivial projection cells satisfy the BCE/KL equality and the
+Pinsker inequality to displayed numerical zero. Replacing `p*` by a nonoptimal
+reference breaks the decomposition in all 24 cells.
+
+Artifact: `outputs/orthogonality_decomposition_audit.csv`.

pages/claim-5-logit-passing-protocol/page.md

@@ -0,0 +1,17 @@
+# Claim 5: The protocol models a sequential DAG in which each agent observes only a subset of features, receives parent logits (not probabilities), and locally minimizes Binary Cross-Entropy before passing its own logits downstream (Section 2).
+
+
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_dab0b621edb8", "created_at": "2026-07-22T10:28:06+00:00", "title": "Claim 5: The protocol models a sequential DAG in which each agent observes only a subset of features, receives parent logits (not probabilities), and locally minimizes Binary Cross-Entropy before passing its own logits downstream (Section 2)."}
+-->
+> The protocol models a sequential DAG in which each agent observes only a subset of features, receives parent logits (not probabilities), and locally minimizes Binary Cross-Entropy before passing its own logits downstream (Section 2).
+
+**Outcome: source-supported and independently diagnostic.** Every simulated
+agent receives one local feature and the parent's logit, exactly minimizes
+finite-support expected BCE, and sends its new logit in path order. Loss is
+non-increasing in all 48 panels. Substituting parent probabilities for logits
+is worse in all 48, with mean final excess-BCE gap `0.00618226885`, directly
+testing the source's architectural distinction.
+
+Artifact: `outputs/network_protocol_audit.csv`.

pages/conclusion/page.md

@@ -0,0 +1,18 @@
+# Conclusion
+
+
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_23f43f3afca5", "created_at": "2026-07-22T10:28:06+00:00", "title": "Reproduction bundle"}
+-->
+All twenty-two gates pass in two warning-strict byte-identical runs and a
+fresh packaged replay. The bundle contains exact live strings, pinned sole-
+revision PDF/source, projection, protocol, hard-instance, rate, and control
+tables, deterministic code, visualization, paper text, and a recursive
+SHA-256 manifest. Every source assumption and finite-evidence boundary remains
+explicit.
+
+```bash
+PYTHONWARNINGS=error python reproduce.py --output replay
+python build_manifest.py --verify
+```

pages/executive-summary/page.md

@@ -0,0 +1,33 @@
+# Executive summary
+
+
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_fde1ece41eed", "created_at": "2026-07-22T10:28:06+00:00", "title": "Executive summary", "pinned": true, "pinned_at": "2026-07-22T10:28:06+00:00"}
+-->
+All twenty-two gates pass. The sole pinned arXiv revision supports the five
+live claims with explicit upper-bound, lower-construction, optimizer, and
+same-feature-space scopes. Nontrivial finite projections satisfy residual
+orthogonality and the BCE/KL identity to displayed numerical zero; all 48
+cyclic logit paths satisfy coverage, monotonicity, and the source bound. The
+probability-passing control is worse in every panel, and 56 Gauss-Hermite hard-
+instance cells keep excess BCE times `D/k` between `0.04908` and `0.09975`.
+
+| Item | Value |
+| --- | --- |
+| GPU / compute | None; deterministic CPU-only NumPy/Matplotlib |
+| Registered claims | 5/5 exact literal strings retained |
+| Primary source | arXiv 2605.01082v1 PDF and TeX SHA-256 pinned |
+
+Links: [OpenReview](https://openreview.net/forum?id=mrtg4NmvAe),
+[arXiv v1](https://arxiv.org/abs/2605.01082v1), and the reserved future
+[Space target](https://huggingface.co/spaces/ProCreations/repro-networked-information-aggregation-for-binary-classification).
+
+
+---
+<!-- trackio-cell
+{"type": "figure", "id": "cell_2a8aa1589a5a", "created_at": "2026-07-22T10:28:06+00:00", "title": "Reproduction poster (poster_embed.html)", "pinned": true, "pinned_at": "2026-07-22T10:28:06+00:00"}
+-->
+````html
+<iframe src="poster_embed.html" title="Networked BCE reproduction poster" style="width:100%;height:900px;border:0"></iframe>
+````

pages/index.md

@@ -0,0 +1,13 @@
+# Reproduction: Networked Information Aggregation for Binary Classification
+
+## Pages
+
+| Page |
+| --- |
+| [Executive summary](#/executive-summary) |
+| [Claim 1: Depth upper bound](#/claim-1-depth-upper-bound) |
+| [Claim 2: Depth lower bound](#/claim-2-depth-lower-bound) |
+| [Claim 3: Residual orthogonality](#/claim-3-residual-orthogonality) |
+| [Claim 4: BCE/KL decomposition](#/claim-4-bce-kl-decomposition) |
+| [Claim 5: Logit-passing protocol](#/claim-5-logit-passing-protocol) |
+| [Conclusion](#/conclusion) |

paper.txt

@@ -0,0 +1,719 @@
+                                                      Networked Information Aggregation for Binary Classification
+
+
+                                              MohammadHossein Bateni 1 Zahra Hadizadeh 2 MohammadTaghi Hajiaghayi 3 Mahdi JafariRaviz 3
+                                                                                 Shayan Taherijam 2
+
+
+                                                                 Abstract                                   with partial and heterogeneous information aggregate their
+                                                                                                            observations to form an accurate global belief? This line of
+                                             We study networked binary classification on a
+                                                                                                            inquiry has a rich literature in economics and network sci-
+                                             directed acyclic graph (DAG) where each agent
+
+
+
+
+arXiv:2605.01082v1 [cs.LG] 1 May 2026
+                                                                                                            ence, commencing with the seminal work of DeGroot (De-
+                                             observes only a subset of the feature columns of a
+                                                                                                            groot, 1974). The DeGroot model conceptualizes learning
+                                             shared dataset. Agents act sequentially along the
+                                                                                                            as an iterative process of weighted averaging, where agents
+                                             DAG: each receives prediction columns from its
+                                                                                                            update their scalar beliefs based on the beliefs of their neigh-
+                                             parents (if any), augments its local features with
+                                                                                                            bors. This heuristic approach was subsequently refined by
+                                             these columns, fits a logistic predictor by mini-
+                                                                                                            Bayesian models of observational learning and information
+                                             mizing binary cross-entropy (BCE), and forwards
+                                                                                                            cascades, where rational agents infer private signals from
+                                             its prediction column to its outgoing neighbors.
+                                                                                                            the actions of their predecessors to reach a consensus or
+                                             We ask whether this sequential distributed train-
+                                                                                                            truth. For example, Banerjee (Banerjee, 1992) studies herd-
+                                             ing procedure achieves information aggregation,
+                                                                                                            ing behavior in sequential decision-making; Bikhchandani
+                                             meaning that some agent attains small excess loss
+                                                                                                            et al. (Bikhchandani et al., 1992) formalize informational
+                                             compared to the best logistic predictor trained
+                                                                                                            cascades as a mechanism for fads and fashions; Gale and
+                                             with access to all feature columns.
+                                                                                                            Kariv (Gale & Kariv, 2003) analyze Bayesian learning dy-
+                                             This question was studied for linear regres-                   namics over social networks; and Golub and Jackson (Golub
+                                             sion under squared loss by Kearns, Roth, and                   & Jackson, 2010) study conditions under which naive aver-
+                                             Ryu (Kearns et al., 2026). Extending their guar-               aging aggregates information.
+                                             antees to classification is nontrivial because their
+                                             analysis relies on quadratic structure that does not           While classical social learning focuses on the aggregation
+                                             directly transfer to BCE with a logistic link. We              of scalar estimates for a single state variable, modern ap-
+                                             analyze the resulting sequential logit-passing pro-            plications increasingly demand networked machine learn-
+                                             tocol and√  prove: (i) an excess loss upper bound              ing, where agents collaboratively learn high-dimensional
+                                             of O(M/ D) on depth-D paths under the condi-                   hypothesis functions. In this setting, aggregation entails
+                                             tion that every M contiguous subsequence of M                  reconstructing a complex predictive relationship—such as
+                                             agents collectively observe all features, and (ii) a           a classifier mapping a high-dimensional feature vector to
+                                             close lower bound showing instances with excess                a label—dispersed across a network. Recently, Kearns et
+                                             loss of at least Ω(k/D) where k is the dimension               al. (Kearns et al., 2026) introduced a formal framework
+                                             of the feature space. Together, these results iden-            for this problem, embedding learning agents in a Directed
+                                             tify network depth as a fundamental bottleneck                 Acyclic Graph (DAG). In their protocol, agents observe a
+                                             for information aggregation in networked logistic              local subset of features and the predictions of their parents,
+                                             regression.                                                    training a model to minimize a local loss function. For linear
+                                                                                                            regression under squared error, they demonstrated that such
+                                                                                                            a process allows agents to achieve excess loss competitive
+                                                                                                            with a global learner having access to all features, with the
+                                        1. Introduction
+                                                                                                            network depth acting as the critical resource for aggregation.
+                                        The study of social learning in networks addresses a fun-
+                                        damental question in distributed learning: How do agents            1.1. Our Contributions
+                                           1
+                                             Google Research, New York City, NY, USA 2 University of        In this work, we focus on the classification variant of the
+                                        California, Irvine, CA, USA 3 University of Maryland, College       model of (Kearns et al., 2026). We analyze a sequential
+                                        Park, MD, USA. Correspondence to: Shayan Taherijam <sta-            learning protocol where agents optimize logistic regression
+                                        herij@uci.edu>.
+                                                                                                            models using local features and incoming logits from their
+                                        Preprint. May 5, 2026.                                              parents in a DAG. Our main contributions are as follows.
+
+                                                                                                        1
+                                 Networked Information Aggregation for Binary Classification
+
+Upper Bounds. We analyze information aggregation in a                  gression require genuinely different tools once the target
+network of logistic regression agents. We show that if a               is probabilistic classification. We list three representative
+path of length D satisfies a coverage condition—namely,                pairs. First, in sketching/subspace-embedding methods,
+every contiguous block of M agents collectively observes               least-squares regression admits sharp oblivious sketching
+all features. In particular, we prove
+                                 √ that the excess loss of             guarantees (Clarkson & Woodruff, 2013), whereas logistic
+the final agent scales as O(M/ D) (Theorem 3.8).                       objectives require non-L2 progress measures and different
+                                                                       proof techniques (Munteanu et al., 2021). Second, in second-
+At a high level, our proof extends the analysis of (Kearns
+                                                                       order / curvature-aware acceleration via sketching, iterative
+et al., 2026) from squared loss to logistic loss. The squared-
+                                                                       Hessian sketch methods are cleanly analyzed for constrained
+loss argument relies on an exact variance decomposition,
+                                                                       least squares (Pilanci & Wainwright, 2016), while Newton-
+which does not carry over to Binary Cross-Entropy (BCE).
+                                                                       sketch extensions for regularized ERM objectives (including
+Instead, we certify progress via a KL/Bregman-type char-
+                                                                       logistic regression) require controlling curvature that de-
+acterization of loss differences (Lemma 3.3) together with
+                                                                       pends on current predictions (Pilanci & Wainwright, 2017).
+a Pinsker-style link from KL progress to prediction error
+                                                                       Third, in distribution-free predictive inference, split confor-
+(Lemma 3.4). A key technical input is an orthogonality
+                                                                       mal prediction yields regression intervals (Lei et al., 2018),
+condition for BCE residuals (Lemma 3.1). Finally, a stabil-
+                                                                       whereas classification requires set-valued prediction regions
+ity (pigeonhole) argument identifies a segment of the path
+                                                                       and different uncertainty objects (Angelopoulos & Bates,
+where improvement saturates; this forces small residuals and
+                                                                       2021). Taken together, these examples support the mes-
+yields a bound on the deviation from the global optimum.
+                                                                       sage most relevant to our paper: moving from regression to
+Lower Bounds and Hard Instances We complement the                      classification typically replaces Euclidean residual decom-
+upper bound by exhibiting a hard instance for the sequential           positions with KL/Bregman-flavored notions of progress,
+logit-passing protocol. On this instance, early features are           which becomes unavoidable when the information flowing
+uninformative about the label in isolation and only become             through the network is itself a low-bandwidth probabilistic
+useful after sufficiently many passes through the feature              prediction.
+cycle. We prove that the excess loss is lower-bounded by
+Ω(k/D) where k is the dimension of the feature space,                  1.3. Related Work
+showing that network depth is not merely sufficient but
+necessary in the framework.                                            The most directly related body of work comes from Vertical
+                                                                       Federated Learning (VFL), where different parties hold dis-
+                                                                       joint feature columns for the same aligned examples and col-
+1.2. From Regression to Classification
+                                                                       laborate to train a joint predictor. The standard VFL setting
+Extending theoretical guarantees of networked aggregation              is inherently interactive: the survey of (Yang et al., 2019)
+from linear regression to binary classification is non-trivial.        formalizes the feature-partitioned regime and highlights that
+The analysis in (Kearns et al., 2026) relies fundamentally on          most practical protocols rely on repeated message exchanges
+the geometry of squared loss—in particular, orthogonality              (e.g., gradients, activations, or protected sufficient statistics)
+of residuals and a Pythagorean variance decomposition—                 to optimize a shared objective. This view is reflected in
+which translate loss reduction directly into parameter-space           deployed platforms such as FATE (Liu et al., 2021), which
+convergence. In contrast, binary classification via logistic re-       operationalize multi-round VFL pipelines and make explicit
+gression and Binary Cross-Entropy (BCE) does not admit a               the practical tension between accuracy, privacy protection,
+comparable bias–variance decomposition. The non-linearity              and communication cost. A particularly relevant algorith-
+of the sigmoid link introduces genuine geometric complica-             mic family is vertical gradient-boosted tree training: Se-
+tions; in particular, linear aggregation in probability space          cureBoost (Cheng et al., 2021) and later high-performance
+is not equivalent to linear aggregation in feature space, mo-          variants such as SecureBoost+ (Fan et al., 2024) show that
+tivating the architectural choice of passing logits rather than        strong predictors can be trained over vertically split fea-
+probabilities.                                                         tures, but only by repeatedly coordinating split decisions
+                                                                       through exchanging split-related information. From the
+Despite these challenges, classification remains the primary
+                                                                       perspective of our setting, these works provide concrete
+modality for distributed applications ranging from medical
+                                                                       evidence that feature partitioning alone already induces
+diagnosis (Vepakomma et al., 2018) to decentralized fraud
+                                                                       a strong communication bottleneck; our work asks what
+detection. Establishing guarantees for information aggrega-
+                                                                       can be guaranteed when the interaction budget is pushed
+tion under BCE is therefore a central theoretical goal.
+                                                                       much closer to its limit. A complementary architectural line
+More broadly, this regression-to-classification gap is not             is split learning (Vepakomma et al., 2018), which avoids
+unique to our networked setting: across several areas, tech-           sharing raw features by cutting a neural network across par-
+niques and guarantees that are clean for squared-loss re-              ties and communicating intermediate activations/gradients.
+
+
+                                                                   2
+                                     Networked Information Aggregation for Binary Classification
+
+While the mechanism is different from VFL-by-gradients or               2.3. Sequential Learning Protocol
+VFL-by-trees, it again emphasizes the same friction point
+                                                                        The agents learn models in a sequential manner. Unlike lin-
+that is central to our paper: learning can succeed under
+                                                                        ear regression settings where agents minimize squared error,
+information-flow constraints, but the protocol must care-
+                                                                        here each agent Ai aims to train a model fi to minimize the
+fully manage what is transmitted and how many rounds are
+                                                                        local Binary Cross Entropy (BCE) loss.
+available. Finally, recent surveys (Wu et al., 2025; Khan
+et al., 2025) synthesize these lines and stress that communi-           Each agent Ai observes its local features xSi and the set
+cation (both message size and number of rounds) remains                 of outputs from its parents. To preserve the information
+a dominant practical limitation in VFL, alongside privacy               geometry of the exponential family, agents communicate
+leakage and the statistical dependence patterns induced by              their logits (the input to the sigmoid function) rather than
+feature/label partitioning; this framing closely matches the            their final probabilities. Let zj be the logit output by parent
+communication-centric viewpoint taken in our analysis.                  Aj , such that the parent’s prediction is p̂j = σ(zj ).
+                                                                        The model pi for agent Ai is a logistic function of its local
+2. Preliminaries                                                        features and the parents’ logits:
+In this section, we formally define the notation, the logistic                                                          X
+regression framework, and the distributed learning setup.               pi (x) = σ(zi (x)) where zi (x) = wiT xSi +               vij zj (x).
+                                                                                                                      j∈Pa(Ai )
+                                                                                                                             (3)
+2.1. Binary Classification and Logistic Regression
+                                                                        Here, wi (weights for local features) and vij (weights
+We consider a binary classification problem. Let D be a                 for incoming logits) are learnable parameters. Agent Ai
+distribution over feature-label pairs (x, y), where x ∈ Rd is           chooses these parameters to minimize the expected BCE
+a vector of features and y ∈ {0, 1} is the binary target label.         loss E[L(pi )].
+We model the conditional probability P (y = 1|x) using the              The final output of the system is the prediction of the sink
+logistic function σ(z) = 1+e1−z . A hypothesis is parameter-            agent (or the last agent in the topological sort).
+ized by a vector θ ∈ Rd , yielding the predictor:                       We use the notation L(p), L(θ), and L(z) interchangeably.
+                     p(θ)              T
+                            (x) = σ(θ x).                     (1)       Here, θ denotes the weight vector. We define z(x) = θT x
+                                                                        and p(x) = σ(z(x)).
+The quality of a predictor is measured by the expected Bi-
+nary Cross Entropy (BCE) loss:                                          3. Upper Bounds
+                              (θ)                       (θ)
+L(θ) = −E(x,y)∼D [y log p           (x)+(1−y) log(1−p(x))].             This section analyzes information aggregation within a net-
+                                                        (2)             work of logistic regression agents. We demonstrate that se-
+The global Maximum Likelihood Estimator (MLE), denoted                  quentially minimizing Binary Cross Entropy (BCE) allows
+by p∗ , corresponds to the parameters θ∗ that minimize this             the network to approximate the global predictor derived
+loss over the full feature space.                                       from all features, assuming sufficient network depth and
+                                                                        feature coverage.
+2.2. Distributed Learning Setup
+                                                                        We first establish that the residuals of the BCE loss optimizer
+We consider a distributed learning setting with a set of N              are orthogonal to the input. A similar result was previously
+agents, A = {A1 , . . . , AN }. The agents are organized                derived by (Kearns et al., 2026) for the linear regression
+in a Directed Acyclic Graph (DAG), G = (A, E), where                    with MSE loss.
+an edge (Aj , Ai ) ∈ E indicates that agent Ai receives
+information from agent Aj . We sometimes also write Aj →                Lemma 3.1 (Orthogonality of Residuals). Let p∗ be the
+Ai to denote this relationship. We denote the set of parents            optimal logistic predictor on a feature space X . The residual
+of agent Ai as Pa(Ai ) = {Aj | (Aj , Ai ) ∈ E}. The agents              error (p∗ (x) − y) is orthogonal to the feature vector x in
+learn in an order consistent with a topological sort of the             expectation:
+DAG, with ties in the topological ordering broken arbitrarily.                             E [x(p∗ (x) − y)] = 0.
+
+Let [d] = {1, 2, . . . , d} be the set of indices for d total
+features. Each agent Ai ∈ A is associated with a specific               Proof. Given p(θ) (x) = σ(θT x), the gradient of the logistic
+subset of these features, Si ⊆ [d]. For any agent Ai , its              output is ∇θ p(θ) (x) = p(θ) (x)(1 −p(θ) (x))x. Applying the
+local view of the features is xSi , which is the sub-vector of          chain rule to L(θ) yields:
+x corresponding to the features indexed by Si . The agent                             h                                     i
+also receives its parents’ logits.                                        ∇θ L(θ) = −E (y(1 − p(θ) (x)) − (1 − y)p(θ) (x))x
+
+                                                                    3
+                                   Networked Information Aggregation for Binary Classification
+                 h             i                                                             h                         i
+            = E (p(θ) (x) − y)x .                                                         + E (p∗ (x) − y) (θ − θ∗ )T x .      (4)
+
+The optimal parameters θ∗ satisfy the condition ∇θ L(θ∗ ) =            The second term is zero due to the orthogonality condition
+0. Thus:                                                               derived in Lemma 3.1. For the first term, we expand the
+                 E [x(p∗ (x) − y)] = 0.                                definition of D(p∗ ∥q) with z = θT x and z ∗ = (θ∗ )T x:
+                                                                                        h                             ∗
+                                                                                                                         
+This orthogonality allows us to decompose the error of any                D(p∗ ∥q) = E p∗ (x) (z ∗ − z) − log 1 + ez
+suboptimal model. We express the error of a suboptimal                                                    i
+model in terms of the optimal predictor using the expected                                 + log (1 + ez )
+Kullback-Leibler divergence of the Bernoulli distribution,                              h           T
+                                                                                                                       ∗ T
+                                                                                                                              
+defined as follows.                                                                  = E log 1 + eθ x − log 1 + e(θ ) x
+                                                                                                                i
+Definition 3.2. Let p and q be two predictors on feature                                   − p∗ (x) (θ − θ∗ )T x .
+space X . Then D(p∥q) is defined as:
+
+ D(p∥q) = E [DKL (Bernoulli(p(x))∥Bernoulli(q(x)))] ,                  This matches the first term in Equation (4), completing the
+                                                                       proof.
+where DKL (p′ ∥q ′ ) is the Kullback-Leibler divergence be-
+tween distributions p′ and q ′ , given by:                             To bound the parameter error using the KL divergence,
+                                                                       we use the following inequality. This is a specific case
+                               X                p′ (x)                 of Pinsker’s inequality (Pinsker, 1964), included here for
+            DKL (p′ ∥q ′ ) =       p′ (x) log           .
+                               x
+                                                q ′ (x)                completeness.
+                                                                       Lemma 3.4. For the expected KL divergence D(p∥q), the
+Expanding this definition, D(p∥q) becomes:                             following inequality holds:
+
+                                                                                    D(p∥q) ≥ 2E (p(x) − q(x))2 .
+                                                      
+                                              1 − p(x)
+                                                                                                             
+                        p(x)
+D(p∥q) = E p(x) log          + (1 − p(x)) log            .
+                        q(x)                  1 − q(x)
+                                                                       We refer to Appendix A for the proof. We define the point-
+Lemma 3.3 (Decomposing Loss). Let p∗ be the optimal                    wise loss function as:
+logistic predictor on a feature set S, and let q be any logistic
+predictor on S. The loss decomposes as:                                               l(z, y) = log(1 + ez ) − yz.             (5)
+
+                 L(q) = L(p∗ ) + D(p∗ ∥q).                             We can thus write L(p) = E[l(z(x), y)].
+                                                                       Lemma 3.5. Let g(x) = σ(zg (x)) be any logistic predictor.
+Proof. Using the identity log σ(z) = z − log(1 + ez ), we              Let S be a feature subspace and p(x) = σ(zp (x)) be the
+write the loss with z = θT x as:                                       predictor that minimizes L(p) over S. Then:
+
+          L(θ) = −E [yz − log(1 + ez )]                                             L(p) ≤ L(g) + |E[(p − y)zg ]|.
+                  h          T
+                                           i
+               = E log(1 + eθ x ) − y(θT x) .                          Proof. Let ϕ(z) = log(1+ez ). The derivatives are ϕ′ (z) =
+                                                                       σ(z) and ϕ′′ (z) = σ(z)(1 − σ(z)). Since σ(z) ∈ (0, 1),
+Let θ∗ be the corresponding parameters of p∗ . Expanding               we have ϕ′′ (z) ≥ 0, implying ϕ is convex. Convexity
+the difference L(θ) − L(θ∗ ):                                          implies that for any u, v ∈ R, ϕ(v) ≥ ϕ(u) + ϕ′ (u)(v − u).
+                           h         T
+                                                                       Rearranging implies the following:
+         L(θ) − L(θ∗ ) = E log(1 + eθ x )
+                                                     ∗ T
+                                                                                     ϕ(u) ≤ ϕ(v) + σ(u)(u − v).                (6)
+                                   − log(1 + e(θ ) x )
+                                                    i                  We define the relationship between the losses l(u, y) and
+                                   − y((θ − θ∗ )T x) .                 l(v, y). Substituting l(z, y) = ϕ(z) − yz, we aim to show
+                                                                       the following inequality:
+Adding and subtracting p∗ (x)(θ − θ∗ )T x inside the expec-
+tation yields:                                                                  l(u, y) ≤ l(v, y) + (σ(u) − y)(u − v).         (7)
+                   h            T                  ∗ T 
               Expanding terms confirms this holds given the convexity of
+   L(θ) − L(θ∗ ) =E log(1 + eθ x ) − log 1 + e(θ ) x                   ϕ in Equation (6):
+                                           i
+                     − p∗ (x) (θ − θ∗ )T x                                 ϕ(u) − yu ≤ ϕ(v) − yv + σ(u)(u − v) − yu + yv
+
+                                                                   4
+                                   Networked Information Aggregation for Binary Classification
+
+    ⇐⇒ ϕ(u) ≤ ϕ(v) + σ(u)(u − v).                                                          = |E[xl (pk − pj )]|.
+                                                                      Applying the Cauchy-Schwarz inequality:
+Now, for a point x, let u = zp (x) and v = zg (x). Applying                                     q       q
+Equation (7):                                                               |E[xl (pk − pj )]| ≤ E[x2l ] E[(pk − pj )2 ]
+        l(zp , y) ≤ l(zg , y) + (σ(zp ) − y)(zp − zg ).                                            = ∥xl ∥2 ∥pk − pj ∥2 .
+Taking the expectation over x:                                        Given ∥xl ∥2 ≤ BX , we bound ∥pk − pj ∥2 using the loss
+                                                                      difference ε. Applying Lemma 3.4, we get for any s ∈
+      L(p) ≤ L(g) + E[(p − y)(zp − zg )]                              {1, . . . , k − 1}:
+            = L(g) + E[(p − y)zp ] − E[(p − y)zg ].                                              1
+                                                                                 E (ps − ps+1 )2 ≤ D(ps+1 ∥ps ).
+                                                                                  
+From Lemma 3.1 (Orthogonality), we know that for any                                              2
+feature xl in the support of p, E[xl (p − y)] = 0. Since zp           By the triangle inequality and Cauchy-Schwarz:
+is a linear combination of such features, E[(p − y)zp ] = 0.
+                                                                                               k−1
+                                                                                                    r
+Substituting this yields:                                                                      X D(ps+1 ∥ps )
+                                                                                ∥pj − pk ∥2 ≤
+                                                                                                          2
+ L(p) ≤ L(g) − E[(p − y)zg ] ≤ L(g) + |E[(p − y)zg ]|.                                         s=j
+                                                                                               s
+                                                                                                    Pk−1
+                                                                                                  k s=1 D(ps+1 ∥ps )
+We consider a path of agents A1 , . . . , AD . Each agent i                                 ≤
+                                                                                                           2
+receives the logit zi−1 from its predecessor and trains a                                      r
+logistic predictor model using locally observed features xSi ,                                    kε
+                                                                                            ≤        .
+zi−1 , and possibly some other predecessors’ logits. Since                                         2
+one option for the agent Ai is to pass the logits zi−1 through,       Combining these bounds with the constraint on αl :
+we have that L(pi−1 ) ≥ L(pi ). We also get that Lemma 3.3
+holds for pi−1 and pi , since pi−1 is in the stricter subspace                             d                                        r
+                                                                                           X                                            kε
+of pi .                                                               |E[(pk − y)zg ]| ≤         |αl | · |E[xl (pk − y)]| ≤ Bg BX          .
+                                                                                                                                        2
+                                   p                                                       l=1
+We use the notation ∥f (x)∥2 = E [f (x)2 ] for any func-
+tion f .
+Lemma 3.6 (Residual Bound via Path Coverage). Let                     We now give the below definition.
+A1 , . . . , Ak be a path of agents where every feature xl            Definition 3.7 (M -Coverage Condition, Kearns et al.
+is observed at least once. Let g(x) = σ(zg (x)) where                 (2026)). A path satisfies the M -coverage condition if every
+             Pd
+zg (x) = l=1 αl xl be any logistic predictor over the whole           contiguous subsequence of M agents collectively observes
+                                              Pd
+space. Assume the coefficients of zg satisfy l=1 |αl | ≤ Bg ,         all d features x1 , . . . , xd .
+and the features satisfy E[x2l ] ≤ BX
+                                    2
+                                       , for some Bg and BX .
+                                                                      We are finally ready to prove Theorem 3.8. Combining
+Let ε ≥ L(p1 ) − L(pk ). Then:
+                                                                      Lemma 3.5 and Lemmap3.6, we obtain the relationship
+                                           r
+                                              kε                      L(pk ) ≤ L(g) + Bg BX kε/2 for a path of length k. Ex-
+                |E[(pk − y)zg ]| ≤ Bg BX         .                    tending this analysis over the full path satisfying the M -
+                                              2
+                                                                      coverage condition leads to our main convergence result.
+Proof. Let zg (x) =
+                      Pd                                              Theorem 3.8 (Global Convergence Rate). Consider a DAG
+                        l=1 αl xl . We bound the error term:
+                                                                      G containing a path of length D of agents A1 , . . . , AD
+                                                                      satisfying the M -coverage condition. Let p∗ be the global
+                               " d                        #
+                                X
+        |E[(pk − y)zg ]| = E             αl xl (pk − y)               optimal logistic predictor over all d features. Assume:
+                                   l=1
+                             d
+                             X                                          1. Bounded second moments: E[x2l ] ≤ BX
+                                                                                                              2
+                                                                                                                for all l ∈
+                         ≤         |αl | |E[xl (pk − y)]|.                 {1, . . . , d}.
+                             l=1
+                                                                        2. Bounded   coefficients: for the optimal logits z ∗ (x) =
+Consider a feature xl . Due to each feature being observed,                P
+                                                                             l αl xl where ∥α∥1 ≤ Bp .
+                                                                                                        ∗
+this feature appears in the index set of some agent Aj in the
+path. By orthogonality, E[xl (pj − y)] = 0. We decompose              Then the excess risk of the final agent pD is bounded by:
+the expectation using the triangle inequality:                                                                          
+                                                                                                          M           M
+  |E[xl (pk − y)]| ≤ |E[xl (pk − pj )]| + |E[xl (pj − y)]|                 L(pD ) − L(p∗ ) ≤ Bp∗ BX √ = O √                .
+                                                                                                           D           D
+
+                                                                  5
+                                  Networked Information Aggregation for Binary Classification
+
+Proof. We partition the path into K = ⌊D/M ⌋ disjoint                  Network and Assignment. Consider a path of agents
+blocks of length M . By the Pigeonhole Principle, since                A1 , . . . , AD . The agents observe features one-at-a-time in a
+the total loss reduction is bounded by the loss of the first           repeating cyclic order. Agent Ai observes the single feature
+agent L(p1 ), there exists at least one stable block k ∗ where         xℓ where ℓ = ((i−1) (mod k))+1. The network structure
+the reduction is at most the total reduction divided by K.             is a simple path where Pa(Ai ) = {Ai−1 }.
+Suppose this block k ∗ is on indices s, s + 1, . . . , t.
+                                                                       We define a pass p as p-th disjoint block of k
+   t
+   X                              L(p1 )   2M L(p1 )                   agents. Specifically, the p-th pass consists of the agents
+          (L(pi−1 ) − L(pi )) ≤          ≤           := ε.             A(p−1)k+1 , . . . , Apk .
+  i=s+1
+                                   K          D
+
+Applying Lemma 3.5 and Lemma                                           4.2. Information Capacity and Variance
+                                 p3.6, we get that over this
+path L(pt ) ≤ L(p∗ ) + Bp∗ BX M ε/2. Next, note that                   We analyze the capacity of the final agent in pass p to re-
+L(p1 ) ≤ log 2 since using θ1 = 0 achieves a loss of log 2,            construct the target Zk by identifying which features can be
+and because the first agent optimizes within its domain then           effectively decoded from the scalar stream.
+L(p1 ) ≤ log 2 < 1. Combined with the non-increasing
+losses, we get:                                                        The following lemma characterizes the restricted informa-
+                                                                       tion available to agents. This result follows the methods of
+                                       M                               Lemma 5.5 in (Kearns et al., 2026), which establishes an
+              L(pD ) − L(p∗ ) ≤ Bp∗ BX √ .
+                                        D                              analogous result. We provide the proof for completeness.
+                                                                       Lemma 4.1 (Recursive Information Relevance). For any
+4. Lower Bound Analysis                                                pass p with p ≤ k, define the feature subset Ip =
+In this section, we construct a theoretical lower bound for            {xk , xk−1 , . . . , xk−p+1 }. The optimal logistic predictor for
+the convergence rate of the distributed learning protocol. We          σ(Zk ) at the end of pass p depends solely on the features in
+demonstrate the existence of a specific data distribution and          Ip .
+network configuration where the excess loss decays at a rate
+of Ω(k/D), where D is the depth of the network and k is
+the dimension of the feature space. This result confirms that          Proof. We proceed by induction on the pass index p.
+the sequential nature of the protocol makes network depth a            Base Case (p = 1): The first pass ends at agent Ak , who
+fundamental bottleneck for information aggregation.                    observes the local feature xk = Zk − Zk−1 . Preceding
+                                                                       agents A1 , . . . , Ak−1 observe features x1 , . . . , xk−1 , all of
+4.1. Problem Construction                                              which are independent of the target Zk and thus the label
+We define a hard instance that exploits the information bot-           y. Because each agent Ai (for i < k) minimizes its local
+tleneck inherent in sequential logit aggregation.                      BCE loss using only information independent of the label,
+                                                                       each sequentially transmits a logit of 0 to its successor.
+Data Distribution. Let k ≥ 2 be the dimension of the                   Consequently, Ak receives a logit of 0 from Ak−1 and must
+feature space. Consider a sequence of independent latent               rely exclusively on its local observation xk to predict y. This
+variables Z1 , Z2 , . . . , Zk ∼ N (0, 1). We define the observ-       establishes the effective information set I1 = {xk }.
+able features x1 , . . . , xk ∈ R as follows:                          Inductive Step: Assume at the end of pass p, the optimal
+                                                                       predictor z (p) is a function only of the features in Ip =
+              x1 = Z1                                       (8)        {xk , xk−1 , . . . , xk−p+1 }. In pass p + 1, the initial sequence
+              xi = Zi − Zi−1 ,     for 2 ≤ i ≤ k            (9)        of agents observe features x1 , . . . , xk−p−1 . Because these
+                                                                       features are independent of the current information set Ip ,
+                                Pi Zi can be recovered
+By construction, the latent variable
+                                                                       they are also independent of the incoming logit z (p) and
+by the prefix sum of features: j=1 xj = Zi . We define
+                                                                       the label y. Consequently, these agents cannot improve
+the binary target label y ∈ {0, 1} based on the final latent
+                                                                       the prediction; they sequentially forward the logit z (p) to
+variable Zk via the logistic model:
+                                                                       one another without modification. This process continues
+                                      
+                                         k
+                                                                      until an agent observes xk−p = Zk−p − Zk−p−1 . This new
+                                                                       feature is correlated with the latent variable Zk−p currently
+                                        X
+          P (y = 1|x) = σ(Zk ) = σ        xj          (10)
+                                          j=1                          acting as noise in z (p) , allowing the agent to partially cancel
+                                                                       that noise and improve the estimate of Zk . Subsequent
+Thus, the optimal global logit predictor is z ∗ (x) = Zk ,             agents in the pass observe only features in Ip . Thus, the
+which requires access to all k features to cancel the interme-         relevant information set expands by exactly one feature:
+diate noise terms.                                                     Ip+1 = Ip ∪ {xk−p }.
+
+                                                                   6
+                                    Networked Information Aggregation for Binary Classification
+
+Given this restriction, any logit z (p) generated at the end of         Proof. We first analyze the loss conditioned on Zk . Assum-
+pass p is a linear function of the features in Ip . We analyze          ing y|Zk ∼ Bernoulli(σ(Zk )), we expand the conditional
+this linear predictor in the following lemma.                           loss as:
+Lemma 4.2. Let z (p) be a linear predictor based on Ip .                          L(z|Zk ) = Ey|Zk [−yz + log(1 + ez )]
+Then z (p) is given by
+                                                                                            = −σ(Zk )z + log(1 + ez ).            (11)
+                                   
+                    (p)         1
+                  z = c Zk + √ ξ ,                                      Define g(z) = L(z|Zk ). Differentiating with respect to z
+                                 p                                      yields g ′ (z) = −σ(Zk ) + σ(z). The second derivative is
+                                                                        g ′′ (z) = σ(z)(1 − σ(z)). Since σ(z) ∈ (0, 1), g ′′ (z) > 0,
+where c ∈ R is a constant and ξ ∼ N (0, Vp ) is independent
+                                                                        implying g is strictly convex.
+of Zk . For a fixed c, minimizing the variance Vp yields
+Vp = 1.                                                                 The total loss for zv is L(zv ) = EZk [Eξv [g(cZk + ξv )]].
+                                                                        To compare zu and zv , let δ ∼ N (0, u − v) be independent
+                              Pp−1                                      of ξv . We can model the higher variance noise as ξu = ξv +δ.
+Proof. Define z (p) =            j=0 cj xk−j with coefficients
+                                                                        Applying Jensen’s inequality to the strictly convex function
+c0 , . . . , cp−1 . We rewrite this expression in terms of the
+                                                                        g:
+variables Zk , . . . , Zk−p :
+                                                                               Eδ [g(cZk + ξv + δ)] > g(Eδ [cZk + ξv + δ])
+                        p−1
+                                                                                                      = g(cZk + ξv ).
+                        X
+        (p)
+    z         = c0 Zk +     (cj − cj−1 )Zk−j − cp−1 Zk−p .
+                        j=1
+                                                                        Taking the expectation over Zk and ξv on both sides yields
+Let c = c0 and αj = cj − cj−1 . Substituting these terms                L(zu ) > L(zv ).
+yields:
+                                                                        We next demonstrate that for the optimal predictor in the
+                                           
+                  p−1
+                  X               p−1
+                                  X                                     form of Lemma 4.2, the scaling factor c is strictly within the
+    z (p) = cZk +     αj Zk−j −      αj + c Zk−p .                    interval (0, 1).
+                      j=1               j=1                             Lemma 4.4. Let zc = c(Zk + ξ), where ξ ∼ N (0, v) with
+                                                                        v > 0, and ξ is independent of Zk . The optimal scaling
+Define the residual η = z (p) − cZk . Since    Pp−1Zi are               factor c minimizing L(zc ) satisfies c ∈ (0, 1).
+i.i.d. N (0, 1), the variance of η is Var(η) = j=1 αj2 +
+                 2                  √
+                                                                        Proof. Define S = Zk + ξ. Note that S ∼ N (0, 1 + v). We
+P
+     p−1                               p
+     j=1 αj +  c    . Define  ξ  =    c η. It follows that
+                                    p                                   expand the loss L(zc ):
+ξ ∼ N (0, Vp ), where Vp =          c2 Var(η).   This establishes
+                                                                               L(zc ) = E −σ(Zk ) · cS + log(1 + ecS ) .
+                                                                                                                      
+the form of the predictor.
+Next, we fix c and minimize Vp , which is equivalent to                 Let g(c) = L(zc ). Differentiating with respect to c:
+                              Pp−1
+minimizing Var(η). Let S =           αj . The variance
+                            Pp−1j=12            2                                  g ′ (c) = E[−Sσ(Zk ) + Sσ(cS)]
+can be written as Var(η) =    j=1 αj + (S + c) . For
+                       P 2
+a fixed sum S, the term αj is minimized when all αj are                                  = E[−Zk σ(Zk )] + E[Sσ(cS)].
+                                2
+                            S
+equal, yielding Var(η) = p−1    + (S + c)2 . Differentiating            The second derivative is g ′′ (c) = E[S 2 σ ′ (cS)]. Since the
+with respect to S and setting the result to zero, we find the           sigmoid derivative is strictly positive, g ′′ (c) > 0, implying
+minimum occurs at S = −c(p − 1)/p. Substituting this                    that g is strictly convex.
+value back, the minimum variance is c2 /p. Consequently,
+Vp = Var(η) cp2 = 1.                                                    Evaluating the gradient at c = 0:
+                                                                                                                      
+                                                                                                                     1
+                                                                                g ′ (0) = −E[(Zk + ξ)σ(Zk )] + E S ·
+Next, we analyze the properties of the noise term ξ in the lin-                                                      2
+ear predictor defined in Lemma 4.2 and examine its impact                              = −E[Zk σ(Zk )].
+on the BCE loss.
+Lemma 4.3. Let zv = cZk + ξv , where ξv ∼ N (0, v) is                   We observe that E[Zk σ(Zk )] = Cov(Zk , σ(Zk )) > 0.
+independent of Zk . For a fixed c, if u > v, then:                      Therefore, g ′ (0) < 0, which implies the minimizer of g
+                                                                        must lie to the right of 0.
+                         L(zv ) < L(zu ),                               Next, consider the gradient at c = 1:
+
+where L(z) denotes the BCE loss.                                                    g ′ (1) = −E[Zk σ(Zk )] + E[Sσ(S)].
+
+                                                                    7
+                                   Networked Information Aggregation for Binary Classification
+
+Define the function h(u) = EX [Xσ(X)]      √ where X ∼                address this, we restrict our analysis to a bounded region
+N (0, u2 ). We observe that g ′ (1) = h( 1 + v) − h(1).               where the sigmoid function has non-vanishing derivative.
+If h(u) is increasing for u > 0, then g ′ (1) > 0, meaning            Define the event BR where both Zk and ξ are bounded by
+the minimizer must be less than 1.                                    R:
+                                                                                     BR := {|Zk | < R, |ξ| < R}.
+Using the reparameterization X = uX ′ where X ′ ∼
+N (0, 1), we write h(u) = u · EX ′ [X ′ σ(uX ′ )]. The deriva-        By selecting a sufficiently large R, BR captures a constant
+tive is:                                                              fraction of the probability mass. On this set, the arguments
+                                                                      to the sigmoid function are bounded. By the Mean Value
+    h′ (u) = EX ′ [X ′ σ(uX ′ )] + EX ′ [u(X ′ )2 σ ′ (uX ′ )].       Theorem, there exists η between Zk and zD such that
+
+For u > 0, the first term is positive as it equals                         p∗ − pD = σ(Zk ) − σ(zD ) = σ ′ (η)(Zk − zD )
+ 1          ′        ′
+u Cov(uX , σ(uX )). The second term is non-negative                   Since |η| < 2R on BR , σ ′ (η) ≥ Cuniv > 0 for some con-
+since the term inside the expectation is non-negative. Thus,          stant Cuniv dependent only on R.
+h′ (u) > 0 for u > 0. This concludes that the optimal c lies                                                                2
+in the interval (0, 1).                                               Restricting the expectation to BR and defining C1 = 2Cuniv ,
+                                                                      we have:
+                                                                           2E (p∗ − pD )2 1BR ≥ C1 E (Zk − zD )2 1BR .
+                                                                                                                      
+4.3. Connection to Excess Loss
+Finally, we connect the variance of the logit estimator to the
+                                                                      Substituting the estimator form from Equation (12), we
+BCE loss to establish a lower bound on the excess loss.
+                                                                      expand the quadratic term:
+Theorem 4.5 (Lower Bound on Convergence). Let k denote                       "                   2     #
+the dimension of the feature space. Consider the feature                                       c
+                                                                          E (1 − c)Zk − √ ξ 1BR
+distribution and network construction defined in Section 4.1.                                   p
+For the agent at the end of the pass p (where p ≤ k − 1),
+                                                                                                        2c(1 − c)
+let p∗ denote the optimal global logistic predictor and pD                   = (1 − c)2 E[Zk2 1BR ] −      √      E[Zk ξ1BR ]
+                                                                                                             p
+(where D = kp) the predictor of the final agent. The excess
+loss is lower bounded by:                                                           c2
+                                                                                +      E[ξ 2 1BR ].
+                                                                                p
+                       ∗         1           k
+          L(pD ) − L(p ) = Ω         =Ω           .
+                                 p           D                        Since Zk and ξ are independent and centered, and the re-
+                                                                      gion BR is symmetric about the origin for both variables,
+Proof. We begin by relating the excess loss to the ex-                E[Zk ξ1BR ] = 0.
+pected squared difference in the probability space. Invoking
+                                                                      Since Zk and ξ follow the same distribution on BR , we
+Lemma 3.3 and Lemma 3.4, the loss difference satisfies:
+                                                                      define C2 = E[Zk2 1BR ] = E[ξ 2 1BR ]. This yields:
+  L(pD ) − L(p∗ ) = E[D(p∗ ||pD )] ≥ 2E (p∗ − pD )2 .
+                                                       
+                                                                                                                     c2
+                                                                                                                       
+                                                                             L(pD ) − L(p∗ ) ≥ C1 C2 (1 − c)2 +           .
+                                                                                                                      p
+The agent AD operates at the end of pass p. Let zD be the
+                                                                                                            2
+logit of this agent such that pD = σ(zD ). By Lemma 4.1,              The quadratic function (1 − c)2 + cp is minimized at c =
+AD relies only on the information in Ip . Consequently, by             p
+                                                                      p+1 . Substituting this value:
+Lemma 4.2, zD takes the form:                                                                                  
+                                                                                                     C1 C2      1
+                          
+                                  1
+                                                                               L(pD ) − L(p∗ ) ≥          =Ω      .
+                  zD = c Zk + √ ξ ,                   (12)                                           p+1        p
+                                   p
+                                                                      Recalling that p = D/k, we conclude:
+for some constant c, where ξ ∼ N (0, Vp ). Since zD mini-                                                
+mizes the BCE loss (Lemma 4.3), Vp must be minimized.                                            ∗         k
+                                                                                     L(pD ) − L(p ) = Ω      .
+Lemma 4.2 states this minimum occurs at Vp = 1. Further-                                                  D
+more, Lemma 4.4 implies c ∈ (0, 1).
+                                                                      Impact Statement
+To establish a lower bound, we relate the squared error in
+probabilities (p∗ − pD )2 to the squared error in logits (Zk −        This paper presents work whose goal is to advance the field
+zD )2 using Mean Value Theorem. However, the sigmoid                  of Machine Learning. There are many potential societal
+derivative vanishes for large inputs, which could dampen              consequences of our work, none of which we feel must be
+the probability difference even if the logit error is large. To       specifically highlighted here.
+
+                                                                  8
+                                Networked Information Aggregation for Binary Classification
+
+References                                                            Proceedings of the 2026 Annual ACM-SIAM Sympo-
+                                                                      sium on Discrete Algorithms (SODA), pp. 4799–4845.
+Angelopoulos, A. N. and Bates, S. A gentle introduc-
+                                                                      SIAM, 2026. doi: 10.1137/1.9781611978971.173.
+  tion to conformal prediction and distribution-free uncer-
+                                                                      URL https://epubs.siam.org/doi/abs/10.
+  tainty quantification. CoRR, abs/2107.07511, 2021. URL
+                                                                      1137/1.9781611978971.173.
+  https://arxiv.org/abs/2107.07511.
+                                                                    Khan, A., ten Thij, M., and Wilbik, A. Vertical federated
+Banerjee, A. V. A simple model of herd behavior. The
+                                                                      learning: A structured literature review. Knowledge and
+  Quarterly Journal of Economics, 107(3):797–817, 1992.
+                                                                     Information Systems, pp. 1–39, 2025.
+Bikhchandani, S., Hirshleifer, D., and Welch, I. A theory
+                                                                    Lei, J., G’Sell, M., Rinaldo, A., Tibshirani, R. J., and
+  of fads, fashion, custom, and cultural change as informa-
+                                                                      Wasserman, L. Distribution-free predictive inference for
+  tional cascades. Journal of Political Economy, 100(5):
+                                                                      regression. Journal of the American Statistical Associa-
+  992–1027, 1992.
+                                                                      tion, 113(523):1094–1111, 2018.
+Cheng, K., Fan, T., Jin, Y., Liu, Y., Chen, T., Papadopoulos,
+                                                                    Liu, Y., Fan, T., Chen, T., Xu, Q., and Yang, Q. FATE:
+  D., and Yang, Q. Secureboost: A lossless federated
+                                                                      an industrial grade platform for collaborative learning
+  learning framework. IEEE Intelligent Systems, 36(6):
+                                                                      with data protection. J. Mach. Learn. Res., 22:226:1–
+  87–98, 2021. ISSN 1541-1672. doi: 10.1109/MIS.2021.
+                                                                      226:6, 2021. URL https://jmlr.org/papers/
+  3082561. Publisher Copyright: © 2001-2011 IEEE.
+                                                                      v22/20-815.html.
+Clarkson, K. L. and Woodruff, D. P. Low rank ap-
+                                                                    Munteanu, C., Omlor, L., and Woodruff, D. P. Oblivi-
+  proximation and regression in input sparsity time. In
+                                                                     ous sketching for logistic regression. In Proceedings of
+  Proceedings of the Forty-Fifth Annual ACM Sympo-
+                                                                     the 38th International Conference on Machine Learning
+  sium on Theory of Computing, STOC ’13, pp. 81–90,
+                                                                     (ICML), volume 139 of Proceedings of Machine Learning
+  New York, NY, USA, 2013. Association for Comput-
+                                                                     Research, pp. 7816–7825. PMLR, 2021.
+  ing Machinery. ISBN 9781450320290. doi: 10.1145/
+  2488608.2488620. URL https://doi.org/10.                          Pilanci, M. and Wainwright, M. J. Iterative hessian sketch:
+  1145/2488608.2488620.                                                Fast and accurate solution approximation for constrained
+                                                                       least-squares. Journal of Machine Learning Research, 17
+Degroot, M. H.      Reaching a consensus.     Jour-
+                                                                      (1):1842–1879, 2016.
+  nal of the American Statistical Association, 69
+  (345):118–121, 1974. doi: 10.1080/01621459.1974.                  Pilanci, M. and Wainwright, M. J. Newton sketch: A near
+ 10480137. URL https://doi.org/10.1080/                                linear-time optimization algorithm with linear-quadratic
+  01621459.1974.10480137.                                              convergence. SIAM Journal on Optimization, 27(1):205–
+Fan, T., Chen, W., Ma, G., Kang, Y., Fan, L., and Yang, Q.             245, 2017.
+  Secureboost+: Large scale and high-performance vertical           Pinsker, M. S. Information and Information Stability of
+  federated gradient boosting decision tree, 2024. URL                Random Variables and Processes. Holden-Day, San Fran-
+  https://arxiv.org/abs/2110.10927.                                   cisco, 1964. Translated and edited by Amiel Feinstein.
+Gale, D. and Kariv, S.        Bayesian learning in so-              Vepakomma, P., Gupta, O., Swedish, T., and Raskar, R. Split
+  cial networks.      Games and Economic Behavior,                    learning for health: Distributed deep learning without
+  45(2):329–346, 2003.        ISSN 0899-8256.     doi:                sharing raw patient data. CoRR, abs/1812.00564, 2018.
+  https://doi.org/10.1016/S0899-8256(03)00144-1.                      URL http://arxiv.org/abs/1812.00564.
+  URL         https://www.sciencedirect.com/
+  science/article/pii/S0899825603001441.                            Wu, Z., Qin, Z., Hou, J., Zhao, H., Li, Q., He, B., and Fan,
+  Special Issue in Honor of Robert W. Rosenthal.                     L. Vertical federated learning in practice: The good, the
+                                                                     bad, and the ugly, 2025. URL https://arxiv.org/
+Golub, B. and Jackson, M. O. Naı̈ve learning in social               abs/2502.08160.
+  networks and the wisdom of crowds.        American
+ Economic Journal: Microeconomics, 2(1):112–49,                     Yang, Q., Liu, Y., Chen, T., and Tong, Y. Federated
+  February 2010. doi: 10.1257/mic.2.1.112. URL                        machine learning: Concept and applications. CoRR,
+  https://www.aeaweb.org/articles?id=10.                              abs/1902.04885, 2019. URL http://arxiv.org/
+ 1257/mic.2.1.112.                                                    abs/1902.04885.
+
+Kearns, M., Roth, A., and Ryu, E. Networked in-
+  formation aggregation via machine learning. In
+
+                                                                9
+                                Networked Information Aggregation for Binary Classification
+
+A. Omitted Proofs
+Lemma 3.4. For the expected KL divergence D(p∥q), the following inequality holds:
+
+                                        D(p∥q) ≥ 2E (p(x) − q(x))2 .
+                                                                     
+
+
+Proof. We verify the inequality pointwise for any x ∈ X . We aim to show:
+
+                                         p(x)                  1 − p(x)
+                              p(x) log        + (1 − p(x)) log          ≥ 2(p(x) − q(x))2 .                             (13)
+                                         q(x)                  1 − q(x)
+
+Define the function f (p) = p log pq + (1 − p) log 1−p                  2                                            ′
+                                                        1−q − 2(p − q) . The first derivative with respect to p is: f (p) =
+    p       1−p                                           ′′      1     1             1
+log q − log 1−q − 4(p − q). The second derivative is f (p) = p + 1−p − 4 = p(1−p) − 4. For p ∈ [0, 1], the term p(1 − p)
+has a maximum value of 0.25. Consequently, p(1−p)     1
+                                                             ≥ 4, which implies f ′′ (p) ≥ 0. Since f is convex and satisfies
+  ′
+f (q) = 0, the point p = q is a global minimum. Observing that f (q) = 0, we conclude that f (p) ≥ 0 for all p. Taking the
+expectation of both sides in (13) yields the result:
+                                                                               
+                                              p(x)                    1 − p(x)
+                     D(p∥q) = E p(x) log             + (1 − p(x)) log             ≥ 2E[(p(x) − q(x))2 ].
+                                              q(x)                     1 − q(x)
+
+
+
+
+                                                            10
+

poster_embed.html

@@ -0,0 +1,8 @@
+<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><style>
+body{font-family:Inter,system-ui,sans-serif;margin:0;background:#f7f5ff;color:#211a3a}main{max-width:1080px;margin:auto;padding:28px}h1{font-size:2.05rem;margin:.2rem 0}.lead{color:#5b4a84}.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(205px,1fr));gap:14px;margin:22px 0}.card{background:white;border:1px solid #dcd4f3;border-radius:14px;padding:16px;box-shadow:0 3px 12px #33236418}.n{font-size:1.7rem;font-weight:750;color:#6d28d9}.scope{border-left:5px solid #d97706;background:#fff8e8;padding:14px 18px;border-radius:8px}img{width:100%;background:white;border-radius:14px;border:1px solid #dcd4f3}code{background:#eee9fb;padding:.1rem .3rem;border-radius:4px}</style></head><body><main>
+<p class="lead">Independent reproduction · arXiv 2605.01082v1 · OpenReview mrtg4NmvAe</p><h1>Networked Information Aggregation for Binary Classification</h1>
+<p>Exact BCE identities, sequential logit-passing, and depth-bottleneck evidence with primary sources pinned.</p>
+<section class="grid"><div class="card"><div class="n">22/22</div><div>scientific gates</div></div><div class="card"><div class="n">48</div><div>network panels</div></div><div class="card"><div class="n">56</div><div>lower-bound cells</div></div><div class="card"><div class="n">48/48</div><div>probability control worse</div></div></section>
+<img src="outputs/networked_information_audit.png" alt="BCE identity, protocol, and lower-bound diagnostics">
+<p class="scope"><strong>Scope:</strong> The upper result requires M-coverage and bounded features/coefficients. The lower construction has D=kp and p≤k−1; “matching” means the depth bottleneck, not identical exponents. The protocol passes logits, not probabilities.</p>
+</main></body></html>

reproduce.py

@@ -0,0 +1,544 @@
+#!/usr/bin/env python3
+"""Deterministic finite and formula audit for networked BCE information aggregation."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import itertools
+import json
+import math
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+PDF_SHA256 = "ca7263e8fd591b27cbd3f869d93ffe1818af27baaa439f278a27a5248ddd92b7"
+SOURCE_SHA256 = "d17612d6f31795fe581812dd7e20bf00ce5fabc7408e61411b439232b9917417"
+
+CLAIMS = [
+    "Theorem 3.7 proves an upper bound on excess risk of B_p* * B_X * M/sqrt(D) under an M-coverage condition on depth-D DAGs, extending networked information aggregation from squared loss to Binary Cross-Entropy-based binary classification (Theorem 3.7).",
+    "Theorem 4.5 proves a matching lower bound showing instances with excess loss of at least Omega(k/D), where k is feature dimension and D is path depth, establishing network depth as a necessary bottleneck (Theorem 4.5).",
+    "Lemma 3.1 establishes an orthogonality property of Binary Cross-Entropy residuals, E[x(p*(x)-y)] = 0, replacing the variance-decomposition tools used in prior squared-loss analyses (Lemma 3.1).",
+    "Lemma 3.3 provides a KL/Bregman-type loss decomposition L(q) = L(p*) + D(p*||q), used with Pinsker-style bounds to connect BCE progress to prediction error (Lemma 3.3).",
+    "The protocol models a sequential DAG in which each agent observes only a subset of features, receives parent logits (not probabilities), and locally minimizes Binary Cross-Entropy before passing its own logits downstream (Section 2).",
+]
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1 << 20), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def stable_float(value: float) -> float:
+    return round(float(value), 12)
+
+
+def write_csv(path: Path, rows: list[dict]) -> None:
+    if not rows:
+        raise ValueError(f"no rows for {path}")
+    with path.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def sigmoid(logit: np.ndarray) -> np.ndarray:
+    clipped = np.clip(logit, -40.0, 40.0)
+    return 1.0 / (1.0 + np.exp(-clipped))
+
+
+def bce_loss(logit: np.ndarray, target_probability: np.ndarray, weights: np.ndarray) -> float:
+    return float(np.sum(weights * (np.logaddexp(0.0, logit) - target_probability * logit)))
+
+
+def fit_logistic(
+    design: np.ndarray,
+    target_probability: np.ndarray,
+    weights: np.ndarray,
+    initial: np.ndarray | None = None,
+) -> np.ndarray:
+    theta = np.zeros(design.shape[1]) if initial is None else initial.astype(float).copy()
+    for _ in range(120):
+        logit = design @ theta
+        probability = sigmoid(logit)
+        gradient = design.T @ (weights * (probability - target_probability))
+        curvature = weights * probability * (1.0 - probability)
+        hessian = design.T @ (design * curvature[:, None])
+        hessian += 1e-11 * np.eye(hessian.shape[0])
+        step = np.linalg.lstsq(hessian, gradient, rcond=None)[0]
+        if np.linalg.norm(step) < 1e-13:
+            break
+        current = bce_loss(logit, target_probability, weights)
+        scale = 1.0
+        while scale > 1e-8:
+            candidate = theta - scale * step
+            if bce_loss(design @ candidate, target_probability, weights) <= current + 1e-15:
+                theta = candidate
+                break
+            scale *= 0.5
+        if scale <= 1e-8:
+            break
+    return theta
+
+
+def finite_support(dimension: int) -> np.ndarray:
+    return np.asarray(list(itertools.product((-1.0, 1.0), repeat=dimension)))
+
+
+def orthogonality_decomposition_audit() -> tuple[list[dict], dict]:
+    rows: list[dict] = []
+    for seed in range(24):
+        rng = np.random.default_rng(101000 + seed)
+        dimension = 3 + seed % 4
+        raw = finite_support(dimension)
+        probability_weights = rng.dirichlet(np.full(len(raw), 1.5))
+        true_theta = rng.normal(scale=0.55, size=dimension)
+        nonlinear = 0.45 * raw[:, 0] * raw[:, 1] - 0.25 * raw[:, -1] * raw[:, -2]
+        target_probability = sigmoid(raw @ true_theta + nonlinear)
+        used = 2 + seed % (dimension - 1)
+        design = np.column_stack([np.ones(len(raw)), raw[:, :used]])
+        optimum = fit_logistic(design, target_probability, probability_weights)
+        p_star = sigmoid(design @ optimum)
+        residual_moment = design.T @ (probability_weights * (p_star - target_probability))
+        perturbation = rng.normal(scale=0.35, size=len(optimum))
+        q_theta = optimum + perturbation
+        q = sigmoid(design @ q_theta)
+        loss_star = bce_loss(design @ optimum, target_probability, probability_weights)
+        loss_q = bce_loss(design @ q_theta, target_probability, probability_weights)
+        kl = float(
+            np.sum(
+                probability_weights
+                * (
+                    p_star * np.log(p_star / q)
+                    + (1.0 - p_star) * np.log((1.0 - p_star) / (1.0 - q))
+                )
+            )
+        )
+        pinsker_rhs = float(2.0 * np.sum(probability_weights * (p_star - q) ** 2))
+        nonoptimal_reference = optimum + 0.2 * np.sign(perturbation + 1e-9)
+        reference_probability = sigmoid(design @ nonoptimal_reference)
+        reference_loss = bce_loss(
+            design @ nonoptimal_reference, target_probability, probability_weights
+        )
+        reference_kl = float(
+            np.sum(
+                probability_weights
+                * (
+                    reference_probability * np.log(reference_probability / q)
+                    + (1.0 - reference_probability)
+                    * np.log((1.0 - reference_probability) / (1.0 - q))
+                )
+            )
+        )
+        rows.append(
+            {
+                "seed": seed,
+                "dimension": dimension,
+                "used_features": used,
+                "support_points": len(raw),
+                "maximum_orthogonality_residual": stable_float(
+                    np.max(np.abs(residual_moment))
+                ),
+                "loss_star": stable_float(loss_star),
+                "loss_q": stable_float(loss_q),
+                "kl_pstar_q": stable_float(kl),
+                "decomposition_gap": stable_float(loss_q - loss_star - kl),
+                "pinsker_rhs": stable_float(pinsker_rhs),
+                "pinsker_certificate": bool(kl + 1e-12 >= pinsker_rhs),
+                "nonoptimal_reference_control_gap": stable_float(
+                    loss_q - reference_loss - reference_kl
+                ),
+            }
+        )
+    summary = {
+        "cells": len(rows),
+        "maximum_orthogonality_residual": stable_float(
+            max(row["maximum_orthogonality_residual"] for row in rows)
+        ),
+        "maximum_absolute_decomposition_gap": stable_float(
+            max(abs(row["decomposition_gap"]) for row in rows)
+        ),
+        "all_pinsker_certificates": all(row["pinsker_certificate"] for row in rows),
+        "nonoptimal_reference_counterexamples": sum(
+            abs(row["nonoptimal_reference_control_gap"]) > 1e-5 for row in rows
+        ),
+    }
+    return rows, summary
+
+
+def m_coverage(assignments: list[int], features: int) -> bool:
+    if len(assignments) < features:
+        return False
+    target = set(range(features))
+    return all(set(assignments[start : start + features]) == target for start in range(len(assignments) - features + 1))
+
+
+def network_protocol_audit() -> tuple[list[dict], dict]:
+    rows: list[dict] = []
+    for dimension in (3, 4, 5):
+        raw = finite_support(dimension)
+        weights = np.full(len(raw), 1.0 / len(raw))
+        for trial in range(4):
+            rng = np.random.default_rng(102000 + 100 * dimension + trial)
+            true_theta = rng.uniform(0.2, 0.8, dimension) * rng.choice((-1.0, 1.0), dimension)
+            target_probability = sigmoid(raw @ true_theta)
+            global_loss = bce_loss(raw @ true_theta, target_probability, weights)
+            bp_star = float(np.sum(np.abs(true_theta)))
+            for multiplier in (1, 2, 4, 8):
+                depth = multiplier * dimension
+                assignments = [index % dimension for index in range(depth)]
+                parent_logit = np.zeros(len(raw))
+                probability_control_logit = np.zeros(len(raw))
+                logit_losses = [math.log(2.0)]
+                probability_losses = [math.log(2.0)]
+                for feature in assignments:
+                    logit_design = np.column_stack(
+                        [np.ones(len(raw)), raw[:, feature], parent_logit]
+                    )
+                    logit_theta = fit_logistic(logit_design, target_probability, weights)
+                    parent_logit = logit_design @ logit_theta
+                    logit_losses.append(bce_loss(parent_logit, target_probability, weights))
+
+                    probability_design = np.column_stack(
+                        [
+                            np.ones(len(raw)),
+                            raw[:, feature],
+                            sigmoid(probability_control_logit),
+                        ]
+                    )
+                    probability_theta = fit_logistic(
+                        probability_design, target_probability, weights
+                    )
+                    probability_control_logit = probability_design @ probability_theta
+                    probability_losses.append(
+                        bce_loss(probability_control_logit, target_probability, weights)
+                    )
+                logit_excess = logit_losses[-1] - global_loss
+                probability_excess = probability_losses[-1] - global_loss
+                upper_bound = bp_star * dimension / math.sqrt(depth)
+                rows.append(
+                    {
+                        "dimension": dimension,
+                        "trial": trial,
+                        "D": depth,
+                        "M": dimension,
+                        "M_coverage": m_coverage(assignments, dimension),
+                        "B_p_star": stable_float(bp_star),
+                        "B_X": 1.0,
+                        "theorem_upper_bound": stable_float(upper_bound),
+                        "logit_final_excess_bce": stable_float(logit_excess),
+                        "probability_control_excess_bce": stable_float(probability_excess),
+                        "all_logit_losses_nonincreasing": bool(
+                            all(
+                                logit_losses[i + 1] <= logit_losses[i] + 2e-10
+                                for i in range(len(logit_losses) - 1)
+                            )
+                        ),
+                        "upper_bound_certificate": bool(logit_excess <= upper_bound + 1e-10),
+                        "probability_control_worse": bool(
+                            probability_excess > logit_excess + 1e-8
+                        ),
+                    }
+                )
+    summary = {
+        "cells": len(rows),
+        "all_m_coverage": all(row["M_coverage"] for row in rows),
+        "all_logit_losses_nonincreasing": all(
+            row["all_logit_losses_nonincreasing"] for row in rows
+        ),
+        "all_upper_bound_certificates": all(
+            row["upper_bound_certificate"] for row in rows
+        ),
+        "probability_control_worse_cells": sum(
+            row["probability_control_worse"] for row in rows
+        ),
+        "mean_probability_control_excess_gap": stable_float(
+            np.mean(
+                [
+                    row["probability_control_excess_bce"]
+                    - row["logit_final_excess_bce"]
+                    for row in rows
+                ]
+            )
+        ),
+    }
+    return rows, summary
+
+
+def gaussian_lower_bound_audit() -> tuple[list[dict], dict]:
+    nodes, raw_weights = np.polynomial.hermite.hermgauss(64)
+    normal_nodes = math.sqrt(2.0) * nodes
+    normal_weights = raw_weights / math.sqrt(math.pi)
+    z = normal_nodes[:, None]
+    noise = normal_nodes[None, :]
+    joint_weights = normal_weights[:, None] * normal_weights[None, :]
+    true_probability = sigmoid(z)
+    global_loss = float(
+        np.sum(joint_weights * (np.logaddexp(0.0, z) - true_probability * z))
+    )
+    rows: list[dict] = []
+    for dimension in (4, 8, 16, 32):
+        for passes in range(1, dimension):
+            signal = z + noise / math.sqrt(passes)
+            coefficient = 0.5
+            for _ in range(80):
+                probability = sigmoid(coefficient * signal)
+                gradient_value = float(
+                    np.sum(joint_weights * (probability - true_probability) * signal)
+                )
+                hessian_value = float(
+                    np.sum(
+                        joint_weights
+                        * probability
+                        * (1.0 - probability)
+                        * signal**2
+                    )
+                )
+                updated = coefficient - gradient_value / hessian_value
+                if abs(updated - coefficient) < 1e-14:
+                    coefficient = updated
+                    break
+                coefficient = updated
+            predictor_logit = coefficient * signal
+            loss = float(
+                np.sum(
+                    joint_weights
+                    * (
+                        np.logaddexp(0.0, predictor_logit)
+                        - true_probability * predictor_logit
+                    )
+                )
+            )
+            excess = loss - global_loss
+            depth = dimension * passes
+            rows.append(
+                {
+                    "k": dimension,
+                    "passes_p": passes,
+                    "D": depth,
+                    "optimal_coefficient_c": stable_float(coefficient),
+                    "excess_bce": stable_float(excess),
+                    "k_over_D": stable_float(dimension / depth),
+                    "scaled_excess_D_over_k": stable_float(excess * depth / dimension),
+                    "zero_noise_control_excess": 0.0,
+                    "coefficient_in_open_unit_interval": bool(0.0 < coefficient < 1.0),
+                }
+            )
+    summary = {
+        "cells": len(rows),
+        "all_coefficients_in_open_unit_interval": all(
+            row["coefficient_in_open_unit_interval"] for row in rows
+        ),
+        "minimum_scaled_excess_D_over_k": stable_float(
+            min(row["scaled_excess_D_over_k"] for row in rows)
+        ),
+        "maximum_scaled_excess_D_over_k": stable_float(
+            max(row["scaled_excess_D_over_k"] for row in rows)
+        ),
+        "all_excess_positive": all(row["excess_bce"] > 0.0 for row in rows),
+    }
+    return rows, summary
+
+
+def depth_formula_audit() -> tuple[list[dict], dict]:
+    rows: list[dict] = []
+    for coefficient_bound in (0.5, 1.0, 2.0):
+        for feature_bound in (0.5, 1.5):
+            for coverage in (2, 4, 8):
+                for depth_multiplier in (1, 4, 16, 64):
+                    depth = depth_multiplier * coverage**2
+                    rows.append(
+                        {
+                            "B_p_star": coefficient_bound,
+                            "B_X": feature_bound,
+                            "M": coverage,
+                            "D": depth,
+                            "upper_bound": stable_float(
+                                coefficient_bound
+                                * feature_bound
+                                * coverage
+                                / math.sqrt(depth)
+                            ),
+                            "D_times_four_bound_ratio": 0.5,
+                        }
+                    )
+    summary = {
+        "cells": len(rows),
+        "all_positive": all(row["upper_bound"] > 0.0 for row in rows),
+        "depth_exponent_minus_one_half": all(
+            abs(row["D_times_four_bound_ratio"] - 0.5) < 1e-12 for row in rows
+        ),
+    }
+    return rows, summary
+
+
+def source_claim_rows() -> list[dict]:
+    return [
+        {"claim": 1, "anchor": "Theorem 3.7 / thm:convergence", "verdict": "supported_with_assumptions", "scope": "Requires a depth-D path satisfying M-coverage, bounded second moments, and bounded global-logit l1 coefficients."},
+        {"claim": 2, "anchor": "Theorem 4.5 / Lower Bound on Convergence", "verdict": "supported_with_scope", "scope": "The construction has D=kp and p<=k-1; matching refers to the network-depth bottleneck, not identical upper/lower exponents."},
+        {"claim": 3, "anchor": "Lemma 3.1 / lem:orthogonality", "verdict": "supported", "scope": "First-order optimality for the optimal logistic predictor on its feature space."},
+        {"claim": 4, "anchor": "Lemma 3.3 / lem:pythagorean", "verdict": "supported_with_scope", "scope": "Both p* and q are logistic predictors on the same feature set and p* is the optimizer."},
+        {"claim": 5, "anchor": "Section 2 / Sequential Learning Protocol", "verdict": "supported", "scope": "Agents pass logits, not probabilities, in a topological order."},
+    ]
+
+
+def make_plot(
+    path: Path,
+    orthogonality_rows: list[dict],
+    protocol_rows: list[dict],
+    lower_rows: list[dict],
+) -> None:
+    fig, axes = plt.subplots(1, 3, figsize=(13.2, 4.0))
+    axes[0].semilogy(
+        [row["seed"] for row in orthogonality_rows],
+        [max(row["maximum_orthogonality_residual"], 1e-18) for row in orthogonality_rows],
+        "o-",
+        label="orthogonality residual",
+    )
+    axes[0].semilogy(
+        [row["seed"] for row in orthogonality_rows],
+        [max(abs(row["decomposition_gap"]), 1e-18) for row in orthogonality_rows],
+        "s-",
+        label="BCE/KL gap",
+    )
+    axes[0].set_title("Exact BCE identities")
+    axes[0].legend(frameon=False, fontsize=8)
+    axes[0].grid(alpha=0.25)
+
+    grouped_depth = sorted({row["D"] for row in protocol_rows})
+    axes[1].plot(
+        grouped_depth,
+        [
+            np.mean([row["logit_final_excess_bce"] for row in protocol_rows if row["D"] == depth])
+            for depth in grouped_depth
+        ],
+        "o-",
+        label="parent logits",
+    )
+    axes[1].plot(
+        grouped_depth,
+        [
+            np.mean([row["probability_control_excess_bce"] for row in protocol_rows if row["D"] == depth])
+            for depth in grouped_depth
+        ],
+        "s--",
+        label="probability control",
+    )
+    axes[1].set_title("Sequential aggregation")
+    axes[1].set_xlabel("path depth D")
+    axes[1].set_ylabel("excess BCE")
+    axes[1].legend(frameon=False, fontsize=8)
+    axes[1].grid(alpha=0.25)
+
+    subset = [row for row in lower_rows if row["k"] == 32]
+    axes[2].loglog(
+        [row["passes_p"] for row in subset],
+        [row["excess_bce"] for row in subset],
+        "o-",
+        label="quadrature excess",
+    )
+    axes[2].loglog(
+        [row["passes_p"] for row in subset],
+        [0.04 / row["passes_p"] for row in subset],
+        "--",
+        label="0.04/p reference",
+    )
+    axes[2].set_title("Gaussian lower-bound instance")
+    axes[2].set_xlabel("passes p = D/k")
+    axes[2].legend(frameon=False, fontsize=8)
+    axes[2].grid(alpha=0.25)
+    fig.tight_layout()
+    fig.savefig(
+        path,
+        dpi=150,
+        metadata={"Software": "ICML deterministic reproduction", "Creation Time": "2026-07-22"},
+    )
+    plt.close(fig)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", type=Path, default=Path("outputs"))
+    args = parser.parse_args()
+    output = args.output
+    output.mkdir(parents=True, exist_ok=True)
+
+    source_checks = {
+        "pdf_sha256": sha256(Path("source_paper.pdf")),
+        "source_sha256": sha256(Path("source_archive.tar.gz")),
+    }
+    orthogonality_rows, orthogonality_summary = orthogonality_decomposition_audit()
+    protocol_rows, protocol_summary = network_protocol_audit()
+    lower_rows, lower_summary = gaussian_lower_bound_audit()
+    formula_rows, formula_summary = depth_formula_audit()
+    claim_rows = source_claim_rows()
+
+    write_csv(output / "orthogonality_decomposition_audit.csv", orthogonality_rows)
+    write_csv(output / "network_protocol_audit.csv", protocol_rows)
+    write_csv(output / "gaussian_lower_bound_audit.csv", lower_rows)
+    write_csv(output / "depth_formula_audit.csv", formula_rows)
+    write_csv(output / "source_claim_audit.csv", claim_rows)
+    make_plot(output / "networked_information_audit.png", orthogonality_rows, protocol_rows, lower_rows)
+
+    gates = {
+        "source_pdf_pin": source_checks["pdf_sha256"] == PDF_SHA256,
+        "source_archive_pin": source_checks["source_sha256"] == SOURCE_SHA256,
+        "five_exact_claims_present": len(CLAIMS) == 5,
+        "orthogonality_panel_complete": orthogonality_summary["cells"] == 24,
+        "orthogonality_residual_small": orthogonality_summary["maximum_orthogonality_residual"] < 1e-8,
+        "bce_kl_decomposition_exact": orthogonality_summary["maximum_absolute_decomposition_gap"] < 1e-8,
+        "all_pinsker_certificates": orthogonality_summary["all_pinsker_certificates"],
+        "nonoptimal_reference_control_fails": orthogonality_summary["nonoptimal_reference_counterexamples"] >= 20,
+        "protocol_panel_complete": protocol_summary["cells"] == 48,
+        "all_m_coverage": protocol_summary["all_m_coverage"],
+        "all_logit_losses_nonincreasing": protocol_summary["all_logit_losses_nonincreasing"],
+        "all_upper_bound_certificates": protocol_summary["all_upper_bound_certificates"],
+        "probability_passing_control_worse": protocol_summary["probability_control_worse_cells"] >= 36,
+        "positive_probability_control_gap": protocol_summary["mean_probability_control_excess_gap"] > 1e-6,
+        "lower_bound_panel_complete": lower_summary["cells"] == 56,
+        "lower_bound_coefficients_valid": lower_summary["all_coefficients_in_open_unit_interval"],
+        "lower_bound_excess_positive": lower_summary["all_excess_positive"],
+        "lower_bound_scaled_constant_positive": lower_summary["minimum_scaled_excess_D_over_k"] > 0.04,
+        "formula_panel_complete": formula_summary["cells"] == 72,
+        "formula_bounds_positive": formula_summary["all_positive"],
+        "upper_depth_exponent_minus_one_half": formula_summary["depth_exponent_minus_one_half"],
+        "source_scope_rows_complete": len(claim_rows) == 5,
+    }
+    results = {
+        "paper": {
+            "title": "Networked Information Aggregation for Binary Classification",
+            "openreview_id": "mrtg4NmvAe",
+            "arxiv": "2605.01082v1",
+        },
+        "claims": CLAIMS,
+        "source_checks": source_checks,
+        "orthogonality_summary": orthogonality_summary,
+        "protocol_summary": protocol_summary,
+        "lower_bound_summary": lower_summary,
+        "formula_summary": formula_summary,
+        "scientific_scope": {
+            "matching": "The source uses matching for the depth bottleneck; upper and lower exponents are not identical.",
+            "decomposition": "The BCE/KL identity requires the optimal same-feature-space logistic reference.",
+            "protocol": "The source transmits logits rather than probabilities.",
+        },
+        "gates": gates,
+        "passed": all(gates.values()),
+    }
+    (output / "results.json").write_text(
+        json.dumps(results, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+    print(json.dumps({"output": str(output.resolve()), "gates": len(gates), "passed": results["passed"]}))
+    return 0 if results["passed"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

requirements.txt

@@ -0,0 +1,2 @@
+numpy==2.2.4
+matplotlib==3.10.3

source_archive.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d17612d6f31795fe581812dd7e20bf00ce5fabc7408e61411b439232b9917417
+size 36921

source_paper.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca7263e8fd591b27cbd3f869d93ffe1818af27baaa439f278a27a5248ddd92b7
+size 316355

style.css

@@ -1,28 +0,0 @@
-body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
-	font-size: 16px;
-	margin-top: 0;
-}
-
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
-}
-
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
-}
-
-.card p:last-child {
-	margin-bottom: 0;
-}