Spaces:

YMRohit
/

icml2026-22249-self-distillation-logbook

Running

App Files Files Community

YMRohit commited on Jul 16

Commit

30290ed

verified ·

1 Parent(s): a8eb0ba

Update logbook: Repro - Optimal Unconstrained Self-Distillation in Ridge Regression

Browse files

Files changed (18) hide show

README.md +13 -5
bucket-icon.svg +5 -0
index.html +52 -17
logbook.css +1602 -0
logbook.js +2275 -0
logbook.json +71 -0
pages/claim-1-exact-improvement-and-sign/page.md +0 -0
pages/claim-2-deterministic-asymptotics/page.md +0 -0
pages/claim-3-one-shot-tuning/page.md +1953 -0
pages/conclusion/page.md +0 -0
pages/icml22249-release-artifacts/page.md +10 -0
pages/icml22249-smoke-figure4/page.md +10 -0
pages/icml22249-smoke-size/page.md +10 -0
pages/icml22249-smoke-structural/page.md +10 -0
pages/index.md +18 -0
trackio-logo-light.png +0 -0
trackio-logo.png +0 -0
trackio-wordmark-dark.png +0 -0

README.md CHANGED Viewed

@@ -1,10 +1,18 @@
 ---
-title: Icml2026 22249 Self Distillation Logbook
-emoji: 🏢
-colorFrom: blue
-colorTo: purple
 sdk: static
 pinned: false
 ---
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

 ---
+title: "Repro - Optimal Unconstrained Self-Distillation in Ridge Regression"
+emoji: 🔬
+colorFrom: yellow
+colorTo: red
 sdk: static
 pinned: false
+tags:
+ - trackio
+ - trackio-logbook
+ - open-experiment
+ - icml2026-repro
+ - paper-MdHcU4C4Rm
 ---
+# Repro - Optimal Unconstrained Self-Distillation in Ridge Regression
+An open experiment logbook, published with [Trackio](https://github.com/gradio-app/trackio).

bucket-icon.svg ADDED Viewed

index.html CHANGED Viewed

@@ -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>

 <!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Repro - Optimal Unconstrained Self-Distillation in Ridge Regression</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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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, "&amp;")
+      .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 ADDED Viewed

	@@ -0,0 +1,71 @@

+{
+  "schema_version": 1,
+  "title": "Repro - Optimal Unconstrained Self-Distillation in Ridge Regression",
+  "emoji": "🔬",
+  "space_id": "YMRohit/icml2026-22249-self-distillation-logbook",
+  "paper": {
+    "arxiv_id": "2602.17565"
+  },
+  "tags": [
+    "icml2026-repro",
+    "paper-MdHcU4C4Rm"
+  ],
+  "updated_at": "2026-07-16T17:53:23+00:00",
+  "root": {
+    "slug": "index",
+    "title": "Repro - Optimal Unconstrained Self-Distillation in Ridge Regression",
+    "file": "pages/index.md",
+    "children": [
+      {
+        "slug": "claim-1-exact-improvement-and-sign",
+        "title": "Claim 1 — Exact improvement and sign",
+        "file": "pages/claim-1-exact-improvement-and-sign/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-2-deterministic-asymptotics",
+        "title": "Claim 2 — Deterministic asymptotics",
+        "file": "pages/claim-2-deterministic-asymptotics/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-3-one-shot-tuning",
+        "title": "Claim 3 — One-shot tuning",
+        "file": "pages/claim-3-one-shot-tuning/page.md",
+        "children": []
+      },
+      {
+        "slug": "icml22249-smoke-structural",
+        "title": "icml22249-smoke-structural",
+        "file": "pages/icml22249-smoke-structural/page.md",
+        "children": []
+      },
+      {
+        "slug": "icml22249-smoke-figure4",
+        "title": "icml22249-smoke-figure4",
+        "file": "pages/icml22249-smoke-figure4/page.md",
+        "children": []
+      },
+      {
+        "slug": "icml22249-smoke-size",
+        "title": "icml22249-smoke-size",
+        "file": "pages/icml22249-smoke-size/page.md",
+        "children": []
+      },
+      {
+        "slug": "conclusion",
+        "title": "Conclusion",
+        "file": "pages/conclusion/page.md",
+        "children": []
+      },
+      {
+        "slug": "icml22249-release-artifacts",
+        "title": "icml22249-release-artifacts",
+        "file": "pages/icml22249-release-artifacts/page.md",
+        "children": []
+      }
+    ]
+  },
+  "agent_view_tokens": 7160,
+  "revision": "1784224403115312366"
+}

pages/claim-1-exact-improvement-and-sign/page.md ADDED Viewed

The diff for this file is too large to render. See raw diff

pages/claim-2-deterministic-asymptotics/page.md ADDED Viewed

The diff for this file is too large to render. See raw diff

pages/claim-3-one-shot-tuning/page.md ADDED Viewed

	@@ -0,0 +1,1953 @@

+# Claim 3 — One-shot tuning
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_ec87e9942c63", "created_at": "2026-07-16T16:15:55+00:00", "title": "Claim and protocol"}
+-->
+Tests Equations 17–21 pointwise at fixed penalties over a p/n=1/2 size ladder. It compares training-only GCV xi/risk estimates to conditional population oracles and includes the deliberately wrong df_PD=tr(H) control against the claimed tr(H²).
+---
+<!-- trackio-cell
+{"type": "dashboard", "id": "cell_8614693ec81c", "created_at": "2026-07-16T16:25:52+00:00", "title": "Dashboard: icml22249-smoke-size", "dashboard_project": "icml22249-smoke-size"}
+-->
+**🎯 Trackio dashboard** `icml22249-smoke-size`
+trackio-local-dashboard://icml22249-smoke-size
+---
+<!-- trackio-cell
+{"type": "code", "id": "cell_39209864e285", "created_at": "2026-07-16T16:25:52+00:00", "title": "Local size-ladder code-path smoke", "command": ["python", "scripts/run_reproduction.py", "--mode", "size", "--config", "configs/smoke.json", "--output-dir", "outputs/smoke/size", "--device", "cpu", "--dtype", "float64", "--trackio-project-prefix", "icml22249-smoke", "--run-name-prefix", "local-smoke-fixed"], "exit_code": 0, "duration_s": 1.438}
+-->
+````bash
+$ python scripts/run_reproduction.py --mode size --config configs/smoke.json --output-dir outputs/smoke/size --device cpu --dtype float64 --trackio-project-prefix icml22249-smoke --run-name-prefix local-smoke-fixed
+````
+exit 0 · 1.4s
+````python title=run_reproduction.py
+#!/usr/bin/env python3
+"""Run the three frozen self-distillation claim protocols.
+The script intentionally has no dependency on the official author repository.
+It writes only machine-readable raw rows and metadata; verdicts are computed by
+``audit_results.py`` in a separate pass.
+"""
+from __future__ import annotations
+import argparse
+import csv
+import hashlib
+import json
+import math
+import os
+import platform
+import sys
+import time
+from pathlib import Path
+from typing import Any
+import numpy as np
+from self_distillation_core import (
+    FiniteSimulationSpec,
+    ar1_covariance,
+    asymptotic_point,
+    bisection_root,
+    finite_simulation,
+    linear_prediction_risk,
+    logspace,
+    residual_cross_risk,
+    ridge_coefficient,
+    ridge_risk_derivative,
+    symmetric_error,
+    top_aligned_signal,
+)
+def write_json(path: Path, payload: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n", encoding="utf-8")
+def clean_row(row: dict[str, Any]) -> dict[str, Any]:
+    cleaned: dict[str, Any] = {}
+    for key, value in row.items():
+        if isinstance(value, (np.integer,)):
+            cleaned[key] = int(value)
+        elif isinstance(value, (np.floating,)):
+            cleaned[key] = float(value)
+        else:
+            cleaned[key] = value
+    return cleaned
+def write_csv(path: Path, rows: list[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if not rows:
+        raise ValueError(f"refusing to write empty CSV: {path}")
+    normalized = [clean_row(row) for row in rows]
+    fields: list[str] = []
+    seen: set[str] = set()
+    for row in normalized:
+        for key in row:
+            if key not in seen:
+                fields.append(key)
+                seen.add(key)
+    with path.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=fields)
+        writer.writeheader()
+        writer.writerows(normalized)
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+def environment_record(config_path: Path, device: str, dtype: str) -> dict[str, Any]:
+    import torch
+    source_path = Path(__file__).resolve()
+    core_path = source_path.with_name("self_distillation_core.py")
+    gpu_name = None
+    if device.startswith("cuda") and torch.cuda.is_available():
+        gpu_name = torch.cuda.get_device_name(torch.device(device))
+    return {
+        "argv": sys.argv,
+        "cwd": str(Path.cwd()),
+        "timestamp_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "python": sys.version,
+        "platform": platform.platform(),
+        "numpy_version": np.__version__,
+        "torch_version": torch.__version__,
+        "cuda_available": bool(torch.cuda.is_available()),
+        "cuda_version": torch.version.cuda,
+        "device": device,
+        "gpu_name": gpu_name,
+        "dtype": dtype,
+        "config_path": str(config_path.resolve()),
+        "config_sha256": sha256_file(config_path),
+        "runner_sha256": sha256_file(source_path),
+        "core_sha256": sha256_file(core_path),
+        "official_code_imported": False,
+    }
+def resolve_lambdas(value: Any) -> tuple[float, ...]:
+    if isinstance(value, list):
+        result = tuple(float(item) for item in value)
+    elif isinstance(value, dict):
+        result = logspace(float(value["low"]), float(value["high"]), int(value["count"]))
+    else:
+        raise TypeError("lambdas must be a list or {low, high, count}")
+    if not result or any(item <= 0 or not np.isfinite(item) for item in result):
+        raise ValueError("all lambdas must be finite and positive")
+    return result
+class TrackioRun:
+    def __init__(self, project: str | None, name: str, config: dict[str, Any]):
+        self.enabled = bool(project)
+        self.project = project
+        if not self.enabled:
+            return
+        import trackio
+        kwargs: dict[str, Any] = {
+            "project": str(project),
+            "name": name,
+            "config": config,
+            "auto_log_gpu": True,
+            "auto_log_cpu": True,
+        }
+        space_id = os.getenv("TRACKIO_SPACE_ID")
+        if space_id:
+            kwargs["space_id"] = space_id
+        trackio.init(**kwargs)
+    def log(self, metrics: dict[str, Any], step: int | None = None) -> None:
+        if not self.enabled:
+            return
+        import trackio
+        trackio.log(metrics, step=step)
+    def finish(self, artifact_path: Path | None = None, artifact_name: str | None = None) -> None:
+        if not self.enabled:
+            return
+        import trackio
+        if artifact_path is not None:
+            artifact = trackio.log_artifact(
+                artifact_path,
+                name=artifact_name,
+                type="dataset",
+                aliases=["latest"],
+            )
+            print(f"TRACKIO_ARTIFACT={artifact.qualified_name}", flush=True)
+        trackio.finish()
+def run_structural(
+    section: dict[str, Any],
+    output_dir: Path,
+    *,
+    tracker: TrackioRun,
+) -> None:
+    n = int(section.get("n", 96))
+    p = int(section.get("p", 24))
+    seed = int(section.get("seed", 22249))
+    noise_variance = float(section.get("noise_variance", 0.7))
+    lambdas = resolve_lambdas(section.get("lambdas", {"low": 1e-4, "high": 1e3, "count": 81}))
+    xi_checks = tuple(float(value) for value in section.get("xi_checks", [-3.0, -0.5, 0.0, 0.4, 1.0, 2.5]))
+    rng = np.random.default_rng(seed)
+    sigma_train = ar1_covariance(p, 0.35)
+    cholesky_train = np.linalg.cholesky(sigma_train)
+    x = rng.standard_normal((n, p)) @ cholesky_train.T
+    beta_train = rng.standard_normal(p)
+    beta_train /= np.linalg.norm(beta_train)
+    y = x @ beta_train + rng.standard_normal(n) * np.sqrt(noise_variance)
+    scale = np.linspace(0.7, 1.35, p)
+    sigma_test_base = ar1_covariance(p, 0.55)
+    sigma_test = scale[:, None] * sigma_test_base * scale[None, :]
+    shift = rng.standard_normal(p)
+    shift -= beta_train * float(beta_train @ shift)
+    shift /= np.linalg.norm(shift)
+    beta_test = 0.9 * beta_train + 0.2 * shift
+    path_rows: list[dict[str, Any]] = []
+    coefficients: dict[float, tuple[np.ndarray, np.ndarray]] = {}
+    for step, lam in enumerate(lambdas):
+        teacher = ridge_coefficient(x, y, lam)
+        pure_distilled = ridge_coefficient(x, x @ teacher, lam)
+        coefficients[lam] = (teacher, pure_distilled)
+        risk_teacher = linear_prediction_risk(teacher, beta_test, sigma_test, noise_variance)
+        risk_pd = linear_prediction_risk(pure_distilled, beta_test, sigma_test, noise_variance)
+        cross = residual_cross_risk(
+            teacher,
+            pure_distilled,
+            beta_test,
+            sigma_test,
+            noise_variance,
+        )
+        delta = teacher - pure_distilled
+        d_direct = float(delta.T @ sigma_test @ delta)
+        d_risk = risk_teacher + risk_pd - 2.0 * cross
+        derivative = ridge_risk_derivative(
+            x,
+            y,
+            teacher,
+            beta_test,
+            sigma_test,
+            lam,
+        )
+        xi_decomposition = (risk_teacher - cross) / d_direct
+        xi_derivative = -lam * derivative / (2.0 * d_direct)
+        risk_sd_decomposition = risk_teacher - (risk_teacher - cross) ** 2 / d_direct
+        risk_sd_derivative = risk_teacher - lam**2 * derivative**2 / (4.0 * d_direct)
+        student = (1.0 - xi_decomposition) * teacher + xi_decomposition * pure_distilled
+        risk_sd_direct = linear_prediction_risk(student, beta_test, sigma_test, noise_variance)
+        xi_constrained = float(np.clip(xi_decomposition, 0.0, 1.0))
+        constrained = (1.0 - xi_constrained) * teacher + xi_constrained * pure_distilled
+        risk_constrained = linear_prediction_risk(constrained, beta_test, sigma_test, noise_variance)
+        normalized_slope = abs(lam * derivative) / max(1.0, risk_teacher)
+        path_rows.append(
+            {
+                "lambda": lam,
+                "risk_teacher": risk_teacher,
+                "risk_pd": risk_pd,
+                "cross": cross,
+                "D_direct": d_direct,
+                "D_risk_form": d_risk,
+                "D_identity_error": symmetric_error(d_direct, d_risk),
+                "risk_derivative": derivative,
+                "normalized_slope": normalized_slope,
+                "xi_decomposition": xi_decomposition,
+                "xi_derivative": xi_derivative,
+                "xi_formula_error": symmetric_error(xi_decomposition, xi_derivative),
+                "risk_sd_decomposition": risk_sd_decomposition,
+                "risk_sd_derivative": risk_sd_derivative,
+                "risk_sd_direct": risk_sd_direct,
+                "risk_formula_error": max(
+                    symmetric_error(risk_sd_decomposition, risk_sd_derivative),
+                    symmetric_error(risk_sd_decomposition, risk_sd_direct),
+                ),
+                "gain": risk_teacher - risk_sd_direct,
+                "sign_rule_holds": int(
+                    normalized_slope <= 1e-9
+                    or np.sign(xi_decomposition) == -np.sign(derivative)
+                ),
+                "xi_constrained": xi_constrained,
+                "risk_constrained": risk_constrained,
+                "unconstrained_gain_over_constrained": risk_constrained - risk_sd_direct,
+            }
+        )
+        if step % max(1, len(lambdas) // 12) == 0:
+            tracker.log(
+                {
+                    "structural/lambda": lam,
+                    "structural/xi_oracle": xi_decomposition,
+                    "structural/gain": risk_teacher - risk_sd_direct,
+                    "structural/formula_error": max(
+                        symmetric_error(xi_decomposition, xi_derivative),
+                        symmetric_error(risk_sd_decomposition, risk_sd_direct),
+                    ),
+                },
+                step=step,
+            )
+    mixed_rows: list[dict[str, Any]] = []
+    selected_indices = sorted(set(np.linspace(0, len(lambdas) - 1, 9, dtype=int).tolist()))
+    for index in selected_indices:
+        lam = lambdas[index]
+        teacher, pure_distilled = coefficients[lam]
+        for xi in xi_checks:
+            mixed_labels = (1.0 - xi) * y + xi * (x @ teacher)
+            direct_student = ridge_coefficient(x, mixed_labels, lam)
+            affine_student = (1.0 - xi) * teacher + xi * pure_distilled
+            coefficient_error = float(
+                np.linalg.norm(direct_student - affine_student)
+                / max(1.0, np.linalg.norm(direct_student), np.linalg.norm(affine_student))
+            )
+            direct_risk = linear_prediction_risk(
+                direct_student, beta_test, sigma_test, noise_variance
+            )
+            affine_risk = linear_prediction_risk(
+                affine_student, beta_test, sigma_test, noise_variance
+            )
+            mixed_rows.append(
+                {
+                    "lambda": lam,
+                    "xi": xi,
+                    "coefficient_error": coefficient_error,
+                    "risk_error": symmetric_error(direct_risk, affine_risk),
+                }
+            )
+    # Locate a stationary penalty on the same conditional OOD risk path.
+    derivative_values = [float(row["risk_derivative"]) for row in path_rows]
+    brackets: list[tuple[float, float]] = []
+    for left, right, f_left, f_right in zip(
+        lambdas[:-1], lambdas[1:], derivative_values[:-1], derivative_values[1:]
+    ):
+        if f_left == 0.0 or np.signbit(f_left) != np.signbit(f_right):
+            brackets.append((left, right))
+    if not brackets:
+        raise RuntimeError("structural seed did not yield a stationary-point bracket")
+    def derivative_at(lam: float) -> float:
+        coefficient = ridge_coefficient(x, y, lam)
+        return ridge_risk_derivative(
+            x,
+            y,
+            coefficient,
+            beta_test,
+            sigma_test,
+            lam,
+        )
+    stationary_lambda = bisection_root(derivative_at, *brackets[0])
+    teacher_stationary = ridge_coefficient(x, y, stationary_lambda)
+    pd_stationary = ridge_coefficient(x, x @ teacher_stationary, stationary_lambda)
+    r_stationary = linear_prediction_risk(
+        teacher_stationary, beta_test, sigma_test, noise_variance
+    )
+    c_stationary = residual_cross_risk(
+        teacher_stationary,
+        pd_stationary,
+        beta_test,
+        sigma_test,
+        noise_variance,
+    )
+    delta_stationary = teacher_stationary - pd_stationary
+    d_stationary = float(delta_stationary.T @ sigma_test @ delta_stationary)
+    xi_stationary = (r_stationary - c_stationary) / d_stationary
+    risk_stationary_sd = r_stationary - (r_stationary - c_stationary) ** 2 / d_stationary
+    stationary_record = {
+        "lambda": stationary_lambda,
+        "risk_derivative": derivative_at(stationary_lambda),
+        "D": d_stationary,
+        "xi": xi_stationary,
+        "risk_teacher": r_stationary,
+        "risk_sd": risk_stationary_sd,
+        "gain": r_stationary - risk_stationary_sd,
+        "xi_symmetric_scale": abs(xi_stationary) / max(1.0, abs(xi_stationary)),
+        "gain_symmetric_scale": abs(r_stationary - risk_stationary_sd)
+        / max(1.0, abs(r_stationary), abs(risk_stationary_sd)),
+    }
+    # D=0 test distribution: x0 is deterministically zero.
+    zero_covariance = np.zeros_like(sigma_test)
+    degenerate_rows: list[dict[str, Any]] = []
+    reference_lambda = lambdas[len(lambdas) // 2]
+    teacher_reference, pd_reference = coefficients[reference_lambda]
+    for xi in xi_checks:
+        candidate = (1.0 - xi) * teacher_reference + xi * pd_reference
+        degenerate_rows.append(
+            {
+                "lambda": reference_lambda,
+                "xi": xi,
+                "risk": linear_prediction_risk(
+                    candidate, beta_test, zero_covariance, noise_variance
+                ),
+                "D": float(
+                    (teacher_reference - pd_reference).T
+                    @ zero_covariance
+                    @ (teacher_reference - pd_reference)
+                ),
+                "optimizer_identifiable": 0,
+            }
+        )
+    write_csv(output_dir / "structural_path.csv", path_rows)
+    write_csv(output_dir / "affine_refits.csv", mixed_rows)
+    write_csv(output_dir / "degenerate_control.csv", degenerate_rows)
+    write_json(output_dir / "stationary_point.json", stationary_record)
+    write_json(
+        output_dir / "structural_metadata.json",
+        {
+            "n": n,
+            "p": p,
+            "seed": seed,
+            "noise_variance": noise_variance,
+            "train_covariance": "AR1(0.35)",
+            "test_covariance": "diagonally scaled AR1(0.55)",
+            "test_projection_shifted": True,
+            "lambda_count": len(lambdas),
+            "affine_refit_count": len(mixed_rows),
+            "stationary_bracket": brackets[0],
+            "D_zero_control": True,
+        },
+    )
+    print(
+        json.dumps(
+            {
+                "mode": "structural",
+                "path_rows": len(path_rows),
+                "affine_refits": len(mixed_rows),
+                "stationary_lambda": stationary_lambda,
+                "max_affine_coefficient_error": max(row["coefficient_error"] for row in mixed_rows),
+                "max_formula_error": max(
+                    max(row["xi_formula_error"], row["risk_formula_error"])
+                    for row in path_rows
+                ),
+            },
+            sort_keys=True,
+        ),
+        flush=True,
+    )
+def seeded_design(
+    n: int,
+    p: int,
+    rho: float,
+    noise_variance: float,
+    seed: int,
+) -> tuple[np.ndarray, np.ndarray]:
+    sigma = ar1_covariance(p, rho)
+    rng = np.random.default_rng(seed)
+    design = rng.standard_normal((n, p)) @ np.linalg.cholesky(sigma).T
+    noise = rng.standard_normal(n) * np.sqrt(noise_variance)
+    return design, noise
+def run_figure4(
+    section: dict[str, Any],
+    output_dir: Path,
+    *,
+    device: str,
+    dtype: str,
+    tracker: TrackioRun,
+) -> None:
+    n = int(section["n"])
+    p = int(section["p"])
+    seeds = int(section["seeds"])
+    snrs = tuple(float(value) for value in section["snrs"])
+    lambdas = resolve_lambdas(section["lambdas"])
+    rho = float(section.get("rho", 0.25))
+    noise_variance = float(section.get("noise_variance", 1.0))
+    signal_seed = int(section.get("signal_seed", 2025))
+    seed_base = int(section.get("seed_base", 12000))
+    top_fraction = float(section.get("top_fraction", 0.1))
+    alignment_factor = float(section.get("alignment_factor", 0.9))
+    sigma = ar1_covariance(p, rho)
+    theory_rows: list[dict[str, Any]] = []
+    signal_rows: list[dict[str, Any]] = []
+    for snr in snrs:
+        beta, signal_info = top_aligned_signal(
+            sigma,
+            snr,
+            seed=signal_seed,
+            top_fraction=top_fraction,
+            alignment_factor=alignment_factor,
+        )
+        signal_rows.append({"snr": snr, **signal_info})
+        for lam in lambdas:
+            theory_rows.append(
+                {
+                    "experiment": "figure4",
+                    "n": n,
+                    "p": p,
+                    "snr": snr,
+                    **asymptotic_point(p / n, sigma, beta, lam, noise_variance),
+                }
+            )
+    raw_rows: list[dict[str, Any]] = []
+    metadata_rows: list[dict[str, Any]] = []
+    progress_step = 0
+    for seed_index in range(seeds):
+        seed = seed_base + seed_index
+        design, noise = seeded_design(n, p, rho, noise_variance, seed)
+        seed_rows: list[dict[str, Any]] = []
+        for snr in snrs:
+            spec = FiniteSimulationSpec(
+                n=n,
+                p=p,
+                seed=seed,
+                snr=snr,
+                lambdas=lambdas,
+                rho=rho,
+                noise_variance=noise_variance,
+                signal_seed=signal_seed,
+                top_fraction=top_fraction,
+                alignment_factor=alignment_factor,
+            )
+            rows, metadata = finite_simulation(
+                spec,
+                device=device,
+                dtype=dtype,
+                design=design,
+                noise=noise,
+            )
+            for row in rows:
+                row["experiment"] = "figure4"
+            seed_rows.extend(rows)
+            metadata_rows.append(metadata)
+        raw_rows.extend(seed_rows)
+        mean_oracle = float(np.mean([row["risk_sd_oracle"] for row in seed_rows]))
+        mean_abs_gcv_error = float(
+            np.mean(
+                [
+                    abs(row["risk_sd_hat"] - row["risk_sd_oracle"])
+                    / max(1.0, row["risk_sd_oracle"])
+                    for row in seed_rows
+                ]
+            )
+        )
+        tracker.log(
+            {
+                "figure4/completed_seeds": seed_index + 1,
+                "figure4/mean_oracle_risk": mean_oracle,
+                "figure4/mean_scaled_gcv_risk_error": mean_abs_gcv_error,
+                "figure4/max_D_hat_identity_error": max(
+                    row["D_hat_identity_error"] for row in seed_rows
+                ),
+            },
+            step=progress_step,
+        )
+        progress_step += 1
+        print(
+            f"figure4 seed {seed_index + 1}/{seeds} complete "
+            f"({len(raw_rows)} rows, device={device}, dtype={dtype})",
+            flush=True,
+        )
+    write_csv(output_dir / "figure4_raw.csv", raw_rows)
+    write_csv(output_dir / "figure4_theory.csv", theory_rows)
+    write_csv(output_dir / "figure4_signal_metadata.csv", signal_rows)
+    write_json(
+        output_dir / "figure4_protocol.json",
+        {
+            "n": n,
+            "p": p,
+            "gamma": p / n,
+            "seed_count": seeds,
+            "seed_base": seed_base,
+            "snrs": snrs,
+            "lambda_count": len(lambdas),
+            "lambda_min": min(lambdas),
+            "lambda_max": max(lambdas),
+            "rho": rho,
+            "noise_variance": noise_variance,
+            "signal_seed": signal_seed,
+            "top_fraction": top_fraction,
+            "alignment_factor": alignment_factor,
+            "population_risk_evaluation": "analytic quadratic form",
+            "raw_row_count": len(raw_rows),
+            "theory_row_count": len(theory_rows),
+        },
+    )
+def run_size_ladder(
+    section: dict[str, Any],
+    output_dir: Path,
+    *,
+    device: str,
+    dtype: str,
+    tracker: TrackioRun,
+) -> None:
+    sizes = tuple(int(value) for value in section["sizes"])
+    gamma = float(section.get("gamma", 0.5))
+    seeds = int(section["seeds"])
+    snr = float(section.get("snr", 1.0))
+    lambdas = resolve_lambdas(section["lambdas"])
+    rho = float(section.get("rho", 0.25))
+    noise_variance = float(section.get("noise_variance", 1.0))
+    signal_seed = int(section.get("signal_seed", 2025))
+    seed_base = int(section.get("seed_base", 42000))
+    top_fraction = float(section.get("top_fraction", 0.1))
+    alignment_factor = float(section.get("alignment_factor", 0.9))
+    raw_rows: list[dict[str, Any]] = []
+    theory_rows: list[dict[str, Any]] = []
+    signal_rows: list[dict[str, Any]] = []
+    progress_step = 0
+    for n in sizes:
+        p = int(round(gamma * n))
+        if p < 2 or p >= n:
+            raise ValueError("size ladder requires 2 <= p < n")
+        sigma = ar1_covariance(p, rho)
+        beta, signal_info = top_aligned_signal(
+            sigma,
+            snr,
+            seed=signal_seed,
+            top_fraction=top_fraction,
+            alignment_factor=alignment_factor,
+        )
+        signal_rows.append({"n": n, "p": p, "snr": snr, **signal_info})
+        for lam in lambdas:
+            theory_rows.append(
+                {
+                    "experiment": "size_ladder",
+                    "n": n,
+                    "p": p,
+                    "snr": snr,
+                    **asymptotic_point(p / n, sigma, beta, lam, noise_variance),
+                }
+            )
+        for seed_index in range(seeds):
+            seed = seed_base + 1000 * n + seed_index
+            design, noise = seeded_design(n, p, rho, noise_variance, seed)
+            spec = FiniteSimulationSpec(
+                n=n,
+                p=p,
+                seed=seed,
+                snr=snr,
+                lambdas=lambdas,
+                rho=rho,
+                noise_variance=noise_variance,
+                signal_seed=signal_seed,
+                top_fraction=top_fraction,
+                alignment_factor=alignment_factor,
+            )
+            rows, _ = finite_simulation(
+                spec,
+                device=device,
+                dtype=dtype,
+                design=design,
+                noise=noise,
+            )
+            for row in rows:
+                row["experiment"] = "size_ladder"
+            raw_rows.extend(rows)
+            scaled_xi_errors = [
+                abs(row["xi_hat"] - row["xi_oracle"]) / max(1.0, abs(row["xi_oracle"]))
+                for row in rows
+                if np.isfinite(row["xi_hat"]) and np.isfinite(row["xi_oracle"])
+            ]
+            tracker.log(
+                {
+                    "size_ladder/n": n,
+                    "size_ladder/completed_seed_at_size": seed_index + 1,
+                    "size_ladder/mean_scaled_xi_error": float(np.mean(scaled_xi_errors)),
+                    "size_ladder/max_D_hat_identity_error": max(
+                        row["D_hat_identity_error"] for row in rows
+                    ),
+                },
+                step=progress_step,
+            )
+            progress_step += 1
+        print(
+            f"size ladder n={n}, p={p}: {seeds} seeds complete "
+            f"({len(raw_rows)} cumulative rows, device={device})",
+            flush=True,
+        )
+    write_csv(output_dir / "size_ladder_raw.csv", raw_rows)
+    write_csv(output_dir / "size_ladder_theory.csv", theory_rows)
+    write_csv(output_dir / "size_ladder_signal_metadata.csv", signal_rows)
+    write_json(
+        output_dir / "size_ladder_protocol.json",
+        {
+            "sizes": sizes,
+            "gamma": gamma,
+            "seeds_per_size": seeds,
+            "snr": snr,
+            "lambdas": lambdas,
+            "rho": rho,
+            "noise_variance": noise_variance,
+            "signal_seed": signal_seed,
+            "top_fraction": top_fraction,
+            "alignment_factor": alignment_factor,
+            "raw_row_count": len(raw_rows),
+            "theory_row_count": len(theory_rows),
+        },
+    )
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--mode", choices=["structural", "figure4", "size", "all"], required=True)
+    parser.add_argument("--config", type=Path, required=True)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument("--device", default="cpu")
+    parser.add_argument("--dtype", choices=["float32", "float64"], default="float64")
+    parser.add_argument("--trackio-project-prefix")
+    parser.add_argument("--run-name-prefix", default="reproduction")
+    return parser.parse_args()
+def main() -> int:
+    args = parse_args()
+    config = json.loads(args.config.read_text(encoding="utf-8"))
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    write_json(
+        args.output_dir / "environment.json",
+        environment_record(args.config, args.device, args.dtype),
+    )
+    write_json(args.output_dir / "resolved_config.json", config)
+    selected_modes = [args.mode] if args.mode != "all" else ["structural", "figure4", "size"]
+    start = time.perf_counter()
+    for mode in selected_modes:
+        mode_output = args.output_dir if args.mode != "all" else args.output_dir / mode
+        mode_output.mkdir(parents=True, exist_ok=True)
+        project = None
+        if args.trackio_project_prefix:
+            project = f"{args.trackio_project_prefix}-{mode}"
+        tracker = TrackioRun(
+            project,
+            f"{args.run_name_prefix}-{mode}",
+            {
+                "paper": "MdHcU4C4Rm",
+                "submission": 22249,
+                "mode": mode,
+                "device": args.device,
+                "dtype": args.dtype,
+                "config_sha256": sha256_file(args.config),
+            },
+        )
+        mode_start = time.perf_counter()
+        try:
+            if mode == "structural":
+                run_structural(config["structural"], mode_output, tracker=tracker)
+            elif mode == "figure4":
+                run_figure4(
+                    config["figure4"],
+                    mode_output,
+                    device=args.device,
+                    dtype=args.dtype,
+                    tracker=tracker,
+                )
+            elif mode == "size":
+                run_size_ladder(
+                    config["size_ladder"],
+                    mode_output,
+                    device=args.device,
+                    dtype=args.dtype,
+                    tracker=tracker,
+                )
+            else:  # pragma: no cover - guarded by argparse/list above
+                raise AssertionError(mode)
+            elapsed = time.perf_counter() - mode_start
+            write_json(
+                mode_output / "runtime.json",
+                {"mode": mode, "wall_time_seconds": elapsed},
+            )
+            tracker.log({f"{mode}/wall_time_seconds": elapsed})
+            tracker.finish(
+                artifact_path=mode_output,
+                artifact_name=f"icml22249-{mode}-{args.run_name_prefix}",
+            )
+        except Exception:
+            tracker.finish()
+            raise
+    total_elapsed = time.perf_counter() - start
+    write_json(
+        args.output_dir / "total_runtime.json",
+        {"mode": args.mode, "wall_time_seconds": total_elapsed},
+    )
+    print(
+        json.dumps(
+            {
+                "status": "complete",
+                "mode": args.mode,
+                "output_dir": str(args.output_dir),
+                "wall_time_seconds": total_elapsed,
+            },
+            sort_keys=True,
+        ),
+        flush=True,
+    )
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())
+````
+````json title=smoke.json
+{
+  "structural": {
+    "n": 64,
+    "p": 12,
+    "seed": 22249,
+    "noise_variance": 0.7,
+    "lambdas": {
+      "low": 0.0001,
+      "high": 1000.0,
+      "count": 51
+    },
+    "xi_checks": [-3.0, -0.5, 0.0, 0.4, 1.0, 2.5]
+  },
+  "figure4": {
+    "n": 80,
+    "p": 40,
+    "seeds": 2,
+    "snrs": [0.5, 1.0, 3.0],
+    "lambdas": {
+      "low": 0.01,
+      "high": 50.0,
+      "count": 9
+    },
+    "rho": 0.25,
+    "noise_variance": 1.0,
+    "signal_seed": 2025,
+    "seed_base": 12000,
+    "top_fraction": 0.1,
+    "alignment_factor": 0.9
+  },
+  "size_ladder": {
+    "sizes": [40, 80],
+    "gamma": 0.5,
+    "seeds": 3,
+    "snr": 1.0,
+    "lambdas": [0.05, 0.5, 5.0],
+    "rho": 0.25,
+    "noise_variance": 1.0,
+    "signal_seed": 2025,
+    "seed_base": 42000,
+    "top_fraction": 0.1,
+    "alignment_factor": 0.9
+  }
+}
+````
+````output
+* Trackio project initialized: icml22249-smoke-size
+* Trackio metrics logged to: /home/tihor/ICML/campaign/wave1/repro_22249_self_distillation/.hf/trackio
+* View dashboard by running in your terminal:
+[1m[38;5;208mtrackio show --project "icml22249-smoke-size"[0m
+* or by running in Python: trackio.show(project="icml22249-smoke-size")
+* Created new run: local-smoke-fixed-size
+size ladder n=40, p=20: 3 seeds complete (9 cumulative rows, device=cpu)
+size ladder n=80, p=40: 3 seeds complete (18 cumulative rows, device=cpu)
+TRACKIO_ARTIFACT=icml22249-smoke-size/icml22249-size-local-smoke-fixed:v0
+* Run finished. Uploading logs to Trackio (please wait...)
+{"mode": "size", "output_dir": "outputs/smoke/size", "status": "complete", "wall_time_seconds": 0.5051872440089937}
+````
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_22a0c4d6ab2b", "created_at": "2026-07-16T16:25:52+00:00", "title": "Artifact: size_ladder_raw.csv", "path": "outputs/smoke/size/size_ladder_raw.csv", "size": 11296, "artifact_type": "dataset", "auto": true}
+-->
+**📦 Artifact** `outputs/smoke/size/size_ladder_raw.csv` · dataset · 11.3 kB
+trackio-local-path://outputs/smoke/size/size_ladder_raw.csv
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_8f0871ca3281", "created_at": "2026-07-16T16:25:52+00:00", "title": "Artifact: size_ladder_theory.csv", "path": "outputs/smoke/size/size_ladder_theory.csv", "size": 3041, "artifact_type": "dataset", "auto": true}
+-->
+**📦 Artifact** `outputs/smoke/size/size_ladder_theory.csv` · dataset · 3.0 kB
+trackio-local-path://outputs/smoke/size/size_ladder_theory.csv
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_884ca4af9497", "created_at": "2026-07-16T16:25:52+00:00", "title": "Artifact: size_ladder_signal_metadata.csv", "path": "outputs/smoke/size/size_ladder_signal_metadata.csv", "size": 330, "artifact_type": "dataset", "auto": true}
+-->
+**📦 Artifact** `outputs/smoke/size/size_ladder_signal_metadata.csv` · dataset · 330 B
+trackio-local-path://outputs/smoke/size/size_ladder_signal_metadata.csv
+---
+<!-- trackio-cell
+{"type": "code", "id": "cell_22d32cd75f5b", "created_at": "2026-07-16T16:25:59+00:00", "title": "Independent smoke-result audit", "command": ["python", "scripts/audit_results.py", "--structural-dir", "outputs/smoke/structural", "--figure4-dir", "outputs/smoke/figure4", "--size-dir", "outputs/smoke/size", "--output-dir", "outputs/smoke/audit", "--profile", "smoke"], "exit_code": 0, "duration_s": 0.028}
+-->
+````bash
+$ python scripts/audit_results.py --structural-dir outputs/smoke/structural --figure4-dir outputs/smoke/figure4 --size-dir outputs/smoke/size --output-dir outputs/smoke/audit --profile smoke
+````
+exit 0 · 0.0s
+````python title=audit_results.py
+#!/usr/bin/env python3
+"""Recompute all frozen claim metrics from raw CSV/JSON outputs.
+This script performs no model fitting.  Its inputs are the immutable seed-level
+rows emitted by ``run_reproduction.py``; its outputs are aggregate tables and
+machine-readable pass/fail dispositions tied directly to ``CLAIMS.md``.
+"""
+from __future__ import annotations
+import argparse
+import csv
+import json
+import math
+import statistics
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, Iterable
+def read_csv(path: Path) -> list[dict[str, str]]:
+    with path.open(newline="", encoding="utf-8") as handle:
+        return list(csv.DictReader(handle))
+def number(row: dict[str, str], key: str) -> float:
+    return float(row[key])
+def integer(row: dict[str, str], key: str) -> int:
+    return int(float(row[key]))
+def key_float(value: float) -> str:
+    return f"{float(value):.14g}"
+def median(values: Iterable[float]) -> float:
+    materialized = list(values)
+    if not materialized:
+        return float("nan")
+    return float(statistics.median(materialized))
+def mean(values: Iterable[float]) -> float:
+    materialized = list(values)
+    if not materialized:
+        return float("nan")
+    return float(statistics.fmean(materialized))
+def quantile(values: Iterable[float], probability: float) -> float:
+    ordered = sorted(float(value) for value in values)
+    if not ordered:
+        return float("nan")
+    if len(ordered) == 1:
+        return ordered[0]
+    position = probability * (len(ordered) - 1)
+    lower = int(math.floor(position))
+    upper = int(math.ceil(position))
+    weight = position - lower
+    return float((1.0 - weight) * ordered[lower] + weight * ordered[upper])
+def sample_standard_error(values: list[float]) -> float:
+    if len(values) < 2:
+        return float("nan")
+    return float(statistics.stdev(values) / math.sqrt(len(values)))
+def write_csv(path: Path, rows: list[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if not rows:
+        raise ValueError(f"empty aggregate table: {path}")
+    fields: list[str] = []
+    seen: set[str] = set()
+    for row in rows:
+        for key in row:
+            if key not in seen:
+                fields.append(key)
+                seen.add(key)
+    with path.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=fields)
+        writer.writeheader()
+        writer.writerows(rows)
+def write_json(path: Path, payload: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n", encoding="utf-8")
+def safe_json_float(value: float) -> float | None:
+    return float(value) if math.isfinite(float(value)) else None
+def gate(name: str, passed: bool, value: Any, threshold: str, detail: str = "") -> dict[str, Any]:
+    return {
+        "name": name,
+        "passed": bool(passed),
+        "value": value,
+        "threshold": threshold,
+        "detail": detail,
+    }
+def audit_claim1(structural_dir: Path) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    path_rows = read_csv(structural_dir / "structural_path.csv")
+    affine_rows = read_csv(structural_dir / "affine_refits.csv")
+    degenerate_rows = read_csv(structural_dir / "degenerate_control.csv")
+    stationary = json.loads((structural_dir / "stationary_point.json").read_text(encoding="utf-8"))
+    max_affine = max(number(row, "coefficient_error") for row in affine_rows)
+    usable = [row for row in path_rows if number(row, "D_direct") > 1e-12]
+    max_formula = max(
+        max(number(row, "xi_formula_error"), number(row, "risk_formula_error"))
+        for row in usable
+    )
+    nonstationary = [row for row in usable if number(row, "normalized_slope") > 1e-9]
+    strict_count = sum(
+        number(row, "gain") > 2e-12 * max(1.0, number(row, "risk_teacher"))
+        for row in nonstationary
+    )
+    sign_count = sum(integer(row, "sign_rule_holds") == 1 for row in nonstationary)
+    over_regularized = [
+        row
+        for row in nonstationary
+        if number(row, "risk_derivative") > 0.0
+    ]
+    over_pass_count = 0
+    for row in over_regularized:
+        teacher = number(row, "risk_teacher")
+        constrained = number(row, "risk_constrained")
+        over_pass_count += int(
+            number(row, "xi_decomposition") < 0.0
+            and abs(number(row, "xi_constrained")) <= 2e-10
+            and abs(constrained - teacher) / max(1.0, abs(teacher), abs(constrained)) <= 2e-10
+            and number(row, "gain") > 2e-12 * max(1.0, teacher)
+        )
+    degenerate_risks = [number(row, "risk") for row in degenerate_rows]
+    degenerate_range = max(degenerate_risks) - min(degenerate_risks)
+    max_degenerate_d = max(abs(number(row, "D")) for row in degenerate_rows)
+    identifiable_count = sum(integer(row, "optimizer_identifiable") for row in degenerate_rows)
+    gates = [
+        gate(
+            "affine_refit_identity",
+            max_affine <= 2e-10,
+            max_affine,
+            "max coefficient error <= 2e-10",
+            f"{len(affine_rows)} direct mixed-label refits",
+        ),
+        gate(
+            "closed_form_identities",
+            max_formula <= 2e-9,
+            max_formula,
+            "max symmetric formula error <= 2e-9",
+            f"{len(usable)} D-positive path points",
+        ),
+        gate(
+            "strict_nonstationary_improvement",
+            bool(nonstationary) and strict_count == len(nonstationary),
+            {"passing": strict_count, "tested": len(nonstationary)},
+            "all normalized-slope > 1e-9 points have gain > numerical tolerance",
+        ),
+        gate(
+            "sign_rule",
+            bool(nonstationary) and sign_count == len(nonstationary),
+            {"passing": sign_count, "tested": len(nonstationary)},
+            "100% sign agreement",
+        ),
+        gate(
+            "stationary_touch",
+            float(stationary["xi_symmetric_scale"]) <= 2e-7
+            and float(stationary["gain_symmetric_scale"]) <= 2e-9,
+            {
+                "lambda": stationary["lambda"],
+                "xi_scale": stationary["xi_symmetric_scale"],
+                "gain_scale": stationary["gain_symmetric_scale"],
+            },
+            "xi scale <= 2e-7 and gain scale <= 2e-9",
+        ),
+        gate(
+            "negative_xi_beats_constrained_control",
+            bool(over_regularized) and over_pass_count == len(over_regularized),
+            {"passing": over_pass_count, "tested": len(over_regularized)},
+            "all over-regularized points: xi*<0, clipped xi=0, only unrestricted fit gains",
+        ),
+        gate(
+            "D_zero_nonidentifiability_control",
+            degenerate_range <= 2e-12
+            and max_degenerate_d <= 2e-12
+            and identifiable_count == 0,
+            {
+                "risk_range": degenerate_range,
+                "max_abs_D": max_degenerate_d,
+                "identifiable_count": identifiable_count,
+            },
+            "risk range and |D| <= 2e-12; optimizer never marked identifiable",
+        ),
+    ]
+    passed = all(item["passed"] for item in gates)
+    summary = {
+        "claim": 1,
+        "headline": "Exact pointwise improvement and unconstrained sign rule",
+        "passed": passed,
+        "verdict": "Supported, conditional" if passed else "Not reproduced",
+        "evidence_class": "full algebraic/numerical identity check on a conditional OOD problem",
+        "gates": gates,
+        "counts": {
+            "path_rows": len(path_rows),
+            "nonstationary_rows": len(nonstationary),
+            "over_regularized_rows": len(over_regularized),
+            "affine_refits": len(affine_rows),
+            "degenerate_controls": len(degenerate_rows),
+        },
+        "scope": "Conditional seeded mechanism evidence; D>0 and nonstationarity are essential.",
+    }
+    return summary, path_rows
+def theory_map(rows: list[dict[str, str]], include_size: bool) -> dict[tuple[str, ...], dict[str, str]]:
+    result: dict[tuple[str, ...], dict[str, str]] = {}
+    for row in rows:
+        components = []
+        if include_size:
+            components.extend([str(integer(row, "n")), str(integer(row, "p"))])
+        components.extend([key_float(number(row, "snr")), key_float(number(row, "lambda"))])
+        result[tuple(components)] = row
+    return result
+def audit_claim2(
+    figure4_dir: Path,
+    size_dir: Path,
+    output_dir: Path,
+) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    raw = read_csv(figure4_dir / "figure4_raw.csv")
+    theory = read_csv(figure4_dir / "figure4_theory.csv")
+    lookup = theory_map(theory, include_size=False)
+    grouped: dict[tuple[str, str], list[dict[str, str]]] = defaultdict(list)
+    for row in raw:
+        grouped[(key_float(number(row, "snr")), key_float(number(row, "lambda")))].append(row)
+    aggregates: list[dict[str, Any]] = []
+    for key, rows in sorted(grouped.items(), key=lambda item: (float(item[0][0]), float(item[0][1]))):
+        theory_row = lookup[key]
+        d_theory = number(theory_row, "D_theory")
+        empirical_risks = [number(row, "risk_sd_oracle") for row in rows]
+        empirical_xis = [number(row, "xi_oracle") for row in rows]
+        risk_mean = mean(empirical_risks)
+        risk_theory = number(theory_row, "risk_sd_theory")
+        relative_error = abs(risk_mean - risk_theory) / max(1e-12, abs(risk_theory))
+        risk_se = sample_standard_error(empirical_risks)
+        covered = int(
+            (math.isfinite(risk_se) and abs(risk_mean - risk_theory) <= 2.0 * risk_se)
+            or relative_error <= 0.03
+        )
+        xi_mean = mean(empirical_xis)
+        xi_theory = number(theory_row, "xi_theory")
+        xi_scaled_error = abs(xi_mean - xi_theory) / max(1.0, abs(xi_theory))
+        sign_eligible = int(abs(xi_theory) >= 0.1)
+        sign_agrees = int(not sign_eligible or math.copysign(1.0, xi_mean) == math.copysign(1.0, xi_theory))
+        aggregates.append(
+            {
+                "snr": number(theory_row, "snr"),
+                "lambda": number(theory_row, "lambda"),
+                "seed_count": len(rows),
+                "D_theory": d_theory,
+                "risk_sd_theory": risk_theory,
+                "risk_sd_empirical_mean": risk_mean,
+                "risk_sd_empirical_se": risk_se,
+                "risk_relative_error": relative_error,
+                "risk_covered_2se_or_3pct": covered,
+                "xi_theory": xi_theory,
+                "xi_empirical_mean": xi_mean,
+                "xi_scaled_error": xi_scaled_error,
+                "xi_sign_eligible": sign_eligible,
+                "xi_sign_agrees": sign_agrees,
+                "fixed_point_residual": number(theory_row, "fixed_point_residual"),
+                "min_D_oracle": min(number(row, "D_oracle") for row in rows),
+            }
+        )
+    usable = [row for row in aggregates if float(row["D_theory"]) > 1e-8]
+    risk_errors = [float(row["risk_relative_error"]) for row in usable]
+    median_risk_error = median(risk_errors)
+    p90_risk_error = quantile(risk_errors, 0.9)
+    coverage_rate = mean(float(row["risk_covered_2se_or_3pct"]) for row in usable)
+    xi_eligible = [row for row in usable if int(row["xi_sign_eligible"]) == 1]
+    sign_rate = mean(float(row["xi_sign_agrees"]) for row in xi_eligible)
+    median_xi_scaled_error = median(float(row["xi_scaled_error"]) for row in usable)
+    max_fp_residual = max(float(row["fixed_point_residual"]) for row in aggregates)
+    min_d = min(
+        min(float(row["D_theory"]), float(row["min_D_oracle"]))
+        for row in usable
+    )
+    size_raw = read_csv(size_dir / "size_ladder_raw.csv")
+    size_theory = read_csv(size_dir / "size_ladder_theory.csv")
+    size_lookup = theory_map(size_theory, include_size=True)
+    size_groups: dict[tuple[str, str, str, str], list[dict[str, str]]] = defaultdict(list)
+    for row in size_raw:
+        key = (
+            str(integer(row, "n")),
+            str(integer(row, "p")),
+            key_float(number(row, "snr")),
+            key_float(number(row, "lambda")),
+        )
+        size_groups[key].append(row)
+    size_cell_rows: list[dict[str, Any]] = []
+    for key, rows in size_groups.items():
+        theory_row = size_lookup[key]
+        empirical_mean = mean(number(row, "risk_sd_oracle") for row in rows)
+        theoretical = number(theory_row, "risk_sd_theory")
+        size_cell_rows.append(
+            {
+                "n": int(key[0]),
+                "p": int(key[1]),
+                "lambda": number(theory_row, "lambda"),
+                "seed_count": len(rows),
+                "risk_sd_empirical_mean": empirical_mean,
+                "risk_sd_theory": theoretical,
+                "risk_relative_error": abs(empirical_mean - theoretical)
+                / max(1e-12, abs(theoretical)),
+            }
+        )
+    errors_by_size: dict[int, list[float]] = defaultdict(list)
+    for row in size_cell_rows:
+        errors_by_size[int(row["n"])].append(float(row["risk_relative_error"]))
+    size_error_rows = [
+        {
+            "n": size,
+            "cell_count": len(values),
+            "mean_risk_relative_error": mean(values),
+            "median_risk_relative_error": median(values),
+        }
+        for size, values in sorted(errors_by_size.items())
+    ]
+    smallest = min(errors_by_size)
+    largest = max(errors_by_size)
+    smallest_error = mean(errors_by_size[smallest])
+    largest_error = mean(errors_by_size[largest])
+    gates = [
+        gate(
+            "median_risk_error",
+            median_risk_error <= 0.05,
+            median_risk_error,
+            "<= 5%",
+        ),
+        gate(
+            "p90_risk_error",
+            p90_risk_error <= 0.12,
+            p90_risk_error,
+            "<= 12%",
+        ),
+        gate(
+            "risk_coverage",
+            coverage_rate >= 0.80,
+            coverage_rate,
+            ">= 80% within 2 SE or 3%",
+        ),
+        gate(
+            "xi_sign_agreement",
+            bool(xi_eligible) and sign_rate >= 0.95,
+            {"rate": sign_rate, "eligible_cells": len(xi_eligible)},
+            ">= 95% where |xi_theory| >= 0.1",
+        ),
+        gate(
+            "median_xi_scaled_error",
+            median_xi_scaled_error <= 0.15,
+            median_xi_scaled_error,
+            "<= 15%",
+        ),
+        gate(
+            "size_convergence",
+            largest_error < smallest_error,
+            {
+                "smallest_n": smallest,
+                "smallest_mean_error": smallest_error,
+                "largest_n": largest,
+                "largest_mean_error": largest_error,
+            },
+            "largest-size aggregate risk error < smallest-size error",
+        ),
+        gate(
+            "fixed_point_and_positive_D",
+            max_fp_residual < 1e-10 and min_d > 0.0,
+            {"max_fixed_point_residual": max_fp_residual, "minimum_usable_D": min_d},
+            "fixed-point residual < 1e-10 and all usable D positive",
+        ),
+    ]
+    passed = all(item["passed"] for item in gates)
+    summary = {
+        "claim": 2,
+        "headline": "Deterministic equivalents align with finite-sample Figure 4 behavior",
+        "passed": passed,
+        "verdict": "Supported" if passed else "Not reproduced",
+        "evidence_class": "paper-native stochastic reproduction plus proportional size check",
+        "gates": gates,
+        "counts": {
+            "raw_seed_rows": len(raw),
+            "theory_cells": len(aggregates),
+            "usable_theory_cells": len(usable),
+            "size_raw_rows": len(size_raw),
+            "size_cells": len(size_cell_rows),
+        },
+        "scope": "Gaussian AR(1), fixed top-aligned signal, analytic in-distribution risk.",
+    }
+    write_csv(output_dir / "claim2_figure4_aggregates.csv", aggregates)
+    write_csv(output_dir / "claim2_size_cells.csv", size_cell_rows)
+    write_csv(output_dir / "claim2_size_summary.csv", size_error_rows)
+    return summary, aggregates
+def audit_claim3(size_dir: Path, output_dir: Path) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    raw = read_csv(size_dir / "size_ladder_raw.csv")
+    usable: list[dict[str, Any]] = []
+    excluded = 0
+    for row in raw:
+        d_oracle = number(row, "D_oracle")
+        d_hat = number(row, "D_hat")
+        if d_oracle <= 1e-10 or d_hat <= 1e-10:
+            excluded += 1
+            continue
+        xi_oracle = number(row, "xi_oracle")
+        xi_hat = number(row, "xi_hat")
+        xi_wrong = number(row, "xi_wrong_df")
+        risk_oracle = number(row, "risk_sd_oracle")
+        risk_hat = number(row, "risk_sd_hat")
+        actual = number(row, "risk_sd_xihat_actual")
+        wrong_actual = number(row, "risk_wrong_df_actual")
+        usable.append(
+            {
+                "n": integer(row, "n"),
+                "p": integer(row, "p"),
+                "seed": integer(row, "seed"),
+                "lambda": number(row, "lambda"),
+                "xi_oracle": xi_oracle,
+                "xi_hat": xi_hat,
+                "xi_wrong_df": xi_wrong,
+                "xi_scaled_error": abs(xi_hat - xi_oracle) / max(1.0, abs(xi_oracle)),
+                "xi_wrong_scaled_error": abs(xi_wrong - xi_oracle) / max(1.0, abs(xi_oracle)),
+                "risk_estimate_scaled_error": abs(risk_hat - risk_oracle)
+                / max(1.0, risk_oracle),
+                "actual_regret_scaled": max(0.0, actual - risk_oracle) / max(1.0, risk_oracle),
+                "wrong_actual_regret_scaled": max(0.0, wrong_actual - risk_oracle)
+                / max(1.0, risk_oracle),
+                "sign_eligible": int(abs(xi_oracle) >= 0.1),
+                "sign_agrees": int(
+                    abs(xi_oracle) < 0.1
+                    or math.copysign(1.0, xi_hat) == math.copysign(1.0, xi_oracle)
+                ),
+                "negative_oracle": int(xi_oracle < -0.1),
+                "negative_sign_agrees": int(xi_oracle >= -0.1 or xi_hat < 0.0),
+                "D_hat": d_hat,
+                "D_hat_identity_error": number(row, "D_hat_identity_error"),
+            }
+        )
+    grouped: dict[int, list[dict[str, Any]]] = defaultdict(list)
+    for row in usable:
+        grouped[int(row["n"])].append(row)
+    size_summaries: list[dict[str, Any]] = []
+    for n, rows in sorted(grouped.items()):
+        eligible = [row for row in rows if row["sign_eligible"]]
+        negatives = [row for row in rows if row["negative_oracle"]]
+        size_summaries.append(
+            {
+                "n": n,
+                "p": int(rows[0]["p"]),
+                "usable_rows": len(rows),
+                "mean_xi_scaled_error": mean(row["xi_scaled_error"] for row in rows),
+                "median_xi_scaled_error": median(row["xi_scaled_error"] for row in rows),
+                "mean_risk_estimate_scaled_error": mean(
+                    row["risk_estimate_scaled_error"] for row in rows
+                ),
+                "median_risk_estimate_scaled_error": median(
+                    row["risk_estimate_scaled_error"] for row in rows
+                ),
+                "mean_actual_regret_scaled": mean(row["actual_regret_scaled"] for row in rows),
+                "median_actual_regret_scaled": median(row["actual_regret_scaled"] for row in rows),
+                "sign_eligible_rows": len(eligible),
+                "sign_agreement": mean(row["sign_agrees"] for row in eligible),
+                "negative_oracle_rows": len(negatives),
+                "negative_sign_agreement": mean(row["negative_sign_agrees"] for row in negatives),
+                "mean_wrong_xi_scaled_error": mean(
+                    row["xi_wrong_scaled_error"] for row in rows
+                ),
+                "mean_wrong_actual_regret_scaled": mean(
+                    row["wrong_actual_regret_scaled"] for row in rows
+                ),
+                "max_D_hat_identity_error": max(row["D_hat_identity_error"] for row in rows),
+                "min_D_hat": min(row["D_hat"] for row in rows),
+            }
+        )
+    smallest_n = min(grouped)
+    largest_n = max(grouped)
+    smallest = next(row for row in size_summaries if int(row["n"]) == smallest_n)
+    largest = next(row for row in size_summaries if int(row["n"]) == largest_n)
+    all_max_identity = max(row["D_hat_identity_error"] for row in usable)
+    all_min_d_hat = min(row["D_hat"] for row in usable)
+    gates = [
+        gate(
+            "pointwise_error_decreases",
+            float(largest["mean_xi_scaled_error"]) < float(smallest["mean_xi_scaled_error"])
+            and float(largest["mean_risk_estimate_scaled_error"])
+            < float(smallest["mean_risk_estimate_scaled_error"]),
+            {
+                "smallest_n": smallest_n,
+                "smallest_mean_xi_error": smallest["mean_xi_scaled_error"],
+                "largest_n": largest_n,
+                "largest_mean_xi_error": largest["mean_xi_scaled_error"],
+                "smallest_mean_risk_error": smallest["mean_risk_estimate_scaled_error"],
+                "largest_mean_risk_error": largest["mean_risk_estimate_scaled_error"],
+            },
+            "largest-size mean xi and risk errors < smallest-size errors",
+        ),
+        gate(
+            "largest_size_accuracy",
+            float(largest["median_xi_scaled_error"]) <= 0.15
+            and float(largest["median_risk_estimate_scaled_error"]) <= 0.05
+            and float(largest["median_actual_regret_scaled"]) <= 0.02,
+            {
+                "median_xi_error": largest["median_xi_scaled_error"],
+                "median_risk_error": largest["median_risk_estimate_scaled_error"],
+                "median_actual_regret": largest["median_actual_regret_scaled"],
+            },
+            "largest size: xi <=15%, risk estimate <=5%, actual regret <=2%",
+        ),
+        gate(
+            "largest_size_signs_including_negative",
+            int(largest["sign_eligible_rows"]) > 0
+            and int(largest["negative_oracle_rows"]) > 0
+            and float(largest["sign_agreement"]) >= 0.90
+            and float(largest["negative_sign_agreement"]) >= 0.90,
+            {
+                "eligible": largest["sign_eligible_rows"],
+                "agreement": safe_json_float(float(largest["sign_agreement"])),
+                "negative_eligible": largest["negative_oracle_rows"],
+                "negative_agreement": safe_json_float(float(largest["negative_sign_agreement"])),
+            },
+            ">=90% overall and negative-weight sign agreement",
+        ),
+        gate(
+            "D_hat_identity_and_nonnegativity",
+            all_max_identity <= 2e-10 and all_min_d_hat >= -2e-12,
+            {"max_identity_error": all_max_identity, "minimum_D_hat": all_min_d_hat},
+            "identity error <=2e-10 and D_hat >=-2e-12",
+        ),
+        gate(
+            "correct_PD_df_beats_wrong_control",
+            float(largest["mean_xi_scaled_error"]) + 1e-5
+            < float(largest["mean_wrong_xi_scaled_error"])
+            and float(largest["mean_actual_regret_scaled"])
+            <= float(largest["mean_wrong_actual_regret_scaled"]),
+            {
+                "correct_mean_xi_error": largest["mean_xi_scaled_error"],
+                "wrong_mean_xi_error": largest["mean_wrong_xi_scaled_error"],
+                "correct_mean_regret": largest["mean_actual_regret_scaled"],
+                "wrong_mean_regret": largest["mean_wrong_actual_regret_scaled"],
+            },
+            "correct xi error at least 1e-5 lower and actual regret no larger",
+        ),
+    ]
+    passed = all(item["passed"] for item in gates)
+    summary = {
+        "claim": 3,
+        "headline": "One-shot GCV tuning is pointwise consistent",
+        "passed": passed,
+        "verdict": "Supported, conditional" if passed else "Not reproduced",
+        "evidence_class": "fixed-penalty proportional size ladder",
+        "gates": gates,
+        "counts": {
+            "raw_rows": len(raw),
+            "usable_rows": len(usable),
+            "excluded_D_small": excluded,
+            "sizes": sorted(grouped),
+        },
+        "scope": "Pointwise fixed penalties only; no uniform lambda-selection claim.",
+    }
+    write_csv(output_dir / "claim3_size_summary.csv", size_summaries)
+    write_csv(output_dir / "claim3_row_errors.csv", usable)
+    return summary, size_summaries
+def build_markdown(claims: list[dict[str, Any]]) -> str:
+    lines = [
+        "# Reproduction audit summary",
+        "",
+        "This file is generated from seed-level raw CSVs by `scripts/audit_results.py`.",
+        "",
+        "| Claim | Verdict | Evidence class |",
+        "|---|---|---|",
+    ]
+    for claim in claims:
+        lines.append(
+            f"| {claim['claim']} — {claim['headline']} | **{claim['verdict']}** | {claim['evidence_class']} |"
+        )
+    for claim in claims:
+        lines.extend(["", f"## Claim {claim['claim']}", ""])
+        for item in claim["gates"]:
+            mark = "PASS" if item["passed"] else "FAIL"
+            lines.append(
+                f"- **{mark} — {item['name']}**: `{json.dumps(item['value'], sort_keys=True)}`; {item['threshold']}."
+            )
+        lines.extend(["", f"Scope: {claim['scope']}"])
+    return "\n".join(lines) + "\n"
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--structural-dir", type=Path, required=True)
+    parser.add_argument("--figure4-dir", type=Path, required=True)
+    parser.add_argument("--size-dir", type=Path, required=True)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument(
+        "--profile",
+        choices=["smoke", "frozen"],
+        default="frozen",
+        help="smoke computes all gates but exits zero if files/invariants parse; frozen exits nonzero on failed claims",
+    )
+    return parser.parse_args()
+def main() -> int:
+    args = parse_args()
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    claim1, _ = audit_claim1(args.structural_dir)
+    claim2, _ = audit_claim2(args.figure4_dir, args.size_dir, args.output_dir)
+    claim3, _ = audit_claim3(args.size_dir, args.output_dir)
+    claims = [claim1, claim2, claim3]
+    payload = {
+        "paper": "MdHcU4C4Rm",
+        "submission": 22249,
+        "profile": args.profile,
+        "all_claims_passed": all(claim["passed"] for claim in claims),
+        "claims": claims,
+    }
+    write_json(args.output_dir / "verdicts.json", payload)
+    (args.output_dir / "audit_summary.md").write_text(build_markdown(claims), encoding="utf-8")
+    print(json.dumps(payload, indent=2, sort_keys=True), flush=True)
+    if args.profile == "frozen" and not payload["all_claims_passed"]:
+        return 2
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())
+````
+````output
+{
+  "all_claims_passed": false,
+  "claims": [
+    {
+      "claim": 1,
+      "counts": {
+        "affine_refits": 54,
+        "degenerate_controls": 6,
+        "nonstationary_rows": 51,
+        "over_regularized_rows": 26,
+        "path_rows": 51
+      },
+      "evidence_class": "full algebraic/numerical identity check on a conditional OOD problem",
+      "gates": [
+        {
+          "detail": "54 direct mixed-label refits",
+          "name": "affine_refit_identity",
+          "passed": true,
+          "threshold": "max coefficient error <= 2e-10",
+          "value": 2.832617238042333e-15
+        },
+        {
+          "detail": "51 D-positive path points",
+          "name": "closed_form_identities",
+          "passed": true,
+          "threshold": "max symmetric formula error <= 2e-9",
+          "value": 1.0628259316071285e-12
+        },
+        {
+          "detail": "",
+          "name": "strict_nonstationary_improvement",
+          "passed": true,
+          "threshold": "all normalized-slope > 1e-9 points have gain > numerical tolerance",
+          "value": {
+            "passing": 51,
+            "tested": 51
+          }
+        },
+        {
+          "detail": "",
+          "name": "sign_rule",
+          "passed": true,
+          "threshold": "100% sign agreement",
+          "value": {
+            "passing": 51,
+            "tested": 51
+          }
+        },
+        {
+          "detail": "",
+          "name": "stationary_touch",
+          "passed": true,
+          "threshold": "xi scale <= 2e-7 and gain scale <= 2e-9",
+          "value": {
+            "gain_scale": 0.0,
+            "lambda": 0.25059061945244254,
+            "xi_scale": 1.2805712565489336e-13
+          }
+        },
+        {
+          "detail": "",
+          "name": "negative_xi_beats_constrained_control",
+          "passed": true,
+          "threshold": "all over-regularized points: xi*<0, clipped xi=0, only unrestricted fit gains",
+          "value": {
+            "passing": 26,
+            "tested": 26
+          }
+        },
+        {
+          "detail": "",
+          "name": "D_zero_nonidentifiability_control",
+          "passed": true,
+          "threshold": "risk range and |D| <= 2e-12; optimizer never marked identifiable",
+          "value": {
+            "identifiable_count": 0,
+            "max_abs_D": 0.0,
+            "risk_range": 0.0
+          }
+        }
+      ],
+      "headline": "Exact pointwise improvement and unconstrained sign rule",
+      "passed": true,
+      "scope": "Conditional seeded mechanism evidence; D>0 and nonstationarity are essential.",
+      "verdict": "Supported, conditional"
+    },
+    {
+      "claim": 2,
+      "counts": {
+        "raw_seed_rows": 54,
+        "size_cells": 6,
+        "size_raw_rows": 18,
+        "theory_cells": 27,
+        "usable_theory_cells": 27
+      },
+      "evidence_class": "paper-native stochastic reproduction plus proportional size check",
+      "gates": [
+        {
+          "detail": "",
+          "name": "median_risk_error",
+          "passed": false,
+          "threshold": "<= 5%",
+          "value": 0.08006072126529783
+        },
+        {
+          "detail": "",
+          "name": "p90_risk_error",
+          "passed": true,
+          "threshold": "<= 12%",
+          "value": 0.11037946969877559
+        },
+        {
+          "detail": "",
+          "name": "risk_coverage",
+          "passed": true,
+          "threshold": ">= 80% within 2 SE or 3%",
+          "value": 1.0
+        },
+        {
+          "detail": "",
+          "name": "xi_sign_agreement",
+          "passed": true,
+          "threshold": ">= 95% where |xi_theory| >= 0.1",
+          "value": {
+            "eligible_cells": 27,
+            "rate": 1.0
+          }
+        },
+        {
+          "detail": "",
+          "name": "median_xi_scaled_error",
+          "passed": true,
+          "threshold": "<= 15%",
+          "value": 0.13512596511948174
+        },
+        {
+          "detail": "",
+          "name": "size_convergence",
+          "passed": true,
+          "threshold": "largest-size aggregate risk error < smallest-size error",
+          "value": {
+            "largest_mean_error": 0.05674350722735142,
+            "largest_n": 80,
+            "smallest_mean_error": 0.10447671076194422,
+            "smallest_n": 40
+          }
+        },
+        {
+          "detail": "",
+          "name": "fixed_point_and_positive_D",
+          "passed": true,
+          "threshold": "fixed-point residual < 1e-10 and all usable D positive",
+          "value": {
+            "max_fixed_point_residual": 1.2860823517257813e-12,
+            "minimum_usable_D": 0.0006743324673149942
+          }
+        }
+      ],
+      "headline": "Deterministic equivalents align with finite-sample Figure 4 behavior",
+      "passed": false,
+      "scope": "Gaussian AR(1), fixed top-aligned signal, analytic in-distribution risk.",
+      "verdict": "Not reproduced"
+    },
+    {
+      "claim": 3,
+      "counts": {
+        "excluded_D_small": 0,
+        "raw_rows": 18,
+        "sizes": [
+          40,
+          80
+        ],
+        "usable_rows": 18
+      },
+      "evidence_class": "fixed-penalty proportional size ladder",
+      "gates": [
+        {
+          "detail": "",
+          "name": "pointwise_error_decreases",
+          "passed": true,
+          "threshold": "largest-size mean xi and risk errors < smallest-size errors",
+          "value": {
+            "largest_mean_risk_error": 0.19362946251869484,
+            "largest_mean_xi_error": 0.2269784791228712,
+            "largest_n": 80,
+            "smallest_mean_risk_error": 0.47501481294468206,
+            "smallest_mean_xi_error": 0.4778794167952708,
+            "smallest_n": 40
+          }
+        },
+        {
+          "detail": "",
+          "name": "largest_size_accuracy",
+          "passed": false,
+          "threshold": "largest size: xi <=15%, risk estimate <=5%, actual regret <=2%",
+          "value": {
+            "median_actual_regret": 0.003739119049884933,
+            "median_risk_error": 0.14030021602939757,
+            "median_xi_error": 0.19477224660886577
+          }
+        },
+        {
+          "detail": "",
+          "name": "largest_size_signs_including_negative",
+          "passed": false,
+          "threshold": ">=90% overall and negative-weight sign agreement",
+          "value": {
+            "agreement": 0.8888888888888888,
+            "eligible": 9,
+            "negative_agreement": 1.0,
+            "negative_eligible": 5
+          }
+        },
+        {
+          "detail": "",
+          "name": "D_hat_identity_and_nonnegativity",
+          "passed": true,
+          "threshold": "identity error <=2e-10 and D_hat >=-2e-12",
+          "value": {
+            "max_identity_error": 1.033895191682177e-15,
+            "minimum_D_hat": 0.016503081186781836
+          }
+        },
+        {
+          "detail": "",
+          "name": "correct_PD_df_beats_wrong_control",
+          "passed": true,
+          "threshold": "correct xi error at least 1e-5 lower and actual regret no larger",
+          "value": {
+            "correct_mean_regret": 0.012903742744689797,
+            "correct_mean_xi_error": 0.2269784791228712,
+            "wrong_mean_regret": 0.154683141035474,
+            "wrong_mean_xi_error": 1.0503204724881403
+          }
+        }
+      ],
+      "headline": "One-shot GCV tuning is pointwise consistent",
+      "passed": false,
+      "scope": "Pointwise fixed penalties only; no uniform lambda-selection claim.",
+      "verdict": "Not reproduced"
+    }
+  ],
+  "paper": "MdHcU4C4Rm",
+  "profile": "smoke",
+  "submission": 22249
+}
+````
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_6cd250549b47", "created_at": "2026-07-16T16:25:59+00:00", "title": "Artifact: claim2_figure4_aggregates.csv", "path": "outputs/smoke/audit/claim2_figure4_aggregates.csv", "size": 6423, "artifact_type": "dataset", "auto": true}
+-->
+**📦 Artifact** `outputs/smoke/audit/claim2_figure4_aggregates.csv` · dataset · 6.4 kB
+trackio-local-path://outputs/smoke/audit/claim2_figure4_aggregates.csv
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_424c204461e9", "created_at": "2026-07-16T16:25:59+00:00", "title": "Artifact: claim3_row_errors.csv", "path": "outputs/smoke/audit/claim3_row_errors.csv", "size": 4311, "artifact_type": "dataset", "auto": true}
+-->
+**📦 Artifact** `outputs/smoke/audit/claim3_row_errors.csv` · dataset · 4.3 kB
+trackio-local-path://outputs/smoke/audit/claim3_row_errors.csv
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_20b2f35b2564", "created_at": "2026-07-16T16:25:59+00:00", "title": "Artifact: claim3_size_summary.csv", "path": "outputs/smoke/audit/claim3_size_summary.csv", "size": 827, "artifact_type": "dataset", "auto": true}
+-->
+**📦 Artifact** `outputs/smoke/audit/claim3_size_summary.csv` · dataset · 827 B
+trackio-local-path://outputs/smoke/audit/claim3_size_summary.csv
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_afdc5260000f", "created_at": "2026-07-16T16:25:59+00:00", "title": "Artifact: claim2_size_cells.csv", "path": "outputs/smoke/audit/claim2_size_cells.csv", "size": 507, "artifact_type": "dataset", "auto": true}
+-->
+**📦 Artifact** `outputs/smoke/audit/claim2_size_cells.csv` · dataset · 507 B
+trackio-local-path://outputs/smoke/audit/claim2_size_cells.csv
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_9caeacee461e", "created_at": "2026-07-16T16:25:59+00:00", "title": "Artifact: claim2_size_summary.csv", "path": "outputs/smoke/audit/claim2_size_summary.csv", "size": 159, "artifact_type": "dataset", "auto": true}
+-->
+**📦 Artifact** `outputs/smoke/audit/claim2_size_summary.csv` · dataset · 159 B
+trackio-local-path://outputs/smoke/audit/claim2_size_summary.csv
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_750abd75381d", "created_at": "2026-07-16T17:05:36+00:00", "title": "Final evidence and verdict"}
+-->
+Verdict: **Supported, conditional.** Across 300 fresh seeds per size, mean scaled xi error decreases from `31.16%` at `n=100` to `9.51%` at `n=1600`; mean risk-estimate error falls from `13.72%` to `3.46%`. At `n=1600`, median xi error is `7.98%`, median risk-estimate error `2.96%`, and median actual population regret `0.129%`. Eligible sign agreement is `95.61%`, including 300/300 negative weights at selected `lambda=5`.
+The wrong-DF control is decisive: replacing `df_PD=tr(H^2)` with `tr(H)` gives mean xi error `99.57%` and mean actual regret `20.14%`, versus `9.51%` and `0.246%` with the paper correction. Maximum direct `D_hat` identity error is `1.985e-15`.
+Scope: three fixed penalties with `p/n=1/2`; this supports pointwise consistency and does not establish uniform consistency or selecting lambda by minimizing the same estimated path. GPU Job: https://huggingface.co/jobs/YMRohit/6a590acb85d9643ce16d6881.
+---
+<!-- trackio-cell
+{"type": "figure", "id": "cell_077a789946a0", "created_at": "2026-07-16T17:05:37+00:00", "title": "One-shot convergence and wrong-DF control"}
+-->
+````html
+<!doctype html><html><head><meta charset='utf-8'><meta name='viewport' content='width=device-width'><style>html,body{margin:0;background:#f8fafb}svg{display:block;width:100%;height:auto}</style></head><body><svg xmlns="http://www.w3.org/2000/svg" width="1280" height="680" viewBox="0 0 1280 680" role="img" aria-label="One-shot tuning convergence and degrees-of-freedom control">
+<rect width="1280" height="680" fill="#f8fafb"/>
+<style>text{font-family:Inter,ui-sans-serif,Arial,sans-serif;fill:#16202a}.small{font-size:13px}.tick{font-size:12px;fill:#667085}.label{font-size:15px;font-weight:600}.title{font-size:27px;font-weight:750;letter-spacing:-.4px}.subtitle{font-size:14px;fill:#667085}.metric{font-size:20px;font-weight:750}</style>
+<text x="48.00" y="49.00" class="title" text-anchor="start">One-shot tuning converges; the PD degrees of freedom matter</text>
+<text x="48.00" y="75.00" class="subtitle" text-anchor="start">Fixed penalties, p/n = 1/2, 300 seeds per size; errors are against conditional population oracles</text>
+<rect x="42" y="100" width="1196" height="520" rx="10" fill="#ffffff" stroke="#dce2e8"/>
+<text x="62.00" y="131.00" class="label" text-anchor="start">Scaled error / population regret</text>
+<line x1="112" y1="491.57" x2="1182" y2="491.57" stroke="#dce2e8"/>
+<text x="103.00" y="495.57" class="tick" text-anchor="end">0.5%</text>
+<line x1="112" y1="456.06" x2="1182" y2="456.06" stroke="#dce2e8"/>
+<text x="103.00" y="460.06" class="tick" text-anchor="end">1%</text>
+<line x1="112" y1="373.62" x2="1182" y2="373.62" stroke="#dce2e8"/>
+<text x="103.00" y="377.62" class="tick" text-anchor="end">5%</text>
+<line x1="112" y1="338.11" x2="1182" y2="338.11" stroke="#dce2e8"/>
+<text x="103.00" y="342.11" class="tick" text-anchor="end">10%</text>
+<line x1="112" y1="255.66" x2="1182" y2="255.66" stroke="#dce2e8"/>
+<text x="103.00" y="259.66" class="tick" text-anchor="end">50%</text>
+<line x1="112" y1="220.15" x2="1182" y2="220.15" stroke="#dce2e8"/>
+<text x="103.00" y="224.15" class="tick" text-anchor="end">100%</text>
+<line x1="112.00" y1="205" x2="112.00" y2="550" stroke="#dce2e8" opacity=".55"/>
+<text x="112.00" y="570.00" class="tick" text-anchor="middle">100</text>
+<line x1="914.50" y1="205" x2="914.50" y2="550" stroke="#dce2e8" opacity=".55"/>
+<text x="914.50" y="570.00" class="tick" text-anchor="middle">800</text>
+<line x1="1182.00" y1="205" x2="1182.00" y2="550" stroke="#dce2e8" opacity=".55"/>
+<text x="1182.00" y="570.00" class="tick" text-anchor="middle">1600</text>
+<line x1="112" y1="550" x2="1182" y2="550" stroke="#16202a" stroke-width="1.2"/>
+<line x1="112" y1="205" x2="112" y2="550" stroke="#16202a" stroke-width="1.2"/>
+<polyline points="112.00,279.89 914.50,327.83 1182.00,340.68" fill="none" stroke="#d64550" stroke-width="3.0" stroke-linejoin="round" stroke-linecap="round" opacity="1.0"/>
+<circle cx="112.00" cy="279.89" r="4.2" fill="#d64550" stroke="#fff" stroke-width="1.5"/>
+<circle cx="914.50" cy="327.83" r="4.2" fill="#d64550" stroke="#fff" stroke-width="1.5"/>
+<circle cx="1182.00" cy="340.68" r="4.2" fill="#d64550" stroke="#fff" stroke-width="1.5"/>
+<line x1="132" y1="166" x2="162" y2="166" stroke="#d64550" stroke-width="3"/>
+<text x="170.00" y="170.00" class="small" text-anchor="start">one-shot ξ error</text>
+<polyline points="112.00,321.89 914.50,377.69 1182.00,392.52" fill="none" stroke="#11845b" stroke-width="3.0" stroke-linejoin="round" stroke-linecap="round" opacity="1.0"/>
+<circle cx="112.00" cy="321.89" r="4.2" fill="#11845b" stroke="#fff" stroke-width="1.5"/>
+<circle cx="914.50" cy="377.69" r="4.2" fill="#11845b" stroke="#fff" stroke-width="1.5"/>
+<circle cx="1182.00" cy="392.52" r="4.2" fill="#11845b" stroke="#fff" stroke-width="1.5"/>
+<line x1="442" y1="166" x2="472" y2="166" stroke="#11845b" stroke-width="3"/>
+<text x="480.00" y="170.00" class="small" text-anchor="start">one-shot risk-estimate error</text>
+<polyline points="112.00,413.37 914.50,504.08 1182.00,527.93" fill="none" stroke="#1769aa" stroke-width="3.0" stroke-linejoin="round" stroke-linecap="round" opacity="1.0"/>
+<circle cx="112.00" cy="413.37" r="4.2" fill="#1769aa" stroke="#fff" stroke-width="1.5"/>
+<circle cx="914.50" cy="504.08" r="4.2" fill="#1769aa" stroke="#fff" stroke-width="1.5"/>
+<circle cx="1182.00" cy="527.93" r="4.2" fill="#1769aa" stroke="#fff" stroke-width="1.5"/>
+<line x1="132" y1="190" x2="162" y2="190" stroke="#1769aa" stroke-width="3"/>
+<text x="170.00" y="194.00" class="small" text-anchor="start">actual one-shot regret</text>
+<polyline points="112.00,220.44 914.50,220.56 1182.00,220.37" fill="none" stroke="#c77800" stroke-width="3.0" stroke-linejoin="round" stroke-linecap="round" stroke-dasharray="8 5" opacity="1.0"/>
+<circle cx="112.00" cy="220.44" r="4.2" fill="#c77800" stroke="#fff" stroke-width="1.5"/>
+<circle cx="914.50" cy="220.56" r="4.2" fill="#c77800" stroke="#fff" stroke-width="1.5"/>
+<circle cx="1182.00" cy="220.37" r="4.2" fill="#c77800" stroke="#fff" stroke-width="1.5"/>
+<line x1="442" y1="190" x2="472" y2="190" stroke="#c77800" stroke-width="3"/>
+<text x="480.00" y="194.00" class="small" text-anchor="start">wrong df_PD ξ error</text>
+<text x="647.00" y="598.00" class="label" text-anchor="middle">sample size n (log scale)</text>
+<text x="54.00" y="650.00" class="subtitle" text-anchor="start">n=1600: median ξ error 7.98%  •  risk-estimate error 2.96%  •  actual regret 0.129%</text>
+</svg>
+</body></html>
+````
+````raw
+n,p,usable_rows,mean_xi_scaled_error,median_xi_scaled_error,mean_risk_estimate_scaled_error,median_risk_estimate_scaled_error,mean_actual_regret_scaled,median_actual_regret_scaled,sign_eligible_rows,sign_agreement,negative_oracle_rows,negative_sign_agreement,selected_over_lambda,selected_over_negative_rows,selected_over_sign_agreement,mean_wrong_xi_scaled_error,mean_wrong_actual_regret_scaled,max_D_hat_identity_error,min_D_hat
+100,50,900,0.3115541422413274,0.22499827754724494,0.13724008913476787,0.11849399341255953,0.02301274488469826,0.010243838841622745,825,0.8424242424242424,448,0.8459821428571429,5.0,300,1.0,0.9944886784384712,0.21833721872271372,1.9845236565174673e-15,0.01431275351699921
+800,400,900,0.12222796278777345,0.0937361791022027,0.046181186953768154,0.03689932669556971,0.003916639716223675,0.0019359537189323896,753,0.9136786188579017,445,0.8719101123595505,5.0,300,1.0,0.9920333469513096,0.20481100723334356,1.797173521111972e-15,0.01987170795748205
+1600,800,900,0.09510709330233892,0.07979459785841933,0.034572977786416555,0.029603787516040852,0.002458608900848219,0.0012918376448209715,729,0.9561042524005487,429,0.9254079254079254,5.0,300,1.0,0.9957149697977374,0.20141494718631495,1.8735013540549517e-15,0.020624512650777485
+````

pages/conclusion/page.md ADDED Viewed

The diff for this file is too large to render. See raw diff

pages/icml22249-release-artifacts/page.md ADDED Viewed

	@@ -0,0 +1,10 @@

+# icml22249-release-artifacts
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_42577a0a57ce", "created_at": "2026-07-16T17:51:11+00:00", "title": "Artifact: icml22249-release-artifacts/icml2026-22249-full-reproduction:v0", "artifact": "icml22249-release-artifacts/icml2026-22249-full-reproduction:v0", "artifact_type": "dataset"}
+-->
+**📦 Artifact** `icml22249-release-artifacts/icml2026-22249-full-reproduction:v0` · dataset · 9.0 MB
+trackio-artifact://icml22249-release-artifacts/icml2026-22249-full-reproduction:v0

pages/icml22249-smoke-figure4/page.md ADDED Viewed

	@@ -0,0 +1,10 @@

+# icml22249-smoke-figure4
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_3758572e8f62", "created_at": "2026-07-16T16:25:42+00:00", "title": "Artifact: icml22249-smoke-figure4/icml22249-figure4-local-smoke-fixed:v0", "artifact": "icml22249-smoke-figure4/icml22249-figure4-local-smoke-fixed:v0", "artifact_type": "dataset"}
+-->
+**📦 Artifact** `icml22249-smoke-figure4/icml22249-figure4-local-smoke-fixed:v0` · dataset · 49.7 kB
+trackio-artifact://icml22249-smoke-figure4/icml22249-figure4-local-smoke-fixed:v0

pages/icml22249-smoke-size/page.md ADDED Viewed

	@@ -0,0 +1,10 @@

+# icml22249-smoke-size
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_912c9006f259", "created_at": "2026-07-16T16:25:52+00:00", "title": "Artifact: icml22249-smoke-size/icml22249-size-local-smoke-fixed:v0", "artifact": "icml22249-smoke-size/icml22249-size-local-smoke-fixed:v0", "artifact_type": "dataset"}
+-->
+**📦 Artifact** `icml22249-smoke-size/icml22249-size-local-smoke-fixed:v0` · dataset · 17.2 kB
+trackio-artifact://icml22249-smoke-size/icml22249-size-local-smoke-fixed:v0

pages/icml22249-smoke-structural/page.md ADDED Viewed

	@@ -0,0 +1,10 @@

+# icml22249-smoke-structural
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_0f52b3046143", "created_at": "2026-07-16T16:25:33+00:00", "title": "Artifact: icml22249-smoke-structural/icml22249-structural-local-smoke-fixed:v0", "artifact": "icml22249-smoke-structural/icml22249-structural-local-smoke-fixed:v0", "artifact_type": "dataset"}
+-->
+**📦 Artifact** `icml22249-smoke-structural/icml22249-structural-local-smoke-fixed:v0` · dataset · 25.8 kB
+trackio-artifact://icml22249-smoke-structural/icml22249-structural-local-smoke-fixed:v0

pages/index.md ADDED Viewed

	@@ -0,0 +1,18 @@

+# Repro - Optimal Unconstrained Self-Distillation in Ridge Regression
+Independent claim-level reproduction of *Optimal Unconstrained
+Self-Distillation in Ridge Regression* (`MdHcU4C4Rm`). Results remain local
+until independent review and root-coordinator approval.
+## Pages
+| Page |
+| --- |
+| [Claim 1 — Exact improvement and sign](#/claim-1-exact-improvement-and-sign) |
+| [Claim 2 — Deterministic asymptotics](#/claim-2-deterministic-asymptotics) |
+| [Claim 3 — One-shot tuning](#/claim-3-one-shot-tuning) |
+| [icml22249-smoke-structural](#/icml22249-smoke-structural) |
+| [icml22249-smoke-figure4](#/icml22249-smoke-figure4) |
+| [icml22249-smoke-size](#/icml22249-smoke-size) |
+| [Conclusion](#/conclusion) |
+| [icml22249-release-artifacts](#/icml22249-release-artifacts) |

trackio-logo-light.png ADDED Viewed

trackio-logo.png ADDED Viewed

trackio-wordmark-dark.png ADDED Viewed