Spaces:

JUNGU
/

repro-memora-a-harmonic-memory-representation-balancing-abstraction-and-specificity

Running

App Files Files Community

JUNGU commited on about 1 month ago

Commit

7628b14

verified ·

1 Parent(s): e54776c

Update logbook: Reproduction: Memora: A Harmonic Memory Representation Balancing Abstraction and Specificity

Browse files

Files changed (18) hide show

README.md +14 -7
bucket-icon.svg +5 -0
index.html +82 -17
logbook.css +2142 -0
logbook.js +0 -0
logbook.json +74 -0
pages/claim-1-locomo-policy-retriever-reaches-0-863-llm-as-a-judge-and-exceeds-full-context/page.md +2440 -0
pages/claim-2-locomo-semantic-retriever-reaches-0-849-llm-as-a-judge-and-exceeds-full-context/page.md +752 -0
pages/claim-3-longmemeval-reaches-87-4-average-accuracy-with-up-to-98-token-reduction/page.md +8 -0
pages/claim-4-harmonic-memory-uses-a-primary-abstraction-concrete-memory-value-and-cue-anchors/page.md +8 -0
pages/claim-5-rag-and-kg-retrieval-are-special-cases-of-the-memora-dual-layer-design/page.md +8 -0
pages/conclusion/page.md +8 -0
pages/executive-summary/page.md +0 -0
pages/index.md +13 -0
trackio-logo-light.png +0 -0
trackio-logo.png +0 -0
trackio-wordmark-dark.png +0 -0
workspace.json +8 -0

README.md CHANGED Viewed

@@ -1,12 +1,19 @@
 ---
-title: >-
-  Repro Memora A Harmonic Memory Representation Balancing Abstraction And
-  Specificity
-emoji: 💻
-colorFrom: pink
-colorTo: indigo
 sdk: static
 pinned: false
 ---
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

 ---
+title: "Reproduction: Memora: A Harmonic Memory Representation Balancing Abstraction and Specificity"
+emoji: 🎯
+colorFrom: yellow
+colorTo: red
 sdk: static
 pinned: false
+tags:
+ - trackio
+ - trackio-logbook
+ - open-experiment
+ - icml2026-repro
+ - paper-zSrvkj0ers
+ - arxiv:2602.03315
 ---
+# Reproduction: Memora: A Harmonic Memory Representation Balancing Abstraction and Specificity
+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,84 @@
 <!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>Reproduction: Memora: A Harmonic Memory Representation Balancing Abstraction and Specificity</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">
+        <nav id="view-tabs" aria-label="Logbook views">
+          <a data-view="code" href="#/view/code/index">
+            <svg viewBox="0 0 24 24" aria-hidden="true">
+              <path d="m18 16 4-4-4-4" />
+              <path d="m6 8-4 4 4 4" />
+              <path d="m14.5 4-5 16" />
+            </svg>
+            <span>Logbook</span>
+          </a>
+          <a data-view="trace" href="#/view/trace">
+            <svg viewBox="0 0 24 24" aria-hidden="true">
+              <path d="M8 5h13" />
+              <path d="M13 12h8" />
+              <path d="M13 19h8" />
+              <path d="M3 10a2 2 0 0 0 2 2h3" />
+              <path d="M3 5v12a2 2 0 0 0 2 2h3" />
+            </svg>
+            <span>Traces</span>
+          </a>
+          <a data-view="workspace" href="#/view/workspace">
+            <svg viewBox="0 0 24 24" aria-hidden="true">
+              <path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z" />
+            </svg>
+            <span>Workspace</span>
+          </a>
+        </nav>
+        <header id="logbook-header">
+          <h1 id="logbook-title"></h1>
+          <div id="logbook-cli"></div>
+        </header>
+        <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,2142 @@

+:root {
+  --bg: #ffffff;
+  --paper: #ffffff;
+  --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.02);
+  --code-bg: #f3f4f6;
+  --radius: 12px;
+  --sidebar-width: 280px;
+  --content-gutter: 40px;
+  --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;
+  scrollbar-gutter: stable;
+}
+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;
+}
+body[data-view="trace"] #sidebar-foot,
+body[data-view="workspace"] #sidebar-foot {
+  display: none;
+}
+/* ---- sidebar (composition-book cover) ---- */
+#sidebar {
+  width: var(--sidebar-width);
+  flex: 0 0 var(--sidebar-width);
+  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 .tree-label {
+  padding: 6px 10px 8px;
+  color: #777a83;
+  font-size: 10px;
+  font-weight: 700;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+}
+#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;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+#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: 24px
+    clamp(
+      var(--content-gutter),
+      calc(100vw - 960px),
+      calc(var(--sidebar-width) + var(--content-gutter))
+    )
+    120px var(--content-gutter);
+  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;
+}
+#logbook-header {
+  width: 100%;
+  max-width: 1080px;
+  margin: 0 auto 20px;
+}
+#logbook-title {
+  font-family: var(--serif);
+  font-size: 34px;
+  line-height: 1.15;
+  letter-spacing: -0.02em;
+  margin: 0 0 10px;
+  overflow-wrap: anywhere;
+}
+#logbook-cli {
+  display: grid;
+  gap: 7px;
+}
+#page {
+  width: 100%;
+  min-width: 0;
+  max-width: 1080px;
+  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: block;
+}
+.page-body {
+  min-width: 0;
+}
+.resource-anchor {
+  display: block;
+  height: 0;
+  overflow: hidden;
+}
+/* ---- pinned notes ---- */
+.pinned-notes {
+  margin: 30px 0 32px;
+}
+.pinned-notes-list .cell {
+  margin: 0;
+}
+.pinned-notes-list .cell-title {
+  display: flex;
+  align-items: center;
+  gap: 7px;
+}
+.pin-ico {
+  flex: 0 0 auto;
+  width: 14px;
+  height: 14px;
+  fill: var(--accent);
+  stroke: none;
+}
+.pinned-notes-list .cell + .cell {
+  margin-top: 12px;
+}
+.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%;
+  margin: 0 0 32px;
+  background: none;
+  border: none;
+  border-radius: 0;
+  box-shadow: none;
+  overflow: visible;
+}
+.cell-head {
+  display: flex;
+  justify-content: space-between;
+  gap: 16px;
+  align-items: baseline;
+  padding: 0 0 5px;
+  background: none;
+  border-bottom: none;
+}
+.cell-head.no-title {
+  justify-content: flex-end;
+  padding: 0 0 3px;
+}
+.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: 0;
+}
+.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;
+}
+.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: 0;
+  background: var(--panel);
+}
+.jp-cmd {
+  display: flex;
+  align-items: baseline;
+  gap: 9px;
+  position: relative;
+  padding: 10px 16px 10px 0;
+  font-family: var(--mono);
+  font-size: 12px;
+  color: #8b8e98;
+}
+.jp-cmd-prompt {
+  color: var(--accent);
+  font-weight: 700;
+}
+#page .jp-cmd code {
+  min-width: 0;
+  color: #b6b9c2;
+  font-family: var(--mono);
+  font-size: 12px;
+  background: none;
+  padding: 0;
+  border-radius: 0;
+  overflow-wrap: anywhere;
+}
+.jp-cmd:hover .copy-snippet {
+  opacity: 1;
+}
+.jp-in-body .jp-cmd + .code-accordion,
+.jp-in-body .jp-cmd + .snippet {
+  border-top: 1px solid rgba(255, 255, 255, 0.09);
+}
+.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;
+  overflow-y: auto;
+  max-height: 26em;
+}
+.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: 0;
+  font-size: 12.5px;
+  color: var(--muted);
+}
+.agent-hint code {
+  flex: 1 1 18rem;
+  min-width: 0;
+  background: var(--code-bg);
+  padding: 2px 9px;
+  border-radius: 6px;
+  font-family: var(--mono);
+  font-size: 12px;
+  font-weight: 500;
+  color: var(--ink);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.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);
+}
+.hub-destination {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 8px;
+  color: var(--muted);
+  font-size: 12.5px;
+}
+.hub-destination a {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  max-width: 100%;
+  padding: 3px 9px;
+  border: 1px solid var(--accent-line);
+  border-radius: 999px;
+  background: var(--accent-soft);
+  color: var(--accent-strong);
+  font-family: var(--mono);
+  font-size: 12px;
+  font-weight: 650;
+  line-height: 1.5;
+  text-decoration: none;
+  overflow-wrap: anywhere;
+  transition: border-color 0.12s, background 0.12s, color 0.12s;
+}
+.hub-destination a:hover {
+  border-color: var(--accent);
+  background: #ffedd5;
+  color: #c2410c;
+}
+.hub-destination svg {
+  width: 13px;
+  height: 13px;
+  flex: 0 0 auto;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 1.8;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+.index-paper-link {
+  margin: 14px 0 30px;
+  font-size: 19px;
+  line-height: 1.35;
+  font-weight: 700;
+}
+.index-paper-link a {
+  text-underline-offset: 4px;
+  text-decoration-thickness: 2px;
+}
+.art-ico {
+  width: 1em;
+  height: 1em;
+  object-fit: contain;
+  vertical-align: -0.15em;
+}
+.art-file-ico {
+  width: 15px;
+  height: 15px;
+  flex: 0 0 auto;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 1.7;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  vertical-align: -0.2em;
+}
+.out-artifact-ico .art-file-ico {
+  color: var(--muted);
+}
+/* ---- 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 {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+  color: var(--accent-strong);
+}
+/* ---- 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;
+}
+/* ---- top-level logbook views ---- */
+#view-tabs {
+  position: sticky;
+  top: 0;
+  z-index: 30;
+  width: 100%;
+  max-width: 1080px;
+  margin: 0 auto 24px;
+  padding-top: 10px;
+  display: flex;
+  align-items: center;
+  justify-content: flex-start;
+  gap: 26px;
+  border-bottom: 1px solid var(--line);
+  background: var(--paper);
+}
+#view-tabs a {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  min-height: 44px;
+  margin-bottom: -1px;
+  color: var(--muted);
+  border-bottom: 2px solid transparent;
+  text-decoration: none;
+  font-size: 13.5px;
+  font-weight: 600;
+  transition: color 0.12s, border-color 0.12s;
+}
+#view-tabs a:hover {
+  color: var(--ink);
+}
+#view-tabs a.active {
+  color: var(--accent-strong);
+  border-bottom-color: var(--accent);
+}
+#view-tabs svg {
+  width: 18px;
+  height: 18px;
+  flex: 0 0 auto;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 2;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+.workspace-file svg,
+.workspace-folder summary svg,
+.workspace-download svg {
+  width: 17px;
+  height: 17px;
+  flex: 0 0 auto;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 1.7;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+#page.trace-page,
+#page.workspace-page {
+  max-width: 1080px;
+}
+.view-loading {
+  padding: 72px 0;
+  color: var(--muted);
+  text-align: center;
+}
+.view-empty {
+  margin: 48px 0;
+  padding: 44px 28px;
+  border: 1px dashed #d8dbe1;
+  border-radius: var(--radius);
+  background: rgba(255, 255, 255, 0.72);
+  text-align: center;
+}
+.view-empty h2 {
+  margin: 0 0 7px;
+  font-size: 18px;
+}
+.view-empty p {
+  max-width: 560px;
+  margin: 0 auto;
+  color: var(--muted);
+}
+.view-empty code {
+  display: inline-block;
+  margin-top: 18px;
+  padding: 7px 10px;
+  border-radius: 7px;
+  background: var(--code-bg);
+  font-family: var(--mono);
+  font-size: 12px;
+}
+#page .repo-ref-link {
+  display: inline-block;
+  margin-top: 18px;
+  padding: 8px 14px;
+  border-radius: 8px;
+  background: var(--accent-strong, #2158d0);
+  color: #fff;
+  font-weight: 600;
+  text-decoration: none;
+}
+#page .repo-ref-link:hover,
+#page .repo-ref-link:focus-visible {
+  color: #fff;
+  filter: brightness(0.95);
+}
+.view-eyebrow {
+  margin-bottom: 4px;
+  color: var(--accent-strong);
+  font-family: var(--mono);
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+}
+/* ---- trace ---- */
+.trace-session {
+  scroll-margin-top: 24px;
+}
+.trace-session + .trace-session {
+  margin-top: 44px;
+  padding-top: 40px;
+  border-top: 1px solid var(--line);
+}
+.trace-session-title {
+  margin: 0 0 14px;
+  color: var(--ink);
+  font-family: var(--serif);
+  font-size: 22px;
+  line-height: 1.2;
+  letter-spacing: -0.02em;
+  overflow-wrap: anywhere;
+}
+.workspace-header h1 {
+  margin: 0;
+  color: var(--ink);
+  font-size: 30px;
+  line-height: 1.2;
+  letter-spacing: -0.025em;
+}
+.trace-meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 9px 20px;
+  margin-bottom: 34px;
+  padding: 14px 16px;
+  border: 1px solid var(--line);
+  border-radius: 10px;
+  background: rgba(255, 255, 255, 0.78);
+  color: var(--muted);
+  font-family: var(--mono);
+  font-size: 11px;
+}
+.trace-meta strong {
+  color: var(--ink);
+  font-weight: 650;
+}
+.trace-source-missing {
+  color: #b45309;
+}
+.trace-timeline {
+  position: relative;
+}
+.trace-timeline::before {
+  content: "";
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 82px;
+  width: 1px;
+  background: #dedfe3;
+}
+.trace-load-controls {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  margin: 22px 0 0 100px;
+  padding-top: 16px;
+  border-top: 1px solid var(--line);
+}
+.trace-load-progress {
+  color: var(--muted);
+  font-family: var(--mono);
+  font-size: 11px;
+}
+.trace-load-more {
+  padding: 7px 12px;
+  border: 1px solid var(--line-strong);
+  border-radius: 7px;
+  background: var(--paper);
+  color: var(--ink);
+  cursor: pointer;
+  font: 650 12px/1.2 var(--sans);
+}
+.trace-load-more:hover:not(:disabled) {
+  border-color: var(--accent);
+  color: var(--accent-strong);
+}
+.trace-load-more:disabled {
+  cursor: default;
+  opacity: 0.65;
+}
+.trace-entry {
+  --trace-depth: 0;
+  position: relative;
+  display: grid;
+  grid-template-columns: 100px minmax(0, 1fr);
+  margin: 0 0 18px calc(var(--trace-depth) * 24px);
+}
+.trace-rail {
+  position: relative;
+  min-height: 36px;
+  padding: 4px 28px 0 0;
+  color: #8a8d95;
+  text-align: right;
+  font-family: var(--mono);
+}
+.trace-number,
+.trace-elapsed {
+  display: block;
+  white-space: nowrap;
+}
+.trace-number {
+  font-size: 12px;
+  font-weight: 650;
+}
+.trace-elapsed {
+  margin-top: 3px;
+  font-size: 10px;
+}
+.trace-dot {
+  position: absolute;
+  top: 10px;
+  right: 11px;
+  width: 11px;
+  height: 11px;
+  border: 2px solid var(--paper);
+  border-radius: 50%;
+  background: var(--accent);
+  box-shadow: 0 0 0 1px #d7d9de;
+}
+.trace-card {
+  min-width: 0;
+  overflow: hidden;
+  border: 1px solid #dddfe4;
+  border-radius: 11px;
+  background: rgba(255, 255, 255, 0.92);
+}
+.trace-card > header {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  min-height: 37px;
+  padding: 8px 13px;
+  border-bottom: 1px solid #eceef1;
+}
+.trace-status .trace-card > header {
+  border-bottom: 0;
+  padding-bottom: 5px;
+}
+.trace-kind {
+  font-family: var(--mono);
+  font-size: 10.5px;
+  font-weight: 750;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+.trace-turn {
+  color: var(--muted);
+  font: 10px var(--mono);
+}
+.trace-status-badge {
+  margin-left: auto;
+  padding: 1px 6px;
+  border-radius: 999px;
+  background: #eef0f3;
+  color: var(--muted);
+  font: 9.5px var(--mono);
+  text-transform: uppercase;
+}
+.trace-status-badge-error,
+.trace-status-badge-failed {
+  background: #fef2f2;
+  color: #b91c1c;
+}
+.trace-body {
+  margin: 0;
+  padding: 15px 17px 17px;
+  overflow-wrap: anywhere;
+  white-space: pre-wrap;
+  font-family: var(--sans);
+  font-size: 13px;
+  line-height: 1.65;
+}
+.trace-reasoning .trace-card {
+  border-style: dashed;
+  border-color: #d7b98a;
+  background: #fffdf8;
+}
+.trace-reasoning .trace-kind {
+  color: #9a6b22;
+}
+.trace-reasoning .trace-body {
+  font-style: italic;
+}
+.trace-user .trace-card {
+  border-left: 3px solid #f3a66d;
+}
+.trace-tool_call .trace-card,
+.trace-tool_result .trace-card {
+  border-color: #2d3036;
+  background: #191a1e;
+  color: #ececf0;
+}
+.trace-tool_call .trace-card > header,
+.trace-tool_result .trace-card > header {
+  border-bottom-color: rgba(255, 255, 255, 0.1);
+}
+.trace-tool_call .trace-kind,
+.trace-tool_result .trace-kind {
+  color: #f5a66d;
+}
+.trace-tool_call .trace-turn,
+.trace-tool_result .trace-turn {
+  color: #979aa3;
+}
+.trace-tool_call .trace-body,
+.trace-tool_result .trace-body,
+.trace-output pre {
+  font-family: var(--mono);
+  font-size: 11.5px;
+  line-height: 1.6;
+}
+#page .trace-tool_call pre.trace-body,
+#page .trace-tool_result pre.trace-body {
+  margin: 0;
+  padding: 15px 17px 17px;
+  border: 0;
+  border-radius: 0;
+  background: transparent;
+  color: #ececf0;
+}
+.trace-output {
+  border-top: 1px dashed rgba(255, 255, 255, 0.14);
+}
+.trace-output summary {
+  padding: 9px 14px;
+  color: #aaaeb7;
+  cursor: pointer;
+  font: 700 10px var(--mono);
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+#page .trace-output pre {
+  max-height: 480px;
+  margin: 0;
+  padding: 0 16px 16px;
+  border: 0;
+  border-radius: 0;
+  background: transparent;
+  overflow: auto;
+  color: #d7d8dd;
+  white-space: pre-wrap;
+}
+/* ---- workspace ---- */
+.workspace-header {
+  padding-bottom: 24px;
+}
+.workspace-header p {
+  margin: 0;
+  color: var(--muted);
+  font-family: var(--mono);
+  font-size: 11px;
+}
+.workspace-inventory {
+  overflow: hidden;
+  border: 1px solid var(--line);
+  border-radius: 11px;
+  background: rgba(255, 255, 255, 0.92);
+}
+.workspace-folder > summary {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-height: 39px;
+  padding: 8px 13px;
+  background: #fafafa;
+  cursor: pointer;
+  font-weight: 650;
+  list-style: none;
+}
+.workspace-folder > summary::-webkit-details-marker {
+  display: none;
+}
+.workspace-folder > summary::after {
+  content: "›";
+  margin-left: auto;
+  color: #989ba2;
+  transform: rotate(90deg);
+}
+.workspace-folder:not([open]) > summary::after {
+  transform: rotate(0);
+}
+.workspace-folder-children {
+  padding-left: 20px;
+}
+.workspace-file {
+  display: grid;
+  grid-template-columns: minmax(180px, 1fr) 72px 78px 180px 36px;
+  align-items: center;
+  min-height: 44px;
+  padding: 7px 10px 7px 13px;
+  color: var(--muted);
+  font-family: var(--mono);
+  font-size: 10.5px;
+}
+.workspace-file-name {
+  display: flex;
+  align-items: center;
+  min-width: 0;
+  gap: 8px;
+  color: var(--ink);
+  font-family: var(--sans);
+  font-size: 12.5px;
+  font-weight: 550;
+}
+.workspace-file-name span {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.workspace-file-type {
+  width: fit-content;
+  padding: 1px 6px;
+  border-radius: 999px;
+  background: var(--accent-soft);
+  color: var(--accent-strong);
+  text-transform: uppercase;
+}
+.workspace-download {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 30px;
+  height: 30px;
+  border-radius: 7px;
+  color: var(--muted);
+}
+.workspace-download:hover {
+  background: var(--accent-soft);
+  color: var(--accent-strong);
+}
+.workspace-unpublished {
+  color: #9ca3af;
+  text-align: center;
+}
+.workspace-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  flex-wrap: wrap;
+}
+.workspace-toggle {
+  display: inline-flex;
+  align-items: center;
+  padding: 2px;
+  border: 1px solid var(--line);
+  border-radius: 999px;
+  background: #fafafa;
+}
+.workspace-toggle-btn {
+  padding: 4px 13px;
+  border: 0;
+  border-radius: 999px;
+  background: transparent;
+  color: var(--muted);
+  font-family: var(--sans);
+  font-size: 12px;
+  font-weight: 600;
+  cursor: pointer;
+}
+.workspace-toggle-btn:hover {
+  color: var(--accent-strong);
+}
+.workspace-toggle-btn.is-active {
+  background: var(--accent);
+  color: #ffffff;
+}
+.workspace-group + .workspace-group {
+  margin-top: 18px;
+}
+.workspace-group-head,
+.workspace-hub-group-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin: 0;
+  padding: 8px 13px;
+  background: #fafafa;
+  border-bottom: 1px solid var(--line);
+  color: var(--ink);
+  font-family: var(--sans);
+  font-size: 12px;
+  font-weight: 650;
+  text-transform: capitalize;
+}
+.workspace-group-count,
+.workspace-hub-count {
+  padding: 0 7px;
+  border-radius: 999px;
+  background: var(--accent-soft);
+  color: var(--accent-strong);
+  font-family: var(--mono);
+  font-size: 10.5px;
+}
+.workspace-group {
+  overflow: hidden;
+  border: 1px solid var(--line);
+  border-radius: 11px;
+  background: rgba(255, 255, 255, 0.92);
+}
+.workspace-hub {
+  margin-top: 28px;
+}
+.workspace-hub-title {
+  margin: 0 0 14px;
+  font-family: var(--sans);
+  font-size: 16px;
+  font-weight: 700;
+  color: var(--ink);
+}
+.workspace-hub-group {
+  overflow: hidden;
+  border: 1px solid var(--line);
+  border-radius: 11px;
+  background: rgba(255, 255, 255, 0.92);
+}
+.workspace-hub-group + .workspace-hub-group {
+  margin-top: 14px;
+}
+.workspace-hub-list {
+  display: flex;
+  flex-direction: column;
+}
+.workspace-hub-link {
+  padding: 9px 13px;
+  color: var(--accent-strong);
+  font-family: var(--mono);
+  font-size: 12px;
+  text-decoration: none;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.workspace-hub-link + .workspace-hub-link {
+  border-top: 1px solid var(--line);
+}
+.workspace-hub-link:hover {
+  background: var(--accent-soft);
+  text-decoration: underline;
+}
+/* --- UI nits --- */
+/* Flush group headers: #page h3/h2 (ID selectors) otherwise inject a top margin
+   that, with overflow:hidden on the card, shows as whitespace above "Jobs" etc. */
+#page .workspace-hub-title {
+  margin: 0 0 14px;
+}
+#page .workspace-hub-group-head,
+#page .workspace-group-head {
+  margin: 0;
+}
+/* HF brand logo before the "Hugging Face artifacts" heading */
+.workspace-hub-title {
+  display: flex;
+  align-items: center;
+  gap: 9px;
+}
+.workspace-hub-logo {
+  width: 22px;
+  height: 22px;
+  flex: none;
+}
+/* Center empty-state placeholders (heading, body, command) */
+.view-empty {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+#page .view-empty h2,
+#page .view-empty p {
+  text-align: center;
+}
+@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;
+  }
+  #view-tabs {
+    margin: 0 0 20px;
+    gap: 18px;
+    justify-content: flex-start;
+    overflow-x: auto;
+  }
+  #view-tabs a {
+    flex: 0 0 auto;
+  }
+  .trace-timeline::before {
+    left: 16px;
+  }
+  .trace-entry {
+    grid-template-columns: 32px minmax(0, 1fr);
+    margin-left: calc(var(--trace-depth) * 10px);
+  }
+  .trace-rail {
+    padding: 0;
+  }
+  .trace-number,
+  .trace-elapsed {
+    display: none;
+  }
+  .trace-dot {
+    top: 10px;
+    right: 10px;
+  }
+  .workspace-file {
+    grid-template-columns: minmax(150px, 1fr) 66px 34px;
+  }
+  .workspace-file-size,
+  .workspace-file-time {
+    display: none;
+  }
+  #page {
+    width: 100%;
+    max-width: 100%;
+  }
+  #page h1,
+  #logbook-title {
+    font-size: 30px;
+  }
+  .cell-head {
+    align-items: flex-start;
+    flex-direction: column;
+    gap: 4px;
+  }
+}

logbook.js ADDED Viewed

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

logbook.json ADDED Viewed

	@@ -0,0 +1,74 @@

+{
+  "schema_version": 2,
+  "title": "Reproduction: Memora: A Harmonic Memory Representation Balancing Abstraction and Specificity",
+  "emoji": "🎯",
+  "space_id": "JUNGU/repro-memora-a-harmonic-memory-representation-balancing-abstraction-and-specificity",
+  "paper": {
+    "arxiv_id": "2602.03315"
+  },
+  "tags": [
+    "icml2026-repro",
+    "paper-zSrvkj0ers"
+  ],
+  "updated_at": "2026-07-24T14:43:13+00:00",
+  "root": {
+    "slug": "index",
+    "title": "Reproduction: Memora: A Harmonic Memory Representation Balancing Abstraction and Specificity",
+    "file": "pages/index.md",
+    "children": [
+      {
+        "slug": "executive-summary",
+        "title": "Executive summary",
+        "file": "pages/executive-summary/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-1-locomo-policy-retriever-reaches-0-863-llm-as-a-judge-and-exceeds-full-context",
+        "title": "Claim 1: LoCoMo Policy Retriever reaches 0.863 LLM-as-a-Judge and exceeds full-context.",
+        "file": "pages/claim-1-locomo-policy-retriever-reaches-0-863-llm-as-a-judge-and-exceeds-full-context/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-2-locomo-semantic-retriever-reaches-0-849-llm-as-a-judge-and-exceeds-full-context",
+        "title": "Claim 2: LoCoMo Semantic Retriever reaches 0.849 LLM-as-a-Judge and exceeds full-context.",
+        "file": "pages/claim-2-locomo-semantic-retriever-reaches-0-849-llm-as-a-judge-and-exceeds-full-context/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-3-longmemeval-reaches-87-4-average-accuracy-with-up-to-98-token-reduction",
+        "title": "Claim 3: LongMemEval reaches 87.4% average accuracy with up to 98% token reduction.",
+        "file": "pages/claim-3-longmemeval-reaches-87-4-average-accuracy-with-up-to-98-token-reduction/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-4-harmonic-memory-uses-a-primary-abstraction-concrete-memory-value-and-cue-anchors",
+        "title": "Claim 4: Harmonic memory uses a primary abstraction, concrete memory value, and cue anchors.",
+        "file": "pages/claim-4-harmonic-memory-uses-a-primary-abstraction-concrete-memory-value-and-cue-anchors/page.md",
+        "children": []
+      },
+      {
+        "slug": "claim-5-rag-and-kg-retrieval-are-special-cases-of-the-memora-dual-layer-design",
+        "title": "Claim 5: RAG and KG retrieval are special cases of the Memora dual-layer design.",
+        "file": "pages/claim-5-rag-and-kg-retrieval-are-special-cases-of-the-memora-dual-layer-design/page.md",
+        "children": []
+      },
+      {
+        "slug": "conclusion",
+        "title": "Conclusion",
+        "file": "pages/conclusion/page.md",
+        "children": []
+      }
+    ]
+  },
+  "traces": [],
+  "workspace": {
+    "file": "workspace.json",
+    "file_count": 0,
+    "total_size": 0,
+    "bucket_id": null
+  },
+  "agent_view_tokens": 3880,
+  "trace_view_tokens": 10,
+  "workspace_view_tokens": 8,
+  "revision": "feab0879a55f521b8739"
+}

pages/claim-1-locomo-policy-retriever-reaches-0-863-llm-as-a-judge-and-exceeds-full-context/page.md ADDED Viewed

	@@ -0,0 +1,2440 @@

+# Claim 1: LoCoMo Policy Retriever reaches 0.863 LLM-as-a-Judge and exceeds full-context.
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_f017fe994a2e", "created_at": "2026-07-24T05:17:39+00:00", "title": "Claim 1: LoCoMo Policy Retriever reaches 0.863 LLM-as-a-Judge and exceeds full-context."}
+-->
+Document setup, runs, and results for **Claim 1: LoCoMo Policy Retriever reaches 0.863 LLM-as-a-Judge and exceeds full-context.**.
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_026153fd1ee3", "created_at": "2026-07-24T05:17:48+00:00", "title": "Protocol and model substitution"}
+-->
+We test the official Memora Policy Retriever on the complete LoCoMo dataset: all 10 conversations, 272 sessions, and 1,540 evaluated questions after the repository-standard exclusion of category 5. The memory construction, cue index, raw-segment episodic memory, factual memory, BM25 hybrid retrieval, top-k=30, and four-step prompted policy are preserved. Because the original GPT-4.1-mini and OpenAI embedding endpoints are unavailable, this is a full-scale portability reproduction using GLM-5.2 through an OpenAI-compatible API and local BAAI/bge-small-en-v1.5 embeddings. We therefore compare against the reported 0.863 Policy score and 0.825 full-context baseline while treating any difference as model-stack-sensitive rather than an exact same-model replication.
+---
+<!-- trackio-cell
+{"type": "code", "id": "cell_dece326842f3", "created_at": "2026-07-24T05:17:56+00:00", "title": "Run: python run_locomo_reproduction.py (exit 1)", "command": [".venv/bin/python", "scripts/run_locomo_reproduction.py", "--strategy", "prompt", "--run-prefix", "glm52-full", "--max-parallel", "3", "--retries", "3", "--env-file", "/Users/conanssam-m4/.ouroboros/worktrees/studymemory/orch_d223290f8ae3/.env", "--trackio"], "exit_code": 1, "duration_s": 1.758}
+-->
+````bash
+$ .venv/bin/python scripts/run_locomo_reproduction.py --strategy prompt --run-prefix glm52-full --max-parallel 3 --retries 3 --env-file /Users/conanssam-m4/.ouroboros/worktrees/studymemory/orch_d223290f8ae3/.env --trackio
+````
+exit 1 · 1.8s
+````python title=run_locomo_reproduction.py
+#!/usr/bin/env python3
+"""Run the full LoCoMo Memora reproduction as restartable conversation splits.
+Each LoCoMo conversation has an isolated Memora user namespace. Running the ten
+conversations in separate processes therefore preserves the official method
+while avoiding result-directory collisions and making multi-hour API runs
+restartable.
+"""
+from __future__ import annotations
+import argparse
+import concurrent.futures
+import hashlib
+import json
+import os
+import subprocess
+import sys
+import time
+from collections import defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+from statistics import fmean
+from typing import Any
+from dotenv import load_dotenv
+REPO_ROOT = Path(__file__).resolve().parents[1]
+LOCOMO_ROOT = REPO_ROOT / "app" / "locomo"
+DATA_PATH = LOCOMO_ROOT / "data" / "locomo10.json"
+DEFAULT_PROJECT = "memora-icml2026-repro"
+PAPER_TARGETS = {
+    "prompt": {"llm_score": 0.863, "f1_score": 0.553, "bleu_score": 0.466},
+    "semantic": {"llm_score": 0.849, "f1_score": 0.552, "bleu_score": 0.464},
+    "full_context": {"llm_score": 0.825},
+}
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--strategy",
+        choices=("prompt", "semantic"),
+        required=True,
+        help="Memora retrieval strategy to reproduce.",
+    )
+    parser.add_argument(
+        "--run-prefix",
+        default="glm52-full",
+        help="Stable campaign name used for result and memory directories.",
+    )
+    parser.add_argument(
+        "--splits",
+        nargs="+",
+        type=int,
+        default=list(range(1, 11)),
+        help="One-based LoCoMo conversation indices (default: all 1..10).",
+    )
+    parser.add_argument(
+        "--max-parallel",
+        type=int,
+        default=3,
+        help="Maximum concurrent GLM-backed split processes.",
+    )
+    parser.add_argument(
+        "--retries",
+        type=int,
+        default=2,
+        help="Process-level attempts per split.",
+    )
+    parser.add_argument(
+        "--env-file",
+        type=Path,
+        help="Optional dotenv file containing GLM_API_KEY and GLM_MODEL.",
+    )
+    parser.add_argument(
+        "--python",
+        type=Path,
+        default=REPO_ROOT / ".venv" / "bin" / "python",
+        help="Python interpreter for split processes.",
+    )
+    parser.add_argument(
+        "--trackio",
+        action="store_true",
+        help="Log split completion and aggregate metrics to Trackio.",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print commands without running the experiment.",
+    )
+    return parser.parse_args()
+def validate_splits(splits: list[int]) -> list[int]:
+    normalized = sorted(set(splits))
+    if not normalized or normalized[0] < 1 or normalized[-1] > 10:
+        raise ValueError("--splits must contain one-based indices between 1 and 10")
+    return normalized
+def load_dataset(path: Path = DATA_PATH) -> list[dict[str, Any]]:
+    with path.open() as f:
+        data = json.load(f)
+    if len(data) != 10:
+        raise ValueError(f"Expected 10 LoCoMo conversations, found {len(data)}")
+    return data
+def dataset_summary(data: list[dict[str, Any]]) -> dict[str, Any]:
+    category_counts: dict[str, int] = defaultdict(int)
+    sessions = 0
+    question_counts = []
+    evaluated_counts = []
+    for item in data:
+        conversation = item["conversation"]
+        sessions += sum(
+            1
+            for key in conversation
+            if key.startswith("session_") and not key.endswith("_date_time")
+        )
+        qa = item["qa"]
+        question_counts.append(len(qa))
+        evaluated = 0
+        for question in qa:
+            category = str(question["category"])
+            category_counts[category] += 1
+            if category != "5":
+                evaluated += 1
+        evaluated_counts.append(evaluated)
+    return {
+        "conversations": len(data),
+        "sessions": sessions,
+        "questions": sum(question_counts),
+        "evaluated_questions": sum(evaluated_counts),
+        "question_counts": question_counts,
+        "evaluated_counts": evaluated_counts,
+        "category_counts": dict(sorted(category_counts.items())),
+    }
+def file_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+def campaign_root(run_prefix: str) -> Path:
+    return LOCOMO_ROOT / "results" / "reproduction" / run_prefix
+def split_output_dir(run_prefix: str, strategy: str, split: int) -> Path:
+    return (
+        campaign_root(run_prefix)
+        / "runs"
+        / f"memora_{strategy}_split{split:02d}"
+    )
+def split_paths(
+    run_prefix: str,
+    strategy: str,
+    split: int,
+) -> dict[str, Path]:
+    method = f"memora_{strategy}"
+    output_dir = split_output_dir(run_prefix, strategy, split)
+    return {
+        "dir": output_dir,
+        "output": output_dir / f"{method}_output.json",
+        "eval": output_dir / f"{method}_eval.json",
+        "scores": output_dir / f"{method}_scores.json",
+        "build_timing": output_dir / "build_timing.json",
+    }
+def memory_store_name(run_prefix: str, split: int) -> str:
+    safe_prefix = "".join(
+        char if char.isalnum() or char in "._-" else "-"
+        for char in run_prefix
+    ).strip("-")
+    if not safe_prefix:
+        raise ValueError("--run-prefix must contain at least one safe character")
+    return f"{safe_prefix}-split{split:02d}"
+def build_split_command(
+    *,
+    python: Path,
+    run_prefix: str,
+    strategy: str,
+    split: int,
+    force_rebuild: bool,
+) -> list[str]:
+    return [
+        str(python),
+        "run_memora.py",
+        "--config-name",
+        "config_glm",
+        f"general.project_path={LOCOMO_ROOT}",
+        f"general.results_path={campaign_root(run_prefix) / 'runs'}",
+        "general.debug=false",
+        "general.resume=true",
+        f"general.run_name=split{split:02d}",
+        f"eval.subset_idx={split}",
+        "eval.max_workers=1",
+        f"memory.memory_store={memory_store_name(run_prefix, split)}",
+        f"memory.force_rebuild={'true' if force_rebuild else 'false'}",
+        f"retrieval.strategy={strategy}",
+    ]
+def evaluated_item_count(path: Path) -> int:
+    with path.open() as f:
+        data = json.load(f)
+    return sum(len(items) for items in data.values())
+def completed_split(
+    run_prefix: str,
+    strategy: str,
+    split: int,
+    expected_count: int,
+) -> bool:
+    paths = split_paths(run_prefix, strategy, split)
+    if not paths["scores"].is_file() or not paths["eval"].is_file():
+        return False
+    try:
+        with paths["scores"].open() as f:
+            scores = json.load(f)
+        return (
+            scores["summary"]["total_questions"] == expected_count
+            and evaluated_item_count(paths["eval"]) == expected_count
+        )
+    except (KeyError, OSError, ValueError, json.JSONDecodeError):
+        return False
+def tail(path: Path, line_count: int = 40) -> str:
+    try:
+        lines = path.read_text(errors="replace").splitlines()
+    except OSError:
+        return ""
+    return "\n".join(lines[-line_count:])
+def run_split(
+    *,
+    python: Path,
+    run_prefix: str,
+    strategy: str,
+    split: int,
+    expected_count: int,
+    retries: int,
+    dry_run: bool,
+) -> dict[str, Any]:
+    started = time.monotonic()
+    root = campaign_root(run_prefix)
+    log_path = root / "logs" / f"{strategy}-split{split:02d}.log"
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    if completed_split(run_prefix, strategy, split, expected_count):
+        return {
+            "split": split,
+            "status": "skipped",
+            "duration_seconds": 0.0,
+            "log": str(log_path),
+        }
+    persist_path = LOCOMO_ROOT / "memory_store" / memory_store_name(
+        run_prefix,
+        split,
+    )
+    if strategy == "semantic" and not persist_path.exists():
+        raise RuntimeError(
+            f"Split {split}: semantic retrieval requires the prompt-built "
+            f"memory store at {persist_path}"
+        )
+    attempts = max(1, retries)
+    for attempt in range(1, attempts + 1):
+        paths = split_paths(run_prefix, strategy, split)
+        force_rebuild = (
+            strategy == "prompt" and not paths["build_timing"].is_file()
+        )
+        command = build_split_command(
+            python=python,
+            run_prefix=run_prefix,
+            strategy=strategy,
+            split=split,
+            force_rebuild=force_rebuild,
+        )
+        if dry_run:
+            return {
+                "split": split,
+                "status": "dry-run",
+                "duration_seconds": 0.0,
+                "command": command,
+                "log": str(log_path),
+            }
+        with log_path.open("a") as log:
+            log.write(
+                f"\n=== attempt {attempt}/{attempts} "
+                f"{datetime.now(timezone.utc).isoformat()} ===\n"
+            )
+            log.flush()
+            completed = subprocess.run(
+                command,
+                cwd=LOCOMO_ROOT,
+                env={**os.environ, "TOKENIZERS_PARALLELISM": "false"},
+                stdout=log,
+                stderr=subprocess.STDOUT,
+                text=True,
+                check=False,
+            )
+        if completed.returncode == 0 and completed_split(
+            run_prefix,
+            strategy,
+            split,
+            expected_count,
+        ):
+            return {
+                "split": split,
+                "status": "completed",
+                "duration_seconds": round(time.monotonic() - started, 3),
+                "attempts": attempt,
+                "log": str(log_path),
+            }
+        if attempt == attempts:
+            raise RuntimeError(
+                f"Split {split} failed after {attempts} attempts "
+                f"(exit {completed.returncode}).\n{tail(log_path)}"
+            )
+    raise AssertionError("unreachable")
+def mean(values: list[float]) -> float:
+    return round(fmean(values), 4)
+def aggregate_strategy(
+    *,
+    run_prefix: str,
+    strategy: str,
+    splits: list[int],
+    expected_counts: list[int],
+) -> dict[str, Any]:
+    aggregate_eval: dict[str, list[dict[str, Any]]] = {}
+    aggregate_output: dict[str, list[dict[str, Any]]] = {}
+    all_eval_items: list[dict[str, Any]] = []
+    for split in splits:
+        paths = split_paths(run_prefix, strategy, split)
+        expected = expected_counts[split - 1]
+        if not completed_split(run_prefix, strategy, split, expected):
+            raise RuntimeError(f"Split {split} is incomplete and cannot be aggregated")
+        with paths["eval"].open() as f:
+            split_eval = json.load(f)
+        with paths["output"].open() as f:
+            split_output = json.load(f)
+        eval_items = [
+            item for items in split_eval.values() for item in items
+        ]
+        output_items = [
+            item for items in split_output.values() for item in items
+        ]
+        aggregate_eval[str(split - 1)] = eval_items
+        aggregate_output[str(split - 1)] = output_items
+        all_eval_items.extend(eval_items)
+    by_category: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for item in all_eval_items:
+        by_category[str(item["category"])].append(item)
+    metrics = ("bleu_score", "f1_score", "llm_score")
+    per_category = {
+        metric: {
+            category: mean([float(item[metric]) for item in items])
+            for category, items in sorted(by_category.items())
+        }
+        for metric in metrics
+    }
+    per_category["count"] = {
+        category: len(items)
+        for category, items in sorted(by_category.items())
+    }
+    overall = {
+        metric: mean([float(item[metric]) for item in all_eval_items])
+        for metric in metrics
+    }
+    scores = {
+        "mean_scores_per_category": per_category,
+        "overall_mean_scores": overall,
+        "summary": {
+            "total_questions": len(all_eval_items),
+            "categories_evaluated": sorted(int(key) for key in by_category),
+            "evaluation_timestamp": datetime.now(timezone.utc).isoformat(),
+            "conversation_splits": splits,
+        },
+    }
+    root = campaign_root(run_prefix)
+    root.mkdir(parents=True, exist_ok=True)
+    for name, payload in (
+        (f"{strategy}_output.json", aggregate_output),
+        (f"{strategy}_eval.json", aggregate_eval),
+        (f"{strategy}_scores.json", scores),
+    ):
+        with (root / name).open("w") as f:
+            json.dump(payload, f, indent=2)
+    return scores
+def write_manifest(
+    *,
+    run_prefix: str,
+    strategy: str,
+    splits: list[int],
+    summary: dict[str, Any],
+    scores: dict[str, Any] | None,
+) -> Path:
+    selected_questions = sum(summary["question_counts"][i - 1] for i in splits)
+    selected_evaluated = sum(
+        summary["evaluated_counts"][i - 1] for i in splits
+    )
+    manifest = {
+        "paper": {
+            "title": (
+                "Memora: A Harmonic Memory Representation Balancing "
+                "Abstraction and Specificity"
+            ),
+            "arxiv_id": "2602.03315",
+            "openreview_id": "zSrvkj0ers",
+            "official_repository": "https://github.com/microsoft/Memora",
+            "official_commit": "dec3f8f2444eace7004fc084abe1be9f3d88270e",
+        },
+        "campaign": run_prefix,
+        "strategy": strategy,
+        "splits": splits,
+        "full_scale": splits == list(range(1, 11)),
+        "dataset": {
+            **summary,
+            "selected_questions": selected_questions,
+            "selected_evaluated_questions": selected_evaluated,
+            "sha256": file_sha256(DATA_PATH),
+        },
+        "implementation": {
+            "llm_provider": "Z.AI OpenAI-compatible API",
+            "llm_model": os.getenv("GLM_MODEL", "glm-4.5-flash"),
+            "embedding_provider": "local FastEmbed",
+            "embedding_model": "BAAI/bge-small-en-v1.5",
+            "retrieval_strategy": strategy,
+            "top_k": 30,
+            "hybrid_search": "BM25",
+            "segmentation": True,
+            "episodic_memory": "raw segments plus factual memories",
+            "cue_index": True,
+            "prompted_policy_max_steps": 4 if strategy == "prompt" else None,
+        },
+        "protocol_deviations": [
+            (
+                "GPT-4.1-mini was replaced by GLM because the original model "
+                "endpoint was unavailable."
+            ),
+            (
+                "The repository-default OpenAI embedding endpoint was replaced "
+                "by local BAAI/bge-small-en-v1.5 embeddings."
+            ),
+            (
+                "The GLM endpoint does not accept the paper's seed parameter; "
+                "temperature was fixed at 0 and thinking was disabled."
+            ),
+            (
+                "Conversations were executed as ten isolated processes and "
+                "aggregated; Memora user namespaces are conversation-local."
+            ),
+        ],
+        "paper_targets": PAPER_TARGETS,
+        "scores": scores,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+    }
+    path = campaign_root(run_prefix) / f"{strategy}_manifest.json"
+    with path.open("w") as f:
+        json.dump(manifest, f, indent=2)
+    return path
+def initialize_trackio(args: argparse.Namespace, splits: list[int]):
+    if not args.trackio:
+        return None
+    try:
+        import trackio
+    except ImportError as exc:
+        raise RuntimeError(
+            "Trackio is not installed in the orchestrator environment. "
+            "Install requirements-glm.txt first."
+        ) from exc
+    trackio.init(
+        project=DEFAULT_PROJECT,
+        name=f"{args.run_prefix}-{args.strategy}",
+        group=args.run_prefix,
+        config={
+            "paper_arxiv": "2602.03315",
+            "strategy": args.strategy,
+            "model": os.getenv("GLM_MODEL", "glm-4.5-flash"),
+            "embedding_model": "BAAI/bge-small-en-v1.5",
+            "splits": ",".join(str(split) for split in splits),
+            "full_scale": splits == list(range(1, 11)),
+        },
+    )
+    return trackio
+def main() -> int:
+    args = parse_args()
+    splits = validate_splits(args.splits)
+    if args.max_parallel < 1:
+        raise ValueError("--max-parallel must be at least 1")
+    if args.env_file:
+        load_dotenv(args.env_file, override=False)
+    if not args.dry_run and not os.getenv("GLM_API_KEY"):
+        raise RuntimeError("GLM_API_KEY is required")
+    if not args.python.is_file():
+        raise FileNotFoundError(f"Python interpreter not found: {args.python}")
+    data = load_dataset()
+    summary = dataset_summary(data)
+    root = campaign_root(args.run_prefix)
+    root.mkdir(parents=True, exist_ok=True)
+    print(
+        json.dumps(
+            {
+                "campaign": args.run_prefix,
+                "strategy": args.strategy,
+                "splits": splits,
+                "selected_questions": sum(
+                    summary["question_counts"][i - 1] for i in splits
+                ),
+                "selected_evaluated_questions": sum(
+                    summary["evaluated_counts"][i - 1] for i in splits
+                ),
+                "max_parallel": args.max_parallel,
+            }
+        ),
+        flush=True,
+    )
+    tracker = initialize_trackio(args, splits)
+    failures: list[str] = []
+    results: list[dict[str, Any]] = []
+    with concurrent.futures.ThreadPoolExecutor(
+        max_workers=args.max_parallel
+    ) as executor:
+        future_to_split = {
+            executor.submit(
+                run_split,
+                python=args.python,
+                run_prefix=args.run_prefix,
+                strategy=args.strategy,
+                split=split,
+                expected_count=summary["evaluated_counts"][split - 1],
+                retries=args.retries,
+                dry_run=args.dry_run,
+            ): split
+            for split in splits
+        }
+        for future in concurrent.futures.as_completed(future_to_split):
+            split = future_to_split[future]
+            try:
+                result = future.result()
+                results.append(result)
+                print(json.dumps(result), flush=True)
+                if tracker and result["status"] != "dry-run":
+                    tracker.log(
+                        {
+                            "split": split,
+                            "split_success": 1,
+                            "split_duration_seconds": result[
+                                "duration_seconds"
+                            ],
+                        }
+                    )
+            except Exception as exc:
+                message = f"split {split}: {exc}"
+                failures.append(message)
+                print(json.dumps({"split": split, "error": str(exc)}), flush=True)
+                if tracker:
+                    tracker.log({"split": split, "split_success": 0})
+    if failures:
+        write_manifest(
+            run_prefix=args.run_prefix,
+            strategy=args.strategy,
+            splits=splits,
+            summary=summary,
+            scores=None,
+        )
+        if tracker:
+            tracker.finish()
+        raise RuntimeError("\n\n".join(failures))
+    if args.dry_run:
+        write_manifest(
+            run_prefix=args.run_prefix,
+            strategy=args.strategy,
+            splits=splits,
+            summary=summary,
+            scores=None,
+        )
+        if tracker:
+            tracker.finish()
+        return 0
+    scores = aggregate_strategy(
+        run_prefix=args.run_prefix,
+        strategy=args.strategy,
+        splits=splits,
+        expected_counts=summary["evaluated_counts"],
+    )
+    manifest_path = write_manifest(
+        run_prefix=args.run_prefix,
+        strategy=args.strategy,
+        splits=splits,
+        summary=summary,
+        scores=scores,
+    )
+    if tracker:
+        tracker.log(
+            {
+                "overall_llm_score": scores["overall_mean_scores"]["llm_score"],
+                "overall_f1_score": scores["overall_mean_scores"]["f1_score"],
+                "overall_bleu_score": scores["overall_mean_scores"]["bleu_score"],
+                "evaluated_questions": scores["summary"]["total_questions"],
+                "paper_llm_target": PAPER_TARGETS[args.strategy]["llm_score"],
+                "delta_from_paper": (
+                    scores["overall_mean_scores"]["llm_score"]
+                    - PAPER_TARGETS[args.strategy]["llm_score"]
+                ),
+            }
+        )
+        tracker.finish()
+    print(
+        json.dumps(
+            {
+                "status": "complete",
+                "scores": scores["overall_mean_scores"],
+                "evaluated_questions": scores["summary"]["total_questions"],
+                "manifest": str(manifest_path),
+            }
+        ),
+        flush=True,
+    )
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())
+````
+````output
+{"campaign": "glm52-full", "strategy": "prompt", "splits": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], "selected_questions": 1986, "selected_evaluated_questions": 1540, "max_parallel": 3}
+* Trackio project initialized: memora-icml2026-repro
+* Trackio metrics logged to: /Users/conanssam-m4/.cache/huggingface/trackio
+* View dashboard by running in your terminal:
+[1m[38;5;208mtrackio show --project "memora-icml2026-repro"[0m
+* or by running in Python: trackio.show(project="memora-icml2026-repro")
+* Created new run: glm52-full-prompt
+{"split": 3, "error": "Split 3 failed after 3 attempts (exit 1).\n\n=== attempt 1/3 2026-07-24T05:17:55.438755+00:00 ===\nTraceback (most recent call last):\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py\", line 23, in <module>\n    from providers.memora.add import MemoraADD\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py\", line 13, in <module>\n    from memora.memora_client import MemoraClient\nModuleNotFoundError: No module named 'memora'\n\n=== attempt 2/3 2026-07-24T05:17:55.608328+00:00 ===\nTraceback (most recent call last):\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py\", line 23, in <module>\n    from providers.memora.add import MemoraADD\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py\", line 13, in <module>\n    from memora.memora_client import MemoraClient\nModuleNotFoundError: No module named 'memora'\n\n=== attempt 3/3 2026-07-24T05:17:55.704686+00:00 ===\nTraceback (most recent call last):\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py\", line 23, in <module>\n    from providers.memora.add import MemoraADD\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py\", line 13, in <module>\n    from memora.memora_client import MemoraClient\nModuleNotFoundError: No module named 'memora'"}
+{"split": 1, "error": "Split 1 failed after 3 attempts (exit 1).\n\n=== attempt 1/3 2026-07-24T05:17:55.438713+00:00 ===\
+... [7444 chars elided] ...
+ in <module>\n    from memora.memora_client import MemoraClient\nModuleNotFoundError: No module named 'memora'\n\n=== attempt 3/3 2026-07-24T05:17:56.267074+00:00 ===\nTraceback (most recent call last):\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py\", line 23, in <module>\n    from providers.memora.add import MemoraADD\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py\", line 13, in <module>\n    from memora.memora_client import MemoraClient\nModuleNotFoundError: No module named 'memora'"}
+{"split": 7, "error": "Split 7 failed after 3 attempts (exit 1).\n\n=== attempt 1/3 2026-07-24T05:17:56.084924+00:00 ===\nTraceback (most recent call last):\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py\", line 23, in <module>\n    from providers.memora.add import MemoraADD\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py\", line 13, in <module>\n    from memora.memora_client import MemoraClient\nModuleNotFoundError: No module named 'memora'\n\n=== attempt 2/3 2026-07-24T05:17:56.175829+00:00 ===\nTraceback (most recent call last):\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py\", line 23, in <module>\n    from providers.memora.add import MemoraADD\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py\", line 13, in <module>\n    from memora.memora_client import MemoraClient\nModuleNotFoundError: No module named 'memora'\n\n=== attempt 3/3 2026-07-24T05:17:56.269298+00:00 ===\nTraceback (most recent call last):\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py\", line 23, in <module>\n    from providers.memora.add import MemoraADD\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py\", line 13, in <module>\n    from memora.memora_client import MemoraClient\nModuleNotFoundError: No module named 'memora'"}
+{"split": 9, "error": "Split 9 failed after 3 attempts (exit 1).\n\n=== attempt 1/3 2026-07-24T05:17:56.084946+00:00 ===\nTraceback (most recent call last):\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py\", line 23, in <module>\n    from providers.memora.add import MemoraADD\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py\", line 13, in <module>\n    from memora.memora_client import MemoraClient\nModuleNotFoundError: No module named 'memora'\n\n=== attempt 2/3 2026-07-24T05:17:56.178439+00:00 ===\nTraceback (most recent call last):\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py\", line 23, in <module>\n    from providers.memora.add import MemoraADD\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py\", line 13, in <module>\n    from memora.memora_client import MemoraClient\nModuleNotFoundError: No module named 'memora'\n\n=== attempt 3/3 2026-07-24T05:17:56.267040+00:00 ===\nTraceback (most recent call last):\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py\", line 23, in <module>\n    from providers.memora.add import MemoraADD\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py\", line 13, in <module>\n    from memora.memora_client import MemoraClient\nModuleNotFoundError: No module named 'memora'"}
+{"split": 10, "error": "Split 10 failed after 3 attempts (exit 1).\n\n=== attempt 1/3 2026-07-24T05:17:56.358486+00:00 ===\nTraceback (most recent call last):\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py\", line 23, in <module>\n    from providers.memora.add import MemoraADD\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py\", line 13, in <module>\n    from memora.memora_client import MemoraClient\nModuleNotFoundError: No module named 'memora'\n\n=== attempt 2/3 2026-07-24T05:17:56.439604+00:00 ===\nTraceback (most recent call last):\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py\", line 23, in <module>\n    from providers.memora.add import MemoraADD\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py\", line 13, in <module>\n    from memora.memora_client import MemoraClient\nModuleNotFoundError: No module named 'memora'\n\n=== attempt 3/3 2026-07-24T05:17:56.530859+00:00 ===\nTraceback (most recent call last):\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py\", line 23, in <module>\n    from providers.memora.add import MemoraADD\n  File \"/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py\", line 13, in <module>\n    from memora.memora_client import MemoraClient\nModuleNotFoundError: No module named 'memora'"}
+* Run finished. Uploading logs to Trackio (please wait...)
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/scripts/run_locomo_reproduction.py", line 666, in <module>
+    raise SystemExit(main())
+                     ^^^^^^
+  File "/Users/conanssam-m4/memora-glm/scripts/run_locomo_reproduction.py", line 609, in main
+    raise RuntimeError("\n\n".join(failures))
+RuntimeError: split 3: Split 3 failed after 3 attempts (exit 1).
+=== attempt 1/3 2026-07-24T05:17:55.438755+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 2/3 2026-07-24T05:17:55.608328+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 3/3 2026-07-24T05:17:55.704686+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+split 1: Split 1 failed after 3 attempts (exit 1).
+=== attempt 1/3 2026-07-24T05:17:55.438713+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 2/3 2026-07-24T05:17:55.608280+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 3/3 2026-07-24T05:17:55.702021+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+split 2: Split 2 failed after 3 attempts (exit 1).
+=== attempt 1/3 2026-07-24T05:17:55.438778+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 2/3 2026-07-24T05:17:55.606921+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 3/3 2026-07-24T05:17:55.703130+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+split 4: Split 4 failed after 3 attempts (exit 1).
+=== attempt 1/3 2026-07-24T05:17:55.806544+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 2/3 2026-07-24T05:17:55.900859+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 3/3 2026-07-24T05:17:55.995169+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+split 6: Split 6 failed after 3 attempts (exit 1).
+=== attempt 1/3 2026-07-24T05:17:55.808622+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 2/3 2026-07-24T05:17:55.900824+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 3/3 2026-07-24T05:17:55.993034+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+split 5: Split 5 failed after 3 attempts (exit 1).
+=== attempt 1/3 2026-07-24T05:17:55.808656+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 2/3 2026-07-24T05:17:55.903523+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 3/3 2026-07-24T05:17:55.993003+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+split 8: Split 8 failed after 3 attempts (exit 1).
+=== attempt 1/3 2026-07-24T05:17:56.084657+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 2/3 2026-07-24T05:17:56.175864+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 3/3 2026-07-24T05:17:56.267074+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+split 7: Split 7 failed after 3 attempts (exit 1).
+=== attempt 1/3 2026-07-24T05:17:56.084924+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 2/3 2026-07-24T05:17:56.175829+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 3/3 2026-07-24T05:17:56.269298+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+split 9: Split 9 failed after 3 attempts (exit 1).
+=== attempt 1/3 2026-07-24T05:17:56.084946+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 2/3 2026-07-24T05:17:56.178439+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 3/3 2026-07-24T05:17:56.267040+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+split 10: Split 10 failed after 3 attempts (exit 1).
+=== attempt 1/3 2026-07-24T05:17:56.358486+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 2/3 2026-07-24T05:17:56.439604+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+=== attempt 3/3 2026-07-24T05:17:56.530859+00:00 ===
+Traceback (most recent call last):
+  File "/Users/conanssam-m4/memora-glm/app/locomo/run_memora.py", line 23, in <module>
+    from providers.memora.add import MemoraADD
+  File "/Users/conanssam-m4/memora-glm/app/locomo/providers/memora/add.py", line 13, in <module>
+    from memora.memora_client import MemoraClient
+ModuleNotFoundError: No module named 'memora'
+````
+---
+<!-- trackio-cell
+{"type": "code", "id": "cell_77cbe73f6342", "created_at": "2026-07-24T11:35:13+00:00", "title": "Run: python run_locomo_reproduction.py (exit 0)", "command": [".venv/bin/python", "scripts/run_locomo_reproduction.py", "--strategy", "prompt", "--run-prefix", "glm52-full", "--max-parallel", "3", "--retries", "3", "--env-file", "/Users/conanssam-m4/.ouroboros/worktrees/studymemory/orch_d223290f8ae3/.env", "--trackio"], "exit_code": 0, "duration_s": 22604.442}
+-->
+````bash
+$ .venv/bin/python scripts/run_locomo_reproduction.py --strategy prompt --run-prefix glm52-full --max-parallel 3 --retries 3 --env-file /Users/conanssam-m4/.ouroboros/worktrees/studymemory/orch_d223290f8ae3/.env --trackio
+````
+exit 0 · 22604.4s
+````python title=run_locomo_reproduction.py
+#!/usr/bin/env python3
+"""Run the full LoCoMo Memora reproduction as restartable conversation splits.
+Each LoCoMo conversation has an isolated Memora user namespace. Running the ten
+conversations in separate processes therefore preserves the official method
+while avoiding result-directory collisions and making multi-hour API runs
+restartable.
+"""
+from __future__ import annotations
+import argparse
+import concurrent.futures
+import hashlib
+import json
+import os
+import subprocess
+import sys
+import time
+from collections import defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+from statistics import fmean
+from typing import Any
+from dotenv import load_dotenv
+REPO_ROOT = Path(__file__).resolve().parents[1]
+LOCOMO_ROOT = REPO_ROOT / "app" / "locomo"
+DATA_PATH = LOCOMO_ROOT / "data" / "locomo10.json"
+DEFAULT_PROJECT = "memora-icml2026-repro"
+PAPER_TARGETS = {
+    "prompt": {"llm_score": 0.863, "f1_score": 0.553, "bleu_score": 0.466},
+    "semantic": {"llm_score": 0.849, "f1_score": 0.552, "bleu_score": 0.464},
+    "full_context": {"llm_score": 0.825},
+}
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--strategy",
+        choices=("prompt", "semantic"),
+        required=True,
+        help="Memora retrieval strategy to reproduce.",
+    )
+    parser.add_argument(
+        "--run-prefix",
+        default="glm52-full",
+        help="Stable campaign name used for result and memory directories.",
+    )
+    parser.add_argument(
+        "--splits",
+        nargs="+",
+        type=int,
+        default=list(range(1, 11)),
+        help="One-based LoCoMo conversation indices (default: all 1..10).",
+    )
+    parser.add_argument(
+        "--max-parallel",
+        type=int,
+        default=3,
+        help="Maximum concurrent GLM-backed split processes.",
+    )
+    parser.add_argument(
+        "--retries",
+        type=int,
+        default=2,
+        help="Process-level attempts per split.",
+    )
+    parser.add_argument(
+        "--env-file",
+        type=Path,
+        help="Optional dotenv file containing GLM_API_KEY and GLM_MODEL.",
+    )
+    parser.add_argument(
+        "--python",
+        type=Path,
+        default=REPO_ROOT / ".venv" / "bin" / "python",
+        help="Python interpreter for split processes.",
+    )
+    parser.add_argument(
+        "--trackio",
+        action="store_true",
+        help="Log split completion and aggregate metrics to Trackio.",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print commands without running the experiment.",
+    )
+    return parser.parse_args()
+def validate_splits(splits: list[int]) -> list[int]:
+    normalized = sorted(set(splits))
+    if not normalized or normalized[0] < 1 or normalized[-1] > 10:
+        raise ValueError("--splits must contain one-based indices between 1 and 10")
+    return normalized
+def load_dataset(path: Path = DATA_PATH) -> list[dict[str, Any]]:
+    with path.open() as f:
+        data = json.load(f)
+    if len(data) != 10:
+        raise ValueError(f"Expected 10 LoCoMo conversations, found {len(data)}")
+    return data
+def dataset_summary(data: list[dict[str, Any]]) -> dict[str, Any]:
+    category_counts: dict[str, int] = defaultdict(int)
+    sessions = 0
+    question_counts = []
+    evaluated_counts = []
+    for item in data:
+        conversation = item["conversation"]
+        sessions += sum(
+            1
+            for key in conversation
+            if key.startswith("session_") and not key.endswith("_date_time")
+        )
+        qa = item["qa"]
+        question_counts.append(len(qa))
+        evaluated = 0
+        for question in qa:
+            category = str(question["category"])
+            category_counts[category] += 1
+            if category != "5":
+                evaluated += 1
+        evaluated_counts.append(evaluated)
+    return {
+        "conversations": len(data),
+        "sessions": sessions,
+        "questions": sum(question_counts),
+        "evaluated_questions": sum(evaluated_counts),
+        "question_counts": question_counts,
+        "evaluated_counts": evaluated_counts,
+        "category_counts": dict(sorted(category_counts.items())),
+    }
+def file_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+def campaign_root(run_prefix: str) -> Path:
+    return LOCOMO_ROOT / "results" / "reproduction" / run_prefix
+def split_output_dir(run_prefix: str, strategy: str, split: int) -> Path:
+    return (
+        campaign_root(run_prefix)
+        / "runs"
+        / f"memora_{strategy}_split{split:02d}"
+    )
+def split_paths(
+    run_prefix: str,
+    strategy: str,
+    split: int,
+) -> dict[str, Path]:
+    method = f"memora_{strategy}"
+    output_dir = split_output_dir(run_prefix, strategy, split)
+    return {
+        "dir": output_dir,
+        "output": output_dir / f"{method}_output.json",
+        "eval": output_dir / f"{method}_eval.json",
+        "scores": output_dir / f"{method}_scores.json",
+        "build_timing": output_dir / "build_timing.json",
+    }
+def memory_store_name(run_prefix: str, split: int) -> str:
+    safe_prefix = "".join(
+        char if char.isalnum() or char in "._-" else "-"
+        for char in run_prefix
+    ).strip("-")
+    if not safe_prefix:
+        raise ValueError("--run-prefix must contain at least one safe character")
+    return f"{safe_prefix}-split{split:02d}"
+def build_split_command(
+    *,
+    python: Path,
+    run_prefix: str,
+    strategy: str,
+    split: int,
+    force_rebuild: bool,
+) -> list[str]:
+    return [
+        str(python),
+        "run_memora.py",
+        "--config-name",
+        "config_glm",
+        f"general.project_path={LOCOMO_ROOT}",
+        f"general.results_path={campaign_root(run_prefix) / 'runs'}",
+        "general.debug=false",
+        "general.resume=true",
+        f"general.run_name=split{split:02d}",
+        f"eval.subset_idx={split}",
+        "eval.max_workers=1",
+        f"memory.memory_store={memory_store_name(run_prefix, split)}",
+        f"memory.force_rebuild={'true' if force_rebuild else 'false'}",
+        f"retrieval.strategy={strategy}",
+    ]
+def evaluated_item_count(path: Path) -> int:
+    with path.open() as f:
+        data = json.load(f)
+    return sum(len(items) for items in data.values())
+def completed_split(
+    run_prefix: str,
+    strategy: str,
+    split: int,
+    expected_count: int,
+) -> bool:
+    paths = split_paths(run_prefix, strategy, split)
+    if not paths["scores"].is_file() or not paths["eval"].is_file():
+        return False
+    try:
+        with paths["scores"].open() as f:
+            scores = json.load(f)
+        return (
+            scores["summary"]["total_questions"] == expected_count
+            and evaluated_item_count(paths["eval"]) == expected_count
+        )
+    except (KeyError, OSError, ValueError, json.JSONDecodeError):
+        return False
+def tail(path: Path, line_count: int = 40) -> str:
+    try:
+        lines = path.read_text(errors="replace").splitlines()
+    except OSError:
+        return ""
+    return "\n".join(lines[-line_count:])
+def child_environment() -> dict[str, str]:
+    env = dict(os.environ)
+    existing = env.get("PYTHONPATH")
+    env["PYTHONPATH"] = (
+        f"{REPO_ROOT / 'src'}{os.pathsep}{existing}"
+        if existing
+        else str(REPO_ROOT / "src")
+    )
+    env["TOKENIZERS_PARALLELISM"] = "false"
+    return env
+def run_split(
+    *,
+    python: Path,
+    run_prefix: str,
+    strategy: str,
+    split: int,
+    expected_count: int,
+    retries: int,
+    dry_run: bool,
+) -> dict[str, Any]:
+    started = time.monotonic()
+    root = campaign_root(run_prefix)
+    log_path = root / "logs" / f"{strategy}-split{split:02d}.log"
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    if completed_split(run_prefix, strategy, split, expected_count):
+        return {
+            "split": split,
+            "status": "skipped",
+            "duration_seconds": 0.0,
+            "log": str(log_path),
+        }
+    persist_path = LOCOMO_ROOT / "memory_store" / memory_store_name(
+        run_prefix,
+        split,
+    )
+    if strategy == "semantic" and not persist_path.exists():
+        raise RuntimeError(
+            f"Split {split}: semantic retrieval requires the prompt-built "
+            f"memory store at {persist_path}"
+        )
+    attempts = max(1, retries)
+    for attempt in range(1, attempts + 1):
+        paths = split_paths(run_prefix, strategy, split)
+        force_rebuild = (
+            strategy == "prompt" and not paths["build_timing"].is_file()
+        )
+        command = build_split_command(
+            python=python,
+            run_prefix=run_prefix,
+            strategy=strategy,
+            split=split,
+            force_rebuild=force_rebuild,
+        )
+        if dry_run:
+            return {
+                "split": split,
+                "status": "dry-run",
+                "duration_seconds": 0.0,
+                "command": command,
+                "log": str(log_path),
+            }
+        with log_path.open("a") as log:
+            log.write(
+                f"\n=== attempt {attempt}/{attempts} "
+                f"{datetime.now(timezone.utc).isoformat()} ===\n"
+            )
+            log.flush()
+            completed = subprocess.run(
+                command,
+                cwd=LOCOMO_ROOT,
+                env=child_environment(),
+                stdout=log,
+                stderr=subprocess.STDOUT,
+                text=True,
+                check=False,
+            )
+        if completed.returncode == 0 and completed_split(
+            run_prefix,
+            strategy,
+            split,
+            expected_count,
+        ):
+            return {
+                "split": split,
+                "status": "completed",
+                "duration_seconds": round(time.monotonic() - started, 3),
+                "attempts": attempt,
+                "log": str(log_path),
+            }
+        if attempt == attempts:
+            raise RuntimeError(
+                f"Split {split} failed after {attempts} attempts "
+                f"(exit {completed.returncode}).\n{tail(log_path)}"
+            )
+    raise AssertionError("unreachable")
+def mean(values: list[float]) -> float:
+    return round(fmean(values), 4)
+def aggregate_strategy(
+    *,
+    run_prefix: str,
+    strategy: str,
+    splits: list[int],
+    expected_counts: list[int],
+) -> dict[str, Any]:
+    aggregate_eval: dict[str, list[dict[str, Any]]] = {}
+    aggregate_output: dict[str, list[dict[str, Any]]] = {}
+    all_eval_items: list[dict[str, Any]] = []
+    for split in splits:
+        paths = split_paths(run_prefix, strategy, split)
+        expected = expected_counts[split - 1]
+        if not completed_split(run_prefix, strategy, split, expected):
+            raise RuntimeError(f"Split {split} is incomplete and cannot be aggregated")
+        with paths["eval"].open() as f:
+            split_eval = json.load(f)
+        with paths["output"].open() as f:
+            split_output = json.load(f)
+        eval_items = [
+            item for items in split_eval.values() for item in items
+        ]
+        output_items = [
+            item for items in split_output.values() for item in items
+        ]
+        aggregate_eval[str(split - 1)] = eval_items
+        aggregate_output[str(split - 1)] = output_items
+        all_eval_items.extend(eval_items)
+    by_category: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for item in all_eval_items:
+        by_category[str(item["category"])].append(item)
+    metrics = ("bleu_score", "f1_score", "llm_score")
+    per_category = {
+        metric: {
+            category: mean([float(item[metric]) for item in items])
+            for category, items in sorted(by_category.items())
+        }
+        for metric in metrics
+    }
+    per_category["count"] = {
+        category: len(items)
+        for category, items in sorted(by_category.items())
+    }
+    overall = {
+        metric: mean([float(item[metric]) for item in all_eval_items])
+        for metric in metrics
+    }
+    scores = {
+        "mean_scores_per_category": per_category,
+        "overall_mean_scores": overall,
+        "summary": {
+            "total_questions": len(all_eval_items),
+            "categories_evaluated": sorted(int(key) for key in by_category),
+            "evaluation_timestamp": datetime.now(timezone.utc).isoformat(),
+            "conversation_splits": splits,
+        },
+    }
+    root = campaign_root(run_prefix)
+    root.mkdir(parents=True, exist_ok=True)
+    for name, payload in (
+        (f"{strategy}_output.json", aggregate_output),
+        (f"{strategy}_eval.json", aggregate_eval),
+        (f"{strategy}_scores.json", scores),
+    ):
+        with (root / name).open("w") as f:
+            json.dump(payload, f, indent=2)
+    return scores
+def write_manifest(
+    *,
+    run_prefix: str,
+    strategy: str,
+    splits: list[int],
+    summary: dict[str, Any],
+    scores: dict[str, Any] | None,
+) -> Path:
+    selected_questions = sum(summary["question_counts"][i - 1] for i in splits)
+    selected_evaluated = sum(
+        summary["evaluated_counts"][i - 1] for i in splits
+    )
+    manifest = {
+        "paper": {
+            "title": (
+                "Memora: A Harmonic Memory Representation Balancing "
+                "Abstraction and Specificity"
+            ),
+            "arxiv_id": "2602.03315",
+            "openreview_id": "zSrvkj0ers",
+            "official_repository": "https://github.com/microsoft/Memora",
+            "official_commit": "dec3f8f2444eace7004fc084abe1be9f3d88270e",
+        },
+        "campaign": run_prefix,
+        "strategy": strategy,
+        "splits": splits,
+        "full_scale": splits == list(range(1, 11)),
+        "dataset": {
+            **summary,
+            "selected_questions": selected_questions,
+            "selected_evaluated_questions": selected_evaluated,
+            "sha256": file_sha256(DATA_PATH),
+        },
+        "implementation": {
+            "llm_provider": "Z.AI OpenAI-compatible API",
+            "llm_model": os.getenv("GLM_MODEL", "glm-4.5-flash"),
+            "embedding_provider": "local FastEmbed",
+            "embedding_model": "BAAI/bge-small-en-v1.5",
+            "retrieval_strategy": strategy,
+            "top_k": 30,
+            "hybrid_search": "BM25",
+            "segmentation": True,
+            "episodic_memory": "raw segments plus factual memories",
+            "cue_index": True,
+            "prompted_policy_max_steps": 4 if strategy == "prompt" else None,
+        },
+        "protocol_deviations": [
+            (
+                "GPT-4.1-mini was replaced by GLM because the original model "
+                "endpoint was unavailable."
+            ),
+            (
+                "The repository-default OpenAI embedding endpoint was replaced "
+                "by local BAAI/bge-small-en-v1.5 embeddings."
+            ),
+            (
+                "The GLM endpoint does not accept the paper's seed parameter; "
+                "temperature was fixed at 0 and thinking was disabled."
+            ),
+            (
+                "Conversations were executed as ten isolated processes and "
+                "aggregated; Memora user namespaces are conversation-local."
+            ),
+        ],
+        "paper_targets": PAPER_TARGETS,
+        "scores": scores,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+    }
+    path = campaign_root(run_prefix) / f"{strategy}_manifest.json"
+    with path.open("w") as f:
+        json.dump(manifest, f, indent=2)
+    return path
+def initialize_trackio(args: argparse.Namespace, splits: list[int]):
+    if not args.trackio:
+        return None
+    try:
+        import trackio
+    except ImportError as exc:
+        raise RuntimeError(
+            "Trackio is not installed in the orchestrator environment. "
+            "Install requirements-glm.txt first."
+        ) from exc
+    trackio.init(
+        project=DEFAULT_PROJECT,
+        name=f"{args.run_prefix}-{args.strategy}",
+        group=args.run_prefix,
+        config={
+            "paper_arxiv": "2602.03315",
+            "strategy": args.strategy,
+            "model": os.getenv("GLM_MODEL", "glm-4.5-flash"),
+            "embedding_model": "BAAI/bge-small-en-v1.5",
+            "splits": ",".join(str(split) for split in splits),
+            "full_scale": splits == list(range(1, 11)),
+        },
+    )
+    return trackio
+def main() -> int:
+    args = parse_args()
+    splits = validate_splits(args.splits)
+    if args.max_parallel < 1:
+        raise ValueError("--max-parallel must be at least 1")
+    if args.env_file:
+        load_dotenv(args.env_file, override=False)
+    if not args.dry_run and not os.getenv("GLM_API_KEY"):
+        raise RuntimeError("GLM_API_KEY is required")
+    if not args.python.is_file():
+        raise FileNotFoundError(f"Python interpreter not found: {args.python}")
+    data = load_dataset()
+    summary = dataset_summary(data)
+    root = campaign_root(args.run_prefix)
+    root.mkdir(parents=True, exist_ok=True)
+    print(
+        json.dumps(
+            {
+                "campaign": args.run_prefix,
+                "strategy": args.strategy,
+                "splits": splits,
+                "selected_questions": sum(
+                    summary["question_counts"][i - 1] for i in splits
+                ),
+                "selected_evaluated_questions": sum(
+                    summary["evaluated_counts"][i - 1] for i in splits
+                ),
+                "max_parallel": args.max_parallel,
+            }
+        ),
+        flush=True,
+    )
+    tracker = initialize_trackio(args, splits)
+    failures: list[str] = []
+    results: list[dict[str, Any]] = []
+    with concurrent.futures.ThreadPoolExecutor(
+        max_workers=args.max_parallel
+    ) as executor:
+        future_to_split = {
+            executor.submit(
+                run_split,
+                python=args.python,
+                run_prefix=args.run_prefix,
+                strategy=args.strategy,
+                split=split,
+                expected_count=summary["evaluated_counts"][split - 1],
+                retries=args.retries,
+                dry_run=args.dry_run,
+            ): split
+            for split in splits
+        }
+        for future in concurrent.futures.as_completed(future_to_split):
+            split = future_to_split[future]
+            try:
+                result = future.result()
+                results.append(result)
+                print(json.dumps(result), flush=True)
+                if tracker and result["status"] != "dry-run":
+                    tracker.log(
+                        {
+                            "split": split,
+                            "split_success": 1,
+                            "split_duration_seconds": result[
+                                "duration_seconds"
+                            ],
+                        }
+                    )
+            except Exception as exc:
+                message = f"split {split}: {exc}"
+                failures.append(message)
+                print(json.dumps({"split": split, "error": str(exc)}), flush=True)
+                if tracker:
+                    tracker.log({"split": split, "split_success": 0})
+    if failures:
+        write_manifest(
+            run_prefix=args.run_prefix,
+            strategy=args.strategy,
+            splits=splits,
+            summary=summary,
+            scores=None,
+        )
+        if tracker:
+            tracker.finish()
+        raise RuntimeError("\n\n".join(failures))
+    if args.dry_run:
+        write_manifest(
+            run_prefix=args.run_prefix,
+            strategy=args.strategy,
+            splits=splits,
+            summary=summary,
+            scores=None,
+        )
+        if tracker:
+            tracker.finish()
+        return 0
+    scores = aggregate_strategy(
+        run_prefix=args.run_prefix,
+        strategy=args.strategy,
+        splits=splits,
+        expected_counts=summary["evaluated_counts"],
+    )
+    manifest_path = write_manifest(
+        run_prefix=args.run_prefix,
+        strategy=args.strategy,
+        splits=splits,
+        summary=summary,
+        scores=scores,
+    )
+    if tracker:
+        tracker.log(
+            {
+                "overall_llm_score": scores["overall_mean_scores"]["llm_score"],
+                "overall_f1_score": scores["overall_mean_scores"]["f1_score"],
+                "overall_bleu_score": scores["overall_mean_scores"]["bleu_score"],
+                "evaluated_questions": scores["summary"]["total_questions"],
+                "paper_llm_target": PAPER_TARGETS[args.strategy]["llm_score"],
+                "delta_from_paper": (
+                    scores["overall_mean_scores"]["llm_score"]
+                    - PAPER_TARGETS[args.strategy]["llm_score"]
+                ),
+            }
+        )
+        tracker.finish()
+    print(
+        json.dumps(
+            {
+                "status": "complete",
+                "scores": scores["overall_mean_scores"],
+                "evaluated_questions": scores["summary"]["total_questions"],
+                "manifest": str(manifest_path),
+            }
+        ),
+        flush=True,
+    )
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())
+````
+````output
+{"campaign": "glm52-full", "strategy": "prompt", "splits": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], "selected_questions": 1986, "selected_evaluated_questions": 1540, "max_parallel": 3}
+* Trackio project initialized: memora-icml2026-repro
+* Trackio metrics logged to: /Users/conanssam-m4/.cache/huggingface/trackio
+* View dashboard by running in your terminal:
+[1m[38;5;208mtrackio show --project "memora-icml2026-repro"[0m
+* or by running in Python: trackio.show(project="memora-icml2026-repro")
+* Created new run: glm52-full-prompt
+{"split": 2, "status": "completed", "duration_seconds": 3519.903, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split02.log"}
+{"split": 1, "status": "completed", "duration_seconds": 4800.859, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split01.log"}
+{"split": 3, "status": "completed", "duration_seconds": 5642.447, "attempts": 2, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split03.log"}
+{"split": 4, "status": "completed", "duration_seconds": 8027.456, "attempts": 2, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split04.log"}
+{"split": 5, "status": "completed", "duration_seconds": 8503.683, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split05.log"}
+{"split": 6, "status": "completed", "duration_seconds": 8146.552, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split06.log"}
+{"split": 7, "status": "completed", "duration_seconds": 6247.446, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split07.log"}
+{"split": 9, "status": "completed", "duration_seconds": 4944.347, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split09.log"}
+{"split": 8, "status": "completed", "duration_seconds": 6118.614, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split08.log"}
+{"split": 10, "status": "completed", "duration_seconds": 4807.175, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split10.log"}
+* Run finished. Uploading logs to Trackio (please wait...)
+{"status": "complete", "scores": {"bleu_score": 0.4879, "f1_score": 0.5937, "llm_score": 0.7851}, "evaluated_questions": 1540, "manifest": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/prompt_manifest.json"}
+````
+---
+<!-- trackio-cell
+{"type": "code", "id": "cell_24968c758ad2", "created_at": "2026-07-24T14:33:53+00:00", "title": "Run: python run_locomo_reproduction.py (exit 0)", "command": [".venv/bin/python", "scripts/run_locomo_reproduction.py", "--strategy", "prompt", "--run-prefix", "glm52-full", "--max-parallel", "1", "--retries", "3", "--env-file", "/Users/conanssam-m4/.ouroboros/worktrees/studymemory/orch_d223290f8ae3/.env", "--trackio"], "exit_code": 0, "duration_s": 363.349}
+-->
+````bash
+$ .venv/bin/python scripts/run_locomo_reproduction.py --strategy prompt --run-prefix glm52-full --max-parallel 1 --retries 3 --env-file /Users/conanssam-m4/.ouroboros/worktrees/studymemory/orch_d223290f8ae3/.env --trackio
+````
+exit 0 · 363.3s
+````python title=run_locomo_reproduction.py
+#!/usr/bin/env python3
+"""Run the full LoCoMo Memora reproduction as restartable conversation splits.
+Each LoCoMo conversation has an isolated Memora user namespace. Running the ten
+conversations in separate processes therefore preserves the official method
+while avoiding result-directory collisions and making multi-hour API runs
+restartable.
+"""
+from __future__ import annotations
+import argparse
+import concurrent.futures
+import hashlib
+import json
+import os
+import subprocess
+import sys
+import time
+from collections import defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+from statistics import fmean
+from typing import Any
+from dotenv import load_dotenv
+REPO_ROOT = Path(__file__).resolve().parents[1]
+LOCOMO_ROOT = REPO_ROOT / "app" / "locomo"
+DATA_PATH = LOCOMO_ROOT / "data" / "locomo10.json"
+DEFAULT_PROJECT = "memora-icml2026-repro"
+PAPER_TARGETS = {
+    "prompt": {"llm_score": 0.863, "f1_score": 0.553, "bleu_score": 0.466},
+    "semantic": {"llm_score": 0.849, "f1_score": 0.552, "bleu_score": 0.464},
+    "full_context": {"llm_score": 0.825},
+}
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--strategy",
+        choices=("prompt", "semantic"),
+        required=True,
+        help="Memora retrieval strategy to reproduce.",
+    )
+    parser.add_argument(
+        "--run-prefix",
+        default="glm52-full",
+        help="Stable campaign name used for result and memory directories.",
+    )
+    parser.add_argument(
+        "--splits",
+        nargs="+",
+        type=int,
+        default=list(range(1, 11)),
+        help="One-based LoCoMo conversation indices (default: all 1..10).",
+    )
+    parser.add_argument(
+        "--max-parallel",
+        type=int,
+        default=3,
+        help="Maximum concurrent GLM-backed split processes.",
+    )
+    parser.add_argument(
+        "--retries",
+        type=int,
+        default=2,
+        help="Process-level attempts per split.",
+    )
+    parser.add_argument(
+        "--env-file",
+        type=Path,
+        help="Optional dotenv file containing GLM_API_KEY and GLM_MODEL.",
+    )
+    parser.add_argument(
+        "--python",
+        type=Path,
+        default=REPO_ROOT / ".venv" / "bin" / "python",
+        help="Python interpreter for split processes.",
+    )
+    parser.add_argument(
+        "--trackio",
+        action="store_true",
+        help="Log split completion and aggregate metrics to Trackio.",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print commands without running the experiment.",
+    )
+    return parser.parse_args()
+def validate_splits(splits: list[int]) -> list[int]:
+    normalized = sorted(set(splits))
+    if not normalized or normalized[0] < 1 or normalized[-1] > 10:
+        raise ValueError("--splits must contain one-based indices between 1 and 10")
+    return normalized
+def load_dataset(path: Path = DATA_PATH) -> list[dict[str, Any]]:
+    with path.open() as f:
+        data = json.load(f)
+    if len(data) != 10:
+        raise ValueError(f"Expected 10 LoCoMo conversations, found {len(data)}")
+    return data
+def dataset_summary(data: list[dict[str, Any]]) -> dict[str, Any]:
+    category_counts: dict[str, int] = defaultdict(int)
+    sessions = 0
+    question_counts = []
+    evaluated_counts = []
+    for item in data:
+        conversation = item["conversation"]
+        sessions += sum(
+            1
+            for key in conversation
+            if key.startswith("session_") and not key.endswith("_date_time")
+        )
+        qa = item["qa"]
+        question_counts.append(len(qa))
+        evaluated = 0
+        for question in qa:
+            category = str(question["category"])
+            category_counts[category] += 1
+            if category != "5":
+                evaluated += 1
+        evaluated_counts.append(evaluated)
+    return {
+        "conversations": len(data),
+        "sessions": sessions,
+        "questions": sum(question_counts),
+        "evaluated_questions": sum(evaluated_counts),
+        "question_counts": question_counts,
+        "evaluated_counts": evaluated_counts,
+        "category_counts": dict(sorted(category_counts.items())),
+    }
+def file_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+def campaign_root(run_prefix: str) -> Path:
+    return LOCOMO_ROOT / "results" / "reproduction" / run_prefix
+def split_output_dir(run_prefix: str, strategy: str, split: int) -> Path:
+    return (
+        campaign_root(run_prefix)
+        / "runs"
+        / f"memora_{strategy}_split{split:02d}"
+    )
+def split_paths(
+    run_prefix: str,
+    strategy: str,
+    split: int,
+) -> dict[str, Path]:
+    method = f"memora_{strategy}"
+    output_dir = split_output_dir(run_prefix, strategy, split)
+    return {
+        "dir": output_dir,
+        "output": output_dir / f"{method}_output.json",
+        "eval": output_dir / f"{method}_eval.json",
+        "scores": output_dir / f"{method}_scores.json",
+        "build_timing": output_dir / "build_timing.json",
+    }
+def memory_store_name(run_prefix: str, split: int) -> str:
+    safe_prefix = "".join(
+        char if char.isalnum() or char in "._-" else "-"
+        for char in run_prefix
+    ).strip("-")
+    if not safe_prefix:
+        raise ValueError("--run-prefix must contain at least one safe character")
+    return f"{safe_prefix}-split{split:02d}"
+def build_split_command(
+    *,
+    python: Path,
+    run_prefix: str,
+    strategy: str,
+    split: int,
+    force_rebuild: bool,
+) -> list[str]:
+    return [
+        str(python),
+        "run_memora.py",
+        "--config-name",
+        "config_glm",
+        f"general.project_path={LOCOMO_ROOT}",
+        f"general.results_path={campaign_root(run_prefix) / 'runs'}",
+        "general.debug=false",
+        "general.resume=true",
+        f"general.run_name=split{split:02d}",
+        f"eval.subset_idx={split}",
+        "eval.max_workers=1",
+        f"memory.memory_store={memory_store_name(run_prefix, split)}",
+        f"memory.force_rebuild={'true' if force_rebuild else 'false'}",
+        f"retrieval.strategy={strategy}",
+    ]
+def evaluated_item_count(path: Path) -> int:
+    with path.open() as f:
+        data = json.load(f)
+    return sum(len(items) for items in data.values())
+def output_has_failed_results(path: Path) -> bool:
+    with path.open() as f:
+        data = json.load(f)
+    return any(
+        str(item.get("response", "")).strip().startswith("ERROR:")
+        for items in data.values()
+        for item in items
+    )
+def completed_split(
+    run_prefix: str,
+    strategy: str,
+    split: int,
+    expected_count: int,
+) -> bool:
+    paths = split_paths(run_prefix, strategy, split)
+    if (
+        not paths["output"].is_file()
+        or not paths["scores"].is_file()
+        or not paths["eval"].is_file()
+    ):
+        return False
+    try:
+        with paths["scores"].open() as f:
+            scores = json.load(f)
+        return (
+            scores["summary"]["total_questions"] == expected_count
+            and evaluated_item_count(paths["eval"]) == expected_count
+            and not output_has_failed_results(paths["output"])
+        )
+    except (KeyError, OSError, ValueError, json.JSONDecodeError):
+        return False
+def tail(path: Path, line_count: int = 40) -> str:
+    try:
+        lines = path.read_text(errors="replace").splitlines()
+    except OSError:
+        return ""
+    return "\n".join(lines[-line_count:])
+def child_environment() -> dict[str, str]:
+    env = dict(os.environ)
+    existing = env.get("PYTHONPATH")
+    env["PYTHONPATH"] = (
+        f"{REPO_ROOT / 'src'}{os.pathsep}{existing}"
+        if existing
+        else str(REPO_ROOT / "src")
+    )
+    env["TOKENIZERS_PARALLELISM"] = "false"
+    return env
+def run_split(
+    *,
+    python: Path,
+    run_prefix: str,
+    strategy: str,
+    split: int,
+    expected_count: int,
+    retries: int,
+    dry_run: bool,
+) -> dict[str, Any]:
+    started = time.monotonic()
+    root = campaign_root(run_prefix)
+    log_path = root / "logs" / f"{strategy}-split{split:02d}.log"
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    if completed_split(run_prefix, strategy, split, expected_count):
+        return {
+            "split": split,
+            "status": "skipped",
+            "duration_seconds": 0.0,
+            "log": str(log_path),
+        }
+    persist_path = LOCOMO_ROOT / "memory_store" / memory_store_name(
+        run_prefix,
+        split,
+    )
+    if strategy == "semantic" and not persist_path.exists():
+        raise RuntimeError(
+            f"Split {split}: semantic retrieval requires the prompt-built "
+            f"memory store at {persist_path}"
+        )
+    attempts = max(1, retries)
+    for attempt in range(1, attempts + 1):
+        paths = split_paths(run_prefix, strategy, split)
+        force_rebuild = (
+            strategy == "prompt" and not paths["build_timing"].is_file()
+        )
+        command = build_split_command(
+            python=python,
+            run_prefix=run_prefix,
+            strategy=strategy,
+            split=split,
+            force_rebuild=force_rebuild,
+        )
+        if dry_run:
+            return {
+                "split": split,
+                "status": "dry-run",
+                "duration_seconds": 0.0,
+                "command": command,
+                "log": str(log_path),
+            }
+        with log_path.open("a") as log:
+            log.write(
+                f"\n=== attempt {attempt}/{attempts} "
+                f"{datetime.now(timezone.utc).isoformat()} ===\n"
+            )
+            log.flush()
+            completed = subprocess.run(
+                command,
+                cwd=LOCOMO_ROOT,
+                env=child_environment(),
+                stdout=log,
+                stderr=subprocess.STDOUT,
+                text=True,
+                check=False,
+            )
+        if completed.returncode == 0 and completed_split(
+            run_prefix,
+            strategy,
+            split,
+            expected_count,
+        ):
+            return {
+                "split": split,
+                "status": "completed",
+                "duration_seconds": round(time.monotonic() - started, 3),
+                "attempts": attempt,
+                "log": str(log_path),
+            }
+        if attempt == attempts:
+            raise RuntimeError(
+                f"Split {split} failed after {attempts} attempts "
+                f"(exit {completed.returncode}).\n{tail(log_path)}"
+            )
+    raise AssertionError("unreachable")
+def mean(values: list[float]) -> float:
+    return round(fmean(values), 4)
+def aggregate_strategy(
+    *,
+    run_prefix: str,
+    strategy: str,
+    splits: list[int],
+    expected_counts: list[int],
+) -> dict[str, Any]:
+    aggregate_eval: dict[str, list[dict[str, Any]]] = {}
+    aggregate_output: dict[str, list[dict[str, Any]]] = {}
+    all_eval_items: list[dict[str, Any]] = []
+    for split in splits:
+        paths = split_paths(run_prefix, strategy, split)
+        expected = expected_counts[split - 1]
+        if not completed_split(run_prefix, strategy, split, expected):
+            raise RuntimeError(f"Split {split} is incomplete and cannot be aggregated")
+        with paths["eval"].open() as f:
+            split_eval = json.load(f)
+        with paths["output"].open() as f:
+            split_output = json.load(f)
+        eval_items = [
+            item for items in split_eval.values() for item in items
+        ]
+        output_items = [
+            item for items in split_output.values() for item in items
+        ]
+        aggregate_eval[str(split - 1)] = eval_items
+        aggregate_output[str(split - 1)] = output_items
+        all_eval_items.extend(eval_items)
+    by_category: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for item in all_eval_items:
+        by_category[str(item["category"])].append(item)
+    metrics = ("bleu_score", "f1_score", "llm_score")
+    per_category = {
+        metric: {
+            category: mean([float(item[metric]) for item in items])
+            for category, items in sorted(by_category.items())
+        }
+        for metric in metrics
+    }
+    per_category["count"] = {
+        category: len(items)
+        for category, items in sorted(by_category.items())
+    }
+    overall = {
+        metric: mean([float(item[metric]) for item in all_eval_items])
+        for metric in metrics
+    }
+    scores = {
+        "mean_scores_per_category": per_category,
+        "overall_mean_scores": overall,
+        "summary": {
+            "total_questions": len(all_eval_items),
+            "categories_evaluated": sorted(int(key) for key in by_category),
+            "evaluation_timestamp": datetime.now(timezone.utc).isoformat(),
+            "conversation_splits": splits,
+        },
+    }
+    root = campaign_root(run_prefix)
+    root.mkdir(parents=True, exist_ok=True)
+    for name, payload in (
+        (f"{strategy}_output.json", aggregate_output),
+        (f"{strategy}_eval.json", aggregate_eval),
+        (f"{strategy}_scores.json", scores),
+    ):
+        with (root / name).open("w") as f:
+            json.dump(payload, f, indent=2)
+    return scores
+def write_manifest(
+    *,
+    run_prefix: str,
+    strategy: str,
+    splits: list[int],
+    summary: dict[str, Any],
+    scores: dict[str, Any] | None,
+) -> Path:
+    selected_questions = sum(summary["question_counts"][i - 1] for i in splits)
+    selected_evaluated = sum(
+        summary["evaluated_counts"][i - 1] for i in splits
+    )
+    manifest = {
+        "paper": {
+            "title": (
+                "Memora: A Harmonic Memory Representation Balancing "
+                "Abstraction and Specificity"
+            ),
+            "arxiv_id": "2602.03315",
+            "openreview_id": "zSrvkj0ers",
+            "official_repository": "https://github.com/microsoft/Memora",
+            "official_commit": "dec3f8f2444eace7004fc084abe1be9f3d88270e",
+        },
+        "campaign": run_prefix,
+        "strategy": strategy,
+        "splits": splits,
+        "full_scale": splits == list(range(1, 11)),
+        "dataset": {
+            **summary,
+            "selected_questions": selected_questions,
+            "selected_evaluated_questions": selected_evaluated,
+            "sha256": file_sha256(DATA_PATH),
+        },
+        "implementation": {
+            "llm_provider": "Z.AI OpenAI-compatible API",
+            "llm_model": os.getenv("GLM_MODEL", "glm-4.5-flash"),
+            "embedding_provider": "local FastEmbed",
+            "embedding_model": "BAAI/bge-small-en-v1.5",
+            "retrieval_strategy": strategy,
+            "top_k": 30,
+            "hybrid_search": "BM25",
+            "segmentation": True,
+            "episodic_memory": "raw segments plus factual memories",
+            "cue_index": True,
+            "prompted_policy_max_steps": 4 if strategy == "prompt" else None,
+        },
+        "protocol_deviations": [
+            (
+                "GPT-4.1-mini was replaced by GLM because the original model "
+                "endpoint was unavailable."
+            ),
+            (
+                "The repository-default OpenAI embedding endpoint was replaced "
+                "by local BAAI/bge-small-en-v1.5 embeddings."
+            ),
+            (
+                "The GLM endpoint does not accept the paper's seed parameter; "
+                "temperature was fixed at 0 and thinking was disabled."
+            ),
+            (
+                "Conversations were executed as ten isolated processes and "
+                "aggregated; Memora user namespaces are conversation-local."
+            ),
+        ],
+        "paper_targets": PAPER_TARGETS,
+        "scores": scores,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+    }
+    path = campaign_root(run_prefix) / f"{strategy}_manifest.json"
+    with path.open("w") as f:
+        json.dump(manifest, f, indent=2)
+    return path
+def initialize_trackio(args: argparse.Namespace, splits: list[int]):
+    if not args.trackio:
+        return None
+    try:
+        import trackio
+    except ImportError as exc:
+        raise RuntimeError(
+            "Trackio is not installed in the orchestrator environment. "
+            "Install requirements-glm.txt first."
+        ) from exc
+    trackio.init(
+        project=DEFAULT_PROJECT,
+        name=f"{args.run_prefix}-{args.strategy}",
+        group=args.run_prefix,
+        config={
+            "paper_arxiv": "2602.03315",
+            "strategy": args.strategy,
+            "model": os.getenv("GLM_MODEL", "glm-4.5-flash"),
+            "embedding_model": "BAAI/bge-small-en-v1.5",
+            "splits": ",".join(str(split) for split in splits),
+            "full_scale": splits == list(range(1, 11)),
+        },
+    )
+    return trackio
+def main() -> int:
+    args = parse_args()
+    splits = validate_splits(args.splits)
+    if args.max_parallel < 1:
+        raise ValueError("--max-parallel must be at least 1")
+    if args.env_file:
+        load_dotenv(args.env_file, override=False)
+    if not args.dry_run and not os.getenv("GLM_API_KEY"):
+        raise RuntimeError("GLM_API_KEY is required")
+    if not args.python.is_file():
+        raise FileNotFoundError(f"Python interpreter not found: {args.python}")
+    data = load_dataset()
+    summary = dataset_summary(data)
+    root = campaign_root(args.run_prefix)
+    root.mkdir(parents=True, exist_ok=True)
+    print(
+        json.dumps(
+            {
+                "campaign": args.run_prefix,
+                "strategy": args.strategy,
+                "splits": splits,
+                "selected_questions": sum(
+                    summary["question_counts"][i - 1] for i in splits
+                ),
+                "selected_evaluated_questions": sum(
+                    summary["evaluated_counts"][i - 1] for i in splits
+                ),
+                "max_parallel": args.max_parallel,
+            }
+        ),
+        flush=True,
+    )
+    tracker = initialize_trackio(args, splits)
+    failures: list[str] = []
+    results: list[dict[str, Any]] = []
+    with concurrent.futures.ThreadPoolExecutor(
+        max_workers=args.max_parallel
+    ) as executor:
+        future_to_split = {
+            executor.submit(
+                run_split,
+                python=args.python,
+                run_prefix=args.run_prefix,
+                strategy=args.strategy,
+                split=split,
+                expected_count=summary["evaluated_counts"][split - 1],
+                retries=args.retries,
+                dry_run=args.dry_run,
+            ): split
+            for split in splits
+        }
+        for future in concurrent.futures.as_completed(future_to_split):
+            split = future_to_split[future]
+            try:
+                result = future.result()
+                results.append(result)
+                print(json.dumps(result), flush=True)
+                if tracker and result["status"] != "dry-run":
+                    tracker.log(
+                        {
+                            "split": split,
+                            "split_success": 1,
+                            "split_duration_seconds": result[
+                                "duration_seconds"
+                            ],
+                        }
+                    )
+            except Exception as exc:
+                message = f"split {split}: {exc}"
+                failures.append(message)
+                print(json.dumps({"split": split, "error": str(exc)}), flush=True)
+                if tracker:
+                    tracker.log({"split": split, "split_success": 0})
+    if failures:
+        write_manifest(
+            run_prefix=args.run_prefix,
+            strategy=args.strategy,
+            splits=splits,
+            summary=summary,
+            scores=None,
+        )
+        if tracker:
+            tracker.finish()
+        raise RuntimeError("\n\n".join(failures))
+    if args.dry_run:
+        write_manifest(
+            run_prefix=args.run_prefix,
+            strategy=args.strategy,
+            splits=splits,
+            summary=summary,
+            scores=None,
+        )
+        if tracker:
+            tracker.finish()
+        return 0
+    scores = aggregate_strategy(
+        run_prefix=args.run_prefix,
+        strategy=args.strategy,
+        splits=splits,
+        expected_counts=summary["evaluated_counts"],
+    )
+    manifest_path = write_manifest(
+        run_prefix=args.run_prefix,
+        strategy=args.strategy,
+        splits=splits,
+        summary=summary,
+        scores=scores,
+    )
+    if tracker:
+        tracker.log(
+            {
+                "overall_llm_score": scores["overall_mean_scores"]["llm_score"],
+                "overall_f1_score": scores["overall_mean_scores"]["f1_score"],
+                "overall_bleu_score": scores["overall_mean_scores"]["bleu_score"],
+                "evaluated_questions": scores["summary"]["total_questions"],
+                "paper_llm_target": PAPER_TARGETS[args.strategy]["llm_score"],
+                "delta_from_paper": (
+                    scores["overall_mean_scores"]["llm_score"]
+                    - PAPER_TARGETS[args.strategy]["llm_score"]
+                ),
+            }
+        )
+        tracker.finish()
+    print(
+        json.dumps(
+            {
+                "status": "complete",
+                "scores": scores["overall_mean_scores"],
+                "evaluated_questions": scores["summary"]["total_questions"],
+                "manifest": str(manifest_path),
+            }
+        ),
+        flush=True,
+    )
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())
+````
+````output
+{"campaign": "glm52-full", "strategy": "prompt", "splits": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], "selected_questions": 1986, "selected_evaluated_questions": 1540, "max_parallel": 1}
+* Trackio project initialized: memora-icml2026-repro
+* Trackio metrics logged to: /Users/conanssam-m4/.cache/huggingface/trackio
+* View dashboard by running in your terminal:
+[1m[38;5;208mtrackio show --project "memora-icml2026-repro"[0m
+* or by running in Python: trackio.show(project="memora-icml2026-repro")
+* Created new run: glm52-full-prompt
+{"split": 1, "status": "skipped", "duration_seconds": 0.0, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split01.log"}
+{"split": 2, "status": "skipped", "duration_seconds": 0.0, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split02.log"}
+{"split": 3, "status": "skipped", "duration_seconds": 0.0, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split03.log"}
+{"split": 4, "status": "completed", "duration_seconds": 359.562, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split04.log"}
+{"split": 5, "status": "skipped", "duration_seconds": 0.0, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split05.log"}
+{"split": 6, "status": "skipped", "duration_seconds": 0.0, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split06.log"}
+{"split": 7, "status": "skipped", "duration_seconds": 0.0, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split07.log"}
+{"split": 8, "status": "skipped", "duration_seconds": 0.0, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split08.log"}
+{"split": 9, "status": "skipped", "duration_seconds": 0.0, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split09.log"}
+{"split": 10, "status": "skipped", "duration_seconds": 0.0, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/prompt-split10.log"}
+* Run finished. Uploading logs to Trackio (please wait...)
+{"status": "complete", "scores": {"bleu_score": 0.4889, "f1_score": 0.5953, "llm_score": 0.7877}, "evaluated_questions": 1540, "manifest": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/prompt_manifest.json"}
+````
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_5e699394a9cc", "created_at": "2026-07-24T14:34:57+00:00", "title": "Corrected full-scale Policy result"}
+-->
+The complete GLM-5.2 substitution run covered all 10 LoCoMo conversations and all 1,540 repository-standard evaluated questions. After automatically retrying three terminal API-error answers, the verified error-free Policy result is LLM-as-a-Judge 0.7877, F1 0.5953, and BLEU-1 0.4889. The LLM score is 0.0753 below the paper Policy value of 0.863 and 0.0373 below its 0.825 full-context baseline, while F1 exceeds the paper value by 0.0423 and BLEU by 0.0229. Thus the headline LLM-judge claim is not reproduced under the documented GLM/local-embedding substitution; this demonstrates portability sensitivity and does not falsify the original same-model experiment.

pages/claim-2-locomo-semantic-retriever-reaches-0-849-llm-as-a-judge-and-exceeds-full-context/page.md ADDED Viewed

	@@ -0,0 +1,752 @@

+# Claim 2: LoCoMo Semantic Retriever reaches 0.849 LLM-as-a-Judge and exceeds full-context.
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_7573342754b8", "created_at": "2026-07-24T05:17:39+00:00", "title": "Claim 2: LoCoMo Semantic Retriever reaches 0.849 LLM-as-a-Judge and exceeds full-context."}
+-->
+Document setup, runs, and results for **Claim 2: LoCoMo Semantic Retriever reaches 0.849 LLM-as-a-Judge and exceeds full-context.**.
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_22f4dbfd0414", "created_at": "2026-07-24T13:22:29+00:00", "title": "Protocol and reuse of full memories"}
+-->
+We evaluate the official Semantic Retriever on the same complete LoCoMo dataset and reuse the ten fully built Memora stores from Claim 1. This preserves all 272 sessions and avoids changing memory construction between retrieval strategies. The only documented substitutions remain GLM-5.2 for GPT-4.1-mini and local BAAI/bge-small-en-v1.5 embeddings for the unavailable OpenAI embedding endpoint. The target is the paper’s 0.849 Semantic LLM-as-a-Judge score and its comparison against the 0.825 full-context baseline.
+---
+<!-- trackio-cell
+{"type": "code", "id": "cell_1b7c2bac0cea", "created_at": "2026-07-24T14:23:03+00:00", "title": "Run: python run_locomo_reproduction.py (exit 0)", "command": [".venv/bin/python", "scripts/run_locomo_reproduction.py", "--strategy", "semantic", "--run-prefix", "glm52-full", "--max-parallel", "3", "--retries", "3", "--env-file", "/Users/conanssam-m4/.ouroboros/worktrees/studymemory/orch_d223290f8ae3/.env", "--trackio"], "exit_code": 0, "duration_s": 3629.683}
+-->
+````bash
+$ .venv/bin/python scripts/run_locomo_reproduction.py --strategy semantic --run-prefix glm52-full --max-parallel 3 --retries 3 --env-file /Users/conanssam-m4/.ouroboros/worktrees/studymemory/orch_d223290f8ae3/.env --trackio
+````
+exit 0 · 3629.7s
+````python title=run_locomo_reproduction.py
+#!/usr/bin/env python3
+"""Run the full LoCoMo Memora reproduction as restartable conversation splits.
+Each LoCoMo conversation has an isolated Memora user namespace. Running the ten
+conversations in separate processes therefore preserves the official method
+while avoiding result-directory collisions and making multi-hour API runs
+restartable.
+"""
+from __future__ import annotations
+import argparse
+import concurrent.futures
+import hashlib
+import json
+import os
+import subprocess
+import sys
+import time
+from collections import defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+from statistics import fmean
+from typing import Any
+from dotenv import load_dotenv
+REPO_ROOT = Path(__file__).resolve().parents[1]
+LOCOMO_ROOT = REPO_ROOT / "app" / "locomo"
+DATA_PATH = LOCOMO_ROOT / "data" / "locomo10.json"
+DEFAULT_PROJECT = "memora-icml2026-repro"
+PAPER_TARGETS = {
+    "prompt": {"llm_score": 0.863, "f1_score": 0.553, "bleu_score": 0.466},
+    "semantic": {"llm_score": 0.849, "f1_score": 0.552, "bleu_score": 0.464},
+    "full_context": {"llm_score": 0.825},
+}
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--strategy",
+        choices=("prompt", "semantic"),
+        required=True,
+        help="Memora retrieval strategy to reproduce.",
+    )
+    parser.add_argument(
+        "--run-prefix",
+        default="glm52-full",
+        help="Stable campaign name used for result and memory directories.",
+    )
+    parser.add_argument(
+        "--splits",
+        nargs="+",
+        type=int,
+        default=list(range(1, 11)),
+        help="One-based LoCoMo conversation indices (default: all 1..10).",
+    )
+    parser.add_argument(
+        "--max-parallel",
+        type=int,
+        default=3,
+        help="Maximum concurrent GLM-backed split processes.",
+    )
+    parser.add_argument(
+        "--retries",
+        type=int,
+        default=2,
+        help="Process-level attempts per split.",
+    )
+    parser.add_argument(
+        "--env-file",
+        type=Path,
+        help="Optional dotenv file containing GLM_API_KEY and GLM_MODEL.",
+    )
+    parser.add_argument(
+        "--python",
+        type=Path,
+        default=REPO_ROOT / ".venv" / "bin" / "python",
+        help="Python interpreter for split processes.",
+    )
+    parser.add_argument(
+        "--trackio",
+        action="store_true",
+        help="Log split completion and aggregate metrics to Trackio.",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print commands without running the experiment.",
+    )
+    return parser.parse_args()
+def validate_splits(splits: list[int]) -> list[int]:
+    normalized = sorted(set(splits))
+    if not normalized or normalized[0] < 1 or normalized[-1] > 10:
+        raise ValueError("--splits must contain one-based indices between 1 and 10")
+    return normalized
+def load_dataset(path: Path = DATA_PATH) -> list[dict[str, Any]]:
+    with path.open() as f:
+        data = json.load(f)
+    if len(data) != 10:
+        raise ValueError(f"Expected 10 LoCoMo conversations, found {len(data)}")
+    return data
+def dataset_summary(data: list[dict[str, Any]]) -> dict[str, Any]:
+    category_counts: dict[str, int] = defaultdict(int)
+    sessions = 0
+    question_counts = []
+    evaluated_counts = []
+    for item in data:
+        conversation = item["conversation"]
+        sessions += sum(
+            1
+            for key in conversation
+            if key.startswith("session_") and not key.endswith("_date_time")
+        )
+        qa = item["qa"]
+        question_counts.append(len(qa))
+        evaluated = 0
+        for question in qa:
+            category = str(question["category"])
+            category_counts[category] += 1
+            if category != "5":
+                evaluated += 1
+        evaluated_counts.append(evaluated)
+    return {
+        "conversations": len(data),
+        "sessions": sessions,
+        "questions": sum(question_counts),
+        "evaluated_questions": sum(evaluated_counts),
+        "question_counts": question_counts,
+        "evaluated_counts": evaluated_counts,
+        "category_counts": dict(sorted(category_counts.items())),
+    }
+def file_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+def campaign_root(run_prefix: str) -> Path:
+    return LOCOMO_ROOT / "results" / "reproduction" / run_prefix
+def split_output_dir(run_prefix: str, strategy: str, split: int) -> Path:
+    return (
+        campaign_root(run_prefix)
+        / "runs"
+        / f"memora_{strategy}_split{split:02d}"
+    )
+def split_paths(
+    run_prefix: str,
+    strategy: str,
+    split: int,
+) -> dict[str, Path]:
+    method = f"memora_{strategy}"
+    output_dir = split_output_dir(run_prefix, strategy, split)
+    return {
+        "dir": output_dir,
+        "output": output_dir / f"{method}_output.json",
+        "eval": output_dir / f"{method}_eval.json",
+        "scores": output_dir / f"{method}_scores.json",
+        "build_timing": output_dir / "build_timing.json",
+    }
+def memory_store_name(run_prefix: str, split: int) -> str:
+    safe_prefix = "".join(
+        char if char.isalnum() or char in "._-" else "-"
+        for char in run_prefix
+    ).strip("-")
+    if not safe_prefix:
+        raise ValueError("--run-prefix must contain at least one safe character")
+    return f"{safe_prefix}-split{split:02d}"
+def build_split_command(
+    *,
+    python: Path,
+    run_prefix: str,
+    strategy: str,
+    split: int,
+    force_rebuild: bool,
+) -> list[str]:
+    return [
+        str(python),
+        "run_memora.py",
+        "--config-name",
+        "config_glm",
+        f"general.project_path={LOCOMO_ROOT}",
+        f"general.results_path={campaign_root(run_prefix) / 'runs'}",
+        "general.debug=false",
+        "general.resume=true",
+        f"general.run_name=split{split:02d}",
+        f"eval.subset_idx={split}",
+        "eval.max_workers=1",
+        f"memory.memory_store={memory_store_name(run_prefix, split)}",
+        f"memory.force_rebuild={'true' if force_rebuild else 'false'}",
+        f"retrieval.strategy={strategy}",
+    ]
+def evaluated_item_count(path: Path) -> int:
+    with path.open() as f:
+        data = json.load(f)
+    return sum(len(items) for items in data.values())
+def completed_split(
+    run_prefix: str,
+    strategy: str,
+    split: int,
+    expected_count: int,
+) -> bool:
+    paths = split_paths(run_prefix, strategy, split)
+    if not paths["scores"].is_file() or not paths["eval"].is_file():
+        return False
+    try:
+        with paths["scores"].open() as f:
+            scores = json.load(f)
+        return (
+            scores["summary"]["total_questions"] == expected_count
+            and evaluated_item_count(paths["eval"]) == expected_count
+        )
+    except (KeyError, OSError, ValueError, json.JSONDecodeError):
+        return False
+def tail(path: Path, line_count: int = 40) -> str:
+    try:
+        lines = path.read_text(errors="replace").splitlines()
+    except OSError:
+        return ""
+    return "\n".join(lines[-line_count:])
+def child_environment() -> dict[str, str]:
+    env = dict(os.environ)
+    existing = env.get("PYTHONPATH")
+    env["PYTHONPATH"] = (
+        f"{REPO_ROOT / 'src'}{os.pathsep}{existing}"
+        if existing
+        else str(REPO_ROOT / "src")
+    )
+    env["TOKENIZERS_PARALLELISM"] = "false"
+    return env
+def run_split(
+    *,
+    python: Path,
+    run_prefix: str,
+    strategy: str,
+    split: int,
+    expected_count: int,
+    retries: int,
+    dry_run: bool,
+) -> dict[str, Any]:
+    started = time.monotonic()
+    root = campaign_root(run_prefix)
+    log_path = root / "logs" / f"{strategy}-split{split:02d}.log"
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    if completed_split(run_prefix, strategy, split, expected_count):
+        return {
+            "split": split,
+            "status": "skipped",
+            "duration_seconds": 0.0,
+            "log": str(log_path),
+        }
+    persist_path = LOCOMO_ROOT / "memory_store" / memory_store_name(
+        run_prefix,
+        split,
+    )
+    if strategy == "semantic" and not persist_path.exists():
+        raise RuntimeError(
+            f"Split {split}: semantic retrieval requires the prompt-built "
+            f"memory store at {persist_path}"
+        )
+    attempts = max(1, retries)
+    for attempt in range(1, attempts + 1):
+        paths = split_paths(run_prefix, strategy, split)
+        force_rebuild = (
+            strategy == "prompt" and not paths["build_timing"].is_file()
+        )
+        command = build_split_command(
+            python=python,
+            run_prefix=run_prefix,
+            strategy=strategy,
+            split=split,
+            force_rebuild=force_rebuild,
+        )
+        if dry_run:
+            return {
+                "split": split,
+                "status": "dry-run",
+                "duration_seconds": 0.0,
+                "command": command,
+                "log": str(log_path),
+            }
+        with log_path.open("a") as log:
+            log.write(
+                f"\n=== attempt {attempt}/{attempts} "
+                f"{datetime.now(timezone.utc).isoformat()} ===\n"
+            )
+            log.flush()
+            completed = subprocess.run(
+                command,
+                cwd=LOCOMO_ROOT,
+                env=child_environment(),
+                stdout=log,
+                stderr=subprocess.STDOUT,
+                text=True,
+                check=False,
+            )
+        if completed.returncode == 0 and completed_split(
+            run_prefix,
+            strategy,
+            split,
+            expected_count,
+        ):
+            return {
+                "split": split,
+                "status": "completed",
+                "duration_seconds": round(time.monotonic() - started, 3),
+                "attempts": attempt,
+                "log": str(log_path),
+            }
+        if attempt == attempts:
+            raise RuntimeError(
+                f"Split {split} failed after {attempts} attempts "
+                f"(exit {completed.returncode}).\n{tail(log_path)}"
+            )
+    raise AssertionError("unreachable")
+def mean(values: list[float]) -> float:
+    return round(fmean(values), 4)
+def aggregate_strategy(
+    *,
+    run_prefix: str,
+    strategy: str,
+    splits: list[int],
+    expected_counts: list[int],
+) -> dict[str, Any]:
+    aggregate_eval: dict[str, list[dict[str, Any]]] = {}
+    aggregate_output: dict[str, list[dict[str, Any]]] = {}
+    all_eval_items: list[dict[str, Any]] = []
+    for split in splits:
+        paths = split_paths(run_prefix, strategy, split)
+        expected = expected_counts[split - 1]
+        if not completed_split(run_prefix, strategy, split, expected):
+            raise RuntimeError(f"Split {split} is incomplete and cannot be aggregated")
+        with paths["eval"].open() as f:
+            split_eval = json.load(f)
+        with paths["output"].open() as f:
+            split_output = json.load(f)
+        eval_items = [
+            item for items in split_eval.values() for item in items
+        ]
+        output_items = [
+            item for items in split_output.values() for item in items
+        ]
+        aggregate_eval[str(split - 1)] = eval_items
+        aggregate_output[str(split - 1)] = output_items
+        all_eval_items.extend(eval_items)
+    by_category: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for item in all_eval_items:
+        by_category[str(item["category"])].append(item)
+    metrics = ("bleu_score", "f1_score", "llm_score")
+    per_category = {
+        metric: {
+            category: mean([float(item[metric]) for item in items])
+            for category, items in sorted(by_category.items())
+        }
+        for metric in metrics
+    }
+    per_category["count"] = {
+        category: len(items)
+        for category, items in sorted(by_category.items())
+    }
+    overall = {
+        metric: mean([float(item[metric]) for item in all_eval_items])
+        for metric in metrics
+    }
+    scores = {
+        "mean_scores_per_category": per_category,
+        "overall_mean_scores": overall,
+        "summary": {
+            "total_questions": len(all_eval_items),
+            "categories_evaluated": sorted(int(key) for key in by_category),
+            "evaluation_timestamp": datetime.now(timezone.utc).isoformat(),
+            "conversation_splits": splits,
+        },
+    }
+    root = campaign_root(run_prefix)
+    root.mkdir(parents=True, exist_ok=True)
+    for name, payload in (
+        (f"{strategy}_output.json", aggregate_output),
+        (f"{strategy}_eval.json", aggregate_eval),
+        (f"{strategy}_scores.json", scores),
+    ):
+        with (root / name).open("w") as f:
+            json.dump(payload, f, indent=2)
+    return scores
+def write_manifest(
+    *,
+    run_prefix: str,
+    strategy: str,
+    splits: list[int],
+    summary: dict[str, Any],
+    scores: dict[str, Any] | None,
+) -> Path:
+    selected_questions = sum(summary["question_counts"][i - 1] for i in splits)
+    selected_evaluated = sum(
+        summary["evaluated_counts"][i - 1] for i in splits
+    )
+    manifest = {
+        "paper": {
+            "title": (
+                "Memora: A Harmonic Memory Representation Balancing "
+                "Abstraction and Specificity"
+            ),
+            "arxiv_id": "2602.03315",
+            "openreview_id": "zSrvkj0ers",
+            "official_repository": "https://github.com/microsoft/Memora",
+            "official_commit": "dec3f8f2444eace7004fc084abe1be9f3d88270e",
+        },
+        "campaign": run_prefix,
+        "strategy": strategy,
+        "splits": splits,
+        "full_scale": splits == list(range(1, 11)),
+        "dataset": {
+            **summary,
+            "selected_questions": selected_questions,
+            "selected_evaluated_questions": selected_evaluated,
+            "sha256": file_sha256(DATA_PATH),
+        },
+        "implementation": {
+            "llm_provider": "Z.AI OpenAI-compatible API",
+            "llm_model": os.getenv("GLM_MODEL", "glm-4.5-flash"),
+            "embedding_provider": "local FastEmbed",
+            "embedding_model": "BAAI/bge-small-en-v1.5",
+            "retrieval_strategy": strategy,
+            "top_k": 30,
+            "hybrid_search": "BM25",
+            "segmentation": True,
+            "episodic_memory": "raw segments plus factual memories",
+            "cue_index": True,
+            "prompted_policy_max_steps": 4 if strategy == "prompt" else None,
+        },
+        "protocol_deviations": [
+            (
+                "GPT-4.1-mini was replaced by GLM because the original model "
+                "endpoint was unavailable."
+            ),
+            (
+                "The repository-default OpenAI embedding endpoint was replaced "
+                "by local BAAI/bge-small-en-v1.5 embeddings."
+            ),
+            (
+                "The GLM endpoint does not accept the paper's seed parameter; "
+                "temperature was fixed at 0 and thinking was disabled."
+            ),
+            (
+                "Conversations were executed as ten isolated processes and "
+                "aggregated; Memora user namespaces are conversation-local."
+            ),
+        ],
+        "paper_targets": PAPER_TARGETS,
+        "scores": scores,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+    }
+    path = campaign_root(run_prefix) / f"{strategy}_manifest.json"
+    with path.open("w") as f:
+        json.dump(manifest, f, indent=2)
+    return path
+def initialize_trackio(args: argparse.Namespace, splits: list[int]):
+    if not args.trackio:
+        return None
+    try:
+        import trackio
+    except ImportError as exc:
+        raise RuntimeError(
+            "Trackio is not installed in the orchestrator environment. "
+            "Install requirements-glm.txt first."
+        ) from exc
+    trackio.init(
+        project=DEFAULT_PROJECT,
+        name=f"{args.run_prefix}-{args.strategy}",
+        group=args.run_prefix,
+        config={
+            "paper_arxiv": "2602.03315",
+            "strategy": args.strategy,
+            "model": os.getenv("GLM_MODEL", "glm-4.5-flash"),
+            "embedding_model": "BAAI/bge-small-en-v1.5",
+            "splits": ",".join(str(split) for split in splits),
+            "full_scale": splits == list(range(1, 11)),
+        },
+    )
+    return trackio
+def main() -> int:
+    args = parse_args()
+    splits = validate_splits(args.splits)
+    if args.max_parallel < 1:
+        raise ValueError("--max-parallel must be at least 1")
+    if args.env_file:
+        load_dotenv(args.env_file, override=False)
+    if not args.dry_run and not os.getenv("GLM_API_KEY"):
+        raise RuntimeError("GLM_API_KEY is required")
+    if not args.python.is_file():
+        raise FileNotFoundError(f"Python interpreter not found: {args.python}")
+    data = load_dataset()
+    summary = dataset_summary(data)
+    root = campaign_root(args.run_prefix)
+    root.mkdir(parents=True, exist_ok=True)
+    print(
+        json.dumps(
+            {
+                "campaign": args.run_prefix,
+                "strategy": args.strategy,
+                "splits": splits,
+                "selected_questions": sum(
+                    summary["question_counts"][i - 1] for i in splits
+                ),
+                "selected_evaluated_questions": sum(
+                    summary["evaluated_counts"][i - 1] for i in splits
+                ),
+                "max_parallel": args.max_parallel,
+            }
+        ),
+        flush=True,
+    )
+    tracker = initialize_trackio(args, splits)
+    failures: list[str] = []
+    results: list[dict[str, Any]] = []
+    with concurrent.futures.ThreadPoolExecutor(
+        max_workers=args.max_parallel
+    ) as executor:
+        future_to_split = {
+            executor.submit(
+                run_split,
+                python=args.python,
+                run_prefix=args.run_prefix,
+                strategy=args.strategy,
+                split=split,
+                expected_count=summary["evaluated_counts"][split - 1],
+                retries=args.retries,
+                dry_run=args.dry_run,
+            ): split
+            for split in splits
+        }
+        for future in concurrent.futures.as_completed(future_to_split):
+            split = future_to_split[future]
+            try:
+                result = future.result()
+                results.append(result)
+                print(json.dumps(result), flush=True)
+                if tracker and result["status"] != "dry-run":
+                    tracker.log(
+                        {
+                            "split": split,
+                            "split_success": 1,
+                            "split_duration_seconds": result[
+                                "duration_seconds"
+                            ],
+                        }
+                    )
+            except Exception as exc:
+                message = f"split {split}: {exc}"
+                failures.append(message)
+                print(json.dumps({"split": split, "error": str(exc)}), flush=True)
+                if tracker:
+                    tracker.log({"split": split, "split_success": 0})
+    if failures:
+        write_manifest(
+            run_prefix=args.run_prefix,
+            strategy=args.strategy,
+            splits=splits,
+            summary=summary,
+            scores=None,
+        )
+        if tracker:
+            tracker.finish()
+        raise RuntimeError("\n\n".join(failures))
+    if args.dry_run:
+        write_manifest(
+            run_prefix=args.run_prefix,
+            strategy=args.strategy,
+            splits=splits,
+            summary=summary,
+            scores=None,
+        )
+        if tracker:
+            tracker.finish()
+        return 0
+    scores = aggregate_strategy(
+        run_prefix=args.run_prefix,
+        strategy=args.strategy,
+        splits=splits,
+        expected_counts=summary["evaluated_counts"],
+    )
+    manifest_path = write_manifest(
+        run_prefix=args.run_prefix,
+        strategy=args.strategy,
+        splits=splits,
+        summary=summary,
+        scores=scores,
+    )
+    if tracker:
+        tracker.log(
+            {
+                "overall_llm_score": scores["overall_mean_scores"]["llm_score"],
+                "overall_f1_score": scores["overall_mean_scores"]["f1_score"],
+                "overall_bleu_score": scores["overall_mean_scores"]["bleu_score"],
+                "evaluated_questions": scores["summary"]["total_questions"],
+                "paper_llm_target": PAPER_TARGETS[args.strategy]["llm_score"],
+                "delta_from_paper": (
+                    scores["overall_mean_scores"]["llm_score"]
+                    - PAPER_TARGETS[args.strategy]["llm_score"]
+                ),
+            }
+        )
+        tracker.finish()
+    print(
+        json.dumps(
+            {
+                "status": "complete",
+                "scores": scores["overall_mean_scores"],
+                "evaluated_questions": scores["summary"]["total_questions"],
+                "manifest": str(manifest_path),
+            }
+        ),
+        flush=True,
+    )
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())
+````
+````output
+{"campaign": "glm52-full", "strategy": "semantic", "splits": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], "selected_questions": 1986, "selected_evaluated_questions": 1540, "max_parallel": 3}
+* Trackio project initialized: memora-icml2026-repro
+* Trackio metrics logged to: /Users/conanssam-m4/.cache/huggingface/trackio
+* View dashboard by running in your terminal:
+[1m[38;5;208mtrackio show --project "memora-icml2026-repro"[0m
+* or by running in Python: trackio.show(project="memora-icml2026-repro")
+* Created new run: glm52-full-semantic
+{"split": 2, "status": "completed", "duration_seconds": 528.373, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/semantic-split02.log"}
+{"split": 3, "status": "completed", "duration_seconds": 879.392, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/semantic-split03.log"}
+{"split": 1, "status": "completed", "duration_seconds": 950.689, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/semantic-split01.log"}
+{"split": 4, "status": "completed", "duration_seconds": 1193.757, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/semantic-split04.log"}
+{"split": 6, "status": "completed", "duration_seconds": 813.608, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/semantic-split06.log"}
+{"split": 5, "status": "completed", "duration_seconds": 1091.521, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/semantic-split05.log"}
+{"split": 7, "status": "completed", "duration_seconds": 805.352, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/semantic-split07.log"}
+{"split": 8, "status": "completed", "duration_seconds": 1133.963, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/semantic-split08.log"}
+{"split": 9, "status": "completed", "duration_seconds": 1198.259, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/semantic-split09.log"}
+{"split": 10, "status": "completed", "duration_seconds": 1099.892, "attempts": 1, "log": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/logs/semantic-split10.log"}
+* Run finished. Uploading logs to Trackio (please wait...)
+{"status": "complete", "scores": {"bleu_score": 0.4905, "f1_score": 0.5977, "llm_score": 0.774}, "evaluated_questions": 1540, "manifest": "/Users/conanssam-m4/memora-glm/app/locomo/results/reproduction/glm52-full/semantic_manifest.json"}
+````
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_e1479ac2eb67", "created_at": "2026-07-24T14:23:41+00:00", "title": "Full-scale Semantic result"}
+-->
+## Result: not reproduced under the GLM/local-embedding substitution
+The full LoCoMo protocol completed on all 10 conversations: 1,986 raw questions and 1,540 evaluated questions (categories 1–4; category 5 skipped by the official evaluator).
+| Metric | Paper Semantic | This run | Delta |
+|---|---:|---:|---:|
+| LLM-as-a-Judge | 0.849 | 0.7740 | -0.0750 |
+| F1 | 0.552 | 0.5977 | +0.0457 |
+| BLEU | 0.464 | 0.4905 | +0.0265 |
+The LLM score also falls below the paper full-context baseline of 0.825 by 0.0510. Therefore Claim 2 is not reproduced in this portability setting, although lexical overlap metrics exceed the paper values. This is not an exact-model falsification: GPT-4.1-mini was replaced by GLM-5.2, OpenAI embeddings by local BAAI/bge-small-en-v1.5, and the endpoint did not accept the original seed parameter. The result isolates sensitivity to the substituted model/embedding stack rather than disproving the original same-model result.
+Primary artifacts: semantic_scores.json, semantic_eval.json, and semantic_manifest.json under app/locomo/results/reproduction/glm52-full/.

pages/claim-3-longmemeval-reaches-87-4-average-accuracy-with-up-to-98-token-reduction/page.md ADDED Viewed

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

+# Claim 3: LongMemEval reaches 87.4% average accuracy with up to 98% token reduction.
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_5657509115a9", "created_at": "2026-07-24T05:17:39+00:00", "title": "Claim 3: LongMemEval reaches 87.4% average accuracy with up to 98% token reduction."}
+-->
+Document setup, runs, and results for **Claim 3: LongMemEval reaches 87.4% average accuracy with up to 98% token reduction.**.

pages/claim-4-harmonic-memory-uses-a-primary-abstraction-concrete-memory-value-and-cue-anchors/page.md ADDED Viewed

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

+# Claim 4: Harmonic memory uses a primary abstraction, concrete memory value, and cue anchors.
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_27f2555ed4a6", "created_at": "2026-07-24T05:17:39+00:00", "title": "Claim 4: Harmonic memory uses a primary abstraction, concrete memory value, and cue anchors."}
+-->
+Document setup, runs, and results for **Claim 4: Harmonic memory uses a primary abstraction, concrete memory value, and cue anchors.**.

pages/claim-5-rag-and-kg-retrieval-are-special-cases-of-the-memora-dual-layer-design/page.md ADDED Viewed

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

+# Claim 5: RAG and KG retrieval are special cases of the Memora dual-layer design.
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_73f8806ef558", "created_at": "2026-07-24T05:17:39+00:00", "title": "Claim 5: RAG and KG retrieval are special cases of the Memora dual-layer design."}
+-->
+Document setup, runs, and results for **Claim 5: RAG and KG retrieval are special cases of the Memora dual-layer design.**.

pages/conclusion/page.md ADDED Viewed

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

+# Conclusion
+---
+<!-- trackio-cell
+{"type": "markdown", "id": "cell_538b51da624a", "created_at": "2026-07-24T14:34:58+00:00", "title": "Conclusion"}
+-->
+The official Memora code path was reproduced at full LoCoMo scale with restartable per-conversation execution, preserved memory construction and retrieval logic, and documented provider substitutions. Policy scored 0.7877 LLM / 0.5953 F1 / 0.4889 BLEU; Semantic scored 0.7740 / 0.5977 / 0.4905. The reported LLM-score gains were not portable to GLM-5.2 plus local BGE embeddings, although lexical metrics remained at or above the paper values. The paired result suggests that Policy retrieval helps LLM-judge correctness mainly on single-hop and temporal questions, but does not yield a general lexical advantage and is slightly worse on multi-hop. Claims about the exact GPT-4.1-mini/OpenAI-embedding configuration remain untested by this substitution study.

pages/executive-summary/page.md ADDED Viewed

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

pages/index.md ADDED Viewed

	@@ -0,0 +1,13 @@

+# Reproduction: Memora: A Harmonic Memory Representation Balancing Abstraction and Specificity
+## Pages
+| Page |
+| --- |
+| [Executive summary](#/executive-summary) |
+| [Claim 1: LoCoMo Policy Retriever reaches 0.863 LLM-as-a-Judge and exceeds full-context.](#/claim-1-locomo-policy-retriever-reaches-0-863-llm-as-a-judge-and-exceeds-full-context) |
+| [Claim 2: LoCoMo Semantic Retriever reaches 0.849 LLM-as-a-Judge and exceeds full-context.](#/claim-2-locomo-semantic-retriever-reaches-0-849-llm-as-a-judge-and-exceeds-full-context) |
+| [Claim 3: LongMemEval reaches 87.4% average accuracy with up to 98% token reduction.](#/claim-3-longmemeval-reaches-87-4-average-accuracy-with-up-to-98-token-reduction) |
+| [Claim 4: Harmonic memory uses a primary abstraction, concrete memory value, and cue anchors.](#/claim-4-harmonic-memory-uses-a-primary-abstraction-concrete-memory-value-and-cue-anchors) |
+| [Claim 5: RAG and KG retrieval are special cases of the Memora dual-layer design.](#/claim-5-rag-and-kg-retrieval-are-special-cases-of-the-memora-dual-layer-design) |
+| [Conclusion](#/conclusion) |

trackio-logo-light.png ADDED Viewed

trackio-logo.png ADDED Viewed

trackio-wordmark-dark.png ADDED Viewed

workspace.json ADDED Viewed

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

+{
+  "schema_version": 1,
+  "file_count": 0,
+  "total_size": 0,
+  "files": [],
+  "hub_refs": [],
+  "reference_only": true
+}