Update paper, README and citation: Data Availability section, corpus release, DOI 10.5281/zenodo.22079081

CITATION.cff

@@ -43,8 +43,8 @@ preferred-citation:
   year: 2026
   institution:
     name: "Project Dockyard"
-  url: "https://doi.org/10.5281/zenodo.20176599"
-  doi: "10.5281/zenodo.20176599"
+  url: "https://doi.org/10.5281/zenodo.22079081"
+  doi: "10.5281/zenodo.22079081"
   notes: "Independent research. Preprint available at Zenodo."
 
 references:

README.md

@@ -8,36 +8,60 @@ tags:
 - Vision-Language Models
 - GUI Agents
 ---
+
 # Memory Archive: A Memory-Grounded Training Paradigm for Computer Use Agents
 
 [![License: CC BY-NC 4.0](https://img.shields.io/badge/License-CC%20BY--NC%204.0-lightgrey.svg)](LICENSE)
-[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.20176599.svg)](https://doi.org/10.5281/zenodo.20176599)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.22079081.svg)](https://doi.org/10.5281/zenodo.22079081)
 [![Project Dockyard](https://img.shields.io/badge/Project-Dockyard-purple)](https://github.com/nullvoider07/Memory-Archive)
-[![Paper](https://img.shields.io/badge/Paper-PDF-red)](memory_archive.pdf)
+[![Paper](https://img.shields.io/badge/Paper-PDF-red)](memory_archive_paradigm.pdf)
+[![Dataset](https://img.shields.io/badge/%F0%9F%A4%97%20Dataset-Memory--Archive--Paradigm-yellow)](https://huggingface.co/datasets/NullVoider/Memory-Archive-Paradigm)
+
+**Kartik A.** · Independent Researcher · Project Dockyard
+
+📄 [Read the Paper (PDF)](memory_archive_paradigm.pdf)  ·  🗂️ [The Corpus (Hugging Face)](https://huggingface.co/datasets/NullVoider/Memory-Archive-Paradigm)  ·  💻 [Memory Archive Tool](https://github.com/nullvoider07/Memory-Archive)
+
+> **Publication note:** As an independent researcher, this architecture is published as an open-science preprint via Zenodo (CERN) to establish formal prior art, with a permanent, globally recognised DOI. This is the design specification and pre-registered research protocol for the paradigm — not an empirical results paper.
 
-**Kartik . A** · Independent Researcher · Project Dockyard
+---
+
+## What this document is (and is not)
 
-📄 [Read the Paper (PDF)](memory_archive_paradigm.pdf)  ·  💻 [Memory Archive Tool](https://github.com/nullvoider07/Memory-Archive)
+This is a **design specification and pre-registered research protocol**, published to establish prior art and to fix an experimental design before any data is seen.
 
-> **Publication note:** As an independent researcher, this architecture is published as an open-science preprint via Zenodo (CERN) to establish formal prior art. A permanent, globally recognised DOI is attached to this work. The full paper is available here in both PDF and Markdown.
+- **Nothing here has been trained end-to-end.** Every quantitative performance figure — task-success targets, latencies, reward weights, schema-validity rates — is a **projection derived from principled reasoning and analogous published systems, and is marked as such** in the paper (see §8, *Limitations and Scope*).
+- The central claim is stated as a **falsifiable, retrieval-conditional hypothesis**, and the paper **pre-registers the experiments that could refute it** — including the minimum-cost first test (§5.3), whose design, metrics, and decision rule are fixed in advance.
+- The architectural contributions — the artifact taxonomy, the format-consistency lifecycle, the three-component memory-adherence reward, and the two-stage retrieval stack — are stated as **designs whose value is contingent on those experiments**, not independent of them.
+
+This framing is deliberate. The paradigm is offered as a testable set of design bets, not a claimed result.
 
 ---
 
 ## The Problem
 
-The dominant CUA training pipeline trains on `(screenshot, action)` pairs and deploys with plain-text prompts and retrieved documents the model has never seen during training. Every task boundary is a distribution shift. Binary outcome rewards provide no per-step signal. Every execution is zero-shot regardless of prior experience with the same task.
+The dominant CUA training pipeline trains on `(screenshot, action)` pairs via behavioral cloning followed by outcome-supervised RL, and deploys with plain-text prompts and retrieved documents the model never saw during training. Five structural limitations are stated as **design premises** — assumptions consistent with published failure analyses of GUI agents, not results measured here:
+
+- **Outcome sparsity** — binary task success/failure gives no per-step gradient on long-horizon tasks.
+- **Intent blindness** — the model learns surface action patterns without causal understanding of task structure.
+- **Train–deploy format mismatch** — screenshot/action training vs. plain-text deployment is a representational distribution gap at every task boundary.
+- **No persistent task knowledge** — every execution is zero-shot regardless of prior experience with the identical task.
+- **Non-compositional generalisation** — monolithic trajectory learning prevents reliable composition of learned sub-procedures into novel sequences.
+
+Whether *format mismatch* — rather than grounding accuracy or long-horizon error compounding — is the **binding** constraint on current CUA performance is precisely what the experimental protocol (§5.1) is designed to test.
 
 ## The Central Thesis
 
-> **Format consistency eliminates the train-deploy distribution gap.**
+> **Format consistency eliminates the train–deploy distribution gap.**
+>
+> The `memory.md` artifact — a structured procedural document with per-step reasoning, actuation commands, and image references — is the same object at pre-training, supervised fine-tuning, post-training RL, and inference. The model trains on exactly what it retrieves at runtime.
 >
-> The `memory.md` artifact — a structured procedural document with per-step reasoning, actuation commands, and image references — is the same object at pre-training, supervised fine-tuning, post-training RL, and inference. The model trains on exactly what it retrieves at runtime. Additionally, the trained model generates its own `memory.md` at inference time, growing the library continuously and providing a multi-dimensional evaluation signal during training without any external benchmark.
+> **The claim is conditional on retrieval.** The predicted advantage concentrates on tasks for which a relevant memory exists in the library, and falls back to a no-memory generalisation path otherwise — so the protocol stratifies every comparison by **retrieval hit rate**. Additionally, the trained model generates its own `memory.md` at inference time, growing the library continuously and providing a multi-dimensional in-training evaluation signal without any external benchmark.
 
 ---
 
 ## Abstract
 
-Memory Archive produces a structured, annotated dataset comprising per-step actuation records, process-level reasoning annotations, visual state triples, and compiled task guides called memories. This data is used across all four stages of the CUA training and deployment lifecycle: pre-training, supervised fine-tuning, post-training reinforcement, and inference-time retrieval. Reasoning annotations are produced by a VLM Reasoning Model as the primary source, with human annotation as an alternative mode. The paper covers all four training stages at full technical depth — mathematical formulations, actuation artifact treatment, data construction pipelines, algorithm specifications, hyperparameter guidance, and failure mode analysis. A fifth section covers self-generated memory as an in-training evaluation mechanism.
+Memory Archive produces a structured, annotated dataset comprising per-step actuation records, process-level reasoning annotations, visual state triples, and compiled task guides called *memories*. This data is used across all four stages of the CUA training and deployment lifecycle: pre-training, supervised fine-tuning, post-training reinforcement, and inference-time retrieval. Reasoning annotations are produced by a VLM Reasoning Model as the primary source, with human annotation as an alternative mode. The paper covers all four stages at full technical depth — mathematical formulations, actuation-artifact treatment, data-construction pipelines, algorithm specifications, hyperparameter guidance, failure-mode analysis, and an explicit compute-requirements model. No result is empirical; every quantitative figure is a projection and is marked as such. Section 5.3 pre-registers the minimum-cost experiment — a memory-conditioned SFT ablation — designed to falsify the central Format Consistency Hypothesis. A fifth section covers self-generated memory as an in-training evaluation mechanism, grounded by **executable replay verification** rather than model-derived judges alone.
 
 ---
 
@@ -71,13 +95,15 @@ The base model learns what a well-formed memory looks like, how step sections ar
 
 **3-phase curriculum:** actuation vocabulary → step-level visual-intent alignment → full compiled memories
 
+**Architecture requirement:** a session with *N* steps encodes 3*N* images; the recommended context window is **128K–256K depending on backbone** (a 50-step fixed-resolution session already costs ≈48K tokens before any `memory.md` text). Backbone choice — MHA vs. GQA, fixed vs. dynamic resolution — is the first architecture decision because it sets every session-length limit.
+
 ---
 
 ### Stage 2 — SFT: Actuation as a First-Class Target
 
-SFT uses **Formulation B** — a retrieved `memory.md` is in context at every training step. The model learns to read and follow a memory at train time, not just at inference.
+SFT uses **Formulation B** — a retrieved `memory.md` is in context at every training step. The model learns to read and follow a memory at train time, not just at inference. Critically, the in-context memory is retrieved from a **different** session of the same/similar task (never the session being supervised) — the same-session memory would be a circular oracle. Cold-start tasks with no cross-session partner use a partial memory (first *k* steps, remainder masked). **10–20% of retrieved memory steps are corrupted** with plausible-but-incorrect alternatives, forcing the model to detect and override memory errors rather than reproduce them verbatim.
 
-**Key design:** `CommandEvent JSON` and step headers are full-weight targets (`w = 1.0`). Reasoning uses stage-dependent weighting (0.75 early → 0.50 late). Memory tokens are masked entirely (`w = 0.0`).
+**Key design:** `CommandEvent JSON` and step headers are full-weight targets (`w = 1.0`). Reasoning uses stage-dependent weighting (0.75 early → 0.50 late). Memory tokens are masked entirely (`w = 0.0`). Per-step ordering is `before → reasoning → action → at → after`, mirroring causal reality (the click at-frame is a *consequence* of the action and is unavailable when the model must generate it).
 
 <div align="center">
 
@@ -91,18 +117,24 @@ SFT uses **Formulation B** — a retrieved `memory.md` is in context at every tr
 
 ### Stage 3 — Post-Training RL: Memory Adherence
 
-**Algorithm:** GRPO — eliminates a separate value network, critical given 150+ image encodings per session in the KV cache.
+**Algorithm:** GRPO — eliminates a separate value network, critical given the multi-image KV cache (a duplicate critic backbone would hold an identical gigabyte-scale copy of the image encodings per session).
 
 **Three-component reward** ($G = 8$ trajectories per task):
 
 | Component | Weight | What it measures |
 |---|---|---|
-| $R_{\text{align}}$ — Step Alignment | $\alpha = 0.3$ | Cosine similarity between agent reasoning and memory step text (domain-specific CUA encoder) |
-| $R_{\text{spatial}}$ — Visual Grounding | $\beta = 0.4$ | Euclidean pixel distance: agent click vs memory at-frame annotation |
-| $R_{\text{outcome}}$ — Outcome Consistency | $\gamma = 0.3$ | Visual encoder similarity between agent after-frame and memory after-frame |
+| $R_{\text{align}}$ — Step Alignment | $\alpha = 0.3$ | Cosine similarity between agent reasoning and memory step text (domain-specific CUA encoder), plus a **Process Reward Model** term ($\lambda = 0.2$) that scores step-level reasoning quality against the three-frame visual context |
+| $R_{\text{spatial}}$ — Visual Grounding | $\beta = 0.4$ | Euclidean pixel distance: agent click vs. memory at-frame annotation, with per-pair tolerance $\tau_{\text{px}}$ (10 px tight / 50 px default) |
+| $R_{\text{outcome}}$ — Outcome Consistency | $\gamma = 0.3$ | Visual-encoder similarity between agent terminal after-frame and memory terminal after-frame |
 
 $R_{\text{spatial}}$ carries the highest weight — spatial precision is the hardest CUA skill to acquire from language supervision alone.
 
+**Reward correctness details that make the signal gameable-resistant:**
+- **Monotonic alignment (DTW).** Trajectory and memory need not have equal length or matching order; per-step terms operate over an explicit monotonic alignment, weighted by trajectory-side coverage so a path that aligns a few steps and wanders elsewhere cannot average away its low scores.
+- **Validity-conditional reward.** On the injected-corruption episodes, per-step terms are computed against the *pre-corruption original* step — so "follow the memory when it is right, override it when it is wrong" is the literal optimum, closing the SFT↔RL contradiction rather than being a hoped-for side effect.
+- **PRM decoupling.** The Process Reward Model is trained *exclusively* on human-annotated sessions and deployed frozen during RL, breaking the circular dependency of critiquing VLM annotations with a critic trained on the same signal.
+- **Cold-start protocol.** A rule-based reward warm-up (first 10% of steps), single-step task curriculum, and group-size annealing ($G{=}4 \to 8$) prevent the degenerate $\text{std}(R)\approx 0$ that would make the group-relative advantage numerically unstable.
+
 <div align="center">
 
 ![GRPO Training Loop](images/fig06.png)
@@ -123,11 +155,11 @@ $R_{\text{spatial}}$ carries the highest weight — spatial precision is the har
 
 </div>
 
-**Two-stage retrieval:** Bi-encoder HNSW (top-50 in ~3ms) → cross-encoder re-ranker (top-3 in ~80ms). Confidence gate at 0.65. OS/version pre-filter prevents stale memories.
+**Two-stage retrieval:** Bi-encoder HNSW (top-50 in ~3ms) → cross-encoder re-ranker (top-3 in ~80ms). Confidence gate at 0.65. OS/version pre-filter prevents stale memories. Staleness half-life is **per application category** (web 30d · desktop productivity 90d · CLI 365d), not a uniform threshold. *(All latencies are projections pending the §6.1 retrieval benchmark.)*
 
-**Working memory update:** deviation from the retrieved memory is tracked per step. Three consecutive steps with deviation score > 0.4 triggers re-retrieval or new memory creation.
+**Working memory update:** deviation from the retrieved memory is tracked per step via after-frame similarity. Three consecutive steps with deviation score > 0.4 triggers re-retrieval or new-memory creation.
 
-**New memory creation:** on task success in the generalisation path, the full execution trajectory is compiled into a new `memory.md` and added to the library — growing it endogenously each cycle.
+**New memory creation:** on task success in the generalisation path, the full execution trajectory is compiled into a new `memory.md` (`pending_review = true`) and added to the library — growing it endogenously each cycle.
 
 <div align="center">
 
@@ -139,29 +171,124 @@ $R_{\text{spatial}}$ carries the highest weight — spatial precision is the har
 
 ---
 
-## Self-Generated Memory as In-Training Evaluation
+## Self-Generated Memory & Executable Replay Verification
 
-At training checkpoints, the model produces its own `memory.md` through live CUA sessions. This gives four diagnostic signals without any external benchmark:
+At training checkpoints, the model produces its own `memory.md` through live CUA sessions — a multi-dimensional evaluation signal without any external benchmark. The load-bearing safeguard is that **no self-generated memory enters training on the strength of model-derived scores alone**:
+
+> **Executable replay verification (judge-independent ground truth).** Every candidate memory is *replayed* — its steps executed in a sandboxed OS by the actuation layer, and its terminal state checked by a *programmatic* task validator (file existence/content, application settings, accessibility-API state). The replay verdict is a function of OS state, not of any learned scorer, and is a **hard gate**: a memory can be retrievable, but it cannot enter the training corpus without a passing replay.
+
+The VLM-derived signals below are retained as diagnostics but are never the sole basis for recycling data into training:
 
 | Signal | Detects | Threshold |
 |---|---|---|
-| MinHash LSH similarity to training memories | Overfitting | > 0.85 flags verbatim reproduction |
-| Step count completeness + causal connective density | Underfitting | Monitored across training |
+| Executable replay pass | Task actually completed (not a look-alike final state) | Binary hard gate |
+| MinHash LSH similarity to training memories, **OOD tasks only** | Overfitting (verbatim reproduction on novel tasks) | > 0.85 flags; track $G_{\text{gap}} = \overline{\text{sim}}_{\text{in-dist}} - \overline{\text{sim}}_{\text{OOD}}$ |
+| Reasoning depth (causal-connective density + step completeness) | Underfitting | Monitored across training |
 | Entity overlap: reasoning vs at/after frames | Context-awareness | > 0.75 average |
-| Step count ratio < 1.0 vs human baseline | Super-human performance | Flagged for human review |
+| Step-count ratio < 1.0 + $R_{\text{outcome}} > 0.85$ + procedure completeness | Super-human performance | All three → mandatory human review |
+
+**Self-training collapse safeguards:** recycled self-generated memories are capped at 25% of any pre-training cycle; a frozen, never-retrained judge holdout raises a reward-drift alarm if acceptance scores climb without a matching replay-pass improvement; and replay verification gates every recycled memory.
+
+---
+
+## Pre-Registered Experiments
+
+The paradigm's value is stated as contingent on experiments whose designs are fixed here in advance.
+
+### Minimum-cost first test — the memory-conditioned SFT ablation (§5.3)
+
+The full paradigm requires pre-training, RL, and a retrieval stack. The Format Consistency Hypothesis, however, admits a **minimum-cost first test that needs none of them** — and the paper commits to it as the first empirical milestone.
+
+| | |
+|---|---|
+| **Backbone** | Qwen2-VL-2B-Instruct (GQA, dynamic resolution, 32K native), LoRA — a single 24–48 GB GPU |
+| **Corpus** | the ≈100-session Phase-1 set, task-clustered so every session has a cross-session partner or a declared singleton — [released](https://huggingface.co/datasets/NullVoider/Memory-Archive-Paradigm) and instantiated at 101 sessions |
+| **Split** | by **task cluster**, never by session (≈80 train / 20 held-out — the recommended scale; the released corpus resolves to 36 clusters, supporting small-scale runs), verified cross-split MinHash similarity < 0.85 |
+| **Conditions** | **B+mem** (Formulation B, cross-session memory in context, 10–20% corruption) vs. **B−mem** (identical in every respect except the memory block is removed); 3 seeds each |
+| **Decision rule** | hypothesis survives iff **B+mem exceeds B−mem on held-out next-action accuracy by ≥ 3 pp** *and* a paired permutation test ($\alpha = 0.05$, two-tailed, $10^4$ permutations) rejects the null |
+| **Cost** | six runs of a few GPU-hours each — roughly a weekend on one GPU |
+
+**Validity threats checked before believing any result:** split leakage (controlled by the cross-split similarity check); winning by *transcription* (if the corrupted-step override rate is ≈0%, the model is copying memories, not learning to use them — the win does not support the hypothesis); and floor effects (if both conditions are at floor on held-out clusters, the corpus is too small and the experiment is *uninformative*, not negative).
+
+> This ablation is the direct motivation for the Memory Archive corpus-capture effort. That capture is now complete: **101 annotated sessions across 36 task clusters** (see [The Corpus](#the-corpus)) are the substrate this first falsification test runs on. The ≈80/20 cluster split is the recommended scale for the confirmatory run — task clusters, not sessions, are the exchangeable unit of the permutation test, so the held-out cluster count sets the attainable power. The released corpus resolves to 36 clusters, since ≈100 sessions yield fewer clusters than sessions whenever the same task is recorded across several modalities or operating systems, and therefore supports a small-scale run rather than the powered test.
+
+### Full three-condition protocol (§5.1)
+
+- **Condition A** (full paradigm): format-consistent pre-training → memory-conditioned SFT → memory-adherence RL → retrieval at inference.
+- **Condition B** (standard): same base model, no `memory.md`, screenshot/action SFT, outcome RL, zero-shot inference.
+- **Condition C** (retrieval-only): trained as B, memory retrieval added at inference only.
+
+**Expected result: A > C > B.** A-vs-C isolates the additional value of format-consistent *training*; C-vs-B isolates inference-only retrieval value. The design is paired (every task under every condition), analysed with a Wilcoxon signed-rank / paired permutation test on per-task differences, Bonferroni-corrected across the three nulls, powered at $N \approx 90$ tasks stratified across OSWorld categories. All comparisons are **reported stratified by retrieval hit/miss**, with the pre-registered prediction that the effect concentrates on retrieval hits — a flat hit/miss profile would indicate the improvement comes from something other than the hypothesised mechanism.
+
+---
+
+## Inference Efficiency — TurboQuant
+
+The inference KV cache has two unusually demanding properties: the context grows continuously as each step appends before/at/after image encodings, and the retrieved `memory.md` head is never evicted. **TurboQuant** (training-free, model-agnostic online vector quantization) is applied at two points, inference-only:
+
+- **KV-cache compression:** 16-bit → ~3.5 bit/element, a **~4.6× reduction**, raising the concurrent-session ceiling on an 80 GB GPU (e.g. ≈21 → ≈98 sessions for a GQA 7B backbone). It relieves memory *capacity*, not context length.
+- **Retrieval-index compression:** the HNSW vector payload compresses **~9.1×** (FP32 → 3.5-bit); end-to-end index compression is roughly half that once the uncompressed graph-link structure is counted.
+
+An open empirical question (§7.1.1): annotated mouse at-frames concentrate KV energy in a spatially bounded region and may present a non-isotropic component that TurboQuant's rotation does not fully whiten — monitoring $R_{\text{spatial}}$ before/after activation is the required check before production deployment.
 
 ---
 
 ## Comparison with Existing CUA Approaches
 
+Scored on a formal, symmetric **Format Consistency** metric — the fraction of a fixed five-field artifact inventory structurally preserved from training to inference (half-credit where an artifact exists at only one end of the boundary). The Memory Archive row reflects **design intent** (no trained checkpoints); every baseline row describes a published, evaluated system.
+
 | System | Process Labels | Memory at Inference | Format Consistency |
 |---|---|---|---|
-| Behavioral Cloning | None | None | Low |
-| UI-TARS / OpenCUA-32B | Synthetic CoT | None | Medium |
-| ICAL | VLM-abstracted | Retrieved (implicit) | High |
-| HyMEM | None | Graph-structured | Medium |
-| SkillRL | Distilled skills | Hierarchical skills | Medium |
-| **Memory Archive** | **VLM-gen + human cal** | **`memory.md` (same as training)** | **High — all stages identical** |
+| Behavioral Cloning | None | None | Low (0/5) |
+| UI-TARS / OpenCUA-32B | Synthetic CoT | None | Medium (2/5) |
+| UI-R1 | None | None | Low (1/5) |
+| ICAL | VLM-abstracted | Retrieved (implicit) | Medium–High (3.5/5) |
+| HyMEM | None | Graph-structured | Medium (1.5/5) |
+| SkillRL | Distilled skills | Hierarchical skills | Medium (1.5/5) |
+| **Memory Archive** | **VLM-gen + human cal** | **`memory.md` (same as training)** | **High (5/5) — by design, untrained** |
+
+**What the strongest counter-arguments get right (owed concessions):** ICAL's abstraction is a *robustness choice* — compressing trajectories into causal programs deliberately discards the per-step pixel coordinates Memory Archive preserves; whether pixel-level grounding (with augmentation and staleness control) beats abstraction is an open empirical question. HyMEM's graph structure addresses task composition, which Memory Archive defers to §6.5 as an open problem. Table 5 legitimately claims a *hypothesis* about format consistency, backed by the pre-registered tests — not a win.
+
+**Broader lineage:** the retrieval-and-reuse core has substantial precedent — Agent Workflow Memory (text-only workflow induction), Synapse (trajectory-as-exemplar), Agent S (web + episodic memory for GUI control), Voyager (self-generated, verified, retrieved skills in an embodied domain), and Reflexion (self-generated textual memory as a learning signal). Memory Archive's distinguishing commitments are narrower than "memory at inference": (1) the memory object is a first-class artifact at *every training stage*; (2) memories carry per-step visual grounding (at-frame references and click coordinates); (3) memory adherence and override are explicit RL training signals.
+
+---
+
+## Open Problems (§6)
+
+Stated as engineering/research prerequisites, not deferred nice-to-haves:
+
+- **Retrieval accuracy benchmark (critical)** — precision@1, recall@5, false-positive rate across task/OS/version filter axes; required before deploying retrieval at all.
+- **Memory versioning & staleness (high)** — `validity_env` metadata, compatibility pre-filtering, an $R_{\text{outcome}}$-divergence staleness detector.
+- **VLM reasoning quality & human–VLM consistency (high)** — the VLM is the primary annotation source, so its hallucination/step-conflation/vocabulary-drift is a *precondition*, not a deferred question.
+- **Actuation schema drift (high)** — CommandEvent schema changes partially misalign existing data; needs version pinning + a migration pipeline.
+- **Memory composition (medium)** — sequential chaining vs. hierarchical decomposition vs. cross-linked composition for multi-memory tasks.
+- **Auto-generated memory quality gate (medium)** — two judge-independent hard gates (replay, novelty) plus a graded composite acceptance score.
+- **Continual learning & memory consolidation (medium)** — merging new sessions into existing memories rather than always creating new ones.
+
+---
+
+## The Corpus
+
+The corpus this paradigm is built on has been captured and finalised. It is the empirical artifact of this work — every session recorded through the instrumentation described above, against live desktop environments rather than simulated ones.
+
+| | |
+|---|---|
+| **Sessions** | 101, all fully annotated (annotation density 1.00) |
+| **Operating systems** | macOS 52 · Windows 49 |
+| **Task clusters** | 36 |
+| **Annotated steps** | 884 |
+| **Per step** | before / at / after frames, actuation record, reasoning annotation |
+| **Per session** | compiled `memory.md`, actuation command files, `metadata.json` |
+
+Sessions are paired for cross-session retrieval: 51 *cross-procedure* pairs (same task, different route), 38 *cross-environment* pairs (same task, different OS or interaction modality), and 12 declared singletons that use the cold-start partial-memory path.
+
+The **task-twin** design is the corpus's distinguishing property — the same job is recorded across GUI and terminal modalities, and across macOS and Windows, so a memory compiled from one modality can be evaluated as retrieval context for its twin.
+
+The corpus is publicly available on the Hugging Face Hub under CC BY-NC 4.0, recorded and annotated by the author using the Memory Archive collection system. Reasoning annotations in this release were authored through the human annotation mode, no VLM Reasoning Model was used in the annotation; every step label is human-authored.
+
+👉 **[huggingface.co/datasets/NullVoider/Memory-Archive-Paradigm](https://huggingface.co/datasets/NullVoider/Memory-Archive-Paradigm)**
+
+Sessions live under `data/sessions/<task-name>/`, each carrying `memory.md`, `metadata.json`, `commands/`, `reasoning/`, and `vision/` — the full artifact set of Table 1 in the paper.
 
 ---
 
@@ -173,6 +300,14 @@ The data collection system that generates the training corpus described in this
 
 ---
 
+## Limitations and Scope
+
+The Memory Archive training paradigm presented here **has not been trained end-to-end**. The scope disclaimer covers not only the numerical hyperparameters — reward weights ($\alpha=0.3,\ \beta=0.4,\ \gamma=0.3$), GRPO group size ($G=8$), LoRA rank and learning rates, token loss weights, data mixing ratios, PRM calibration weights, retrieval thresholds ($\text{conf}=0.65,\ \text{dev}=0.4$), and staleness periods — **but equally every performance figure**: the SFT/RL targets, the retrieval recall and latency figures, the OSWorld variance planning value, and the phase-scale minimums. All are design recommendations and projections derived from principled reasoning and analogous published systems. None has been validated on any Memory Archive training run; each should be treated as a starting point requiring held-out validation before production use.
+
+Validation milestones, in order of cost: **first**, the pre-registered memory-conditioned SFT ablation (§5.3) — a weekend of compute on the Phase-1 corpus, testing the format-prior component directly; **second**, a small-scale pre-training experiment on a 1B–3B VLM; **third**, the full three-condition protocol (§5.1).
+
+---
+
 ## Citation
 
 ```bibtex
@@ -182,16 +317,23 @@ The data collection system that generates the training corpus described in this
   author       = {Kartik A.},
   year         = {2026},
   howpublished = {Project Dockyard},
-  doi          = {10.5281/zenodo.20176599},
-  note         = {Independent Research. Preprint available at Zenodo:
-                  \url{https://doi.org/10.5281/zenodo.20176599}}
+  doi          = {10.5281/zenodo.22079081},
+  note         = {Independent Research. Design specification and
+                  pre-registered protocol. Preprint available at Zenodo:
+                  \url{https://doi.org/10.5281/zenodo.22079081}}
 }
 ```
 
 ---
 
+## Acknowledgements
+
+I acknowledge Anthropic's Claude for assistance during the research and conceptualisation phase of this work. Both Claude and Google's Gemini provided support in debugging, formatting, and typesetting the final LaTeX manuscript.
+
+---
+
 ## License
 
 This work is licensed under the [CC-BY-NC 4.0](LICENSE).
 
-© 2026 Kartik A. · Project Dockyard
+© 2026 Kartik A. · Project Dockyard

memory_archive_paradigm.pdf

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:29a6f0cd06aa477d1eebe8f3e997796351d7ccd425956950b85ccc19432b7b49
-size 1270702
+oid sha256:04f3cf286946d64dba8e0d36393b683f65664850c9f4517fff36be910fdea9bc
+size 1373242