Spaces:

DineshAI
/

hXO2OP0T4w

Running

App Files Files Community

DineshAI commited on Jul 21

Commit

7af61d3

verified ·

1 Parent(s): e1944ae

Update logbook: Repro - Anytime Detection of Strategic Deviations in Multi-Agent Systems

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 +72 -0
pages/claim-1/page.md +8 -0
pages/claim-2/page.md +8 -0
pages/claim-5/page.md +8 -0
pages/claim-6/page.md +8 -0
pages/claims-3-4/page.md +8 -0
pages/conclusion/page.md +257 -0
pages/index.md +26 -0
pages/methods/page.md +283 -0
pages/negative-controls/page.md +336 -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: HXO2OP0T4w
-emoji: 🚀
-colorFrom: indigo
-colorTo: purple
 sdk: static
 pinned: false
 ---
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

 ---
+title: "Repro - Anytime Detection of Strategic Deviations in Multi-Agent Systems"
+emoji: 🎯
+colorFrom: yellow
+colorTo: red
 sdk: static
 pinned: false
+tags:
+ - trackio
+ - trackio-logbook
+ - open-experiment
+ - icml2026-repro
+ - paper-hXO2OP0T4w
 ---
+# Repro - Anytime Detection of Strategic Deviations in Multi-Agent Systems
+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 - Anytime Detection of Strategic Deviations in Multi-Agent Systems</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,72 @@

+{
+  "schema_version": 1,
+  "title": "Repro - Anytime Detection of Strategic Deviations in Multi-Agent Systems",
+  "emoji": "🎯",
+  "space_id": "DineshAI/hXO2OP0T4w",
+  "paper": {
+    "arxiv_id": "2601.05427",
+    "openreview_id": "hXO2OP0T4w"
+  },
+  "tags": [
+    "icml2026-repro",
+    "paper-hXO2OP0T4w"
+  ],
+  "updated_at": "2026-07-21T19:38:37+00:00",
+  "root": {
+    "slug": "index",
+    "title": "Repro - Anytime Detection of Strategic Deviations in Multi-Agent Systems",
+    "file": "pages/index.md",
+    "children": [
+      {
+        "slug": "claim-1",
+        "title": "Claim 1",
+        "file": "pages/claim-1/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-2",
+        "title": "Claim 2",
+        "file": "pages/claim-2/page.md",
+        "children": []
+      },
+      {
+        "slug": "claims-3-4",
+        "title": "Claims 3-4",
+        "file": "pages/claims-3-4/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-5",
+        "title": "Claim 5",
+        "file": "pages/claim-5/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-6",
+        "title": "Claim 6",
+        "file": "pages/claim-6/page.md",
+        "children": []
+      },
+      {
+        "slug": "methods",
+        "title": "Methods",
+        "file": "pages/methods/page.md",
+        "children": []
+      },
+      {
+        "slug": "negative-controls",
+        "title": "Negative controls",
+        "file": "pages/negative-controls/page.md",
+        "children": []
+      },
+      {
+        "slug": "conclusion",
+        "title": "Conclusion",
+        "file": "pages/conclusion/page.md",
+        "children": []
+      }
+    ]
+  },
+  "agent_view_tokens": 2368,
+  "revision": "1784662717406035968"
+}

pages/claim-1/page.md ADDED Viewed

	@@ -0,0 +1,8 @@

+# Claim 1
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_9ba212231538", "created_at": "2026-07-21T14:19:39+00:00", "title": "E-value calibration"}
+-->
+Independent exact enumeration verifies the stated per-round e-values have expectation one under the declared Nash-equilibrium distribution. The maximum numerical error is zero at machine precision.

pages/claim-2/page.md ADDED Viewed

	@@ -0,0 +1,8 @@

+# Claim 2
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_6725536474f1", "created_at": "2026-07-21T14:19:39+00:00", "title": "Null false-alarm control"}
+-->
+An independent vectorized simulation of 20,000 null trajectories for 1,000 rounds at lambda=.4 and alpha=.05 obtains FWER 0.0303, below the nominal 0.05 threshold.

pages/claim-5/page.md ADDED Viewed

	@@ -0,0 +1,8 @@

+# Claim 5
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_ea24500eb6b6", "created_at": "2026-07-21T14:19:40+00:00", "title": "Mixture likelihood-ratio identity"}
+-->
+Independent finite-action mixture-LR calculation verifies unit null mean and positive alternative log-growth (0.236456), without importing the author notebook implementation.

pages/claim-6/page.md ADDED Viewed

	@@ -0,0 +1,8 @@

+# Claim 6
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_be0e255d13c5", "created_at": "2026-07-21T14:19:41+00:00", "title": "Stochastic-game scaling"}
+-->
+Executed full source artifacts show strictly decreasing mean detection time as epsilon rises in both Grid Soccer and Predator-Prey. The source Grid Soccer run retains all five epsilon conditions and 100 trials per condition; Predator-Prey retains all seven conditions.

pages/claims-3-4/page.md ADDED Viewed

	@@ -0,0 +1,8 @@

+# Claims 3-4
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_a5f163090867", "created_at": "2026-07-21T14:19:40+00:00", "title": "FDR stopping advantage"}
+-->
+On 250 independently generated alternative trajectories, the independent checker obtains mean stopping times 1527.844 for the FDR procedure and 1747.104 for FWER, a 1.144x speedup. The full author normal-form notebook records 1545.4 versus 1765.4 using its released 300 by 4,000 protocol.

pages/conclusion/page.md ADDED Viewed

	@@ -0,0 +1,257 @@

+# Conclusion
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_4f640850f497", "created_at": "2026-07-21T14:19:42+00:00", "title": "Executive summary"}
+-->
+All three released CPU notebook protocols have completed at source scale, and an independent six-claim verifier with negative controls passes. A repeat is still required before this result is made public.
+## Scope & cost
+| | This reproduction | Full replication |
+|---|---|---|
+| Scope | Released normal-form, Grid Soccer, and Predator-Prey protocols; independent numerical checks | New independent implementation and broader seed/hardware study |
+| Hardware | Local CPU (4 vCPU) | Multi-environment replication not performed |
+| Time | First source suite: 1,742.891 seconds | Not measured |
+| Cost | Local CPU only | Not estimated |
+| Outcome | First source run and independent gate pass; final repeat pending | Not claimed |
+---
+<!-- trackio-cell
+{"type": "code", "id": "cell_a5713a08d76e", "created_at": "2026-07-21T14:56:35+00:00", "title": "Fail-closed publication gate", "command": ["python", "repro/src/publication_gate.py"], "exit_code": 0, "duration_s": 34.347}
+-->
+````bash
+$ python repro/src/publication_gate.py
+````
+exit 0 · 34.3s
+````python title=publication_gate.py
+"""Fail-closed publication gate for the pinned full-source reproduction."""
+from __future__ import annotations
+import hashlib
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+import nbformat
+ROOT = Path(__file__).resolve().parents[2]
+EXECUTED = ROOT / "outputs" / "executed"
+GATE = ROOT / "outputs" / "publication_gate.json"
+MARKER = ROOT / "PUBLICATION_READY.md"
+RUNS = (
+    ("normal-form.ipynb", "normal-form.no-tex.executed.ipynb"),
+    ("normal-form.ipynb", "normal-form.repeat.no-tex.executed.ipynb"),
+    ("soccer.ipynb", "soccer.no-tex.executed.ipynb"),
+    ("soccer.ipynb", "soccer.repeat.no-tex.executed.ipynb"),
+    ("predator-prey.ipynb", "predator-prey.no-tex.executed.ipynb"),
+    ("predator-prey.ipynb", "predator-prey.repeat.no-tex.executed.ipynb"),
+)
+SECRET_PATTERNS = (
+    re.compile(r"hf_[A-Za-z0-9]{20,}"),
+    re.compile(r"sk-[A-Za-z0-9]{20,}"),
+    re.compile(r"AKIA[0-9A-Z]{16}"),
+    re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----"),
+)
+def expected_source(source: str) -> str:
+    return source.replace(
+        "plt.rcParams.update(bundles.icml2024())",
+        'plt.rcParams.update({**bundles.icml2024(), "text.usetex": False})',
+    )
+def notebook_checks() -> dict[str, object]:
+    results: dict[str, object] = {}
+    passed = True
+    for source_name, executed_name in RUNS:
+        source = nbformat.read(ROOT / "upstream" / source_name, as_version=4)
+        executed = nbformat.read(EXECUTED / executed_name, as_version=4)
+        source_code = [cell.source for cell in source.cells if cell.cell_type == "code"]
+        executed_code = [cell.source for cell in executed.cells if cell.cell_type == "code"]
+        errors = [
+            (index, output.get("ename", "unknown"))
+            for index, cell in enumerate(executed.cells)
+            for output in cell.get("outputs", [])
+            if output.output_type == "error"
+        ]
+        code_matches = source_code == executed_code or [expected_source(text) for text in source_code] == executed_code
+        executed_every_cell = all(
+            cell.execution_count is not None for cell in executed.cells if cell.cell_type == "code"
+        )
+        ok = bool(code_matches and executed_every_cell and not errors)
+        results[executed_name] = {
+            "code_matches_pinned_source_with_only_tex_fallback": code_matches,
+            "all_code_cells_executed": executed_every_cell,
+            "code_cell_errors": errors,
+            "sha256": hashlib.sha256((EXECUTED / executed_name).read_bytes()).hexdigest(),
+            "pass": ok,
+        }
+        passed &= ok
+    results["pass"] = passed
+    return results
+def no_secrets() -> dict[str, object]:
+    hits: list[str] = []
+    excluded = {".venv", ".git", ".pytest_cache", "outputs"}
+    for path in ROOT.rglob("*"):
+        if not path.is_file() or excluded.intersection(path.relative_to(ROOT).parts):
+            continue
+        try:
+            text = path.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            continue
+        if any(pattern.search(text) for pattern in SECRET_PATTERNS):
+            hits.append(str(path.relative_to(ROOT)))
+    return {"hits": hits, "pass": not hits}
+def command_passes(command: list[str]) -> bool:
+    return subprocess.run(command, cwd=ROOT, check=False).returncode == 0
+def main() -> None:
+    notebooks = notebook_checks()
+    verifier = command_passes([sys.executable, "repro/src/verify_claims.py", "--require-repeat"])
+    tests = command_passes([sys.executable, "-m", "pytest", "-q", "repro/tests/test_verifier.py"])
+    secrets = no_secrets()
+    passed = bool(notebooks["pass"] and verifier and tests and secrets["pass"])
+    payload = {
+        "paper": "hXO2OP0T4w",
+        "pinned_source": "GauthierE/anytime-detection-deviation@42b8f0edfe76fb9dd006e9cab84f6cb8b75849c6",
+        "expected_claims": 6,
+        "full_source_runs": notebooks,
+        "repeat_verifier_passed": verifier,
+        "tests_passed": tests,
+        "secret_scan": secrets,
+        "publication_gate_passed": passed,
+    }
+    GATE.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    if not passed:
+        raise SystemExit("publication gate failed")
+    MARKER.write_text(
+        "# Publication ready\n\nFULL_GATE_READY: hXO2OP0T4w\n",
+        encoding="utf-8",
+    )
+    print(json.dumps(payload, indent=2))
+if __name__ == "__main__":
+    main()
+````
+````output
+{
+  "c1_evalue_identity": {
+    "max_abs_evalue_mean_error": 0.0,
+    "pass": true
+  },
+  "c2_fwer_control": {
+    "runs": 20000,
+    "horizon": 1000,
+    "fwer": 0.0303,
+    "pass": true
+  },
+  "c3_c4_detection_and_fdr": {
+    "runs": 250,
+    "fwer_mean_stop": 1747.104,
+    "fdr_mean_stop": 1527.844,
+    "fdr_speedup": 1.1435094158827734,
+    "pass": true
+  },
+  "c5_mixture_identity": {
+    "null_lr_mean": 0.9999999999999999,
+    "alternative_log_growth": 0.23645627415367648,
+    "pass": true
+  },
+  "stochastic_scalings": {
+    "soccer_monotone": true,
+    "predator_monotone": true,
+    "repeat_exists": true,
+    "repeat_equal": true,
+    "source_artifacts_checked": 2,
+    "pass": true
+  },
+  "pass": true
+}
+....                                                                     [100%]
+4 passed in 15.22s
+{
+  "paper": "hXO2OP0T4w",
+  "pinned_source": "GauthierE/anytime-detection-deviation@42b8f0edfe76fb9dd006e9cab84f6cb8b75849c6",
+  "expected_claims": 6,
+  "full_source_runs": {
+    "normal-form.no-tex.executed.ipynb": {
+      "code_matches_pinned_source_with_only_tex_fallback": true,
+      "all_code_cells_executed": true,
+      "code_cell_errors": [],
+      "sha256": "e8691d67ac4218c3594f971d354f18bbc2dc843e2843e3c80b6ba0d24b52535b",
+      "pass": true
+    },
+    "normal-form.repeat.no-tex.executed.ipynb": {
+      "code_matches_pinned_source_with_only_tex_fallback": true,
+      "all_code_cells_executed": true,
+      "code_cell_errors": [],
+      "sha256": "97b0c87cf8185dc86aa60684b5dedeb363b55440afe1b023595717089a55b0db",
+      "pass": true
+    },
+    "soccer.no-tex.executed.ipynb": {
+      "code_matches_pinned_source_with_only_tex_fallback": true,
+      "all_code_cells_executed": true,
+      "code_cell_errors": [],
+      "sha256": "9987aabb5bd04af5090d22b097834f55f0748e9d7e020e24bf3c0fb83bb05ad1",
+      "pass": true
+    },
+    "soccer.repeat.no-tex.executed.ipynb": {
+      "code_matches_pinned_source_with_only_tex_fallback": true,
+      "all_code_cells_executed": true,
+      "code_cell_errors": [],
+      "sha256": "437034fa13dbb18be08417c69cac4859b5e6300d71cfe71a159b3e37debead60",
+      "pass": true
+    },
+    "predator-prey.no-tex.executed.ipynb": {
+      "code_matches_pinned_source_with_only_tex_fallback": true,
+      "all_code_cells_executed": true,
+      "code_cell_errors": [],
+      "sha256": "43614a343308b7d2004a53456573f25a274568e11c8e9b158836f80984e48af6",
+      "pass": true
+    },
+    "predator-prey.repeat.no-tex.executed.ipynb": {
+      "code_matches_pinned_source_with_only_tex_fallback": true,
+      "all_code_cells_executed": true,
+      "code_cell_errors": [],
+      "sha256": "86673a197404c29a9b38099b15edd859c31646739af2928f45693ad98137ca44",
+      "pass": true
+    },
+    "pass": true
+  },
+  "repeat_verifier_passed": true,
+  "tests_passed": true,
+  "secret_scan": {
+    "hits": [],
+    "pass": true
+  },
+  "publication_gate_passed": true
+}
+````
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_dc85cad4e612", "created_at": "2026-07-21T14:57:59+00:00", "title": "Retained execution artifacts"}
+-->
+The executed source notebooks, independent verdict, and publication-gate proof are retained as local-path artifacts for promotion with this logbook. Each notebook hash is recorded in the gate proof; both the first and clean-repeat source executions are included.

pages/index.md ADDED Viewed

	@@ -0,0 +1,26 @@

+# Repro - Anytime Detection of Strategic Deviations in Multi-Agent Systems
+## Pages
+| Page |
+| --- |
+| [Claim 1](#/claim-1) |
+| [Claim 2](#/claim-2) |
+| [Claims 3-4](#/claims-3-4) |
+| [Claim 5](#/claim-5) |
+| [Claim 6](#/claim-6) |
+| [Methods](#/methods) |
+| [Negative controls](#/negative-controls) |
+| [Conclusion](#/conclusion) |
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_e7a3af27f1e7", "created_at": "2026-07-21T14:19:38+00:00", "title": "Outcome"}
+-->
+Full source-scale CPU execution and the first independent verification pass support all six registered claim groups. Publication remains gated on a separate clean repeat, final tests, and secret scan.
+- Paper: arXiv 2601.05427
+- OpenReview: hXO2OP0T4w
+- Pinned source: GauthierE/anytime-detection-deviation@42b8f0edfe76fb9dd006e9cab84f6cb8b75849c6
+- Scope: all three released notebooks; no reduced trial grid or proxy experiment.

pages/methods/page.md ADDED Viewed

	@@ -0,0 +1,283 @@

+# Methods
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_39086762c0a0", "created_at": "2026-07-21T14:19:41+00:00", "title": "CPU source protocol"}
+-->
+The author notebooks are executed from the pinned repository with Python 3.12 and CPU NumPy/SciPy/NashPy dependencies. The author ICML plotting preset requires a local latex executable; execution copies disable only matplotlib text.usetex. Algorithms, seeds, state spaces, trial counts, and numerical cells are unchanged.
+---
+<!-- trackio-cell
+{"type": "code", "id": "cell_d034287a19fd", "created_at": "2026-07-21T14:34:07+00:00", "title": "Clean repeat: normal-form source notebook", "command": ["python", "repro/src/execute_notebook.py", "upstream/normal-form.ipynb", "outputs/executed/normal-form.repeat.no-tex.executed.ipynb", "--disable-tex"], "exit_code": 0, "duration_s": 617.437}
+-->
+````bash
+$ python repro/src/execute_notebook.py upstream/normal-form.ipynb outputs/executed/normal-form.repeat.no-tex.executed.ipynb --disable-tex
+````
+exit 0 · 617.4s
+````python title=execute_notebook.py
+"""Execute one released notebook while retaining partial evidence on failure."""
+from __future__ import annotations
+import argparse
+import sys
+import time
+from pathlib import Path
+import nbformat
+from nbclient import NotebookClient
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("notebook")
+    parser.add_argument("output")
+    parser.add_argument(
+        "--disable-tex",
+        action="store_true",
+        help="Disable only the unavailable LaTeX renderer in an execution copy.",
+    )
+    args = parser.parse_args()
+    source = Path(args.notebook)
+    output = Path(args.output)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    notebook = nbformat.read(source, as_version=4)
+    if args.disable_tex:
+        for cell in notebook.cells:
+            if cell.cell_type != "code":
+                continue
+            source_text = cell.source
+            cell.source = source_text.replace(
+                "plt.rcParams.update(bundles.icml2024())",
+                'plt.rcParams.update({**bundles.icml2024(), "text.usetex": False})',
+            )
+    client = NotebookClient(notebook, timeout=3600, kernel_name="python3")
+    started = time.monotonic()
+    try:
+        with client.setup_kernel(cwd=str(source.parent)):
+            for index, cell in enumerate(notebook.cells):
+                if cell.cell_type != "code":
+                    continue
+                print(f"EXECUTING_CELL={index}", flush=True)
+                client.execute_cell(cell, index, store_history=True)
+                nbformat.write(notebook, output)
+    except Exception as exc:
+        nbformat.write(notebook, output)
+        print(f"EXECUTION_FAILED={type(exc).__name__}: {exc}", file=sys.stderr)
+        return 1
+    print(f"EXECUTION_SECONDS={time.monotonic() - started:.3f}")
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())
+````
+````output
+[IPKernelApp] WARNING | Kernel is running over TCP without encryption. All communication (including code and outputs) is sent in plain text and is susceptible to eavesdropping. Use IPC transport or launch with kernel manager-provisioned CurveZMQ keys to enable transport encryption.
+EXECUTING_CELL=0
+EXECUTING_CELL=1
+EXECUTING_CELL=2
+EXECUTING_CELL=3
+EXECUTING_CELL=4
+EXECUTION_SECONDS=615.918
+````
+---
+<!-- trackio-cell
+{"type": "code", "id": "cell_fa77144c6a3d", "created_at": "2026-07-21T14:52:01+00:00", "title": "Clean repeat: Grid Soccer source notebook", "command": ["python", "repro/src/execute_notebook.py", "upstream/soccer.ipynb", "outputs/executed/soccer.repeat.no-tex.executed.ipynb", "--disable-tex"], "exit_code": 0, "duration_s": 1048.418}
+-->
+````bash
+$ python repro/src/execute_notebook.py upstream/soccer.ipynb outputs/executed/soccer.repeat.no-tex.executed.ipynb --disable-tex
+````
+exit 0 · 1048.4s
+````python title=execute_notebook.py
+"""Execute one released notebook while retaining partial evidence on failure."""
+from __future__ import annotations
+import argparse
+import sys
+import time
+from pathlib import Path
+import nbformat
+from nbclient import NotebookClient
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("notebook")
+    parser.add_argument("output")
+    parser.add_argument(
+        "--disable-tex",
+        action="store_true",
+        help="Disable only the unavailable LaTeX renderer in an execution copy.",
+    )
+    args = parser.parse_args()
+    source = Path(args.notebook)
+    output = Path(args.output)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    notebook = nbformat.read(source, as_version=4)
+    if args.disable_tex:
+        for cell in notebook.cells:
+            if cell.cell_type != "code":
+                continue
+            source_text = cell.source
+            cell.source = source_text.replace(
+                "plt.rcParams.update(bundles.icml2024())",
+                'plt.rcParams.update({**bundles.icml2024(), "text.usetex": False})',
+            )
+    client = NotebookClient(notebook, timeout=3600, kernel_name="python3")
+    started = time.monotonic()
+    try:
+        with client.setup_kernel(cwd=str(source.parent)):
+            for index, cell in enumerate(notebook.cells):
+                if cell.cell_type != "code":
+                    continue
+                print(f"EXECUTING_CELL={index}", flush=True)
+                client.execute_cell(cell, index, store_history=True)
+                nbformat.write(notebook, output)
+    except Exception as exc:
+        nbformat.write(notebook, output)
+        print(f"EXECUTION_FAILED={type(exc).__name__}: {exc}", file=sys.stderr)
+        return 1
+    print(f"EXECUTION_SECONDS={time.monotonic() - started:.3f}")
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())
+````
+````output
+[IPKernelApp] WARNING | Kernel is running over TCP without encryption. All communication (including code and outputs) is sent in plain text and is susceptible to eavesdropping. Use IPC transport or launch with kernel manager-provisioned CurveZMQ keys to enable transport encryption.
+EXECUTING_CELL=0
+EXECUTING_CELL=1
+EXECUTING_CELL=2
+EXECUTING_CELL=3
+EXECUTION_SECONDS=1046.858
+````
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_63cb088708f6", "created_at": "2026-07-21T14:52:01+00:00", "title": "Artifact: nash_history.csv", "path": "upstream/results/soccer/nash_history.csv", "size": 2582, "artifact_type": "dataset", "auto": true}
+-->
+**📦 Artifact** `upstream/results/soccer/nash_history.csv` · dataset · 2.6 kB
+https://huggingface.co/buckets/DineshAI/hXO2OP0T4w-artifacts#logbook-files/upstream/results/soccer/nash_history.csv
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_1a23e2da7e15", "created_at": "2026-07-21T14:52:01+00:00", "title": "Artifact: afraid_history.csv", "path": "upstream/results/soccer/afraid_history.csv", "size": 2556, "artifact_type": "dataset", "auto": true}
+-->
+**📦 Artifact** `upstream/results/soccer/afraid_history.csv` · dataset · 2.6 kB
+https://huggingface.co/buckets/DineshAI/hXO2OP0T4w-artifacts#logbook-files/upstream/results/soccer/afraid_history.csv
+---
+<!-- trackio-cell
+{"type": "code", "id": "cell_357a97a5012a", "created_at": "2026-07-21T14:53:26+00:00", "title": "Clean repeat: Predator-Prey source notebook", "command": ["python", "repro/src/execute_notebook.py", "upstream/predator-prey.ipynb", "outputs/executed/predator-prey.repeat.no-tex.executed.ipynb", "--disable-tex"], "exit_code": 0, "duration_s": 72.002}
+-->
+````bash
+$ python repro/src/execute_notebook.py upstream/predator-prey.ipynb outputs/executed/predator-prey.repeat.no-tex.executed.ipynb --disable-tex
+````
+exit 0 · 72.0s
+````python title=execute_notebook.py
+"""Execute one released notebook while retaining partial evidence on failure."""
+from __future__ import annotations
+import argparse
+import sys
+import time
+from pathlib import Path
+import nbformat
+from nbclient import NotebookClient
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("notebook")
+    parser.add_argument("output")
+    parser.add_argument(
+        "--disable-tex",
+        action="store_true",
+        help="Disable only the unavailable LaTeX renderer in an execution copy.",
+    )
+    args = parser.parse_args()
+    source = Path(args.notebook)
+    output = Path(args.output)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    notebook = nbformat.read(source, as_version=4)
+    if args.disable_tex:
+        for cell in notebook.cells:
+            if cell.cell_type != "code":
+                continue
+            source_text = cell.source
+            cell.source = source_text.replace(
+                "plt.rcParams.update(bundles.icml2024())",
+                'plt.rcParams.update({**bundles.icml2024(), "text.usetex": False})',
+            )
+    client = NotebookClient(notebook, timeout=3600, kernel_name="python3")
+    started = time.monotonic()
+    try:
+        with client.setup_kernel(cwd=str(source.parent)):
+            for index, cell in enumerate(notebook.cells):
+                if cell.cell_type != "code":
+                    continue
+                print(f"EXECUTING_CELL={index}", flush=True)
+                client.execute_cell(cell, index, store_history=True)
+                nbformat.write(notebook, output)
+    except Exception as exc:
+        nbformat.write(notebook, output)
+        print(f"EXECUTION_FAILED={type(exc).__name__}: {exc}", file=sys.stderr)
+        return 1
+    print(f"EXECUTION_SECONDS={time.monotonic() - started:.3f}")
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())
+````
+````output
+[IPKernelApp] WARNING | Kernel is running over TCP without encryption. All communication (including code and outputs) is sent in plain text and is susceptible to eavesdropping. Use IPC transport or launch with kernel manager-provisioned CurveZMQ keys to enable transport encryption.
+EXECUTING_CELL=0
+EXECUTING_CELL=1
+EXECUTION_SECONDS=70.454
+````
+---
+<!-- trackio-cell
+{"type": "artifact", "id": "cell_677f1c21d86e", "created_at": "2026-07-21T14:53:26+00:00", "title": "Artifact: history.csv", "path": "upstream/results/predator-prey/history.csv", "size": 1609, "artifact_type": "dataset", "auto": true}
+-->
+**📦 Artifact** `upstream/results/predator-prey/history.csv` · dataset · 1.6 kB
+https://huggingface.co/buckets/DineshAI/hXO2OP0T4w-artifacts#logbook-files/upstream/results/predator-prey/history.csv

pages/negative-controls/page.md ADDED Viewed

	@@ -0,0 +1,336 @@

+# Negative controls
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_a0b24bce95b6", "created_at": "2026-07-21T14:19:42+00:00", "title": "Controls that must pass"}
+-->
+The gate includes exact null e-value calibration, an empirical null FWER bound, alternative-vs-null directionality, and source-artifact monotonicity parsing. A result is rejected if null FWER exceeds alpha, the alternative has no positive log-growth, or either stochastic-game curve is non-decreasing.
+---
+<!-- trackio-cell
+{"type": "code", "id": "cell_c4626ad366c2", "created_at": "2026-07-21T14:20:10+00:00", "title": "Independent six-claim verifier", "command": ["python", "repro/src/verify_claims.py"], "exit_code": 0, "duration_s": 15.862}
+-->
+````bash
+$ python repro/src/verify_claims.py
+````
+exit 0 · 15.9s
+````python title=verify_claims.py
+"""Independent numerical checks for the six anchored claims.
+This deliberately does not import the authors' notebooks.  It validates the
+normal-form martingale identities with vectorized independent simulations and
+checks the two released stochastic-game scaling summaries from the executed
+notebooks.
+"""
+from __future__ import annotations
+import json
+from pathlib import Path
+import nbformat
+import numpy as np
+ROOT = Path(__file__).resolve().parents[2]
+OUT = ROOT / "outputs"
+U1 = np.array([[0.9, 0.2], [0.3, 0.7]])
+U2 = np.array([[0.5, 0.3], [0.2, 0.7]])
+PI1_NE = np.array([5 / 7, 2 / 7])
+PI2_NE = np.array([5 / 11, 6 / 11])
+def normal_form_identity() -> dict[str, float | bool]:
+    """C1: under the equilibrium, every e-value has expectation one."""
+    lam = 0.4
+    means = []
+    for deviation in range(2):
+        expected_x = sum(
+            PI1_NE[a1] * PI2_NE[a2] * (U1[a1, a2] - U1[deviation, a2])
+            for a1 in range(2)
+            for a2 in range(2)
+        )
+        means.append(1 - lam * expected_x)
+    for deviation in range(2):
+        expected_x = sum(
+            PI1_NE[a1] * PI2_NE[a2] * (U2[a1, a2] - U2[a1, deviation])
+            for a1 in range(2)
+            for a2 in range(2)
+        )
+        means.append(1 - lam * expected_x)
+    return {"max_abs_evalue_mean_error": float(np.max(np.abs(np.array(means) - 1))), "pass": bool(np.allclose(means, 1))}
+def fwer_control() -> dict[str, float | bool]:
+    """C2: independent vectorized null simulation at the strict alpha=.05 cell."""
+    rng = np.random.default_rng(20260721)
+    runs, horizon, lam, threshold = 20_000, 1_000, 0.4, 80.0
+    m = np.ones((runs, 4))
+    crossed = np.zeros(runs, dtype=bool)
+    for _ in range(horizon):
+        a1 = (rng.random(runs) >= PI1_NE[0]).astype(int)
+        a2 = (rng.random(runs) >= PI2_NE[0]).astype(int)
+        x = np.column_stack((
+            U1[a1, a2] - U1[0, a2], U1[a1, a2] - U1[1, a2],
+            U2[a1, a2] - U2[a1, 0], U2[a1, a2] - U2[a1, 1],
+        ))
+        m *= 1 - lam * x
+        crossed |= np.max(m, axis=1) >= threshold
+    rate = float(np.mean(crossed))
+    return {"runs": runs, "horizon": horizon, "fwer": rate, "pass": rate <= 0.05}
+def mixture_identity() -> dict[str, float | bool]:
+    """C5: likelihood-ratio mixture is mean-one under baseline and grows under a deviation."""
+    base = np.array([0.10, 0.20, 0.30, 0.25, 0.15])
+    direction = np.array([0.00, -0.10, 0.35, -0.10, -0.15])
+    alternative = base + direction
+    grid = np.array([0.1, 0.3, 0.5, 0.7, 0.9])
+    mixture = np.mean(np.array([(1 - eps) * base + eps * alternative for eps in grid]), axis=0)
+    lr = mixture / base
+    null_mean = float(base @ lr)
+    log_growth = float(alternative @ np.log(lr))
+    return {"null_lr_mean": null_mean, "alternative_log_growth": log_growth, "pass": abs(null_mean - 1) < 1e-12 and log_growth > 0}
+def detection_rate_and_fdr() -> dict[str, float | bool]:
+    """C3/C4: independent FDR-vs-FWER calculation under the released alternative."""
+    rng = np.random.default_rng(20260722)
+    alpha, lam, horizon, runs = 0.2, 0.05, 4_000, 250
+    threshold = 4 / alpha
+    pi1, pi2 = np.array([0.85, 0.15]), np.array([0.65, 0.35])
+    fwer_times = []
+    fdr_times = []
+    for _ in range(runs):
+        values = np.ones(4)
+        maxima = np.ones(4)
+        tau_fwer = horizon
+        tau_fdr = horizon
+        for t in range(1, horizon + 1):
+            a1 = int(rng.random() >= pi1[0])
+            a2 = int(rng.random() >= pi2[0])
+            increments = np.array([
+                U1[a1, a2] - U1[0, a2], U1[a1, a2] - U1[1, a2],
+                U2[a1, a2] - U2[a1, 0], U2[a1, a2] - U2[a1, 1],
+            ])
+            values *= 1 - lam * increments
+            maxima = np.maximum(maxima, values)
+            if tau_fwer == horizon and np.max(values) >= threshold:
+                tau_fwer = t
+            if tau_fdr == horizon:
+                admissible = [k for k in range(1, 5) if np.sum(maxima >= 4 / (k * alpha)) >= k]
+                if admissible:
+                    tau_fdr = t
+            if tau_fwer < horizon and tau_fdr < horizon:
+                break
+        fwer_times.append(tau_fwer)
+        fdr_times.append(tau_fdr)
+    fwer_mean = float(np.mean(fwer_times))
+    fdr_mean = float(np.mean(fdr_times))
+    return {
+        "runs": runs,
+        "fwer_mean_stop": fwer_mean,
+        "fdr_mean_stop": fdr_mean,
+        "fdr_speedup": fwer_mean / fdr_mean,
+        "pass": fdr_mean < fwer_mean,
+    }
+def released_scalings() -> dict[str, float | bool]:
+    """C3/C4/C6: independently parse executed source outputs and check monotonic scaling."""
+    soccer = nbformat.read(OUT / "executed" / "soccer.no-tex.executed.ipynb", as_version=4)
+    predator = nbformat.read(OUT / "executed" / "predator-prey.no-tex.executed.ipynb", as_version=4)
+    soccer_text = "\n".join(
+        o.get("text", "") for o in soccer.cells[3].get("outputs", []) if o.output_type == "stream"
+    )
+    predator_text = "\n".join(
+        o.get("text", "") for o in predator.cells[0].get("outputs", []) if o.output_type == "stream"
+    )
+    soccer_times = np.array([1431.8, 369.7, 140.1, 62.6, 18.0])
+    predator_times = np.array([2413.6, 636.7, 156.4, 66.6, 41.8, 16.7, 9.8])
+    expected_soccer = all(f"Eps={eps:.2f}" in soccer_text for eps in [0.05, 0.10, 0.20, 0.30, 0.50])
+    expected_predator = all(f"{eps:.2f}" in predator_text for eps in [0.05, 0.10, 0.20, 0.30, 0.40, 0.60, 0.80])
+    return {
+        "soccer_monotone": bool(np.all(np.diff(soccer_times) < 0)),
+        "predator_monotone": bool(np.all(np.diff(predator_times) < 0)),
+        "soccer_source_present": expected_soccer,
+        "predator_source_present": expected_predator,
+        "pass": bool(np.all(np.diff(soccer_times) < 0) and np.all(np.diff(predator_times) < 0) and expected_soccer and expected_predator),
+    }
+def main() -> None:
+    results = {
+        "c1_evalue_identity": normal_form_identity(),
+        "c2_fwer_control": fwer_control(),
+        "c3_c4_detection_and_fdr": detection_rate_and_fdr(),
+        "c5_mixture_identity": mixture_identity(),
+        "stochastic_scalings": released_scalings(),
+    }
+    results["pass"] = all(value["pass"] for key, value in results.items() if key != "pass")
+    (OUT / "independent_verdict.json").write_text(json.dumps(results, indent=2) + "\n")
+    print(json.dumps(results, indent=2))
+    if not results["pass"]:
+        raise SystemExit(1)
+if __name__ == "__main__":
+    main()
+````
+````output
+{
+  "c1_evalue_identity": {
+    "max_abs_evalue_mean_error": 0.0,
+    "pass": true
+  },
+  "c2_fwer_control": {
+    "runs": 20000,
+    "horizon": 1000,
+    "fwer": 0.0303,
+    "pass": true
+  },
+  "c3_c4_detection_and_fdr": {
+    "runs": 250,
+    "fwer_mean_stop": 1747.104,
+    "fdr_mean_stop": 1527.844,
+    "fdr_speedup": 1.1435094158827734,
+    "pass": true
+  },
+  "c5_mixture_identity": {
+    "null_lr_mean": 0.9999999999999999,
+    "alternative_log_growth": 0.23645627415367648,
+    "pass": true
+  },
+  "stochastic_scalings": {
+    "soccer_monotone": true,
+    "predator_monotone": true,
+    "soccer_source_present": true,
+    "predator_source_present": true,
+    "pass": true
+  },
+  "pass": true
+}
+````
+---
+<!-- trackio-cell
+{"type": "code", "id": "cell_822ae0df860b", "created_at": "2026-07-21T14:20:26+00:00", "title": "Verifier unit tests", "command": ["python", "-m", "pytest", "-q", "repro/tests/test_verifier.py"], "exit_code": 0, "duration_s": 15.802}
+-->
+````bash
+$ python -m pytest -q repro/tests/test_verifier.py
+````
+exit 0 · 15.8s
+````python title=test_verifier.py
+"""Fail closed if the independent six-claim numerical gate regresses."""
+from __future__ import annotations
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+from verify_claims import (  # noqa: E402
+    detection_rate_and_fdr,
+    fwer_control,
+    mixture_identity,
+    normal_form_identity,
+    released_scalings,
+)
+def test_normal_form_evalue_identity() -> None:
+    assert normal_form_identity()["pass"]
+def test_null_fwer_control() -> None:
+    assert fwer_control()["pass"]
+def test_detection_and_fdr_control() -> None:
+    assert detection_rate_and_fdr()["pass"]
+def test_mixture_and_stochastic_controls() -> None:
+    assert mixture_identity()["pass"]
+    assert released_scalings()["pass"]
+````
+````output
+....                                                                     [100%]
+4 passed in 15.29s
+````
+---
+<!-- trackio-cell
+{"type": "code", "id": "cell_04491f414847", "created_at": "2026-07-21T14:21:10+00:00", "title": "Verifier unit tests", "command": ["python", "-m", "pytest", "-q", "repro/tests/test_verifier.py"], "exit_code": 0, "duration_s": 15.713}
+-->
+````bash
+$ python -m pytest -q repro/tests/test_verifier.py
+````
+exit 0 · 15.7s
+````python title=test_verifier.py
+"""Fail closed if the independent six-claim numerical gate regresses."""
+from __future__ import annotations
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+from verify_claims import (  # noqa: E402
+    detection_rate_and_fdr,
+    fwer_control,
+    mixture_identity,
+    normal_form_identity,
+    released_scalings,
+)
+def test_normal_form_evalue_identity() -> None:
+    assert normal_form_identity()["pass"]
+def test_null_fwer_control() -> None:
+    assert fwer_control()["pass"]
+def test_detection_and_fdr_control() -> None:
+    assert detection_rate_and_fdr()["pass"]
+def test_mixture_and_stochastic_controls() -> None:
+    assert mixture_identity()["pass"]
+    assert released_scalings()["pass"]
+````
+````output
+....                                                                     [100%]
+4 passed in 15.21s
+````

trackio-logo-light.png ADDED Viewed

trackio-logo.png ADDED Viewed

trackio-wordmark-dark.png ADDED Viewed