docs: add bilingual repository summary and topics

.gitattributes

@@ -5,3 +5,4 @@ artifacts/**/*.tar.zst filter=lfs diff=lfs merge=lfs -text
 artifacts/lfs-smoke/*.bin filter=lfs diff=lfs merge=lfs -text
 artifacts/public-resources-20261001/**/payload-*.bin filter=lfs diff=lfs merge=lfs -text
 artifacts/public-resources-20261001/**/*.jsonl.gz filter=lfs diff=lfs merge=lfs -text
+artifacts/acceleration-20261001/*.tar.zst filter=lfs diff=lfs merge=lfs -text

CURRENT.md

@@ -1,8 +1,29 @@
 # Digital Drosophila — 当前状态
 
-更新：2026-10-01。独立分支：`codex/lif-author-semantics-lab`。
+更新：2026-10-01。统一成果入口：`main`。
 
-## 最新状态（取代下方历史摘要的“当前／下一步”表述）
+## 仓库整理（不是科学实验）
+
+CPU/GPU 加速成果与公开 LFS 资源按保留双亲的合并历史整合到 `main`。旧 7 个分支先按精确 SHA 创建 `archive/2026-10-01/*` 标签，再核验并清理远端分支；不改旧工作树、不修改已封存数据或模型。完整映射见[分支说明](docs/40-operations/branches-20261001.md)，执行结果以 `registry/branch-consolidation-20261001/` 的实际回执为准。
+
+历史 registry 文档保留原字节，其旧分支恢复命令由[统一恢复指南](docs/30-reproducibility/main-restore.md)取代。
+
+## 最新状态：暂停研究，CPU/GPU 两套方案保留
+
+用户要求保存并上传现有成果，以后再继续。没有恢复训练、没有启动新实验，没有切换正式科学实现。
+
+- Phase 4AR 按真实已提交账本停在 **1,033/30,000 轮训练及 CPU 校验、138/3,920 probes**；末个未完成提交不算完成，也不自动重试。
+- 原科学登记 SHA 为 `b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740`，注册源码为 `80aeb2093db655329774eff7b32fb6e417b8b40b`。
+- CPU 原方案、独立 CPU 校验和常驻进程方案全部保留；GPU eligibility/update 原型在两张 V100 与 4090 的固定回放上通过逐位比较，没有替换原 CPU 代码。
+- 全脑常驻回放保持原 4090 环境、原始数学与 fresh state，42/42 次逐位一致。13 组稳态配对：原运行函数中位 5.9825 → 3.7222 秒，配对倍率中位 1.6201×；不是整轮训练加速，也不是学习成功。
+- 原实验 64,034 文件/16 源码、前一轮 659 产物/13 源码均保持一致。完整历史 Phase 1–4AQ 没有重跑。
+- 公开原始/参考数据已在独立 LFS 发布分支保存；本次另保存 CPU/GPU 科学回放结果，不包含环境、编译缓存或未确认许可的软件包。
+
+[CPU/GPU 方案、结果、恢复与限制](registry/acceleration-20261001/README.md) · [为什么有多个分支](docs/40-operations/branches-20261001.md)
+
+以下全部是历史状态，不能据此恢复任务或认为仍在运行。
+
+## 2026-10-01 00:09 的历史快照（已被上文停止状态取代）
 
 Phase 4AQ 已封存为 **PASS-EXACT-UPDATED-BOUNDARY-ENGINEERING-NOT-LEARNING**。Phase 4AR 的普通嗅觉 acquisition 已登记并启动，仍在执行；学习成功尚未判定，没有新 learned candidate。
 

README.md

@@ -1,11 +1,23 @@
 # Digital Drosophila / MaleCNS 全脑模型研究
 
+<!-- repository-metadata:start -->
+**中文简介**：围绕连接组、神经动力学与可塑性的数字果蝇研究。
+
+**English summary**: Digital fruit-fly research covering connectomics, neural dynamics and plasticity.
+
+| 中文标签 | English topic |
+| --- | --- |
+| 研究 | `research` |
+| 连接组 | `connectomics` |
+| 神经仿真 | `neural-simulation` |
+<!-- repository-metadata:end -->
+
 面向 MaleCNS v1.0 的可审计连接组、LIF 模型、感觉接口与局部可塑性机制研究。
 **这是研究工程仓库，不是已经实现自主学习或游戏控制的果蝇。**
 
-截至 2026-10-01 00:09（Asia/Shanghai），最新封存阶段是 **Phase 4AQ：PASS-EXACT-UPDATED-BOUNDARY-ENGINEERING-NOT-LEARNING**。
-**Phase 4AR 普通嗅觉 acquisition 正在执行，科学结论未判定**：采样时已提交 411/30,000 轮训练及 CPU 校验、62/3,920 次独立 probe；不是实时自动更新计数。
-最新研发分支为 `codex/lif-author-semantics-lab`，远端默认分支仍为初始化分支。本页状态不表示已完成分支合并。
+截至 2026-10-01，最新正式封存科学阶段仍是 **Phase 4AQ：PASS-EXACT-UPDATED-BOUNDARY-ENGINEERING-NOT-LEARNING**。
+**Phase 4AR 已按用户要求停止，暂不恢复**：已提交 1,033/30,000 轮训练及 CPU 校验、138/3,920 次独立 probe；执行尚未完成，学习成功未判定。
+统一入口为 **`main`**，包含注册科学代码、CPU/GPU 两套方案及已公开的 LFS 数据。7 个旧分支的精确版本通过 `archive/2026-10-01/*` 标签保留，见[分支与恢复说明](docs/40-operations/branches-20261001.md)。这次只是仓库整理，不是生产运行时升级，也没有恢复训练。
 项目顶层验收口径为 **5/10（50%）**；这不是生物学逼真度、工作量完成率或剩余工期。
 最新正式候选运行时为 `MaleCNS-LIF-runtime-v2-deterministic-candidate`。
 `MaleCNS-TemporalEligibility-v2-candidate` 与 `MaleCNS-OlfactoryEncoder-v1-candidate` 保留。
@@ -15,13 +27,13 @@
 
 | 主题 | 文档 |
 |---|---|
-| 最新运行状态、证据与下一步 | [当前状态](CURRENT.md)、[本次同步说明](docs/progress/repository-sync-20261001.md) |
+| 最新运行状态、证据与下一步 | [当前状态](CURRENT.md)、[CPU/GPU 保存说明](registry/acceleration-20261001/README.md) |
 | 顶层验收比例与历史基线 | [项目状态](docs/00-overview/status.md) |
 | 目录和数据流 | [架构与目录](docs/00-overview/architecture.md) |
 | 科学数据定义和来源 | [数据契约](docs/10-data/data-contract.md)、[来源登记](docs/10-data/provenance.md) |
 | 模型边界 | [模型与冻结契约](docs/20-model/baseline.md) |
 | 论文、引用与证据用途 | [参考文献入口](references/README.md)、[证据边界](references/evidence-map.md) |
-| 环境与复现 | [环境](docs/30-reproducibility/environment.md)、[恢复](docs/30-reproducibility/restore.md) |
+| 环境与复现 | [环境](docs/30-reproducibility/environment.md)、[统一恢复入口](docs/30-reproducibility/main-restore.md) |
 | Git 同步、大数据备份与安全 | [同步说明](docs/40-operations/git-sync.md)、[备份](docs/40-operations/backup.md) |
 | 每个阶段的原始证据副本 | [阶段索引](registry/catalog-20260929/stages.json) |
 | 全部科学文件路径/大小/SHA-256 | [快照说明](registry/README.md) |
@@ -38,17 +50,17 @@
 
 服务器项目根目录：`/data/digital-drosophila/`。
 远程：`ssh://git@192.168.10.31:2222/qishizhe/digital-drosophila.git`。
-初始化／当前远端默认分支：`codex/project-bootstrap`；最新研发分支：`codex/lif-author-semantics-lab`。
+统一主分支：`main`。历史版本由归档标签保留；原注册科学源码仍固定为 `80aeb2093db655329774eff7b32fb6e417b8b40b`，不随主分支移动。
 
 Git 保存源代码、配置、文档、书目、阶段证据副本和逐文件哈希清单。
-**Git 不保存原始 SWC/Feather、CSR、完整事件/状态、模型 checkpoint、虚拟环境或大型压缩包。**
+普通 Git 不直接保存大型科学二进制。**Git LFS** 保存获准公开再分发的原始/参考数据，以及本次 CPU/GPU 回放结果；两套原归档指针均原样整合到 `main`。没有上传虚拟环境、SDK 编译缓存、凭据或其他服务的数据。
 原项目实占约 29.72 GB（十进制、初始化前统计），不会因为初始化 Git 被删除、搬移或重写。
-仅 clone 本仓库不能恢复全数据；按[恢复说明](docs/30-reproducibility/restore.md)配置单独的数据副本。
+只取得 Git pointer 不能恢复全数据；需按[统一恢复指南](docs/30-reproducibility/main-restore.md)下载所需 LFS 对象并验证内部成员。已封存报告中的旧分支命令仅作历史记录；不要据此重新运行实验。这不是全服务器灾备。
 
 ## 安全的首次检查
 
 ```bash
-git clone --branch codex/lif-author-semantics-lab ssh://git@192.168.10.31:2222/qishizhe/digital-drosophila.git
+GIT_LFS_SKIP_SMUDGE=1 git clone --branch main ssh://git@192.168.10.31:2222/qishizhe/digital-drosophila.git
 cd digital-drosophila
 python3 -B tools/repo_guard.py
 ```

docs/30-reproducibility/main-restore.md

@@ -0,0 +1,43 @@
+# 从 main 恢复代码和已发布数据
+
+这是新的统一入口。已封存 `registry/publication-20261001/` 和 `registry/acceleration-20261001/` 文档保持原字节，其中旧分支名称是历史记录；当前应 clone main，或使用 `archive/2026-10-01/*` 精确标签。
+
+## 先获取轻量代码
+
+```sh
+GIT_LFS_SKIP_SMUDGE=1 git clone --branch main \
+  ssh://git@192.168.10.31:2222/qishizhe/digital-drosophila.git digital-drosophila-restore
+cd digital-drosophila-restore
+git lfs install --local
+```
+
+不要 clone 到已存在的 `/data/digital-drosophila`，不要运行封存阶段的生成脚本。首次 clone 跳过 LFS，避免意外下载约 9.9 GB 的全部发布对象。
+
+## 按需获取
+
+CPU/GPU 回放约 76.4 MB：
+
+```sh
+git lfs pull --include='artifacts/acceleration-20261001/**' --exclude=''
+python3 -B tools/acceleration-publication/archive_results.py verify
+```
+
+官方/参考数据：
+
+```sh
+git lfs pull --include='artifacts/public-resources-20261001/**' --exclude=''
+python3 -B tools/lfs-publication/publish_archives.py verify \
+  --group-dir artifacts/public-resources-20261001/malecns-swc
+```
+
+对需要的每组分别 verify。8 组原数据的来源、许可、组名和原始验证记录见 `registry/publication-20261001/README.md`。仅获取一个组时，可将 include 缩小到该组路径。
+
+main 保留 **181 个 artifacts Git 路径、171 个 LFS pointer 路径**，其中包含成员/排除清单等 LFS 文件，不是 171 个模型。原始/参考资源含 226,859 个内部文件；两份性能回放归档含 1,680 个内部文件。没有重打包、修改 OID 或重新上传原数据。
+
+## 重要边界
+
+- Git 指针不是数据本体；只有下载并验证过的对象才能当作已恢复。
+- CPU/GPU 回放包不是完整 Phase 4AR 训练现场备份；全 E/AQ 与脑回放仍依赖外部原始 checkpoint、请求、静态 bundle 和固定科学源码。完整依赖由保存的 source pins 描述。
+- 旧目录级 manifest 可能包含有意未公开的编译缓存。性能归档应使用 `publication-catalog.json` 验证；不能把缓存缺失说成科学数据损坏。
+- 不要求内网专用 transfer adapter 才能读取标准 LFS 对象。服务器上已有的 LAN adapter 只解决特定网络路径，不应复制其本机绝对路径到别的电脑。
+- 不覆盖 raw、Phase 1–4AQ 及独立性能封存文件；不自动恢复训练、升级模型或启动后续实验。

docs/40-operations/branches-20261001.md

@@ -0,0 +1,47 @@
+# 分支整理与历史恢复
+
+2026-10-01 用户明确确认：统一 `main`，先标签归档并验证可恢复，再清理旧远端分支。服务器已有工作目录保持原样。
+
+## 日常入口
+
+只使用 `main` 查看最新代码、CPU/GPU 方案、文档及 LFS 归档。数据、实验结果仍保留原有科学版本；仓库合并不等于模型升级或学习成功。
+
+旧阶段不再长期占用远端分支列表，改为以下 **带说明、约定不重写的归档标签**。标签保留的 Git 提交、科学源码、LFS OID/size 均不变；此处“不重写”是维护规则，不宣称服务器已强制开启标签保护。
+
+| 旧分支（原均带 codex/） | 归档标签（前缀 archive/2026-10-01/） | 精确提交 |
+|---|---|---|
+| project-bootstrap | project-bootstrap | `3981628ff893132a8148668aa94726886dba57a3` |
+| apl-pn-scope-audit | apl-pn-scope-audit | `d6843e675dec5ae38a06f2ba70d74836aea53ace` |
+| terminal-scope-diagnostic | terminal-scope-diagnostic | `3213aada793740961885ba525494e95f019be6f8` |
+| lif-semantics-audit | lif-semantics-audit | `5008cd85ca11750f23ce7bc001e8e821763b7501` |
+| lif-author-semantics-lab | lif-author-semantics-lab | `09187e4d4d67badf1b418c5f211258ca5d8fb328` |
+| lfs-public-resources | lfs-public-resources | `5b1d1b72d7683b5c3dcc1f78b408e1d9dd2832ac` |
+| v100-conditioning-acceleration | v100-conditioning-acceleration | `4436241976887d8cc10088b0d44bc7ed70978fe6` |
+
+前五个是线性历史链，后两条从 `09187e4` 分出。本次保留双亲合并而非 squash/rebase，所有旧提交仍可追溯。
+
+远端分支删除不删除 Git 提交或 LFS 对象，历史版本由标签继续引用。执行记录在 `registry/branch-consolidation-20261001/`；清理须在归档标签实际远端核验、main 上传与默认入口切换后进行。
+
+## 不动服务器科学现场
+
+- `/data/digital-drosophila` 仍停在原本地科学分支和 `09187e4`；不 checkout main，不 pull/merge，不重试 AR。
+- `/home/qishizhe/digital-drosophila-v100-acceleration` 保留独立实验原工作树。
+- 旧本地分支保留；远端同名分支移除后，不应从这些冻结工作树重新 push 旧分支。
+- 后续开发从新的 main clone 开始。原 Phase 4AR 仍停止于 1,033 轮已 CPU 校验训练、138 probes，科学结论未判定。
+
+## 恢复指定历史版本
+
+在新的空目录获取，而不是覆盖原科学目录：
+
+```sh
+GIT_LFS_SKIP_SMUDGE=1 git clone --branch archive/2026-10-01/v100-conditioning-acceleration \
+  ssh://git@192.168.10.31:2222/qishizhe/digital-drosophila.git digital-drosophila-history
+```
+
+clone tag 会得到 detached HEAD，这是只读查看历史的正常状态。原始资源归档对应 `archive/2026-10-01/lfs-public-resources`。
+
+如以后确需恢复旧分支，可在新 clone 中从对应 tag 创建分支；需用户再次授权推送，避免重新制造已整理的远端分支。
+
+## 今后的规则
+
+`main` 是统一入口；短期开发使用 `codex/<task>`。工作完成、通过相应验收后合并，重要节点打标签。实验失败同样保留报告与标签，不通过删除失败证据整理仓库。任何受保护科学输入/产物仍遵循原冻结契约。

models/male-cns-lif/conditioning-acceleration-v1/PROTOCOL.md

@@ -0,0 +1,31 @@
+# Conditioning acceleration v1 — independent engineering benchmark
+
+Authority: user requested V100 acceleration and algorithm optimization on 2026-10-01. This work DOES NOT resume or change Phase 4AR, and does not authorize a new 30,000-epoch scientific experiment.
+
+## Frozen scientific semantics
+
+Preserve original Phase 4J/AM eligibility, compartment mapping, the complete candidate mask, anatomical base weights, float32 update semantics, all time steps and original event ordering. No threshold/gain/eta/tau/sign change, reduced trial count claim, surrogate gradients, skip-time power approximation, new connections or model learning claim. GPU outputs are diagnostic replay products only and are never installed into a brain.
+
+The oracle is the exact SHA-pinned original Torch CPU update running in the original science environment. Candidate CuPy CUDA code runs in a separate environment with NumPy 2.2.6 and CuPy 13.6.0, using the installed CUDA 12.6 toolkit. Do not modify the original environment, ComfyUI or frozen source files.
+
+## Fixed validation and measurement plan
+
+Select the first and last fully ledger-committed training task for each observed arm by deterministic task-ID order, without inspecting learning scores. This is coverage of available saved inputs only, not all registered conditions. Export fixed original inputs and recomputed CPU reference outputs into a new directory; compare them with the saved scientific outputs before use.
+
+Compare all sampled traces, final traces and local delta arrays byte-for-byte against the original CPU oracle on both physical V100s and the 4090. Add synthetic edge cases: no spikes, non-KC spikes, no US, US at zero/final tick, duplicate/invalid events rejection, multiple US snapshots for trace-only API, saturation, D=0, frozen identity, all compartments, and seeded sparse/random traces. Do not select only passing cases. Any mismatch blocks promotion.
+
+Use 3 warmups and 20 timed repeats for every real fixture on each GPU, with the same fixture order. Record first-use compilation/context cost separately, CPU preparation, transfer-inclusive host wall time, kernel event time, GPU identity, memory and exact software/source hashes. Repeat within a resident process to expose avoidable per-process overhead. Never present kernel-only speedup as full training speedup.
+
+Budget: at most 15 minutes of candidate benchmark execution after dependencies/compilation, one process per GPU initially; do not occupy a GPU with a nonempty ComfyUI queue or evict services. No automatic scientific retry. Implementation failures may be diagnosed and corrected in new benchmark attempts, retaining earlier reports. No modification of any frozen experiment. Independent CPU verification remains required before any future production integration.
+
+## Gate and limits
+
+Passing this benchmark means only ELIGIBILITY-UPDATE-REPLAY-EQUIVALENCE for the tested inputs. It does not establish full-brain event equivalence, end-to-end acceleration, learning success, resumability, or completion of Phase 4AR. Integration, persistent brain workers and independent-seed multi-GPU scheduling require separately validated execution/audit changes. Stop before installing any update or starting learning.
+
+Keep source, configuration, environment installation report, fixed input manifest, raw timing samples, comparisons, failures and SHA-256 manifest. Check Phase 4AR registration/source and the prior saved-file inventory before/after; report the exact scope (not a new Phase 1–4AQ numerical regression).
+
+## Recorded implementation correction (before successful GPU execution)
+
+The first candidate installation attempted pip's `--report` with the new venv's inherited pip 22.0.2, which does not support it. Only the candidate venv was upgraded to pip 25.2; both logs remain preserved.
+
+GPU attempt `v100a-01` failed before running kernels because CuPy 13.6's RawKernel cache compiler appends `-ftz=true`, conflicting with the required `--ftz=false`. Do not remove the precision requirement. The corrected candidate compiles the same CUDA recurrence with installed nvcc 12.6, explicit separate rounding and `--ftz=false`, then loads the precompiled module through CuPy. Compiler commands, sources, output and binary hashes are preserved in candidate-only caches. The original scientific recurrence and all predeclared fixtures remain unchanged; failed attempt records are not replaced.

models/male-cns-lif/conditioning-acceleration-v1/audit_integrity.py

@@ -0,0 +1,49 @@
+"""Read-only rehash of the saved Phase4AR shutdown inventory and registered sources."""
+import argparse
+from datetime import datetime, timezone
+import hashlib
+import json
+from pathlib import Path
+import subprocess
+import time
+
+INVENTORY = Path('/home/qishizhe/phase4ar-user-shutdown-20260930T203113Z/saved-files.sha256.jsonl')
+INVENTORY_SHA = 'd7b675b0d0d4647d8fe2fcf9616b9a599e5bc3c15565e604e0d66a046afb835a'
+REG = Path('/data/digital-drosophila/experiments/phase4ar-normal-conditioning/protocol/preregistered.json')
+REG_SHA = 'b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740'
+
+def sha(path):
+    h = hashlib.sha256()
+    with Path(path).open('rb') as f:
+        for chunk in iter(lambda: f.read(8 << 20), b''): h.update(chunk)
+    return h.hexdigest()
+
+p = argparse.ArgumentParser()
+p.add_argument('--output', type=Path, required=True)
+a = p.parse_args()
+assert not a.output.exists() and a.output.parent.is_dir()
+start = time.perf_counter()
+assert sha(INVENTORY) == INVENTORY_SHA and sha(REG) == REG_SHA
+records = [json.loads(line) for line in INVENTORY.read_text().splitlines()]
+differences = []
+for row in records:
+    path = Path(row['path'])
+    if not path.is_file() or path.stat().st_size != row['bytes'] or sha(path) != row['sha256']:
+        differences.append(str(path))
+reg = json.loads(REG.read_text())
+source_mismatches = [path for path, expected in reg['source_sha256'].items() if sha(path) != expected]
+head = subprocess.check_output(['git', '-C', '/data/digital-drosophila', 'rev-parse', 'HEAD'], text=True).strip()
+status = subprocess.check_output(['git', '-C', '/data/digital-drosophila', 'status', '--porcelain'], text=True)
+summary = dict(status='PASS' if not differences and not source_mismatches and status == '' else 'FAIL',
+    created_utc=datetime.now(timezone.utc).isoformat(), files_checked=len(records),
+    bytes_checked=sum(r['bytes'] for r in records), inventory_sha256=INVENTORY_SHA,
+    registration_sha256=REG_SHA, registered_science_commit=reg['source_code_commit'],
+    sources_checked=len(reg['source_sha256']), file_mismatches=differences,
+    source_mismatches=source_mismatches, original_git_head=head, original_git_status=status,
+    wall_seconds=time.perf_counter()-start,
+    scope='Saved Phase4AR experiment/control files and registered source files; NOT a new Phase1-4AQ numerical regression',
+    training_epochs_cpu_verified_unchanged=1033, probes_completed_unchanged=138,
+    original_experiment_resumed=False)
+with a.output.open('x') as f: json.dump(summary, f, indent=2)
+print(json.dumps(summary), flush=True)
+raise SystemExit(0 if summary['status'] == 'PASS' else 1)

models/male-cns-lif/conditioning-acceleration-v1/benchmark.py

@@ -0,0 +1,257 @@
+"""Bounded replay benchmark. No brain simulation, training, or weight installation."""
+from __future__ import annotations
+import argparse
+from datetime import datetime, timezone
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import statistics
+import subprocess
+import sys
+import time
+import traceback
+import urllib.request
+
+import numpy as np
+from gpu_backend import CudaEligibility, prepare_events
+
+REG_SHA = 'b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740'
+IDENTITY_KEYS = ('kc', 'candidate_edge_id', 'candidate_sources', 'candidate_targets',
+                 'candidate_compartments', 'base_candidate')
+OUTPUTS = ('sampled_trace', 'final_trace', 'snapshots', 'delta_after')
+
+def sha(path):
+    h = hashlib.sha256()
+    with Path(path).open('rb') as stream:
+        for chunk in iter(lambda: stream.read(8 << 20), b''):
+            h.update(chunk)
+    return h.hexdigest()
+
+def save(path, value):
+    with Path(path).open('x', encoding='utf-8') as stream:
+        json.dump(value, stream, indent=2, sort_keys=True, allow_nan=False)
+        stream.write('\n')
+
+def read(path):
+    return json.loads(Path(path).read_text())
+
+def evidence(a):
+    return dict(dtype=a.dtype.str, shape=list(a.shape), sha256=hashlib.sha256(a.tobytes()).hexdigest())
+
+def contained(root, relative):
+    p = root / relative
+    assert not p.is_symlink() and p.resolve().is_relative_to(root.resolve()), 'Escaping fixture path'
+    return p
+
+def idle_queues():
+    result = {}
+    for port in (8188, 8189, 8190):
+        with urllib.request.urlopen(f'http://192.168.10.51:{port}/queue', timeout=5) as response:
+            q = json.load(response)
+        assert set(('queue_running', 'queue_pending')).issubset(q)
+        result[str(port)] = {key: len(q[key]) for key in ('queue_running', 'queue_pending')}
+        assert not any(result[str(port)].values()), 'ComfyUI has work; benchmark will not compete'
+    return result
+
+def gpu_snapshot(uuid):
+    text = subprocess.check_output(['nvidia-smi', '--id=' + uuid,
+        '--query-gpu=uuid,name,pci.bus_id,memory.total,memory.used,utilization.gpu,driver_version',
+        '--format=csv,noheader,nounits'], text=True).strip()
+    fields = [s.strip() for s in text.split(',')]
+    assert fields[0] == uuid
+    return dict(zip(('uuid', 'name', 'pci_bus_id', 'memory_total_mib', 'memory_used_mib',
+                     'utilization_percent', 'driver_version'), fields))
+
+def stats(values):
+    return dict(n=len(values), min=min(values), median=statistics.median(values),
+                mean=statistics.mean(values), max=max(values))
+
+def compare(result, arrays):
+    report = {}
+    for key in OUTPUTS:
+        actual, expected = getattr(result, key), arrays['reference_' + key]
+        exact = actual.dtype == expected.dtype and actual.shape == expected.shape and actual.tobytes() == expected.tobytes()
+        diff = np.abs(actual.astype(np.float64) - expected.astype(np.float64))
+        report[key] = dict(bitwise_exact=exact, actual=evidence(actual), expected=evidence(expected),
+                           max_abs_error=float(np.max(diff)) if diff.size else 0.,
+                           mean_abs_error=float(np.mean(diff)) if diff.size else 0.)
+    return report
+
+def load_fixtures(manifests):
+    fixtures = []
+    common_identity = None
+    for manifest_path in manifests:
+        m = read(manifest_path)
+        assert m.get('complete') is True and m['registration_sha256'] == REG_SHA
+        root = manifest_path.parent
+        for f in m['fixtures']:
+            npz = contained(root, f['npz'])
+            command_path = contained(root, f['command'])
+            assert sha(npz) == f['npz_sha256'] and sha(command_path) == f['command_sha256']
+            with np.load(npz, allow_pickle=False) as z:
+                a = {k: z[k].copy() for k in z.files}
+            identity = {k: evidence(a[k]) for k in IDENTITY_KEYS}
+            if common_identity is None:
+                common_identity = identity
+            assert common_identity == identity, 'Full KC/mask/base identity differs across fixtures'
+            assert len(a['kc']) == 4064 and len(a['candidate_edge_id']) == 14232
+            sources_path = npz.parent / 'reference-sources.json'
+            assert sha(sources_path) == m['files'][sources_path.relative_to(root).as_posix()]['sha256']
+            source_pins = read(sources_path)
+            expected_sources = dict(
+                conditioning_update_source='96efff678cff910654eb08e86f1a17789e4e5589e340345f419c7027a7d547e2',
+                eligibility_bridge_source='174fb8d14619189e74b095e77a6db18b14c93046dc431c0b55710a5aa2dd2e61',
+                phase4j_source='abb4574da85f00bd9ef61024c65993ef81d42651ff8d8d63c15dd69c6222471e')
+            assert set(source_pins) == set(expected_sources)
+            for role, info in source_pins.items():
+                assert info['sha256'] == expected_sources[role] and sha(info['path']) == info['sha256'], 'Reference source changed'
+            # Extract constants from the authenticated original bridge, without import/exec.
+            import ast
+            bridge = source_pins['eligibility_bridge_source']
+            assert bridge['sha256'] == '174fb8d14619189e74b095e77a6db18b14c93046dc431c0b55710a5aa2dd2e61'
+            constants = {}
+            for node in ast.parse(Path(bridge['path']).read_text()).body:
+                if isinstance(node, ast.Assign):
+                    for target in node.targets:
+                        if isinstance(target, ast.Name) and target.id in ('DT_MS', 'TAU_MS', 'ETA_MV', 'FLOOR_FRACTION', 'POLARITY'):
+                            constants[target.id] = ast.literal_eval(node.value)
+            assert constants['POLARITY'] == -1
+            rule = dict(eta_mv=constants['ETA_MV'], floor_fraction=constants['FLOOR_FRACTION'],
+                        decay=math.exp(-constants['DT_MS'] / constants['TAU_MS']))
+            fixtures.append(dict(group=root.name, record=f, arrays=a, command=read(command_path),
+                                 rule=rule, input_path=str(npz), manifest_sha256=sha(manifest_path)))
+    assert fixtures
+    return fixtures, common_identity
+
+def check_rejections(manifests, backend, rule):
+    reports = []
+    for path in manifests:
+        for case in read(path).get('invalid_cases', []):
+            root = path.parent
+            npz, command = contained(root, case['npz']), contained(root, case['command'])
+            assert sha(npz) == case['npz_sha256'] and sha(command) == case['command_sha256']
+            with np.load(npz, allow_pickle=False) as z:
+                a = {k: z[k].copy() for k in z.files}
+            c = read(command)
+            commands = [] if c['us_tick'] is None else [c['us_tick']]
+            stage = 'prepare'
+            try:
+                prepared = prepare_events(a['step'], a['neuron_idx'], a['kc'], c['steps'], commands,
+                                          n_neurons=c['n_neurons'])
+                stage = 'run'
+                backend.run(prepared, a['candidate_sources'], a['candidate_compartments'],
+                    c['compartment'], a['delta_before'], a['base_candidate'],
+                    d=c['d_command'], frozen=c['frozen'], **rule)
+            except ValueError as error:
+                assert stage == case['stage'], 'Rejected at a different validation boundary'
+                reports.append(dict(case_name=case['case_name'], rejected=True,
+                                    stage=stage, expected_exception=case['expected_exception'], message=str(error)))
+            else:
+                raise AssertionError('Candidate accepted invalid case: ' + case['case_name'])
+    return reports
+
+def main(args):
+    assert os.environ.get('CUDA_VISIBLE_DEVICES') == args.uuid, 'Use one explicit physical UUID per process'
+    assert args.output.is_absolute() and not args.output.exists()
+    args.output.mkdir()
+    started = time.perf_counter()
+    try:
+        queues_before = idle_queues()
+        gpu_before = gpu_snapshot(args.uuid)
+        initial_manifest_pins = {str(p): sha(p) for p in args.manifest}
+        fixtures, common_identity = load_fixtures(args.manifest)
+        backend = CudaEligibility(device_index=0)
+        cp = backend.cp
+        props = cp.cuda.runtime.getDeviceProperties(0)
+        bus = cp.cuda.runtime.deviceGetPCIBusId(0)
+        if isinstance(bus, bytes): bus = bus.decode()
+        assert bus.lower()[-10:] == gpu_before['pci_bus_id'].lower()[-10:], 'Physical GPU binding differs'
+        device = dict(**gpu_before, runtime_pci_bus_id=bus, compute_capability=backend.device.compute_capability,
+                      initialization_seconds=backend.initialization_seconds, cupy_version=cp.__version__,
+                      numpy_version=np.__version__, python_version=sys.version,
+                      runtime_version=cp.cuda.runtime.runtimeGetVersion(), driver_version_runtime=cp.cuda.runtime.driverGetVersion(),
+                      runtime_name=props['name'].decode() if isinstance(props['name'], bytes) else props['name'])
+        source = Path(__file__).resolve().parent
+        commit = subprocess.check_output(['git', '-C', str(source), 'rev-parse', 'HEAD'], text=True).strip()
+        assert subprocess.check_output(['git', '-C', str(source), 'status', '--porcelain'], text=True) == '', 'Candidate source worktree dirty'
+        save(args.output / 'authority.json', dict(device=device, queues_before=queues_before,
+            candidate_commit=commit, common_full_mapping_identity=common_identity,
+            fixture_manifests=initial_manifest_pins, repeats=20, warmups=3,
+            all_source_files={p.name: sha(p) for p in sorted(source.iterdir()) if p.is_file()},
+            scope='eligibility/delta replay only; no brain, training, or installation',
+            original_experiment_resumed=False, created_utc=datetime.now(timezone.utc).isoformat()))
+        reports = []
+        peak_reserved = 0
+        for i, fixture in enumerate(fixtures):
+            assert time.perf_counter() - started < 900, 'Benchmark wall budget exhausted'
+            idle_queues()
+            a, c, rule = fixture['arrays'], fixture['command'], fixture['rule']
+            arrays_before = {k: evidence(v) for k, v in a.items()}
+            f_id = fixture['group'] + '--' + fixture['record']['fixture_id']
+            def run_once(resident=False):
+                begin = time.perf_counter()
+                prepared = prepare_events(a['step'], a['neuron_idx'], a['kc'], c['steps'],
+                                          a['reference_command_steps'], n_neurons=c['n_neurons'])
+                result = backend.run(prepared, a['candidate_sources'], a['candidate_compartments'],
+                    c['compartment'], a['delta_before'], a['base_candidate'],
+                    d=c['d_command'], frozen=c['frozen'], **rule,
+                    kernel_warmup=3 if resident else 0, kernel_repeats=20 if resident else 1)
+                comparison = compare(result, a)
+                elapsed = time.perf_counter() - begin
+                if not all(r['bitwise_exact'] for r in comparison.values()):
+                    save(args.output / (f_id + '-mismatch.json'), comparison)
+                    raise AssertionError('GPU bitwise mismatch: ' + f_id)
+                return result, comparison, elapsed
+            cold, comp, cold_wall = run_once()
+            for _ in range(3):
+                run_once()
+            samples = []
+            for _ in range(20):
+                result, comp, elapsed = run_once()
+                samples.append(dict(**result.timing, replay_wall_including_preparation_and_comparison_seconds=elapsed))
+            resident, _, resident_wall = run_once(resident=True)
+            peak_reserved = max(peak_reserved, cp.get_default_memory_pool().total_bytes())
+            assert arrays_before == {k: evidence(v) for k, v in a.items()}, 'Input arrays mutated'
+            report = dict(fixture_id=f_id, input_path=fixture['input_path'], fixture_manifest_sha256=fixture['manifest_sha256'],
+                command=c, rule=rule, first_call_timing=cold.timing, first_call_wall_seconds=cold_wall,
+                raw_warm_samples=samples, resident_timing=resident.timing,
+                summaries={key: stats([s[key] for s in samples]) for key in
+                           ('preparation_seconds', 'kernel_seconds', 'end_to_end_seconds',
+                            'replay_wall_including_preparation_and_comparison_seconds')},
+                comparison=comp, input_unchanged=True, all_repeats_bitwise_exact=True,
+                reference_timing=fixture['record'].get('reference_timing'), audit=result.audit)
+            save(args.output / (f_id + '.json'), report)
+            reports.append(report)
+            print(json.dumps(dict(fixture=f_id, exact=True,
+                median_ms=1000 * report['summaries']['replay_wall_including_preparation_and_comparison_seconds']['median'])), flush=True)
+        # Recheck original exported files at the end, not just at read time.
+        assert initial_manifest_pins == {str(p): sha(p) for p in args.manifest}, 'Fixture manifest changed'
+        load_fixtures(args.manifest)
+        rejections = check_rejections(args.manifest, backend, fixtures[0]['rule'])
+        save(args.output / 'invalid-input-rejections.json', rejections)
+        assert commit == subprocess.check_output(['git', '-C', str(source), 'rev-parse', 'HEAD'], text=True).strip()
+        assert subprocess.check_output(['git', '-C', str(source), 'status', '--porcelain'], text=True) == ''
+        result = dict(status='PASS-ELIGIBILITY-UPDATE-REPLAY-EQUIVALENCE', fixtures=len(reports),
+            device=device, candidate_commit=commit, all_fixture_repeats_bitwise_exact=True,
+            observed_cuda_pool_reserved_peak_bytes=peak_reserved, gpu_after=gpu_snapshot(args.uuid),
+            queues_after=idle_queues(), wall_seconds=time.perf_counter()-started,
+            original_experiment_resumed=False, brain_simulation_tested=False,
+            rejected_invalid_cases=len(rejections),
+            full_training_speedup_measured=False, learning_success_claimed=False,
+            coverage_limit='available prefix + fixed synthetic edge cases, not all registered conditions',
+            files={p.name: sha(p) for p in sorted(args.output.iterdir()) if p.is_file()})
+        save(args.output / 'summary.json', result)
+        print(json.dumps(result), flush=True)
+    except Exception:
+        save(args.output / 'failure.json', dict(exit_code=1, traceback=traceback.format_exc(),
+              wall_seconds=time.perf_counter()-started, original_experiment_resumed=False))
+        raise
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--manifest', type=Path, action='append', required=True)
+    parser.add_argument('--output', type=Path, required=True)
+    parser.add_argument('--uuid', required=True)
+    main(parser.parse_args())

models/male-cns-lif/conditioning-acceleration-v1/export_fixtures.py

@@ -0,0 +1,518 @@
+"""Export CPU reference fixtures from the fixed, committed Phase 4AR prefix.
+
+Run with the ORIGINAL models/male-cns-lif/.venv/bin/python -B and --output an
+absolute, nonexistent directory outside frozen input/source directories. This
+tool never launches a brain, resumes training, installs weights or changes AR.
+The original AQ CPU validator is run in fresh CPU-only subprocesses; its only
+new receipts are placed inside the requested output. A second fresh process per
+fixture computes the original U Torch CPU reference, including a warm repeat.
+
+Selection is first and last task_id in each available arm among committed
+brain/update/verify triples, determined before result/metric files are opened.
+This bounded engineering sample does not cover all scientific conditions.
+"""
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import hashlib
+import importlib.util
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import time
+
+
+ROOT = Path('/data/digital-drosophila')
+MODEL = ROOT / 'models/male-cns-lif'
+EXP = ROOT / 'experiments/phase4ar-normal-conditioning'
+ORIGINAL_ENV = MODEL / '.venv'
+REG_SHA = 'b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740'
+SOURCE_COMMIT = '80aeb2093db655329774eff7b32fb6e417b8b40b'
+U_SHA = '96efff678cff910654eb08e86f1a17789e4e5589e340345f419c7027a7d547e2'
+BRIDGE_SHA = '174fb8d14619189e74b095e77a6db18b14c93046dc431c0b55710a5aa2dd2e61'
+J_SHA = 'abb4574da85f00bd9ef61024c65993ef81d42651ff8d8d63c15dd69c6222471e'
+ARMS = ('cs_only', 'd_zero', 'dan_only', 'frozen', 'paired', 'random_reward', 'unpaired')
+INPUT_ARRAYS = ('step', 'neuron_idx', 'kc', 'candidate_edge_id', 'candidate_sources',
+                'candidate_targets', 'candidate_compartments', 'delta_before', 'base_candidate')
+OUTPUT_ARRAYS = ('delta_after', 'sampled_trace', 'final_trace')
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def canonical(value):
+    return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=False, allow_nan=False)
+
+
+def digest(path):
+    h = hashlib.sha256()
+    with Path(path).open('rb') as stream:
+        for chunk in iter(lambda: stream.read(8 << 20), b''):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def unlinked(path):
+    path = Path(path)
+    require(path.is_absolute() and '..' not in path.parts, 'Absolute nonescaping path required')
+    require(not any(p.is_symlink() or (hasattr(p, 'is_junction') and p.is_junction())
+                    for p in (path, *path.parents)), 'Linked path forbidden: ' + str(path))
+    return path
+
+
+def read(path):
+    def pairs(items):
+        result = {}
+        for key, value in items:
+            require(key not in result, 'Duplicate JSON key')
+            result[key] = value
+        return result
+    return json.loads(unlinked(path).read_text(encoding='utf-8'), object_pairs_hook=pairs,
+                      parse_constant=lambda _: (_ for _ in ()).throw(ValueError('Nonfinite JSON')))
+
+
+def save(path, value):
+    with unlinked(path).open('x', encoding='utf-8', newline='\n') as stream:
+        json.dump(value, stream, sort_keys=True, indent=2, ensure_ascii=False, allow_nan=False)
+        stream.write('\n')
+
+
+def identity(path):
+    path = unlinked(path)
+    require(path.is_file(), 'Missing regular file: ' + str(path))
+    size = path.stat().st_size
+    result = dict(sha256=digest(path), bytes=size)
+    require(path.stat().st_size == size, 'File size changed while hashing')
+    return result
+
+
+def check(path, expected):
+    observed = identity(path)
+    sha = expected if isinstance(expected, str) else expected['sha256']
+    require(observed['sha256'] == sha, 'Pinned bytes changed: ' + str(path))
+    if isinstance(expected, dict) and 'bytes' in expected:
+        require(observed['bytes'] == expected['bytes'], 'Pinned size changed: ' + str(path))
+    return observed
+
+
+def task_key(task):
+    return 'task-' + hashlib.sha256(task['task_id'].encode()).hexdigest()
+
+
+def select_tasks(tasks, committed_ids):
+    """Only plan metadata and committed entry IDs participate in selection."""
+    available = {arm: [] for arm in ARMS}
+    seen = set()
+    for task in tasks:
+        require(task['task_id'] not in seen, 'Duplicate plan task identity')
+        seen.add(task['task_id'])
+        if task['kind'] != 'train':
+            continue
+        require(task['arm'] in available, 'Unexpected training arm')
+        key = task_key(task)
+        if all(key + '--' + stage in committed_ids for stage in ('brain', 'update', 'verify')):
+            available[task['arm']].append(task)
+    selected = []
+    for arm in ARMS:
+        ordered = sorted(available[arm], key=lambda task: task['task_id'])
+        if ordered:
+            selected.append(ordered[0])
+            if ordered[-1]['task_id'] != ordered[0]['task_id']:
+                selected.append(ordered[-1])
+    require(selected, 'No committed train triple is available')
+    return selected, {arm: len(available[arm]) for arm in ARMS}
+
+
+def ledger_snapshot(exp, reg):
+    """Read ledger controls, not all historical outcomes; never instantiate Ledger."""
+    control = exp / '.append-ledger'
+    require(not (control / 'writer.lock').exists(), 'Ledger writer/stale lock present')
+    header_path = control / 'header.json'
+    header = read(header_path)
+    require(header['schema'] == 'normal-append-ledger-v1' and header['root'] == str(exp)
+            and header['registration_sha256'] == REG_SHA, 'Ledger header authority differs')
+    expected_initial = {str(Path(p).relative_to(exp)): sha for p, sha in reg['prepared_sha256'].items()}
+    expected_initial['protocol/preregistered.json'] = REG_SHA
+    require({p: info['sha256'] for p, info in header['initial_inventory'].items()} == expected_initial,
+            'Ledger initial inventory differs from registration')
+    control_pins = {str(header_path): identity(header_path)}
+    tracked = {str(exp / p): info for p, info in header['initial_inventory'].items()}
+    entries = {}
+    tail = None
+    paths = sorted((control / 'entries').iterdir())
+    for sequence, path in enumerate(paths, 1):
+        require(path.name == f'{sequence:016d}.json', 'Ledger entries must form a contiguous prefix')
+        row = read(path)
+        name = row['entry_id']
+        require(name not in entries and row['schema'] == 'normal-append-ledger-v1-entry'
+                and row['registration_sha256'] == REG_SHA and row['sequence'] == sequence
+                and row['prev_entry_sha256'] == tail and row['scientific_gate_claimed'] is False,
+                'Ledger chain identity differs')
+        start_path = control / 'started' / (name + '.json')
+        start = read(start_path)
+        control_pins[str(start_path)] = check(start_path, row['start_sha256'])
+        require(start['schema'] == 'normal-append-ledger-v1-start' and start['entry_id'] == name
+                and start['registration_sha256'] == REG_SHA and start['next_sequence'] == sequence
+                and start['prev_entry_sha256'] == tail and start['retry_authorized'] is False,
+                'Ledger start identity differs')
+        for output in row['new_outputs']:
+            output_path = unlinked(output['path'])
+            require(output_path.is_relative_to(exp) and str(output_path.relative_to(exp)) == output['relative_path']
+                    and str(output_path) not in tracked, 'Output escapes or repeats immutable history')
+            tracked[str(output_path)] = {key: output[key] for key in ('bytes', 'sha256')}
+        control_pins[str(path)] = identity(path)
+        tail = control_pins[str(path)]['sha256']
+        entries[name] = dict(row=row, start=start, ledger_path=str(path), ledger_sha256=tail)
+    require(entries, 'Empty committed prefix')
+    return entries, tracked, control_pins, dict(entries=len(entries), head_sha256=tail,
+        uncommitted_starts=sorted(p.stem for p in (control / 'started').glob('*.json') if p.stem not in entries),
+        scope='ledger chain controls and selected artifacts; not a full historical payload audit')
+
+
+def validate_process(entry, tracked, exp):
+    row, start = entry['row'], entry['start']
+    name = row['entry_id']
+    metadata = row['metadata']
+    job_path = unlinked(metadata['job_file'])
+    process_path = unlinked(metadata['process_receipt_file'])
+    require(job_path == exp / 'jobs' / (name + '.json') and process_path == exp / 'receipts' / name / 'process.json',
+            'Process/job location differs')
+    require(str(job_path) in tracked and str(process_path) in tracked, 'Process/job not in committed history')
+    job_pin = check(job_path, tracked[str(job_path)])
+    process_pin = check(process_path, tracked[str(process_path)])
+    require(start['job']['path'] == str(job_path) and start['job']['sha256'] == job_pin['sha256'],
+            'Started job differs from committed job')
+    process = read(process_path)
+    require(process['entry_id'] == name and process['registration_sha256'] == REG_SHA
+            and process['job_sha256'] == job_pin['sha256'] and process['complete'] is True
+            and type(process['exit_code']) is int and process['exit_code'] == 0
+            and process['timed_out'] is False and process['exit_observed_by_parent'] is True
+            and process.get('launch_error') is None and type(metadata['observed_returncode']) is int
+            and metadata['observed_returncode'] == 0, 'Selected process is not committed observed exit zero')
+    require(process['argv'][0] == str(ORIGINAL_ENV / 'bin/python') and '-B' in process['argv'],
+            'Selected process did not use original -B interpreter')
+    job = read(job_path)
+    require(job['registration_sha256'] == REG_SHA, 'Selected job registration differs')
+    outgoing = {item['path']: item for item in row['new_outputs']}
+    require(str(job_path) in outgoing and str(process_path) in outgoing,
+            'Job/process must be outputs of this exact committed entry')
+    consumed = {item['path']: item['sha256'] for item in row['consumed_inputs']}
+    require(all(consumed.get(path) == sha for path, sha in job['input_sha256'].items()),
+            'Selected job input pins differ from committed ledger')
+    return job, {str(job_path): job_pin, str(process_path): process_pin}, process
+
+
+def array_evidence(array):
+    return dict(dtype=array.dtype.str, shape=list(array.shape), nbytes=int(array.nbytes),
+                raw_c_order_sha256=hashlib.sha256(array.tobytes(order='C')).hexdigest())
+
+
+def load_npz(path):
+    import numpy as np
+    with np.load(unlinked(path), allow_pickle=False) as archive:
+        return {name: archive[name].copy() for name in archive.files}
+
+
+def save_npz(path, arrays):
+    import numpy as np
+    with unlinked(path).open('xb') as stream:
+        np.savez_compressed(stream, **arrays)
+
+
+def load_verified_source(name, path, sha):
+    raw = unlinked(path).read_bytes()
+    require(hashlib.sha256(raw).hexdigest() == sha and name not in sys.modules, 'Unverified source/module binding')
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    exec(compile(raw, str(path), 'exec'), module.__dict__)
+    return module
+
+
+def cpu_environment():
+    require(sys.dont_write_bytecode and 'torch' not in sys.modules and 'runtime_light' not in sys.modules,
+            'Use a fresh original Python -B process')
+    require(Path(sys.prefix) == ORIGINAL_ENV, 'Reference export requires the original registered .venv')
+    os.environ['CUDA_VISIBLE_DEVICES'] = ''
+    os.environ['PYTHONDONTWRITEBYTECODE'] = '1'
+
+
+def run_cpu(argv, directory, label):
+    started = time.perf_counter()
+    environment = dict(os.environ, CUDA_VISIBLE_DEVICES='', PYTHONDONTWRITEBYTECODE='1')
+    with (directory / (label + '.stdout.log')).open('xb') as stdout, \
+            (directory / (label + '.stderr.log')).open('xb') as stderr:
+        process = subprocess.run(argv, cwd=directory, env=environment, stdout=stdout, stderr=stderr,
+                                 timeout=1800, check=False)
+    elapsed = time.perf_counter() - started
+    save(directory / (label + '-process.json'), dict(argv=argv, exit_code=process.returncode,
+         wall_seconds=elapsed, CUDA_VISIBLE_DEVICES='', brain_executed=False))
+    require(process.returncode == 0, label + ' failed; partial outputs retained')
+    return elapsed
+
+
+def reference_worker(directory):
+    cpu_environment()
+    import numpy as np
+    directory = unlinked(directory)
+    inputs = load_npz(directory / 'inputs.npz')
+    command = read(directory / 'command.json')
+    sources = read(directory / 'reference-sources.json')
+    require(sources['conditioning_update_source']['sha256'] == U_SHA
+            and sources['eligibility_bridge_source']['sha256'] == BRIDGE_SHA
+            and sources['phase4j_source']['sha256'] == J_SHA, 'Original source pins differ')
+    for info in sources.values():
+        check(info['path'], info['sha256'])
+    update = load_verified_source('_acceleration_original_U', sources['conditioning_update_source']['path'], U_SHA)
+    kwargs = {**inputs, **command, 'bridge_source': sources['eligibility_bridge_source']['path'],
+              'phase4j_source': sources['phase4j_source']['path']}
+    before = {name: array_evidence(value) for name, value in inputs.items()}
+    started = time.perf_counter()
+    cold = update.update_epoch(**kwargs)
+    cold_seconds = time.perf_counter() - started
+    started = time.perf_counter()
+    warm = update.update_epoch(**kwargs)
+    warm_seconds = time.perf_counter() - started
+    require(canonical(cold.receipt) == canonical(warm.receipt), 'Cold/warm original receipts differ')
+    for name in OUTPUT_ARRAYS:
+        require(array_evidence(getattr(cold, name)) == array_evidence(getattr(warm, name)),
+                'Cold/warm original output differs: ' + name)
+    require(before == {name: array_evidence(value) for name, value in inputs.items()}, 'Reference input mutated')
+    import torch
+    require(not torch.cuda.is_initialized() and os.environ['CUDA_VISIBLE_DEVICES'] == '', 'CUDA initialized in CPU reference')
+    arrays = {'reference_' + name: getattr(cold, name) for name in OUTPUT_ARRAYS}
+    commands = [] if command['us_tick'] is None else [command['us_tick']]
+    arrays['reference_command_steps'] = np.asarray(commands, dtype=np.int64)
+    arrays['reference_snapshots'] = (np.empty((0, len(inputs['kc'])), np.float32) if not commands
+                                    else cold.sampled_trace[None, :].copy())
+    save_npz(directory / 'reference.npz', arrays)
+    save(directory / 'reference-update-receipt.json', cold.receipt)
+    save(directory / 'reference-timing.json', dict(schema='conditioning-original-cpu-timing-v1',
+        python_version=sys.version, executable=sys.executable, environment_prefix=sys.prefix,
+        numpy_version=np.__version__, torch_version=torch.__version__, cuda_initialized=False,
+        cold_update_seconds=cold_seconds, warm_update_seconds=warm_seconds,
+        timing_scope='original update_epoch API with loaded arrays, includes source checks/AST parsing; cold includes first Torch import; not pure kernel time',
+        process_time_scope='reference-process.json separately includes startup, loading, two updates and output serialization',
+        snapshot_scope='exact sole declared-US snapshot equals sampled_trace; empty snapshots for no US',
+        output_arrays={name: array_evidence(array) for name, array in arrays.items()},
+        source_pins=sources, cold_warm_bitwise_exact=True, brain_executed=False, weights_installed=False))
+
+
+def validate_destination(output, protected):
+    output = unlinked(output)
+    require(not output.exists() and output.parent.is_dir(), 'Output must be a fresh directory with an existing parent')
+    require(not any(output.is_relative_to(unlinked(parent)) for parent in protected),
+            'Output overlaps a frozen input/source directory')
+    return output
+
+
+def export(output):
+    cpu_environment()
+    started = time.perf_counter()
+    own = identity(Path(__file__).absolute())
+    regpath = EXP / 'protocol/preregistered.json'
+    check(regpath, REG_SHA)
+    reg = read(regpath)
+    require(reg['schema'] == 'normal-conditioning-registration-v1'
+            and reg['source_code_commit'] == SOURCE_COMMIT and reg['scientific_scope'] == 'normal-acquisition-only'
+            and reg['subsequent_assays_authorized'] is False, 'Wrong fixed AR authority')
+    source_pins = {**reg['source_sha256'], **{p: sha for p, sha in reg['input_sha256'].items()
+                                          if Path(p).is_relative_to(MODEL)}}
+    for path, sha in source_pins.items():
+        check(path, sha)
+    planpath = EXP / 'protocol/normal-plan.json'
+    check(planpath, reg['prepared_sha256'][str(planpath)])
+    plan = read(planpath)
+    entries, tracked, control_pins, snapshot = ledger_snapshot(EXP, reg)
+    selected, available = select_tasks(plan['tasks'], set(entries))
+    tasks_by_id = {task['task_id']: task for task in plan['tasks']}
+    protected = {EXP, MODEL, *[Path(p).parent for p in reg['input_sha256']]}
+    output = validate_destination(output, protected)
+    output.mkdir()
+    selection = dict(schema='conditioning-acceleration-selection-v1', registration_sha256=REG_SHA,
+        source_code_commit=SOURCE_COMMIT, rule='first and last lexicographic task_id per arm among committed train brain/update/verify triples',
+        metrics_used_for_selection=False, available_train_counts=available, selected_tasks=selected,
+        selected_count=len(selected), maximum_cases=14, ledger_snapshot=snapshot,
+        coverage_limit='engineering fixtures only; neither complete scientific-condition coverage nor a learning result')
+    save(output / 'selection.json', selection)
+    save(output / 'original-source-pins.json', source_pins)
+    # No task result, update or event array is read before the immutable selection above.
+    fixtures = []
+    for index, task in enumerate(selected):
+        item_started = time.perf_counter()
+        fixture_id = f'{index:02d}-{task["arm"]}'
+        directory = output / fixture_id
+        directory.mkdir()
+        key = task_key(task)
+        file_pins = {}
+        jobs = {}
+        process_records = {}
+        for stage in ('brain', 'update', 'verify'):
+            job, pins, process = validate_process(entries[key + '--' + stage], tracked, EXP)
+            jobs[stage] = job
+            file_pins.update(pins)
+            process_records[stage] = process
+        result_path = EXP / 'results' / (key + '.json')
+        file_pins[str(result_path)] = check(result_path, tracked[str(result_path)])
+        result = read(result_path)
+        require(result['schema'] == 'normal-task-result-v1' and result['complete'] is True
+                and result['registration_sha256'] == REG_SHA and result['task'] == task, 'Selected result/plan differs')
+        authority_path = unlinked(result['epoch_authority']['path'])
+        authority_sha = result['epoch_authority']['sha256']
+        file_pins[str(authority_path)] = check(authority_path, tracked[str(authority_path)])
+        require(file_pins[str(authority_path)]['sha256'] == authority_sha, 'Authority result/ledger pin differs')
+        authority = read(authority_path)
+        command = dict(authority['command'], n_neurons=166700)
+        require(authority['epoch_id'] == task['task_id'] and authority['diagnostic_mode'] == 'light'
+                and command == dict(steps=task['steps'], n_neurons=166700, compartment=task['compartment_verbatim'],
+                    us_tick=task['recipe']['us']['tick'], d_command=task['recipe']['D_command'],
+                    frozen=not task['recipe']['update_enabled'], trace_backend='torch'), 'Actual command differs from registered task')
+        update_dir = unlinked(result['update_dir'])
+        require(update_dir == EXP / 'updates' / key and authority_path == EXP / 'jobs' / (key + '.authority.json')
+                and authority['checkpoint_dir'] == result['checkpoint_dir'] == str(EXP / 'runs' / key)
+                and authority['checkpoint_manifest_sha256'] == result['checkpoint_manifest_sha256'],
+                'Task checkpoint/update location differs')
+        for stage in ('update', 'verify'):
+            require(jobs[stage]['authority_file'] == str(authority_path) and jobs[stage]['authority_sha256'] == authority_sha,
+                    'Authority not bound to selected successful job')
+        require(jobs['brain']['output_dir'] == authority['checkpoint_dir'] and jobs['update']['output_dir'] == str(update_dir)
+                and jobs['verify']['update_dir'] == str(update_dir), 'Selected process output differs')
+        require(jobs['brain']['kind'] == 'brain' and jobs['update']['kind'] == 'update'
+                and jobs['verify']['kind'] == 'cpu_verify', 'Selected process role differs')
+        dependency = task['delta_dependency']
+        if dependency == dict(kind='zero', source=None):
+            expected_before = reg['initial_overlay']
+        else:
+            require(dependency['kind'] == 'epoch_delta_after' and dependency['source'].endswith('/delta-after'),
+                    'Unknown registered overlay dependency')
+            previous = tasks_by_id[dependency['source'][:-len('/delta-after')]]
+            require(previous['kind'] == 'train' and all(previous[field] == task[field] for field in ('block_id', 'arm'))
+                    and task_key(previous) + '--verify' in entries, 'Previous overlay is not a committed same-arm training output')
+            previous_dir = EXP / 'updates' / task_key(previous)
+            expected_before = dict(overlay_file=str(previous_dir / 'delta-after.npz'),
+                                   overlay_manifest=str(previous_dir / 'overlay-manifest.json'))
+        require(result['overlay_before'] == expected_before
+                and jobs['brain']['overlay_file'] == expected_before['overlay_file']
+                and jobs['brain']['overlay_manifest'] == expected_before['overlay_manifest']
+                and authority['files']['overlay_before']['path'] == expected_before['overlay_file']
+                and authority['files']['overlay_manifest_before']['path'] == expected_before['overlay_manifest'],
+                'Actual before overlay differs from registered branch dependency')
+        registered_files = {**reg['input_sha256'], **reg['prepared_sha256']}
+        for info in authority['files'].values():
+            require(jobs['update']['input_sha256'].get(info['path']) == info['sha256'], 'Authority role absent from successful update inputs')
+            trusted_sha = registered_files.get(info['path'], tracked.get(info['path'], {}).get('sha256'))
+            require(trusted_sha == info['sha256'], 'Authority role lacks registered or committed file identity')
+            file_pins[info['path']] = check(info['path'], info['sha256'])
+        for name in ('chain-receipt.json', 'update-receipt.json', 'delta-after.npz', 'overlay-manifest.json'):
+            path = update_dir / name
+            file_pins[str(path)] = check(path, tracked[str(path)])
+        chain_sha = file_pins[str(update_dir / 'chain-receipt.json')]['sha256']
+        require(jobs['verify']['chain_sha256'] == chain_sha, 'Selected CPU validator used a different chain')
+        cpu_path = unlinked(result['cpu_validation']['path'])
+        file_pins[str(cpu_path)] = check(cpu_path, tracked[str(cpu_path)])
+        require(file_pins[str(cpu_path)]['sha256'] == result['cpu_validation']['sha256'], 'Original CPU receipt pin differs')
+        original_validation = read(cpu_path)
+        require(original_validation['complete'] is True and original_validation['frozen_U_verify_receipt_recomputed'] is True
+                and original_validation['actual_sealed_events_used'] is True
+                and original_validation['full_candidate_mapping_verified'] is True
+                and original_validation['epoch_authority_sha256'] == authority_sha, 'Original CPU validation incomplete')
+        validator = MODEL / 'conditioning-execution-v1/validate_update_cpu.py'
+        check(validator, reg['input_sha256'][str(validator)])
+        validator_seconds = run_cpu([sys.executable, '-B', str(validator), '--authority', str(authority_path),
+            '--authority-sha256', authority_sha, '--update-dir', str(update_dir), '--chain-sha256', chain_sha,
+            '--receipt', str(directory / 'fresh-cpu-validation.json')], directory, 'validation')
+        fresh = read(directory / 'fresh-cpu-validation.json')
+        require(fresh == original_validation, 'Fresh original validator receipt differs from committed receipt')
+        import numpy as np
+        paths = {role: unlinked(info['path']) for role, info in authority['files'].items()}
+        state = load_npz(paths['state'])
+        mapping = load_npz(paths['candidate_map'])
+        before = load_npz(paths['overlay_before'])
+        after = load_npz(update_dir / 'delta-after.npz')
+        arrays = dict(step=state['step'], neuron_idx=state['neuron_idx'],
+            kc=np.load(paths['kc'], allow_pickle=False), candidate_edge_id=np.load(paths['mask'], allow_pickle=False),
+            candidate_sources=mapping['source_neuron_idx'], candidate_targets=mapping['target_neuron_idx'],
+            candidate_compartments=mapping['target_compartment_verbatim'], delta_before=before['plastic_delta_mv'],
+            base_candidate=np.load(paths['base_candidate'], allow_pickle=False))
+        require(len(arrays['kc']) == 4064 and len(arrays['candidate_edge_id']) == 14232, 'Complete identity dimensions differ')
+        save_npz(directory / 'inputs.npz', arrays)
+        save(directory / 'command.json', command)
+        sources = {role: authority['files'][role] for role in
+                   ('conditioning_update_source', 'eligibility_bridge_source', 'phase4j_source')}
+        save(directory / 'reference-sources.json', sources)
+        reference_seconds = run_cpu([sys.executable, '-B', str(Path(__file__).absolute()),
+                                    '--reference-worker', str(directory)], directory, 'reference')
+        reference = load_npz(directory / 'reference.npz')
+        receipt = read(directory / 'reference-update-receipt.json')
+        stored_receipt = read(update_dir / 'update-receipt.json')
+        require(canonical(receipt) == canonical(stored_receipt), 'Original recomputation differs from stored update receipt')
+        require(array_evidence(reference['reference_delta_after']) == array_evidence(after['plastic_delta_mv']),
+                'Original reference delta bytes differ from committed delta-after')
+        for name in OUTPUT_ARRAYS:
+            require(array_evidence(reference['reference_' + name]) == stored_receipt['outputs'][name],
+                    'Reference trace/delta does not match original receipt byte identity')
+        fixture = {**arrays, **reference, 'stored_delta_after': after['plastic_delta_mv']}
+        save_npz(directory / 'fixture.npz', fixture)
+        save(directory / 'authority.json', authority)
+        save(directory / 'stored-update-receipt.json', stored_receipt)
+        save(directory / 'source-file-pins.json', file_pins)
+        timing = read(directory / 'reference-timing.json')
+        record = dict(fixture_id=fixture_id, task=task, npz=f'{fixture_id}/fixture.npz',
+            command=f'{fixture_id}/command.json', npz_sha256=digest(directory / 'fixture.npz'),
+            command_sha256=digest(directory / 'command.json'), authority_sha256=authority_sha,
+            original_update_payload_sha256=receipt['payload_sha256'],
+            exact_stored_delta_and_trace_verified=True, full_canonical_KC_count=4064, full_candidate_edge_count=14232,
+            original_validator_verified_full_graph_mapping=True, reference_timing=timing,
+            reference_subprocess_wall_seconds=reference_seconds, original_validator_subprocess_wall_seconds=validator_seconds,
+            fixture_end_to_end_seconds=time.perf_counter() - item_started,
+            historical_process_seconds={stage: {field: proc[field] for field in ('child_wall_seconds', 'end_to_end_seconds')}
+                                        for stage, proc in process_records.items()},
+            input_arrays={name: array_evidence(value) for name, value in arrays.items()},
+            output_arrays={name: array_evidence(value) for name, value in reference.items()})
+        save(directory / 'fixture.json', record)
+        fixtures.append(record)
+        print(canonical(dict(fixture=fixture_id, complete=True, task_id=task['task_id'])), flush=True)
+    for path, pin in control_pins.items():
+        check(path, pin)
+    require(not (EXP / '.append-ledger/writer.lock').exists()
+            and len(list((EXP / '.append-ledger/entries').iterdir())) == snapshot['entries'],
+            'Ledger changed during export; fixture set not published')
+    for path, sha in source_pins.items():
+        check(path, sha)
+    check(Path(__file__).absolute(), own)
+    # Recheck all selected immutable input/output pins after the entire export.
+    all_pins = {}
+    for fixture in fixtures:
+        all_pins.update(read(output / fixture['fixture_id'] / 'source-file-pins.json'))
+    for path, pin in all_pins.items():
+        check(path, pin)
+    manifest = dict(schema='conditioning-acceleration-fixtures-v1', complete=True,
+        registration_sha256=REG_SHA, source_code_commit=SOURCE_COMMIT,
+        exporter_source=dict(path=str(Path(__file__).absolute()), **own),
+        created_utc=datetime.now(timezone.utc).isoformat(), selection_sha256=digest(output / 'selection.json'),
+        fixtures=fixtures, fixture_count=len(fixtures), coverage=selection,
+        total_export_seconds=time.perf_counter() - started,
+        original_files_modified=False, brain_executed=False, training_executed=False,
+        weights_installed=False, learning_pass_claimed=False,
+        authority_limit='committed selected historical processes and original CPU reference only; AR remains incomplete',
+        files={str(path.relative_to(output)): identity(path) for path in sorted(output.rglob('*')) if path.is_file()})
+    save(output / 'manifest.json', manifest)
+    return manifest
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    mode = parser.add_mutually_exclusive_group(required=True)
+    mode.add_argument('--output', type=Path)
+    mode.add_argument('--reference-worker', type=Path, help=argparse.SUPPRESS)
+    args = parser.parse_args()
+    if args.reference_worker:
+        reference_worker(args.reference_worker)
+    else:
+        result = export(args.output)
+        print(canonical(dict(complete=True, output=str(args.output), fixtures=result['fixture_count'])), flush=True)

models/male-cns-lif/conditioning-acceleration-v1/export_synthetic.py

@@ -0,0 +1,362 @@
+"""Fixed synthetic full-mapping fixtures, using only the original CPU oracle.
+
+Run the original science Python -B with --template pointing to a completed real
+export's fixture.npz and --output a new directory. Anatomical arrays retain the
+real fixture's authenticated identity; events and delta-before are explicitly
+synthetic. No brain, training, installed weights or original files are changed.
+"""
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+from pathlib import Path
+import sys
+import time
+
+import export_fixtures as original
+
+
+COMPARTMENTS = ("B2B'2a", "a1", "y2a'1", "y5B'2a")
+STATIC_ARRAYS = ("kc", "candidate_edge_id", "candidate_sources", "candidate_targets",
+                 "candidate_compartments", "base_candidate")
+STEPS = 1200
+N_NEURONS = 166700
+SEEDS = (717, 20261001)
+
+
+def template_binding(template, metadata=None, manifest_path=None):
+    """Bind to a completed real export and its original full-graph validation."""
+    template = original.unlinked(template)
+    directory = template.parent
+    root = directory.parent
+    metadata = original.unlinked(metadata or directory / 'fixture.json')
+    manifest_path = original.unlinked(manifest_path or root / 'manifest.json')
+    original.require(template == directory / 'fixture.npz' and metadata == directory / 'fixture.json'
+                     and manifest_path == root / 'manifest.json', 'Use one intact real-fixture export')
+    manifest = original.read(manifest_path)
+    original.require(manifest['schema'] == 'conditioning-acceleration-fixtures-v1'
+                     and manifest['complete'] is True and manifest['registration_sha256'] == original.REG_SHA,
+                     'Template requires a completed real-fixture manifest')
+    required = ('fixture.npz', 'fixture.json', 'command.json', 'reference-sources.json',
+                'fresh-cpu-validation.json', 'validation-process.json', 'reference-process.json')
+    pins = {str(manifest_path): original.identity(manifest_path)}
+    for name in required:
+        path = directory / name
+        rel = path.relative_to(root).as_posix()
+        original.require(rel in manifest['files'], 'Template file absent from manifest: ' + rel)
+        pins[str(path)] = original.check(path, manifest['files'][rel])
+    record = original.read(metadata)
+    original.require(record in manifest['fixtures'] and record['fixture_id'] == directory.name
+                     and record['npz'] == template.relative_to(root).as_posix()
+                     and record['npz_sha256'] == pins[str(template)]['sha256']
+                     and record['exact_stored_delta_and_trace_verified'] is True
+                     and record['original_validator_verified_full_graph_mapping'] is True
+                     and record['full_canonical_KC_count'] == 4064
+                     and record['full_candidate_edge_count'] == 14232,
+                     'Template record does not bind an authenticated complete original mapping')
+    fresh = original.read(directory / 'fresh-cpu-validation.json')
+    original.require(fresh['complete'] is True and fresh['full_candidate_mapping_verified'] is True
+                     and fresh['frozen_U_verify_receipt_recomputed'] is True
+                     and fresh['epoch_authority_sha256'] == record['authority_sha256'],
+                     'Original full-graph CPU validation differs')
+    for name in ('validation-process.json', 'reference-process.json'):
+        process = original.read(directory / name)
+        original.require(type(process['exit_code']) is int and process['exit_code'] == 0
+                         and process['argv'][0] == str(original.ORIGINAL_ENV / 'bin/python')
+                         and process['CUDA_VISIBLE_DEVICES'] == '', 'Template original CPU process invalid')
+    sources = original.read(directory / 'reference-sources.json')
+    expected = dict(conditioning_update_source=original.U_SHA,
+                    eligibility_bridge_source=original.BRIDGE_SHA, phase4j_source=original.J_SHA)
+    original.require(set(sources) == set(expected), 'Original source roles differ')
+    for role, sha in expected.items():
+        original.require(sources[role]['sha256'] == sha, 'Original source identity differs: ' + role)
+        pins[sources[role]['path']] = original.check(sources[role]['path'], sha)
+    arrays = original.load_npz(template)
+    for name in original.INPUT_ARRAYS:
+        original.require(original.array_evidence(arrays[name]) == record['input_arrays'][name],
+                         'Template input array identity differs: ' + name)
+    command = original.read(directory / 'command.json')
+    original.require(command['steps'] == STEPS and command['n_neurons'] == N_NEURONS
+                     and command['trace_backend'] == 'torch', 'Unexpected original fixture dimensions')
+    return arrays, sources, pins, record
+
+
+def fixed_cases(template):
+    """Create the declared sixteen cases without inspecting candidate outputs."""
+    import numpy as np
+    kc = template['kc']
+    sources = template['candidate_sources']
+    base = template['base_candidate']
+    lower = np.float32(-0.25) * base
+    original.require(kc.dtype == np.int32 and len(kc) == 4064 and np.all(kc[1:] > kc[:-1])
+                     and len(base) == len(template['candidate_edge_id']) == 14232,
+                     'Expected complete canonical anatomical arrays')
+    original.require(set(np.unique(template['candidate_compartments'])) == set(COMPARTMENTS),
+                     'Template must cover all four original compartments')
+    active_sources = np.unique(sources)
+    chosen = active_sources[:3]
+    original.require(len(chosen) == 3, 'Need three distinct candidate KC sources')
+    non_kc = int(np.flatnonzero(~np.isin(np.arange(N_NEURONS, dtype=np.int32), kc))[0])
+    zero = np.zeros(len(base), np.float32)
+    partial = np.float32(-0.125) * base
+    partial[::3] = np.float32(0)
+
+    def events(rows):
+        rows = sorted(set((int(t), int(n)) for t, n in rows))
+        return (np.asarray([row[0] for row in rows], np.int32),
+                np.asarray([row[1] for row in rows], np.int32))
+
+    def case(name, rows, *, us=900, d=1., frozen=False, compartment=COMPARTMENTS[0], delta=None, tags=()):
+        tick, neuron = events(rows)
+        arrays = {key: template[key].copy() for key in STATIC_ARRAYS}
+        arrays.update(step=tick, neuron_idx=neuron,
+                      delta_before=(zero if delta is None else delta).copy())
+        return dict(name=name, arrays=arrays,
+                    command=dict(steps=STEPS, n_neurons=N_NEURONS, compartment=compartment,
+                                 us_tick=us, d_command=d, frozen=frozen, trace_backend='torch'),
+                    tags=list(tags), synthetic_events=True, synthetic_delta_before=True)
+
+    boundary = [(899, chosen[0]), (900, chosen[1]), (901, chosen[2]),
+                (0, non_kc), (900, non_kc), (1199, non_kc)]
+    ends = [(0, chosen[0]), (1, chosen[1]), (1199, chosen[2]), (0, non_kc), (1199, non_kc)]
+    all_active = [(900, n) for n in active_sources]
+    cases = [
+        case('empty-us900', [], tags=('empty', 'positive-zero')),
+        case('non-kc-only', [(0, non_kc), (900, non_kc), (1199, non_kc)], tags=('ignore-non-KC',)),
+        case('no-us-mixed', boundary, us=None, d=0., tags=('no-US', 'sampled-positive-zero', 'nonzero-final')),
+        case('us-first-tick', ends, us=0, tags=('US-zero', 'after-current-spike')),
+        case('us-final-tick', ends, us=1199, tags=('US-final', 'after-current-spike')),
+        case('before-on-after-us900', boundary, tags=('US-boundary', 'mixed-KC-non-KC')),
+        case('d-zero-existing-delta', boundary, d=0., delta=partial, tags=('D-zero', 'bitwise-identity')),
+        case('frozen-existing-delta', boundary, frozen=True, delta=partial, tags=('frozen', 'bitwise-identity')),
+    ]
+    for index, compartment in enumerate(COMPARTMENTS):
+        cases.append(case(f'compartment-{index}', all_active, compartment=compartment, delta=partial,
+                          tags=('full-source-activation', 'off-compartment-bitwise-identity', compartment)))
+    cases.append(case('already-at-floor', all_active, delta=lower, tags=('floor', 'already-saturated')))
+    near = np.nextafter(lower, np.full_like(lower, np.inf))
+    cases.append(case('one-ulp-above-floor', all_active, delta=near, tags=('floor', 'new-saturation')))
+    for seed in SEEDS:
+        rng = np.random.default_rng(seed)
+        ticks = rng.integers(0, STEPS, size=5000)
+        neurons = rng.choice(kc, size=5000)
+        extra_ticks = rng.integers(0, STEPS, size=1000)
+        extra_neurons = rng.integers(0, N_NEURONS, size=1000)
+        rows = list(zip(ticks, neurons)) + list(zip(extra_ticks, extra_neurons))
+        delta = -(rng.uniform(0., .249, len(base)).astype(np.float32) * base)
+        delta[::7] = np.float32(0)
+        delta[1::11] = lower[1::11]
+        item = case(f'seeded-sparse-{seed}', rows, delta=delta, tags=('seeded-sparse', 'mixed-delta', 'canonical-zero'))
+        item['rng_seed'] = seed
+        cases.append(item)
+    original.require(len(cases) == 16, 'Fixed synthetic coverage changed')
+    for item in cases:
+        for name in STATIC_ARRAYS:
+            original.require(original.array_evidence(item['arrays'][name]) == original.array_evidence(template[name]),
+                             'Synthetic generation changed an anatomical array: ' + name)
+        original.require(not np.any((item['arrays']['delta_before'] == 0)
+                                    & np.signbit(item['arrays']['delta_before'])), 'Synthetic delta has negative zero')
+    cases[4]['trace_command_steps'] = [0, 900, 1199]
+    cases[4]['tags'].append('multiple-US-snapshots')
+    return cases
+
+
+def supplemental_worker(directory):
+    """Fresh original CPU process for multiple snapshots or rejection evidence."""
+    original.cpu_environment()
+    import numpy as np
+    directory = original.unlinked(directory)
+    sources = original.read(directory / 'reference-sources.json')
+    expected = dict(conditioning_update_source=original.U_SHA,
+                    eligibility_bridge_source=original.BRIDGE_SHA, phase4j_source=original.J_SHA)
+    original.require(set(sources) == set(expected), 'Supplemental source roles differ')
+    for role, sha in expected.items():
+        original.require(sources[role]['sha256'] == sha, 'Supplemental frozen source differs')
+        original.check(sources[role]['path'], sha)
+    if (directory / 'trace-command-steps.json').exists():
+        arrays = original.load_npz(directory / 'inputs.npz')
+        command = original.read(directory / 'command.json')
+        commands = original.read(directory / 'trace-command-steps.json')
+        bridge = original.load_verified_source('_synthetic_original_bridge',
+            sources['eligibility_bridge_source']['path'], original.BRIDGE_SHA)
+        trace = bridge.trace_from_events(arrays['step'], arrays['neuron_idx'], arrays['kc'],
+            command['steps'], commands, phase4j_source=sources['phase4j_source']['path'],
+            backend='torch', n_neurons=command['n_neurons'])
+        sole = original.load_npz(directory / 'reference.npz')
+        original.require(original.array_evidence(trace.final) == original.array_evidence(sole['reference_final_trace'])
+                         and original.array_evidence(trace.last_command_trace)
+                         == original.array_evidence(sole['reference_sampled_trace']),
+                         'Multiple-US last sample or final differs from original single-US U reference')
+        original.save_npz(directory / 'multiple-reference.npz', dict(reference_snapshots=trace.snapshots,
+            reference_command_steps=trace.command_steps, reference_sampled_trace=trace.last_command_trace,
+            reference_final_trace=trace.final))
+        import torch
+        original.require(not torch.cuda.is_initialized(), 'Supplemental CPU oracle initialized CUDA')
+        original.save(directory / 'multiple-reference.json', dict(complete=True, trace_audit=trace.audit,
+            source_pins=sources, numpy_version=np.__version__, torch_version=torch.__version__,
+            final_and_last_sample_match_original_U=True, brain_executed=False, weights_installed=False))
+        return
+    cases = original.read(directory / 'invalid-selection.json')
+    update = original.load_verified_source('_synthetic_rejection_original_U',
+        sources['conditioning_update_source']['path'], original.U_SHA)
+    records = []
+    for item in cases:
+        arrays = original.load_npz(directory / item['npz'])
+        command = original.read(directory / item['command'])
+        try:
+            update.update_epoch(**arrays, **command,
+                bridge_source=sources['eligibility_bridge_source']['path'],
+                phase4j_source=sources['phase4j_source']['path'])
+        except ValueError as error:
+            records.append(dict(case_name=item['case_name'], rejected=True, exception='ValueError', message=str(error)))
+        else:
+            raise ValueError('Original U unexpectedly accepted invalid case: ' + item['case_name'])
+    original.save(directory / 'original-rejections.json', dict(complete=True, cases=records,
+        source_pins=sources, brain_executed=False, weights_installed=False))
+
+
+def export_invalid(output, valid_case, sources):
+    import numpy as np
+    directory = output / 'invalid'
+    directory.mkdir()
+    original.save(directory / 'reference-sources.json', sources)
+    definitions = [('duplicate-events', 'prepare'), ('unsorted-events', 'prepare'),
+                   ('out-of-range-tick', 'prepare'), ('negative-zero-delta', 'run'),
+                   ('non-kc-candidate-source', 'run'), ('unsorted-kc', 'prepare')]
+    records = []
+    for index, (name, stage) in enumerate(definitions):
+        arrays = {key: value.copy() for key, value in valid_case['arrays'].items()}
+        if name == 'duplicate-events':
+            arrays['step'] = np.array([0, 0], np.int32)
+            arrays['neuron_idx'] = np.full(2, arrays['kc'][0], np.int32)
+        elif name == 'unsorted-events':
+            arrays['step'] = np.array([1, 0], np.int32)
+            arrays['neuron_idx'] = np.full(2, arrays['kc'][0], np.int32)
+        elif name == 'out-of-range-tick':
+            arrays['step'] = np.array([STEPS], np.int32)
+            arrays['neuron_idx'] = np.array([arrays['kc'][0]], np.int32)
+        elif name == 'negative-zero-delta':
+            arrays['delta_before'][0] = np.float32(-0.)
+        elif name == 'non-kc-candidate-source':
+            arrays['candidate_sources'][0] = int(np.flatnonzero(
+                ~np.isin(np.arange(N_NEURONS, dtype=np.int32), arrays['kc']))[0])
+        elif name == 'unsorted-kc':
+            arrays['kc'] = arrays['kc'][::-1].copy()
+        npz = f'{index:02d}-{name}.npz'
+        command = f'{index:02d}-{name}.json'
+        original.save_npz(directory / npz, arrays)
+        original.save(directory / command, valid_case['command'])
+        records.append(dict(case_name=name, npz=npz, command=command, stage=stage,
+                            expected_exception='ValueError', npz_sha256=original.digest(directory / npz),
+                            command_sha256=original.digest(directory / command)))
+    original.save(directory / 'invalid-selection.json', records)
+    original.run_cpu([sys.executable, '-B', str(Path(__file__).absolute()), '--supplemental-worker', str(directory)],
+                     directory, 'original-rejection')
+    evidence = original.read(directory / 'original-rejections.json')
+    original.require(evidence['complete'] is True and len(evidence['cases']) == len(records),
+                     'Original rejection coverage incomplete')
+    for record, result in zip(records, evidence['cases']):
+        original.require(record['case_name'] == result['case_name'] and result['rejected'] is True,
+                         'Original rejection identity differs')
+        record.update(npz='invalid/' + record['npz'], command='invalid/' + record['command'],
+                      original_oracle_rejection=result)
+    return records
+
+
+def export(template, output, metadata=None, manifest_path=None):
+    original.cpu_environment()
+    started = time.perf_counter()
+    own = original.identity(Path(__file__).absolute())
+    helper = original.identity(Path(original.__file__).absolute())
+    arrays, sources, pins, template_record = template_binding(template, metadata, manifest_path)
+    cases = fixed_cases(arrays)
+    protected = {original.ROOT, Path(template).parent.parent, Path(__file__).absolute().parent,
+                 *(Path(info['path']).parent for info in sources.values())}
+    output = original.validate_destination(output, protected)
+    output.mkdir()
+    original.save(output / 'template-binding.json', dict(template=str(template), template_record=template_record,
+        input_pins=pins, scope='complete anatomical identity inherited from original full-graph CPU validation',
+        original_events_reused=False, original_delta_before_reused=False))
+    original.save(output / 'selection.json', dict(schema='conditioning-fixed-synthetic-selection-v1',
+        names=[item['name'] for item in cases], count=16, seeds=list(SEEDS),
+        chosen_before_candidate_execution=True, original_full_mapping_preserved=True))
+    fixtures = []
+    for index, item in enumerate(cases):
+        fixture_id = f'{index:02d}-{item["name"]}'
+        directory = output / fixture_id
+        directory.mkdir()
+        original.save_npz(directory / 'inputs.npz', item['arrays'])
+        original.save(directory / 'command.json', item['command'])
+        original.save(directory / 'reference-sources.json', sources)
+        seconds = original.run_cpu([sys.executable, '-B', str(Path(original.__file__).absolute()),
+                                    '--reference-worker', str(directory)], directory, 'reference')
+        reference = original.load_npz(directory / 'reference.npz')
+        receipt = original.read(directory / 'reference-update-receipt.json')
+        timing = original.read(directory / 'reference-timing.json')
+        original.require(timing['numpy_version'] == template_record['reference_timing']['numpy_version']
+                         and timing['torch_version'] == template_record['reference_timing']['torch_version'],
+                         'Synthetic oracle differs from the real fixture original environment')
+        for name in original.OUTPUT_ARRAYS:
+            original.require(original.array_evidence(reference['reference_' + name]) == receipt['outputs'][name],
+                             'Synthetic reference output/receipt differs: ' + name)
+        if 'trace_command_steps' in item:
+            original.save(directory / 'trace-command-steps.json', item['trace_command_steps'])
+            original.run_cpu([sys.executable, '-B', str(Path(__file__).absolute()),
+                              '--supplemental-worker', str(directory)], directory, 'multiple-reference')
+            reference.update(original.load_npz(directory / 'multiple-reference.npz'))
+        original.save_npz(directory / 'fixture.npz', {**item['arrays'], **reference})
+        record = dict(fixture_id=fixture_id, kind='synthetic', name=item['name'], tags=item['tags'],
+            npz=f'{fixture_id}/fixture.npz', command=f'{fixture_id}/command.json',
+            npz_sha256=original.digest(directory / 'fixture.npz'),
+            command_sha256=original.digest(directory / 'command.json'),
+            original_update_payload_sha256=receipt['payload_sha256'],
+            exact_stored_delta_and_trace_verified=False, historical_scientific_output_exists=False,
+            full_canonical_KC_count=4064, full_candidate_edge_count=14232,
+            original_validator_verified_full_graph_mapping=True,
+            mapping_identity_scope='inherited unchanged from template; events and delta-before are synthetic',
+            reference_timing=timing, reference_subprocess_wall_seconds=seconds,
+            input_arrays={name: original.array_evidence(value) for name, value in item['arrays'].items()},
+            output_arrays={name: original.array_evidence(value) for name, value in reference.items()})
+        if 'trace_command_steps' in item:
+            record['snapshot_scope'] = 'Original Torch bridge multiple-US snapshots; last sample matches original U single final-US output'
+            record['command_steps'] = item['trace_command_steps']
+        original.save(directory / 'fixture.json', record)
+        fixtures.append(record)
+        print(original.canonical(dict(fixture=fixture_id, kind='synthetic', complete=True)), flush=True)
+    invalid_cases = export_invalid(output, cases[5], sources)
+    for path, pin in pins.items():
+        original.check(path, pin)
+    original.check(Path(__file__).absolute(), own)
+    original.check(Path(original.__file__).absolute(), helper)
+    manifest = dict(schema='conditioning-acceleration-fixtures-v1', kind='synthetic', complete=True,
+        registration_sha256=original.REG_SHA, source_code_commit=original.SOURCE_COMMIT,
+        exporter_source=dict(path=str(Path(__file__).absolute()), **own),
+        original_helper_source=dict(path=str(Path(original.__file__).absolute()), **helper),
+        created_utc=datetime.now(timezone.utc).isoformat(), fixtures=fixtures, fixture_count=len(fixtures),
+        invalid_cases=invalid_cases, invalid_case_count=len(invalid_cases),
+        selection_sha256=original.digest(output / 'selection.json'),
+        template_binding_sha256=original.digest(output / 'template-binding.json'),
+        total_export_seconds=time.perf_counter() - started, original_files_modified=False,
+        brain_executed=False, training_executed=False, weights_installed=False, learning_pass_claimed=False,
+        authority_limit='synthetic arithmetic edge cases with original mapping; not historical scientific trials',
+        files={str(path.relative_to(output)): original.identity(path)
+               for path in sorted(output.rglob('*')) if path.is_file()})
+    original.save(output / 'manifest.json', manifest)
+    return manifest
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--template', type=Path)
+    parser.add_argument('--metadata', type=Path)
+    parser.add_argument('--manifest', type=Path)
+    parser.add_argument('--output', type=Path)
+    parser.add_argument('--supplemental-worker', type=Path, help=argparse.SUPPRESS)
+    args = parser.parse_args()
+    if args.supplemental_worker:
+        original.require(not any((args.template, args.output, args.metadata, args.manifest)), 'Do not combine worker/export modes')
+        supplemental_worker(args.supplemental_worker)
+    else:
+        original.require(args.template is not None and args.output is not None, '--template and --output are required')
+        result = export(args.template, args.output, args.metadata, args.manifest)
+        print(original.canonical(dict(complete=True, output=str(args.output), fixtures=result['fixture_count'])), flush=True)

models/male-cns-lif/conditioning-acceleration-v1/finalize_report.py

@@ -0,0 +1,109 @@
+"""Aggregate measured replay-only results; never estimate unmeasured full-training acceleration."""
+import argparse
+from datetime import datetime, timezone
+import hashlib
+import json
+from pathlib import Path
+import statistics
+import subprocess
+
+BASE = Path('/home/qishizhe/phase4ar-v100-acceleration-20261001')
+SOURCE = Path(__file__).resolve().parent
+
+def read(path): return json.loads(Path(path).read_text())
+def sha(path):
+    h = hashlib.sha256()
+    with Path(path).open('rb') as f:
+        for c in iter(lambda: f.read(8 << 20), b''): h.update(c)
+    return h.hexdigest()
+def save(path, data):
+    with Path(path).open('x') as f: json.dump(data, f, indent=2, sort_keys=True, allow_nan=False)
+
+p = argparse.ArgumentParser()
+p.add_argument('--run', action='append', required=True)
+a = p.parse_args()
+assert len(a.run) == len(set(a.run)) == 3
+integrity = read(BASE / 'integrity-after-gpu.json')
+assert integrity['status'] == 'PASS'
+devices = []
+pins = set()
+for name in a.run:
+    path = BASE / name
+    assert path.parent == BASE and path.is_dir()
+    s = read(path / 'summary.json')
+    assert s['status'] == 'PASS-ELIGIBILITY-UPDATE-REPLAY-EQUIVALENCE'
+    assert s['fixtures'] == 30 and s['rejected_invalid_cases'] == 6 and s['all_fixture_repeats_bitwise_exact']
+    process = read(BASE / 'jobs' / (name + '.exit.json'))
+    assert process['observed_exit'] and process['exit_code'] == 0 and not process['timed_out']
+    pins.add(s['candidate_commit'])
+    real = [read(f) for f in sorted(path.glob('fixtures--*.json'))]
+    assert len(real) == 14
+    medians = [r['summaries']['replay_wall_including_preparation_and_comparison_seconds']['median'] for r in real]
+    kernels = [statistics.median(t['kernel_seconds'] for t in r['resident_timing']['resident_kernel_samples']) for r in real]
+    cpu = [r['reference_timing']['warm_update_seconds'] for r in real]
+    cpu_cold = [r['reference_timing']['cold_update_seconds'] for r in real]
+    devices.append(dict(run=name, device=s['device'], real_fixture_count=len(real),
+        median_real_fixture_cpu_original_update_api_seconds=statistics.median(cpu),
+        median_real_fixture_cpu_cold_update_api_seconds=statistics.median(cpu_cold),
+        median_real_fixture_candidate_replay_seconds=statistics.median(medians),
+        median_real_fixture_resident_kernel_seconds=statistics.median(kernels),
+        mean_real_fixture_candidate_replay_seconds=statistics.mean(medians),
+        original_update_api_to_candidate_replay_ratio=statistics.median([x/y for x,y in zip(cpu,medians)]),
+        ratio_warning='Different API overhead boundaries: original U checks/AST every call; candidate authenticates sources/mapping once. NOT pure CPU/GPU hardware ratio.',
+        cpu_baseline_sample_warning='One cold plus ONE warm original API sample per fixture; GPU 3 warmups +20 repeats per fixture.',
+        first_use_compile_seconds=real[0]['first_call_timing']['cold_compile_seconds'],
+        context_initialization_seconds=s['device']['initialization_seconds'],
+        observed_cuda_pool_reserved_peak_bytes=s['observed_cuda_pool_reserved_peak_bytes'],
+        positive_fixtures=30, invalid_inputs_rejected=6, bitwise_exact=True,
+        benchmark_wall_seconds=s['wall_seconds'], result_sha256=sha(path / 'summary.json')))
+assert len(pins) == 1, 'GPU runs used different candidate commits'
+summary = dict(status='PASS-ELIGIBILITY-UPDATE-REPLAY-EQUIVALENCE',
+    created_utc=datetime.now(timezone.utc).isoformat(), benchmark_candidate_commit=next(iter(pins)),
+    report_code_commit=subprocess.check_output(['git','-C',str(SOURCE),'rev-parse','HEAD'],text=True).strip(),
+    devices=devices, frozen_integrity=integrity,
+    scientific_experiment_status='STOPPED, unchanged:1033/30000 CPU-verified training epochs and138/3920 probes',
+    original_experiment_resumed=False, full_training_acceleration_measured=False, weights_installed=False,
+    full_brain_gpu_event_equivalence_tested=False, learned_candidate_created=False,
+    limitations=['Replay module only, not a production training backend',
+      'The sampled committed prefix covers7arms but only available physiological/PAM15/reinforce_A subset',
+      'Repeated kernel calculations reset state and replay identical saved inputs, not additional learning trials',
+      'Original CPU verification remains independent and required',
+      'No simultaneous two-V100 training/scheduling benchmark; devices tested separately',
+      'Original9.07-day estimate is not replaced by this component benchmark'],
+    fixes_preserved=['Initial candidate pip22 lacked--report; upgraded pip only in new venv',
+      'First GPU compile rejected conflictingFTZ options; no kernel executed; explicit nvcc compilation retains original precision'],
+    next_work='Separately validate persistent training/update/verification workers and complete chain timing before authorizing a new scientific execution version')
+save(BASE / 'final-summary.json', summary)
+lines = ['# V100 conditioning acceleration — engineering replay result', '',
+    'Status: **PASS-ELIGIBILITY-UPDATE-REPLAY-EQUIVALENCE**. This is not a learning result or a production-training promotion.', '',
+    f'Benchmark code commit: `{next(iter(pins))}`.', '',
+    '| Device | Real-fixture replay median (prep + transfers + comparison) | Resident CUDA kernel median |',
+    '|---|---:|---:|']
+for d in devices:
+    lines.append(f"| {d['device']['runtime_name']} ({d['run']}) | {d['median_real_fixture_candidate_replay_seconds']*1000:.3f} ms | {d['median_real_fixture_resident_kernel_seconds']*1000:.3f} ms |")
+lines += ['', 'Each GPU passed14sealed real fixtures +16fixed synthetic cases, with sampled trace, final trace, allUS snapshots and delta byte-identical to the original independent CPU oracle. Six invalid inputs were rejected on each GPU.', '',
+    'CPU warm reference includes the original API\'s repeated provenance checks and AST parsing; it is only one warm sample perfixture. GPU authenticates the source and complete anatomical mapping once. Therefore ratios in JSON describe API implementation replay, not pure hardware acceleration.', '',
+    'The CUDA kernels preserve every timestep, float32 separate round-to-nearest operations, exact US timing, noUS zeros, compartment/frozen/D0 identity and the depression floor. No gain/learning-rate/tau/threshold/connectome/sign changes. No dense time×neuron matrix.', '',
+    'A new candidate-only CuPy environment and explicit CUDA12.6 nvcc compilation are used. Original science and ComfyUI environments are unchanged. All three ComfyUI queues were checked before each fixture; no services were stopped.', '',
+    f"Integrity: {integrity['files_checked']} saved files, {integrity['bytes_checked']} bytes, {integrity['sources_checked']} registered source files checked; no mismatch. This is the saved Phase4AR inventory, not a new Phase1–4AQ numerical regression.", '',
+    'Phase4AR remains stopped at1033/30000CPU-verified epochs and138/3920probes. No weights were installed and no training was resumed.', '',
+    'Next: a separately validated persistent-worker pipeline and end-to-end benchmark. This local optimization does not justify dividing the9-day estimate by the kernel speedup. Independent-seed V100 parallelism is not yet measured.', '',
+    'Preserved failures: candidate packaging incompatibility (--report unsupported bypip22); first CuPy compile FTZ flag conflict (before any kernel ran). Both were corrected only in the independent branch.', '',
+    'Compiler references: [CuPy precompiled RawModule](https://docs.cupy.dev/en/v13.6.0/reference/generated/cupy.RawModule.html), [CUDA12.6 compiler options](https://docs.nvidia.com/cuda/archive/12.6.3/cuda-compiler-driver-nvcc/index.html).', '']
+with (BASE / 'RESULTS.md').open('x') as f: f.write('\n'.join(lines))
+# Exclude installed environment, reproducible compiler caches and final manifests themselves;
+# environment packages/wheel hashes are retained in pip-install-report + freeze.
+excluded = {'.venv'}
+files = {}
+for path in sorted(BASE.rglob('*')):
+    rel = path.relative_to(BASE)
+    if path.is_file() and not path.is_symlink() and not any(part in excluded for part in rel.parts):
+        files[rel.as_posix()] = dict(sha256=sha(path), bytes=path.stat().st_size)
+save(BASE / 'artifact-manifest.json', dict(schema='independent-acceleration-artifacts-v1',
+    code_commit=summary['report_code_commit'], source_files={p.name:sha(p) for p in SOURCE.iterdir() if p.is_file()},
+    files=files, excluded=['.venv (package versions and downloaded wheel hashes are in installation receipts)'],
+    no_frozen_source_modified=True, no_training_run=True))
+with (BASE / 'SHA256SUMS').open('x') as f:
+    for rel, info in files.items(): f.write(info['sha256'] + '  ' + rel + '\n')
+    f.write(sha(BASE/'artifact-manifest.json') + '  artifact-manifest.json\n')
+print(json.dumps(summary), flush=True)

models/male-cns-lif/conditioning-acceleration-v1/gpu_backend.py

@@ -0,0 +1,574 @@
+"""Independent CUDA eligibility candidate; never installs weights or runs a brain.
+
+The caller authenticates frozen sources, configuration, the complete KC list,
+and the candidate edge mapping. This module does not infer D from DAN activity.
+CuPy is imported only when CudaEligibility is instantiated. Set CUPY_CACHE_DIR
+to a dedicated candidate directory before doing so. The only files this module
+writes are explicit nvcc build evidence and cubins beneath that cache directory.
+
+API: prepare_events(...) once, then CudaEligibility(...).run(prepared, ...).
+All commands are sampled AFTER the current tick; only the LAST command snapshot
+feeds the single epoch-boundary update. With no commands sampled_trace is +0.
+cpu_reference has the same run arguments for host-only validation, and is not a
+replacement for comparison against the SHA-pinned frozen implementation.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import subprocess
+import time
+from typing import Any
+
+import numpy as np
+
+
+COMPARTMENTS = ("B2B'2a", "a1", "y2a'1", "y5B'2a")
+_INT32_MAX = np.iinfo(np.int32).max
+CUDA_OPTIONS = ("--std=c++11", "--fmad=false", "--ftz=false")
+DEFAULT_NVCC = "/usr/local/cuda/bin/nvcc"
+CUDA_SOURCE = r'''
+extern "C" __global__
+void eligibility_trace(const long long* ptr, const int* ticks,
+                       const int* commands, const int n_commands,
+                       const int n_kc, const int n_steps, const float decay,
+                       float* snapshots, float* final_trace, float* sampled) {
+    const int k = blockDim.x * blockIdx.x + threadIdx.x;
+    if (k >= n_kc) return;
+    long long cursor = ptr[k];
+    const long long end = ptr[k + 1];
+    int command = 0;
+    float trace = 0.0f;
+    float last_sample = 0.0f;
+    // Each KC follows the FULL sequential recurrence, including empty ticks.
+    for (int tick = 0; tick < n_steps; ++tick) {
+        float spike = 0.0f;
+        if (cursor < end && ticks[cursor] == tick) {
+            spike = 1.0f;
+            ++cursor;
+        }
+        trace = __fmul_rn(trace, decay);
+        trace = __fadd_rn(trace, spike);
+        trace = trace < 1.0f ? trace : 1.0f;
+        if (command < n_commands && commands[command] == tick) {
+            snapshots[(long long)command * n_kc + k] = trace;
+            last_sample = trace;
+            ++command;
+        }
+    }
+    final_trace[k] = trace;
+    sampled[k] = last_sample;
+}
+
+extern "C" __global__
+void eligibility_delta(const float* sampled, const int* source_local,
+                       const unsigned char* selected, const float* delta,
+                       const float* base, const int n_edges,
+                       const float negative_eta_times_d,
+                       const float negative_floor, const int nonzero_d,
+                       const int frozen, float* output) {
+    const int edge = blockDim.x * blockIdx.x + threadIdx.x;
+    if (edge >= n_edges) return;
+    if (frozen) {
+        output[edge] = delta[edge];
+        return;
+    }
+    float update = 0.0f;
+    if (nonzero_d && selected[edge])
+        update = __fmul_rn(negative_eta_times_d, sampled[source_local[edge]]);
+    const float out = __fadd_rn(delta[edge], update);
+    const float lower = __fmul_rn(negative_floor, base[edge]);
+    // np.maximum chooses its SECOND operand on equal finite values, including
+    // +0/-0. CUDA fmaxf is deliberately not substituted for that tie behavior.
+    output[edge] = out > lower ? out : lower;
+}
+'''
+
+
+def _file_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _save_json_new(path: Path, value: Any) -> None:
+    with path.open("x", encoding="utf-8", newline="\n") as stream:
+        json.dump(value, stream, sort_keys=True, indent=2, allow_nan=False)
+        stream.write("\n")
+
+
+def _nvcc_cubin(cache_root: Path, capability: str, nvcc_path: Path) -> tuple[Path, dict, dict]:
+    """Compile outside CuPy's compiler path, which injects -ftz=true in 13.6.
+
+    A cache entry is immutable. Failed/incomplete entries are retained and cause
+    an error on reuse; the caller can select a fresh candidate cache directory.
+    Only the subprocess's temporary-directory environment is changed.
+    """
+    probe_started = time.perf_counter()
+    _require(capability.isdigit() and 2 <= len(capability) <= 3, "invalid CUDA compute capability")
+    _require(cache_root.is_absolute(), "candidate cache directory must be absolute")
+    _require(nvcc_path.is_absolute() and nvcc_path.is_file(), "nvcc must be an existing absolute compiler path")
+    _require(not any(os.environ.get(key, "").strip()
+                     for key in ("NVCC_PREPEND_FLAGS", "NVCC_APPEND_FLAGS")),
+             "NVCC injected flags are incompatible with explicit candidate compiler options")
+    cache_root = cache_root.resolve()
+    nvcc_path = nvcc_path.resolve()
+    version = subprocess.run([str(nvcc_path), "--version"], capture_output=True, text=True,
+                             timeout=30, check=False)
+    _require(version.returncode == 0, "nvcc --version failed: " + version.stderr)
+    options = ("--cubin", "-arch=sm_" + capability, *CUDA_OPTIONS, "--keep")
+    identity = dict(schema="conditioning-cuda-nvcc-build-v1",
+                    source_sha256=hashlib.sha256(CUDA_SOURCE.encode("utf-8")).hexdigest(),
+                    nvcc_path=str(nvcc_path), nvcc_sha256=_file_sha256(nvcc_path),
+                    nvcc_version_stdout=version.stdout, nvcc_version_stderr=version.stderr,
+                    options=list(options), compute_capability=capability,
+                    nvcc_ccbin=os.environ.get("NVCC_CCBIN", ""))
+    key = hashlib.sha256(json.dumps(identity, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+    build_dir = cache_root / "eligibility-nvcc" / key
+    _require(not build_dir.is_symlink() and build_dir.resolve().is_relative_to(cache_root),
+             "candidate build cache path escapes the requested directory")
+    cubin = build_dir / "eligibility.cubin"
+    receipt_path = build_dir / "build-receipt.json"
+    probe_seconds = time.perf_counter() - probe_started
+    if build_dir.exists():
+        _require(receipt_path.is_file(), "incomplete nvcc candidate build retained: " + str(build_dir))
+        receipt = json.loads(receipt_path.read_text(encoding="utf-8"))
+        _require(receipt.get("complete") is True and receipt["identity"] == identity,
+                 "failed or mismatched nvcc candidate build retained: " + str(build_dir))
+        for name, expected in receipt["files_sha256"].items():
+            path = build_dir / name
+            _require(path.name == name and not path.is_symlink()
+                     and path.resolve().is_relative_to(build_dir)
+                     and _file_sha256(path) == expected, "nvcc cache artifact changed: " + name)
+        _require(receipt["files_sha256"].get("eligibility.cubin") == _file_sha256(cubin)
+                 and receipt["files_sha256"].get("eligibility.cu") == identity["source_sha256"],
+                 "nvcc cache lacks authenticated source/cubin")
+        return cubin, dict(cache_key=key, cache_directory=str(build_dir), cache_hit=True,
+                           receipt_sha256=_file_sha256(receipt_path), **receipt), dict(
+                               compiler_probe_seconds=probe_seconds, nvcc_compile_seconds=0.0)
+    build_dir.mkdir(parents=True, exist_ok=False)
+    source_path = build_dir / "eligibility.cu"
+    with source_path.open("x", encoding="utf-8", newline="\n") as stream:
+        stream.write(CUDA_SOURCE)
+    command = [str(nvcc_path), *options, "--keep-dir", str(build_dir),
+               str(source_path), "-o", str(cubin)]
+    _save_json_new(build_dir / "compile-command.json", dict(argv=command, cwd=str(build_dir),
+        temp_directory=str(build_dir), inherited_nvcc_injected_flags=False))
+    _save_json_new(build_dir / "compiler-identity.json", identity)
+    environment = dict(os.environ, TMPDIR=str(build_dir), TMP=str(build_dir), TEMP=str(build_dir))
+    compile_started = time.perf_counter()
+    returncode = None
+    failure = None
+    try:
+        with (build_dir / "compiler.stdout.log").open("xb") as stdout, \
+                (build_dir / "compiler.stderr.log").open("xb") as stderr:
+            process = subprocess.run(command, cwd=build_dir, env=environment,
+                                     stdout=stdout, stderr=stderr, timeout=120, check=False)
+        returncode = process.returncode
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        failure = f"{type(exc).__name__}: {exc}"
+    compile_seconds = time.perf_counter() - compile_started
+    complete = returncode == 0 and cubin.is_file() and cubin.stat().st_size > 0
+    receipt = dict(complete=complete, identity=identity, command=command,
+                   returncode=returncode, failure=failure,
+                   nvcc_compile_seconds=compile_seconds,
+                   files_sha256={path.name: _file_sha256(path) for path in sorted(build_dir.iterdir())
+                                 if path.is_file() and not path.is_symlink()})
+    _save_json_new(receipt_path, receipt)
+    if not complete:
+        raise RuntimeError("explicit nvcc candidate compilation failed; evidence retained at " + str(build_dir))
+    return cubin, dict(cache_key=key, cache_directory=str(build_dir), cache_hit=False,
+                       receipt_sha256=_file_sha256(receipt_path), **receipt), dict(
+                           compiler_probe_seconds=probe_seconds, nvcc_compile_seconds=compile_seconds)
+
+
+def _require(condition: Any, message: str) -> None:
+    if not condition:
+        raise ValueError(message)
+
+
+def _integer(value: Any, name: str, minimum: int = 1) -> int:
+    _require(isinstance(value, (int, np.integer)) and not isinstance(value, (bool, np.bool_)),
+             f"{name} must be an integer")
+    _require(minimum <= int(value) <= _INT32_MAX, f"{name} outside supported int32 range")
+    return int(value)
+
+
+def _array(value: Any, dtype: Any, name: str) -> np.ndarray:
+    _require(isinstance(value, np.ndarray) and value.ndim == 1 and value.dtype == np.dtype(dtype),
+             f"{name} must be a one-dimensional {np.dtype(dtype)} ndarray")
+    return value
+
+
+def _owned(value: np.ndarray) -> np.ndarray:
+    result = np.array(value, copy=True, order="C")
+    result.setflags(write=False)
+    return result
+
+
+def _scalar(value: Any, name: str) -> float:
+    _require(isinstance(value, (float, int, np.floating, np.integer))
+             and not isinstance(value, (bool, np.bool_)), f"{name} must be a real scalar")
+    try:
+        result = float(value)
+    except (ValueError, OverflowError) as exc:
+        raise ValueError(f"{name} must be a finite scalar") from exc
+    _require(math.isfinite(result), f"{name} must be finite")
+    return result
+
+
+@dataclass(frozen=True)
+class PreparedEvents:
+    kc: np.ndarray
+    indptr: np.ndarray
+    ticks: np.ndarray
+    command_steps: np.ndarray
+    steps: int
+    n_neurons: int
+    input_event_count: int
+    preparation_seconds: float
+
+    @property
+    def kc_event_count(self) -> int:
+        return len(self.ticks)
+
+
+@dataclass(frozen=True)
+class EligibilityResult:
+    sampled_trace: np.ndarray
+    final_trace: np.ndarray
+    snapshots: np.ndarray
+    delta_after: np.ndarray
+    timing: dict[str, Any]
+    audit: dict[str, Any]
+
+
+def prepare_events(step: np.ndarray, neuron_idx: np.ndarray, kc: np.ndarray,
+                   steps: int, command_steps: Any, *, n_neurons: int = 166700) -> PreparedEvents:
+    """Validate original sparse events and pack sorted per-KC event CSR on CPU.
+
+    Inputs must be sorted by (tick, global neuron ID), unique and int32. No
+    [steps, neurons] raster is allocated. Original input storage is not retained.
+    Empty, one, or multiple sorted unique command ticks are supported.
+    """
+    started = time.perf_counter()
+    steps = _integer(steps, "steps")
+    n_neurons = _integer(n_neurons, "n_neurons")
+    step = _array(step, np.int32, "step")
+    neuron_idx = _array(neuron_idx, np.int32, "neuron_idx")
+    kc = _array(kc, np.int32, "kc")
+    _require(0 < len(kc) <= _INT32_MAX and np.all((kc >= 0) & (kc < n_neurons)),
+             "KC IDs empty or outside graph")
+    _require(np.all(kc[1:] > kc[:-1]), "KC IDs must be sorted unique global IDs")
+    _require(len(step) == len(neuron_idx), "event columns have different lengths")
+    _require(np.all((step >= 0) & (step < steps)), "event tick outside trial")
+    _require(np.all((neuron_idx >= 0) & (neuron_idx < n_neurons)), "event neuron outside graph")
+    _require(np.all((step[1:] > step[:-1]) |
+                    ((step[1:] == step[:-1]) & (neuron_idx[1:] > neuron_idx[:-1]))),
+             "events must be sorted by tick/global ID and unique")
+    commands = np.asarray(command_steps)
+    _require(commands.ndim == 1, "command_steps must be one-dimensional")
+    if commands.size == 0:
+        commands = np.empty(0, np.int32)
+    _require(commands.dtype.kind in "iu", "command_steps must be integers")
+    _require(np.all((commands >= 0) & (commands < steps)), "command tick outside trial")
+    _require(np.all(commands[1:] > commands[:-1]), "command_steps must be sorted unique")
+    local = np.searchsorted(kc, neuron_idx)
+    keep = (local < len(kc)) & (kc[np.minimum(local, len(kc) - 1)] == neuron_idx)
+    local = local[keep]
+    order = np.argsort(local, kind="stable")
+    ticks = step[keep][order]
+    counts = np.bincount(local, minlength=len(kc)).astype(np.int64, copy=False)
+    ptr = np.empty(len(kc) + 1, np.int64)
+    ptr[0] = 0
+    np.cumsum(counts, out=ptr[1:])
+    return PreparedEvents(_owned(kc), _owned(ptr), _owned(ticks),
+                          _owned(commands.astype(np.int32)), steps, n_neurons,
+                          len(step), time.perf_counter() - started)
+
+
+def _validate_prepared(prepared: PreparedEvents) -> None:
+    _require(isinstance(prepared, PreparedEvents), "prepared must come from prepare_events")
+    _integer(prepared.steps, "steps")
+    _integer(prepared.n_neurons, "n_neurons")
+    kc = _array(prepared.kc, np.int32, "prepared.kc")
+    ptr = _array(prepared.indptr, np.int64, "prepared.indptr")
+    ticks = _array(prepared.ticks, np.int32, "prepared.ticks")
+    commands = _array(prepared.command_steps, np.int32, "prepared.command_steps")
+    _require(0 < len(kc) <= _INT32_MAX and np.all((kc >= 0) & (kc < prepared.n_neurons))
+             and np.all(kc[1:] > kc[:-1]), "invalid prepared KC IDs")
+    _require(len(ptr) == len(kc) + 1 and ptr[0] == 0 and ptr[-1] == len(ticks)
+             and np.all(ptr[1:] >= ptr[:-1]), "invalid prepared CSR offsets")
+    _require(np.all((ticks >= 0) & (ticks < prepared.steps)), "invalid prepared event ticks")
+    # A decrease/equality is permitted only at a CSR row boundary. Checking all
+    # adjacent pairs stays vectorized and also catches a forged PreparedEvents.
+    nonincreasing = ticks[1:] <= ticks[:-1]
+    if len(ticks) > 1:
+        boundaries = ptr[1:-1]
+        boundaries = boundaries[(boundaries > 0) & (boundaries < len(ticks))] - 1
+        nonincreasing[boundaries] = False
+    _require(not np.any(nonincreasing), "prepared KC ticks must be sorted unique")
+    _require(np.all((commands >= 0) & (commands < prepared.steps))
+             and np.all(commands[1:] > commands[:-1]), "invalid prepared command ticks")
+
+
+def _validate_run(prepared, candidate_sources, candidate_compartments, compartment,
+                  delta_before, base_candidate, d, frozen, eta_mv, floor_fraction, decay):
+    _validate_prepared(prepared)
+    sources = _array(candidate_sources, np.int32, "candidate_sources")
+    delta = _array(delta_before, np.float32, "delta_before")
+    base = _array(base_candidate, np.float32, "base_candidate")
+    comps = candidate_compartments
+    _require(isinstance(comps, np.ndarray) and comps.ndim == 1 and comps.dtype.kind == "U",
+             "candidate_compartments must be a Unicode vector")
+    _require(len(delta) <= _INT32_MAX and len(sources) == len(delta) == len(base) == len(comps),
+             "candidate columns have different lengths or exceed int32 capacity")
+    _require(compartment in COMPARTMENTS and np.all(np.isin(comps, COMPARTMENTS)),
+             "unrecognized exact frozen compartment")
+    local = np.searchsorted(prepared.kc, sources)
+    _require(np.all(local < len(prepared.kc)), "all candidate sources must be canonical KCs")
+    _require(np.all(prepared.kc[local] == sources), "all candidate sources must be canonical KCs")
+    d = _scalar(d, "D")
+    _require(d in (0.0, 1.0), "D must be the fixed artificial scalar 0 or 1")
+    _require(isinstance(frozen, (bool, np.bool_)), "frozen must be Boolean")
+    eta = _scalar(eta_mv, "eta_mv")
+    floor = _scalar(floor_fraction, "floor_fraction")
+    decay_value = _scalar(decay, "decay")
+    _require(0 < eta <= np.finfo(np.float32).max, "eta_mv must be positive finite float32 representable")
+    _require(0 < floor <= 1, "floor_fraction must lie in (0,1]")
+    _require(0 < decay_value <= 1, "decay must lie in (0,1]")
+    _require(np.float32(eta) > 0 and np.float32(floor) > 0 and np.float32(decay_value) > 0,
+             "rule scalar underflows float32")
+    _require(np.all(np.isfinite(base)) and np.all(base > 0),
+             "original base must be finite positive float32 mV")
+    lower = np.float32(-floor) * base
+    _require(np.all(np.isfinite(delta)) and np.all((delta >= lower) & (delta <= 0)),
+             "delta violates original frozen floor")
+    _require(not np.any((delta == 0) & np.signbit(delta)), "delta zero must be canonical +0")
+    return dict(local=np.array(local, dtype=np.int32, order="C"),
+                selected=np.asarray(comps == compartment, dtype=np.uint8),
+                delta=np.array(delta, copy=True, order="C"),
+                base=np.array(base, copy=True, order="C"), d=d, frozen=bool(frozen),
+                eta=eta, floor=floor, decay=decay_value,
+                negative_eta_times_d=np.float32(-eta * d), negative_floor=np.float32(-floor))
+
+
+def _audit(prepared: PreparedEvents, work: dict, backend: str) -> dict[str, Any]:
+    return dict(backend=backend, steps=prepared.steps, kc_count=len(prepared.kc),
+                events=prepared.input_event_count, actual_kc_events=prepared.kc_event_count,
+                command_count=len(prepared.command_steps), candidate_count=len(work["base"]),
+                d_command=work["d"], frozen=work["frozen"], eta_mv=work["eta"],
+                floor_fraction=work["floor"], decay_python_float=work["decay"],
+                decay_float32_bits=int(np.asarray(np.float32(work["decay"])).view(np.uint32)),
+                initial_trace="float32 canonical +0", sampling="after_current_tick_spike",
+                update_sample="last command snapshot, or canonical +0 without commands",
+                trace_tick_skipping=False, dense_tick_neuron_raster=False,
+                original_source_executed=False, caller_must_verify_source_identity=True,
+                source_identity_verified_by_this_module=False,
+                complete_mapping_verified_by_this_module=False,
+                d_semantics="artificial scheduled command; not measured DAN activity",
+                actual_dan_activity_used_to_gate=False, brain_dynamics_executed=False,
+                training_executed=False, weights_installed=False, learning_pass_claimed=False)
+
+
+def cpu_reference(prepared: PreparedEvents, candidate_sources: np.ndarray,
+                  candidate_compartments: np.ndarray, compartment: str,
+                  delta_before: np.ndarray, base_candidate: np.ndarray, *, d: float,
+                  frozen: bool, eta_mv: float, floor_fraction: float, decay: float) -> EligibilityResult:
+    """Host arithmetic mirror for tests; frozen-source validation is external."""
+    started = time.perf_counter()
+    work = _validate_run(prepared, candidate_sources, candidate_compartments, compartment,
+                         delta_before, base_candidate, d, frozen, eta_mv, floor_fraction, decay)
+    nkc = len(prepared.kc)
+    trace = np.zeros(nkc, np.float32)
+    snapshots = np.empty((len(prepared.command_steps), nkc), np.float32)
+    positions = prepared.indptr[:-1].copy()
+    ends = prepared.indptr[1:]
+    spike = np.zeros(nkc, np.float32)
+    command = 0
+    for tick in range(prepared.steps):
+        spike.fill(0)
+        active = np.flatnonzero(positions < ends)
+        active = active[prepared.ticks[positions[active]] == tick]
+        spike[active] = np.float32(1)
+        positions[active] += 1
+        np.multiply(trace, np.float32(work["decay"]), out=trace)
+        np.add(trace, spike, out=trace)
+        np.minimum(trace, np.float32(1), out=trace)
+        if command < len(prepared.command_steps) and prepared.command_steps[command] == tick:
+            snapshots[command] = trace
+            command += 1
+    sampled = snapshots[-1].copy() if len(snapshots) else np.zeros(nkc, np.float32)
+    output = work["delta"].copy()
+    if not work["frozen"]:
+        update = np.zeros(len(output), np.float32)
+        selected = work["selected"].astype(bool)
+        if work["d"] != 0:
+            update[selected] = work["negative_eta_times_d"] * sampled[work["local"][selected]]
+        output = output + update
+        output = np.maximum(output, work["negative_floor"] * work["base"]).astype(np.float32)
+    return EligibilityResult(_owned(sampled), _owned(trace), _owned(snapshots), _owned(output),
+                             dict(end_to_end_seconds=time.perf_counter() - started,
+                                  preparation_seconds=prepared.preparation_seconds),
+                             _audit(prepared, work, "numpy-host-math-mirror"))
+
+
+class CudaEligibility:
+    """Explicit nvcc cubin, loaded by CuPy, with separate float32 rounding.
+
+    Use a dedicated environment and set an absolute CUPY_CACHE_DIR outside any
+    frozen tree before construction. The first run builds or authenticates one
+    nvcc cubin and loads its kernels with RawModule(path=...). CuPy's compiler
+    is not called, so it cannot inject an incompatible FTZ option. Cold timing
+    separates nvcc compilation, compiler probing and driver module loading.
+    run includes validation, transfers and output ownership in end-to-end wall.
+    """
+
+    def __init__(self, device_index: int = 0, *, nvcc_path: str = DEFAULT_NVCC):
+        started = time.perf_counter()
+        self.device_index = _integer(device_index, "device_index", 0)
+        cache_dir = os.environ.get("CUPY_CACHE_DIR", "")
+        _require(bool(cache_dir) and Path(cache_dir).is_absolute(),
+                 "set CUPY_CACHE_DIR to an absolute candidate cache directory outside frozen trees")
+        self.cache_root = Path(cache_dir)
+        self.nvcc_path = Path(nvcc_path)
+        try:
+            import cupy as cp
+        except ImportError as exc:
+            raise RuntimeError("CuPy unavailable; use the dedicated CUDA candidate environment") from exc
+        self.cp = cp
+        self.device = cp.cuda.Device(self.device_index)
+        with self.device:
+            self.stream = cp.cuda.Stream(non_blocking=True)
+            self.device.synchronize()
+        self.initialization_seconds = time.perf_counter() - started
+        self._compiled = False
+
+    def run(self, prepared: PreparedEvents, candidate_sources: np.ndarray,
+            candidate_compartments: np.ndarray, compartment: str,
+            delta_before: np.ndarray, base_candidate: np.ndarray, *, d: float,
+            frozen: bool, eta_mv: float, floor_fraction: float, decay: float,
+            kernel_warmup: int = 0, kernel_repeats: int = 1) -> EligibilityResult:
+        """Transfer one fixture and optionally benchmark resident kernel repeats.
+
+        Each repeat starts from zero trace and the SAME delta_before; repeats
+        never accumulate training updates. CUDA timing fields are medians across
+        kernel_repeats. end_to_end_seconds includes all warmups and repeats, so
+        use default counts for a single-call end-to-end benchmark.
+        """
+        started = time.perf_counter()
+        work = _validate_run(prepared, candidate_sources, candidate_compartments, compartment,
+                             delta_before, base_candidate, d, frozen, eta_mv, floor_fraction, decay)
+        kernel_warmup = _integer(kernel_warmup, "kernel_warmup", 0)
+        kernel_repeats = _integer(kernel_repeats, "kernel_repeats")
+        validation_seconds = time.perf_counter() - started
+        cp = self.cp
+        first_run = not self._compiled
+        compile_seconds = 0.0
+        compilation_timing = dict(compiler_probe_seconds=0.0, nvcc_compile_seconds=0.0,
+                                  module_load_seconds=0.0)
+        with self.device, self.stream:
+            if first_run:
+                compile_started = time.perf_counter()
+                cubin, self.compilation_audit, probe_timing = _nvcc_cubin(
+                    self.cache_root, str(self.device.compute_capability), self.nvcc_path)
+                compilation_timing.update(probe_timing)
+                load_started = time.perf_counter()
+                self.module = cp.RawModule(path=str(cubin))
+                self.trace_kernel = self.module.get_function("eligibility_trace")
+                self.delta_kernel = self.module.get_function("eligibility_delta")
+                self.stream.synchronize()
+                compilation_timing["module_load_seconds"] = time.perf_counter() - load_started
+                compile_seconds = time.perf_counter() - compile_started
+                self._compiled = True
+            transfer_started = time.perf_counter()
+            ptr_gpu, ticks_gpu, commands_gpu, local_gpu, selected_gpu, delta_gpu, base_gpu = [
+                cp.asarray(a) for a in (prepared.indptr, prepared.ticks, prepared.command_steps,
+                                       work["local"], work["selected"], work["delta"], work["base"])]
+            nkc, nedges = len(prepared.kc), len(work["delta"])
+            snapshots_gpu = cp.empty((len(prepared.command_steps), nkc), cp.float32)
+            final_gpu = cp.empty(nkc, cp.float32)
+            sampled_gpu = cp.empty(nkc, cp.float32)
+            output_gpu = cp.empty(nedges, cp.float32)
+            self.stream.synchronize()
+            upload_seconds = time.perf_counter() - transfer_started
+            trace_args = (
+                ptr_gpu, ticks_gpu, commands_gpu, np.int32(len(prepared.command_steps)),
+                np.int32(nkc), np.int32(prepared.steps), np.float32(work["decay"]),
+                snapshots_gpu, final_gpu, sampled_gpu)
+            delta_args = (
+                sampled_gpu, local_gpu, selected_gpu, delta_gpu, base_gpu,
+                np.int32(nedges), work["negative_eta_times_d"], work["negative_floor"],
+                np.int32(work["d"] != 0), np.int32(work["frozen"]), output_gpu)
+
+            def launch_pair():
+                self.trace_kernel(((nkc + 127) // 128,), (128,), trace_args)
+                if nedges:
+                    self.delta_kernel(((nedges + 255) // 256,), (256,), delta_args)
+
+            for _ in range(kernel_warmup):
+                launch_pair()
+            self.stream.synchronize()
+            resident_samples = []
+            for _ in range(kernel_repeats):
+                trace_start, trace_end, update_end = cp.cuda.Event(), cp.cuda.Event(), cp.cuda.Event()
+                trace_start.record(self.stream)
+                self.trace_kernel(((nkc + 127) // 128,), (128,), trace_args)
+                trace_end.record(self.stream)
+                if nedges:
+                    self.delta_kernel(((nedges + 255) // 256,), (256,), delta_args)
+                update_end.record(self.stream)
+                update_end.synchronize()
+                resident_samples.append(dict(
+                    trace_kernel_seconds=cp.cuda.get_elapsed_time(trace_start, trace_end) / 1000.0,
+                    update_kernel_seconds=cp.cuda.get_elapsed_time(trace_end, update_end) / 1000.0,
+                    kernel_seconds=cp.cuda.get_elapsed_time(trace_start, update_end) / 1000.0))
+            medians = {key: float(np.median([sample[key] for sample in resident_samples]))
+                       for key in resident_samples[0]}
+            download_started = time.perf_counter()
+            sampled, final, snapshots, output = [
+                _owned(cp.asnumpy(a, stream=self.stream, blocking=True))
+                for a in (sampled_gpu, final_gpu, snapshots_gpu, output_gpu)]
+            download_seconds = time.perf_counter() - download_started
+        guard_started = time.perf_counter()
+        for name, array in (("sampled_trace", sampled), ("final_trace", final), ("snapshots", snapshots)):
+            if not (np.all(np.isfinite(array)) and np.all((array >= 0) & (array <= 1))):
+                raise RuntimeError(f"CUDA output guard failed: invalid {name}")
+        lower = work["negative_floor"] * work["base"]
+        if not (np.all(np.isfinite(output)) and np.all((output >= lower) & (output <= 0))):
+            raise RuntimeError("CUDA output guard failed: delta outside finite frozen floor")
+        selected = work["selected"].astype(bool)
+        if output[~selected].tobytes() != work["delta"][~selected].tobytes():
+            raise RuntimeError("CUDA output guard failed: off-compartment delta changed")
+        if (work["frozen"] or work["d"] == 0) and output.tobytes() != work["delta"].tobytes():
+            raise RuntimeError("CUDA output guard failed: frozen/zero-D identity")
+        guard_seconds = time.perf_counter() - guard_started
+        timing = dict(first_run=first_run, initialization_seconds=self.initialization_seconds,
+                      cold_compile_seconds=compile_seconds,
+                      **compilation_timing,
+                      compile_timing_semantics="first-use nvcc probe/build or authenticated cache, then driver module load",
+                      preparation_seconds=prepared.preparation_seconds,
+                      run_validation_seconds=validation_seconds,
+                      host_to_device_and_allocation_seconds=upload_seconds,
+                      **medians, device_to_host_seconds=download_seconds,
+                      output_guard_seconds=guard_seconds,
+                      resident_kernel_warmup=kernel_warmup,
+                      resident_kernel_repeats=kernel_repeats,
+                      resident_kernel_samples=resident_samples,
+                      kernel_statistic="median of resident timed repeats",
+                      end_to_end_semantics="all requested warmups/repeats and transfers; preparation excluded",
+                      end_to_end_seconds=time.perf_counter() - started)
+        audit = _audit(prepared, work, "nvcc-cubin-cupy-independent-candidate")
+        audit.update(numpy_version=str(np.__version__), cupy_version=str(cp.__version__),
+                     device_index=self.device_index, cuda_options=list(CUDA_OPTIONS),
+                     compiler_backend="external nvcc --cubin; CuPy RawModule path loading only",
+                     compilation=self.compilation_audit,
+                     float32_separate_rounding_intrinsics=True, tf32_used=False,
+                     numerical_equivalence_established_by_this_call=False)
+        return EligibilityResult(sampled, final, snapshots, output, timing, audit)

models/male-cns-lif/conditioning-acceleration-v1/launch_job.py

@@ -0,0 +1,36 @@
+"""Write new engineering child-process exit receipts; never retry a job."""
+import argparse
+from datetime import datetime, timezone
+import json
+import os
+from pathlib import Path
+import re
+import subprocess
+import time
+
+p = argparse.ArgumentParser()
+p.add_argument('--label', required=True)
+p.add_argument('--timeout', type=int, default=900)
+p.add_argument('command', nargs=argparse.REMAINDER)
+a = p.parse_args()
+assert re.fullmatch(r'[a-z0-9-]+', a.label)
+assert a.command
+out = Path('/home/qishizhe/phase4ar-v100-acceleration-20261001') / 'jobs'
+out.mkdir(exist_ok=True)
+start = time.perf_counter()
+receipt = dict(command=a.command, label=a.label, started_utc=datetime.now(timezone.utc).isoformat(),
+               original_experiment_resumed=False)
+with (out / (a.label + '.start.json')).open('x') as f:
+    json.dump(receipt, f, indent=2)
+with (out / (a.label + '.stdout.log')).open('x') as stdout, (out / (a.label + '.stderr.log')).open('x') as stderr:
+    try:
+        result = subprocess.run(a.command, stdout=stdout, stderr=stderr,
+            env={**os.environ, 'PYTHONDONTWRITEBYTECODE': '1'}, timeout=a.timeout)
+        receipt.update(exit_code=result.returncode, observed_exit=True, timed_out=False)
+    except subprocess.TimeoutExpired:
+        receipt.update(exit_code=None, observed_exit=False, timed_out=True)
+receipt.update(wall_seconds=time.perf_counter()-start, finished_utc=datetime.now(timezone.utc).isoformat())
+with (out / (a.label + '.exit.json')).open('x') as f:
+    json.dump(receipt, f, indent=2)
+print(json.dumps(receipt), flush=True)
+raise SystemExit(receipt['exit_code'] if receipt['observed_exit'] else 124)

models/male-cns-lif/conditioning-acceleration-v1/repair_environment.py

@@ -0,0 +1,22 @@
+"""Log repair of candidate-only packaging tool; preserve first failed attempt."""
+import json
+import os
+from pathlib import Path
+import subprocess
+
+OUT = Path('/home/qishizhe/phase4ar-v100-acceleration-20261001')
+PYTHON = OUT / '.venv/bin/python'
+assert PYTHON.exists() and (OUT / 'install-candidate.stderr.log').exists()
+
+def run(args, stem):
+    with (OUT / (stem + '.stdout.log')).open('x') as stdout, (OUT / (stem + '.stderr.log')).open('x') as stderr:
+        result = subprocess.run([str(PYTHON), '-B', '-m', 'pip', *args], stdout=stdout, stderr=stderr,
+                                env={**os.environ, 'PYTHONDONTWRITEBYTECODE': '1'})
+    print(json.dumps({'step': stem, 'exit_code': result.returncode}), flush=True)
+    if result.returncode:
+        raise RuntimeError(stem)
+
+run(['install', '--disable-pip-version-check', 'pip==25.2'], 'upgrade-candidate-pip')
+run(['install', '--disable-pip-version-check', '--report', str(OUT / 'pip-install-report.json'),
+     'numpy==2.2.6', 'cupy-cuda12x==13.6.0'], 'install-candidate-attempt-02')
+run(['freeze'], 'candidate-freeze')

models/male-cns-lif/conditioning-acceleration-v1/requirements-candidate.txt

@@ -0,0 +1,2 @@
+numpy==2.2.6
+cupy-cuda12x==13.6.0

models/male-cns-lif/conditioning-acceleration-v1/setup_environment.py

@@ -0,0 +1,33 @@
+"""Provision only a new worktree and independent benchmark environment."""
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+from datetime import datetime, timezone
+
+ROOT=Path('/data/digital-drosophila')
+WORK=Path('/home/qishizhe/digital-drosophila-v100-acceleration')
+OUT=Path('/home/qishizhe/phase4ar-v100-acceleration-20261001')
+BASE='09187e4d4d67badf1b418c5f211258ca5d8fb328'
+
+def run(argv, log):
+    with (OUT/(log+'.stdout.log')).open('x') as out, (OUT/(log+'.stderr.log')).open('x') as err:
+        r=subprocess.run(argv,stdout=out,stderr=err,env={**os.environ,'PYTHONDONTWRITEBYTECODE':'1'})
+    print(json.dumps({'step':log,'exit_code':r.returncode}),flush=True)
+    if r.returncode:raise RuntimeError('Environment preparation failed: '+log)
+
+assert not WORK.exists() and not OUT.exists(), 'Provisioning targets must be new'
+assert subprocess.check_output(['git','-C',str(ROOT),'rev-parse','HEAD'],text=True).strip()==BASE
+assert subprocess.check_output(['git','-C',str(ROOT),'status','--porcelain'],text=True)==''
+OUT.mkdir()
+with (OUT/'environment-authority.json').open('x') as f:
+    json.dump(dict(scope='independent engineering replay only',base_commit=BASE,
+        created_utc=datetime.now(timezone.utc).isoformat(),original_science_environment_modified=False,
+        original_experiment_resumed=False),f,indent=2)
+run(['git','-C',str(ROOT),'worktree','add','-b','codex/v100-conditioning-acceleration',str(WORK),BASE],'create-worktree')
+run([sys.executable,'-m','venv',str(OUT/'.venv')],'create-venv')
+run([str(OUT/'.venv/bin/python'),'-B','-m','pip','install','--disable-pip-version-check',
+    '--report',str(OUT/'pip-install-report.json'),'numpy==2.2.6','cupy-cuda12x==13.6.0'],'install-candidate')
+run([str(OUT/'.venv/bin/python'),'-B','-m','pip','freeze'],'candidate-freeze')
+print(json.dumps({'worktree':str(WORK),'benchmark_root':str(OUT),'environment_ready':True}),flush=True)

models/male-cns-lif/conditioning-acceleration-v1/test_export_fixtures.py

@@ -0,0 +1,135 @@
+"""Small authority/selection tests; never access or run the production brain."""
+import importlib.util
+from pathlib import Path
+import tempfile
+import unittest
+
+
+PATH = Path(__file__).with_name('export_fixtures.py')
+SPEC = importlib.util.spec_from_file_location('acceleration_fixture_export_tests', PATH)
+E = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(E)
+
+
+def task(arm, number, kind='train'):
+    return dict(task_id=f'block/normal/{arm}/{number:03d}', arm=arm, kind=kind)
+
+
+def committed(tasks):
+    return {E.task_key(t) + '--' + stage for t in tasks for stage in ('brain', 'update', 'verify')}
+
+
+class SelectionTests(unittest.TestCase):
+    def test_fixed_first_last_all_seven_arms_before_metrics(self):
+        tasks = [task(arm, n) for arm in E.ARMS for n in range(5)]
+        selected, counts = E.select_tasks(list(reversed(tasks)), committed(tasks))
+        self.assertEqual(len(selected), 14)
+        self.assertEqual(counts, {arm: 5 for arm in E.ARMS})
+        self.assertEqual([(t['arm'], t['task_id'].split('/')[-1]) for t in selected],
+                         [(arm, n) for arm in E.ARMS for n in ('000', '004')])
+
+    def test_uncommitted_last_is_not_selected(self):
+        tasks = [task('paired', n) for n in range(4)]
+        ids = committed(tasks)
+        ids.remove(E.task_key(tasks[-1]) + '--verify')
+        selected, counts = E.select_tasks(tasks, ids)
+        self.assertEqual(selected, [tasks[0], tasks[2]])
+        self.assertEqual(counts['paired'], 3)
+
+    def test_probe_and_duplicate_selection(self):
+        train, probe = task('paired', 0), task('paired', 1, 'probe')
+        selected, _ = E.select_tasks([train, probe], committed([train, probe]))
+        self.assertEqual(selected, [train])
+        with self.assertRaisesRegex(ValueError, 'Duplicate'):
+            E.select_tasks([train, train], committed([train]))
+
+    def test_no_complete_triple_fails(self):
+        train = task('paired', 0)
+        with self.assertRaisesRegex(ValueError, 'No committed'):
+            E.select_tasks([train], {E.task_key(train) + '--verify'})
+
+
+class FileSafetyTests(unittest.TestCase):
+    def test_output_must_be_new_and_outside_protected(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary).resolve()
+            frozen = root / 'frozen'
+            frozen.mkdir()
+            with self.assertRaisesRegex(ValueError, 'fresh'):
+                E.validate_destination(frozen, [frozen])
+            with self.assertRaisesRegex(ValueError, 'overlaps'):
+                E.validate_destination(frozen / 'new', [frozen])
+            self.assertEqual(E.validate_destination(root / 'allowed', [frozen]), root / 'allowed')
+            self.assertFalse((root / 'allowed').exists())
+
+    def test_exclusive_save_and_mismatch_rejection(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            path = Path(temporary).resolve() / 'new.json'
+            E.save(path, {'a': 1})
+            original = path.read_bytes()
+            with self.assertRaises(FileExistsError):
+                E.save(path, {'a': 2})
+            self.assertEqual(path.read_bytes(), original)
+            with self.assertRaisesRegex(ValueError, 'Pinned bytes'):
+                E.check(path, '0' * 64)
+
+    def test_duplicate_json_rejected(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            path = Path(temporary).resolve() / 'bad.json'
+            path.write_text('{"a":1,"a":2}', encoding='utf-8')
+            with self.assertRaisesRegex(ValueError, 'Duplicate'):
+                E.read(path)
+
+
+class ProcessAuthorityTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.root = Path(self.temp.name).resolve()
+        self.name = 'task-synthetic--verify'
+        self.job_path = self.root / 'jobs' / (self.name + '.json')
+        self.process_path = self.root / 'receipts' / self.name / 'process.json'
+        self.job_path.parent.mkdir()
+        self.process_path.parent.mkdir(parents=True)
+        E.save(self.job_path, dict(registration_sha256=E.REG_SHA, input_sha256={}))
+        self.process = dict(entry_id=self.name, registration_sha256=E.REG_SHA,
+            job_sha256=E.digest(self.job_path), complete=True, exit_code=0, timed_out=False,
+            exit_observed_by_parent=True, launch_error=None, argv=[str(E.ORIGINAL_ENV / 'bin/python'), '-B', 'validator.py'])
+
+    def tearDown(self):
+        self.temp.cleanup()
+
+    def verify(self, process):
+        E.save(self.process_path, process)
+        tracked = {str(p): E.identity(p) for p in (self.job_path, self.process_path)}
+        row = dict(entry_id=self.name, metadata=dict(job_file=str(self.job_path),
+            process_receipt_file=str(self.process_path), observed_returncode=0), consumed_inputs=[],
+            new_outputs=[dict(path=p, **info) for p, info in tracked.items()])
+        start = dict(job=dict(path=str(self.job_path), sha256=E.digest(self.job_path)))
+        return E.validate_process(dict(row=row, start=start), tracked, self.root)
+
+    def test_observed_complete_zero_is_required(self):
+        self.verify(self.process)
+
+    def test_failed_or_unobserved_process_rejected(self):
+        self.process['exit_code'] = 1
+        with self.assertRaisesRegex(ValueError, 'observed exit zero'):
+            self.verify(self.process)
+
+    def test_boolean_zero_is_not_os_exit(self):
+        self.process['exit_code'] = False
+        with self.assertRaisesRegex(ValueError, 'observed exit zero'):
+            self.verify(self.process)
+
+    def test_different_registration_rejected(self):
+        self.process['registration_sha256'] = '0' * 64
+        with self.assertRaisesRegex(ValueError, 'observed exit zero'):
+            self.verify(self.process)
+
+    def test_different_interpreter_rejected(self):
+        self.process['argv'][0] = '/different/venv/bin/python'
+        with self.assertRaisesRegex(ValueError, 'original -B'):
+            self.verify(self.process)
+
+
+if __name__ == '__main__':
+    unittest.main()

models/male-cns-lif/conditioning-acceleration-v1/test_gpu_math.py

@@ -0,0 +1,315 @@
+"""Host-only tests; CUDA equality requires separate real-device evidence."""
+from __future__ import annotations
+
+from dataclasses import replace
+import importlib.util
+import math
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+import numpy as np
+
+from gpu_backend import (CUDA_OPTIONS, CUDA_SOURCE, COMPARTMENTS, CudaEligibility, _nvcc_cubin, cpu_reference,
+                         prepare_events)
+
+
+ROOT = Path(__file__).resolve().parents[1]
+PHASE4J = Path(os.environ.get("PHASE4J_SOURCE", str(ROOT / "models" / "male-cns-lif" / "phase4j.py")))
+BRIDGE_PATH = Path(os.environ.get("ELIGIBILITY_BRIDGE_SOURCE", str(ROOT / "wholebrain-plastic-interface-v1" / "eligibility_bridge.py")))
+spec = importlib.util.spec_from_file_location("_gpu_math_frozen_bridge", BRIDGE_PATH)
+bridge = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = bridge
+spec.loader.exec_module(bridge)
+
+
+def assert_bits(test, left, right):
+    test.assertEqual(left.dtype, right.dtype)
+    test.assertEqual(left.shape, right.shape)
+    test.assertEqual(left.tobytes(), right.tobytes())
+
+
+class HostMathTests(unittest.TestCase):
+    def setUp(self):
+        self.kc = np.array([2, 5, 9], np.int32)
+        self.step = np.array([0, 0, 1, 2, 2, 5, 7], np.int32)
+        self.neurons = np.array([2, 4, 2, 5, 9, 9, 2], np.int32)
+        self.sources = np.array([2, 2, 5, 9], np.int32)
+        self.compartments = np.array([COMPARTMENTS[0], COMPARTMENTS[1],
+                                      COMPARTMENTS[0], COMPARTMENTS[0]])
+        self.base = np.array([0.001, 0.01, 0.004, 0.08], np.float32)
+        self.delta = np.zeros(4, np.float32)
+        self.kw = dict(d=1.0, frozen=False, eta_mv=bridge.ETA_MV,
+                       floor_fraction=bridge.FLOOR_FRACTION,
+                       decay=math.exp(-bridge.DT_MS / bridge.TAU_MS))
+
+    def prepared(self, commands=(0, 2, 6), steps=8):
+        return prepare_events(self.step, self.neurons, self.kc, steps, commands, n_neurons=12)
+
+    def run_host(self, prepared=None, **overrides):
+        args = self.kw | overrides
+        return cpu_reference(self.prepared() if prepared is None else prepared,
+                             self.sources, self.compartments, COMPARTMENTS[0],
+                             self.delta, self.base, **args)
+
+    def test_matches_frozen_trace_and_update_and_no_input_mutation(self):
+        arrays = (self.step, self.neurons, self.kc, self.sources,
+                  self.compartments, self.base, self.delta)
+        before = [(a.tobytes(), a.flags.writeable) for a in arrays]
+        prepared = self.prepared()
+        result = self.run_host(prepared)
+        trace = bridge.trace_from_events(self.step, self.neurons, self.kc, 8, [0, 2, 6],
+                                        phase4j_source=PHASE4J, n_neurons=12)
+        expected, _ = bridge.apply_eligibility(trace.last_command_trace, self.kc,
+            self.sources, self.compartments, COMPARTMENTS[0], self.delta, self.base,
+            d=1.0, frozen=False, phase4j_source=PHASE4J, n_neurons=12)
+        for left, right in ((result.snapshots, trace.snapshots),
+                            (result.final_trace, trace.final),
+                            (result.sampled_trace, trace.last_command_trace),
+                            (result.delta_after, expected)):
+            assert_bits(self, left, right)
+            self.assertFalse(left.flags.writeable)
+        self.assertEqual(before, [(a.tobytes(), a.flags.writeable) for a in arrays])
+        self.assertEqual(prepared.kc_event_count, 6)
+        self.assertEqual(prepared.indptr.tolist(), [0, 3, 4, 6])
+        self.assertEqual(prepared.ticks.tolist(), [0, 1, 7, 2, 2, 5])
+
+    def test_no_command_returns_positive_zero_but_nonzero_final(self):
+        result = self.run_host(self.prepared(()), d=0)
+        self.assertEqual(result.snapshots.shape, (0, 3))
+        assert_bits(self, result.sampled_trace, np.zeros(3, np.float32))
+        self.assertTrue(np.any(result.final_trace > 0))
+        assert_bits(self, result.delta_after, self.delta)
+
+    def test_sampling_after_spike_and_last_command_only(self):
+        result = self.run_host(self.prepared((0, 2, 7)))
+        self.assertEqual(result.snapshots[0, 0], np.float32(1))
+        self.assertEqual(result.snapshots[1, 1], np.float32(1))
+        assert_bits(self, result.sampled_trace, result.snapshots[-1])
+        assert_bits(self, result.final_trace, result.snapshots[-1])
+
+    def test_frozen_d_zero_off_compartment_and_floor(self):
+        self.delta = np.array([-0.0001, -0.0005, -0.001, 0], np.float32)
+        for kwargs in (dict(d=0), dict(frozen=True)):
+            assert_bits(self, self.run_host(**kwargs).delta_after, self.delta)
+        result = self.run_host()
+        assert_bits(self, result.delta_after[1:2], self.delta[1:2])
+        self.assertEqual(result.delta_after[0], np.float32(-0.25) * self.base[0])
+        self.assertEqual(result.delta_after[2], self.delta[2])
+
+    def test_empty_events_and_one_tick(self):
+        prepared = prepare_events(np.empty(0, np.int32), np.empty(0, np.int32),
+                                  self.kc, 1, [0], n_neurons=12)
+        result = self.run_host(prepared)
+        assert_bits(self, result.final_trace, np.zeros(3, np.float32))
+        assert_bits(self, result.delta_after, self.delta)
+
+    def test_long_empty_gap_does_not_use_power(self):
+        self.step = np.array([0], np.int32)
+        self.neurons = np.array([2], np.int32)
+        prepared = self.prepared((9999,), steps=10000)
+        result = self.run_host(prepared)
+        expected = np.float32(1)
+        for _ in range(9999):
+            expected = np.float32(expected * np.float32(self.kw["decay"]))
+        assert_bits(self, result.sampled_trace[:1], np.array([expected], np.float32))
+        jumped = np.float32(float(np.float32(self.kw["decay"])) ** 9999)
+        self.assertNotEqual(expected.view(np.uint32), jumped.view(np.uint32))
+
+    def test_random_sparse_case_matches_frozen(self):
+        rng = np.random.default_rng(717)
+        self.kc = np.arange(0, 80, 2, dtype=np.int32)
+        encoded = np.unique(rng.integers(0, 80 * 257, size=1400))
+        self.step = (encoded // 80).astype(np.int32)
+        self.neurons = (encoded % 80).astype(np.int32)
+        self.sources = rng.choice(self.kc, 159).astype(np.int32)
+        self.compartments = rng.choice(np.asarray(COMPARTMENTS), 159)
+        self.base = rng.uniform(0.0001, 2, 159).astype(np.float32)
+        self.delta = -(rng.uniform(0, 0.24, 159).astype(np.float32) * self.base)
+        prepared = prepare_events(self.step, self.neurons, self.kc, 257, [0, 1, 20, 99, 256], n_neurons=80)
+        result = self.run_host(prepared)
+        trace = bridge.trace_from_events(self.step, self.neurons, self.kc, 257,
+            [0, 1, 20, 99, 256], phase4j_source=PHASE4J, n_neurons=80)
+        expected, _ = bridge.apply_eligibility(trace.last_command_trace, self.kc,
+            self.sources, self.compartments, COMPARTMENTS[0], self.delta, self.base,
+            d=1, phase4j_source=PHASE4J, n_neurons=80)
+        assert_bits(self, result.snapshots, trace.snapshots)
+        assert_bits(self, result.delta_after, expected)
+
+    def test_signed_zero_source_floor_tie_is_preserved(self):
+        # The bridge's identity guard rejects this pathological subnormal base.
+        # Compare the original apply_v2 directly: np.maximum(+0,-0) gives -0.
+        self.base[:] = np.nextafter(np.float32(0), np.float32(1))
+        result = self.run_host(d=0)
+        original, _, _ = bridge._load_original(PHASE4J)
+        from types import SimpleNamespace
+        validator = SimpleNamespace(n=12, kc=self.kc, base_candidate=self.base,
+            cand={"source_neuron_idx": bridge._Column(self.sources),
+                  "target_compartment_verbatim": bridge._Column(self.compartments)})
+        expected, _ = original(validator, result.sampled_trace, COMPARTMENTS[0], 0,
+            self.delta, {"eligibility_v2": {"eta_effective_mv": bridge.ETA_MV,
+                                          "max_fractional_depression": bridge.FLOOR_FRACTION}})
+        assert_bits(self, result.delta_after, expected)
+        self.assertTrue(np.all(np.signbit(result.delta_after)))
+        assert_bits(self, self.run_host(frozen=True).delta_after, self.delta)
+
+    def test_input_validation(self):
+        bad_events = [
+            (self.step.astype(np.int64), self.neurons, self.kc, 8, [0]),
+            (self.step, self.neurons.astype(np.float32), self.kc, 8, [0]),
+            (self.step, self.neurons, self.kc[::-1], 8, [0]),
+            (self.step, self.neurons, self.kc, 8, [0, 0]),
+            (self.step, self.neurons, self.kc, 8, [0.0]),
+            (self.step, self.neurons, self.kc, 8, [8]),
+            (self.step, self.neurons, self.kc, True, [0]),
+            (self.step, self.neurons, self.kc, 0, []),
+            (np.array([0, 0], np.int32), np.array([2, 2], np.int32), self.kc, 8, []),
+        ]
+        for args in bad_events:
+            with self.subTest(args=args), self.assertRaises(ValueError):
+                prepare_events(*args, n_neurons=12)
+        for kwargs in (dict(d=True), dict(d=0.5), dict(d=float("nan")),
+                       dict(frozen=1), dict(eta_mv=float("inf")),
+                       dict(floor_fraction=0), dict(decay=float("nan"))):
+            with self.subTest(kwargs=kwargs), self.assertRaises(ValueError):
+                self.run_host(**kwargs)
+        self.delta[0] = -0.0
+        with self.assertRaises(ValueError):
+            self.run_host()
+        self.delta[0] = 0
+        self.base[0] = np.nan
+        with self.assertRaises(ValueError):
+            self.run_host()
+
+    def test_forged_prepared_rejected(self):
+        prepared = self.prepared()
+        bad = replace(prepared, ticks=np.array([0, 0, 7, 2, 2, 5], np.int32))
+        with self.assertRaises(ValueError):
+            self.run_host(bad)
+
+    def test_cuda_entry_rejects_bad_inputs_before_accessing_device(self):
+        # An uninitialized shell has no cp/device fields. Rejection therefore
+        # proves the CUDA entry's validation happens before any CUDA operation.
+        backend = object.__new__(CudaEligibility)
+        prepared = self.prepared()
+        base_args = dict(prepared=prepared, candidate_sources=self.sources,
+                         candidate_compartments=self.compartments, compartment=COMPARTMENTS[0],
+                         delta_before=self.delta, base_candidate=self.base, **self.kw)
+        bad = [dict(candidate_sources=self.sources.astype(np.int64)),
+               dict(candidate_compartments=self.compartments.astype("S")),
+               dict(delta_before=self.delta.astype(np.float64)),
+               dict(base_candidate=np.array([np.inf, 1, 1, 1], np.float32)),
+               dict(delta_before=np.array([np.nan, 0, 0, 0], np.float32)),
+               dict(candidate_sources=np.array([1, 2, 5, 9], np.int32)),
+               dict(candidate_sources=np.array([2, 2, 5, 11], np.int32)),
+               dict(delta_before=np.array([-1, 0, 0, 0], np.float32)),
+               dict(compartment="unknown"), dict(kernel_warmup=-1),
+               dict(kernel_repeats=0), dict(kernel_repeats=True)]
+        for overrides in bad:
+            with self.subTest(overrides=overrides), self.assertRaises(ValueError):
+                backend.run(**(base_args | overrides))
+
+    def test_no_dense_tick_raster_and_input_storage_owned(self):
+        prepared = self.prepared()
+        for arr in (prepared.kc, prepared.indptr, prepared.ticks, prepared.command_steps):
+            self.assertEqual(arr.ndim, 1)
+            self.assertFalse(arr.flags.writeable)
+        self.kc[:] = 0
+        self.step[:] = 0
+        self.assertEqual(prepared.kc.tolist(), [2, 5, 9])
+        self.assertEqual(prepared.ticks.tolist(), [0, 1, 7, 2, 2, 5])
+
+    def test_kernel_explicit_rounding_controls(self):
+        self.assertIn("--fmad=false", CUDA_OPTIONS)
+        self.assertIn("--ftz=false", CUDA_OPTIONS)
+        self.assertIn("__fmul_rn", CUDA_SOURCE)
+        self.assertIn("__fadd_rn", CUDA_SOURCE)
+        self.assertNotIn("pow(", CUDA_SOURCE)
+        self.assertNotIn("__expf", CUDA_SOURCE)
+
+
+class CompilerCacheTests(unittest.TestCase):
+    """Host-side compiler invocation/evidence checks; these do not compile CUDA."""
+
+    def test_explicit_flags_authenticated_cache_and_no_global_environment_mutation(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            compiler = root / "nvcc"
+            compiler.write_bytes(b"host-test-compiler-placeholder")
+            calls = []
+
+            def run(argv, **kwargs):
+                if argv[-1] == "--version":
+                    return subprocess.CompletedProcess(argv, 0, stdout="nvcc test version", stderr="")
+                calls.append((argv, kwargs))
+                self.assertIn("--ftz=false", argv)
+                self.assertIn("--fmad=false", argv)
+                self.assertIn("-arch=sm_70", argv)
+                self.assertNotIn("--use_fast_math", argv)
+                self.assertNotIn("-ftz=true", argv)
+                Path(argv[argv.index("-o") + 1]).write_bytes(b"test cubin, not executable CUDA")
+                kwargs["stdout"].write(b"mock nvcc stdout\n")
+                kwargs["stderr"].write(b"mock nvcc stderr\n")
+                return subprocess.CompletedProcess(argv, 0)
+
+            with mock.patch.dict(os.environ, {"NVCC_PREPEND_FLAGS": "", "NVCC_APPEND_FLAGS": ""}), \
+                    mock.patch("gpu_backend.subprocess.run", side_effect=run):
+                before = dict(os.environ)
+                cubin, evidence, timing = _nvcc_cubin(root / "cache", "70", compiler)
+                self.assertFalse(evidence["cache_hit"])
+                self.assertTrue(evidence["complete"])
+                self.assertIn("eligibility.cubin", evidence["files_sha256"])
+                self.assertIn("compiler.stdout.log", evidence["files_sha256"])
+                self.assertIn("compiler.stderr.log", evidence["files_sha256"])
+                self.assertEqual(before, dict(os.environ))
+                again, cached, second_timing = _nvcc_cubin(root / "cache", "70", compiler)
+                self.assertEqual(cubin, again)
+                self.assertTrue(cached["cache_hit"])
+                self.assertEqual(second_timing["nvcc_compile_seconds"], 0)
+                self.assertEqual(len(calls), 1)
+                self.assertEqual(evidence["receipt_sha256"], cached["receipt_sha256"])
+                cubin.write_bytes(b"corrupted test cache")
+                with self.assertRaisesRegex(ValueError, "artifact changed"):
+                    _nvcc_cubin(root / "cache", "70", compiler)
+
+    def test_failed_compile_evidence_is_retained_and_not_overwritten(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            compiler = root / "nvcc"
+            compiler.write_bytes(b"host-test-compiler-placeholder")
+
+            def run(argv, **kwargs):
+                if argv[-1] == "--version":
+                    return subprocess.CompletedProcess(argv, 0, stdout="nvcc test version", stderr="")
+                kwargs["stderr"].write(b"mock compiler failure\n")
+                return subprocess.CompletedProcess(argv, 1)
+
+            with mock.patch.dict(os.environ, {"NVCC_PREPEND_FLAGS": "", "NVCC_APPEND_FLAGS": ""}), \
+                    mock.patch("gpu_backend.subprocess.run", side_effect=run):
+                with self.assertRaisesRegex(RuntimeError, "evidence retained"):
+                    _nvcc_cubin(root / "cache", "70", compiler)
+                receipts = list((root / "cache").rglob("build-receipt.json"))
+                self.assertEqual(len(receipts), 1)
+                before = receipts[0].read_bytes()
+                with self.assertRaisesRegex(ValueError, "failed or mismatched"):
+                    _nvcc_cubin(root / "cache", "70", compiler)
+                self.assertEqual(receipts[0].read_bytes(), before)
+
+    def test_injected_compiler_flags_rejected_without_clearing_global_environment(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            compiler = root / "nvcc"
+            compiler.write_bytes(b"host-test-compiler-placeholder")
+            with mock.patch.dict(os.environ, {"NVCC_APPEND_FLAGS": "--ftz=true"}):
+                with self.assertRaisesRegex(ValueError, "injected flags"):
+                    _nvcc_cubin(root / "cache", "70", compiler)
+                self.assertEqual(os.environ["NVCC_APPEND_FLAGS"], "--ftz=true")
+                self.assertFalse((root / "cache").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

models/male-cns-lif/conditioning-pipeline-acceleration-v1/PROTOCOL.md

@@ -0,0 +1,41 @@
+# Persistent-process engineering replay — 2026-10-01
+
+User authorized continuing performance optimization after the exact V100 eligibility prototype. This is a NEW bounded engineering experiment, not a resumption, retry, or extension of the stopped scientific Phase4AR run. No future assay, learning run, game or decoder is authorized here.
+
+## Immutable inputs and selection
+
+- Original registration SHA256: `b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740`.
+- Original scientific source commit: `80aeb2093db655329774eff7b32fb6e417b8b40b`.
+- Prior exact-GPU replay code commit: `221e1f13f758ebe8d9f188bab976c361f7cacf45`.
+- Fixed real fixture manifest: `/home/qishizhe/phase4ar-v100-acceleration-20261001/fixtures/manifest.json`.
+- Fixture manifest SHA256: `481df128d39bf28e5984a6f2e5757f83d45cb7a6136f8d2843ecc0a67eca437b`.
+- Use all14 fixtures in their existing order: first and last committed task by task-ID within7arms, chosen in the prior experiment without reading outcomes. Coverage is only the available committed prefix, not the complete scientific design.
+- All anatomical data, sources, saved requests, before-overlay, historical checkpoint and original update references remain read-only. No new update is installed. No request/RNG regeneration, learning-rate, sign, threshold, timestep or eligibility change.
+
+## CPU lanes
+
+Measure original U in fresh processes and separate resident producer/verifier processes. The verifier owns independently loaded inputs and invokes unchanged original U recomputation. This measures update-interface overhead, NOT full AQ authority/checkpoint verification. Use3 fixed passes; all outputs/receipts must match the original CPU oracle.
+
+Also measure unchanged original E.postprocess_epoch in a resident CPU process,2 fixed passes, new output per call. Preserve all checks inside E. Original full AQ validation remains a fresh CPU subprocess; never bypass its fresh-interpreter guards. Profile function costs separately; profiler-instrumented timings are not speed benchmarks.
+
+## Brain lanes
+
+Use only the original scientific environment and admitted RTX4090 for this pass. Original Torch lacks V100 support for its frozen whole-brain runtime; V100 eligibility compatibility does not establish whole-brain compatibility.
+
+Run unchanged R.run_light and original checkpoint seal/read functions. Baseline:14 fresh child processes. Candidate: one resident child executes14 forward then14 reverse. Every call creates a fresh neuronal/APL state through the unmodified function. No use of checkpoint continuation, old BrainRuntime, custom state reset, or previous effective-weight accumulation. This first pass reuses interpreter, verified module caches, CUDA context, and the runtime's existing caches only; it does not cache GPU graph tensors or rewrite the numerical loop.
+
+Compare every event, counts, final v/g/ref, spike ring, APL state/pending/phase, effective-weight hash and request acceptance against the historical sealed trial. Check exact dtypes, shapes and bytes. Verify source/input pins before and after trials. Failures stop the affected lane and retain evidence; no selection of passing trials.
+
+## Audit, timing and bounds
+
+Each resident job has a completion record but NOT a fictitious OS exit code. Its session receives an independently observed actual process exit only when the whole child exits. No old AR ledger is modified.
+
+Report initialization/compilation, immutable-input authentication, execution, checkpoint seal/read, comparison, output I/O and complete child wall times separately. Report data transfer, recording and checks that remain. Independent stage measurements cannot be added and advertised as a measured end-to-end training speedup; no new full-run ETA from isolated kernels.
+
+Run CPU and GPU timing lanes serially to avoid artificial contention. Check all3 ComfyUI queues before each GPU trial; no service eviction. Maximum engineering workflow30minutes, each child15minutes, new artifacts capped at2GiB and100GiB minimum free disk reserve. If an infrastructure or candidate bug occurs, preserve the attempt and correct only new source/attempt paths; never retry scientific AR tasks.
+
+Outputs: `/home/qishizhe/phase4ar-pipeline-acceleration-20261001/`. Source: new `conditioning-pipeline-acceleration-v1` directory in independent worktree `/home/qishizhe/digital-drosophila-v100-acceleration`.
+
+Pre/post checks: original saved64,034-file Phase4AR inventory,16 registered sources, previous acceleration artifact manifest and previous acceleration source hashes. This is NOT a new Phase1–4AQ numerical regression.
+
+Possible gate: `PASS-PERSISTENT-REPLAY-EQUIVALENCE` for tested lanes only. It is not a learned-model candidate, formal production-runtime promotion, full scientific-gate pass, or permission to resume30,000epochs.

models/male-cns-lif/conditioning-pipeline-acceleration-v1/brain_replay.py

@@ -0,0 +1,566 @@
+"""Bounded unchanged-runtime replay: 14 fresh execs versus one resident exec.
+
+Only the original R.run_light is executed, in the original 4090 environment.
+Every call allocates fresh neural/APL state. No GPU graph residency, numerical
+optimization, conditioning coordinator, generated overlay, or AR resume is used.
+All output is new, outside the scientific tree. Original checkpoints are read.
+"""
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import hashlib
+import importlib.util
+import json
+import os
+from pathlib import Path
+import signal
+import subprocess
+import sys
+import time
+import traceback
+
+
+ROOT = Path('/data/digital-drosophila')
+MODEL = ROOT / 'models/male-cns-lif'
+EXP = ROOT / 'experiments/phase4ar-normal-conditioning'
+ORIGINAL_ENV = MODEL / '.venv'
+ORIGINAL_PYTHON = ORIGINAL_ENV / 'bin/python'
+REG_PATH = EXP / 'protocol/preregistered.json'
+REG_SHA = 'b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740'
+SOURCE_COMMIT = '80aeb2093db655329774eff7b32fb6e417b8b40b'
+GPU = 'GPU-79f3a85d-adce-7833-7003-6488140ca596'
+R_PATH = MODEL / 'olfactory-conditioning-lab-v1/runtime_light.py'
+C_PATH = MODEL / 'olfactory-conditioning-lab-v1/runtime_continuation.py'
+AP_PATH = MODEL / 'conditioning-interface-v2/isolated_workers.py'
+R_SHA = '522b8c31ea938890fe15364fccd25ccc5bded54101754909f255532e7ad01aae'
+C_SHA = '0b8e8e0a6a23a079dc62a88355ce355d53b3ae22f6665519a8f6aef2dcfc5aba'
+AP_SHA = 'e47651a8ea99d7c44115107ff6b5dc71312183609ae11c891db65bb21ed61e30'
+STATE_KEYS = ('step', 'neuron_idx', 'counts', 'v', 'g', 'ref')
+TERMINAL_KEYS = ('spike_ring', 'apl_state', 'apl_pending', 'next_tick')
+ARMS = ('cs_only', 'd_zero', 'dan_only', 'frozen', 'paired', 'random_reward', 'unpaired')
+SUMMARY_KEYS = ('completed_ticks', 'nodes', 'edges', 'precision', 'apl_precision', 'state_units',
+    'total_spikes', 'requested', 'accepted_requests', 'rejected_requests', 'arriving_edges',
+    'accepted_arriving_edges', 'counts_match_sparse_events', 'all_finite', 'record_history',
+    'apl_fast_edges_zeroed', 'kc_targets_present', 'effective_weights_raw_sha256', 'apl_schedule',
+    'apl_si_conversion', 'apl_delay_steps', 'pending_generated_count', 'pending_initial_zero_prefix',
+    'pending_tail_shape', 'future_generated_decay_tail_included', 'diagnostic_mode',
+    'within_trial_weight_updates', 'checkpoint_continuation_used', 'explicit_steps_executed',
+    'first_failure_tick')
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def path_checked(path):
+    path = Path(path)
+    require(path.is_absolute() and '..' not in path.parts, 'Absolute nonescaping path required')
+    require(not any(p.is_symlink() or (hasattr(p, 'is_junction') and p.is_junction())
+                    for p in (path, *path.parents)), 'Linked path forbidden: ' + str(path))
+    return path
+
+
+def sha(path):
+    digest = hashlib.sha256()
+    with path_checked(path).open('rb') as stream:
+        for block in iter(lambda: stream.read(8 << 20), b''):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def read(path):
+    def pairs(items):
+        result = {}
+        for key, value in items:
+            require(key not in result, 'Duplicate JSON key')
+            result[key] = value
+        return result
+    return json.loads(path_checked(path).read_text(encoding='utf-8'), object_pairs_hook=pairs,
+                      parse_constant=lambda _: (_ for _ in ()).throw(ValueError('Nonfinite JSON')))
+
+
+def save(path, value):
+    with path_checked(path).open('x', encoding='utf-8', newline='\n') as stream:
+        json.dump(value, stream, indent=2, sort_keys=True, allow_nan=False)
+        stream.write('\n')
+
+
+def pin_add(pins, path, expected):
+    path = str(path_checked(path))
+    expected = expected if isinstance(expected, str) else expected['sha256']
+    require(isinstance(expected, str) and len(expected) == 64
+            and all(c in '0123456789abcdef' for c in expected), 'Invalid SHA256')
+    require(path not in pins or pins[path] == expected, 'Conflicting authority pin: ' + path)
+    pins[path] = expected
+
+
+def verify(pins):
+    for path, expected in pins.items():
+        require(sha(path) == expected, 'Pinned input changed: ' + path)
+
+
+def contained(root, relative):
+    path = path_checked(root / relative)
+    require(path.is_relative_to(root), 'Fixture path leaves exported root')
+    return path
+
+
+def load_source(name, path, expected):
+    raw = path_checked(path).read_bytes()
+    require(hashlib.sha256(raw).hexdigest() == expected and name not in sys.modules,
+            'Unverified or repeated module binding: ' + name)
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    exec(compile(raw, str(path), 'exec'), module.__dict__)
+    return module
+
+
+def fixture_order(count):
+    require(count == 14, 'The fixed manifest must contain exactly 14 real fixtures')
+    return [('forward', index) for index in range(count)] + [('reverse', index) for index in range(count - 1, -1, -1)]
+
+
+def build_selection(fixtures, manifest_sha):
+    """Bind saved case/overlay and old checkpoint to the authenticated export."""
+    fixtures = path_checked(fixtures)
+    manifest_path = fixtures / 'manifest.json'
+    require(sha(manifest_path) == manifest_sha, 'Export manifest differs from external pin')
+    manifest = read(manifest_path)
+    require(manifest.get('complete') is True and manifest.get('schema') == 'conditioning-acceleration-fixtures-v1'
+            and manifest.get('registration_sha256') == REG_SHA and manifest.get('source_code_commit') == SOURCE_COMMIT,
+            'Unexpected completed real export authority')
+    records = manifest['fixtures']
+    fixture_order(len(records))
+    require(len({record['fixture_id'] for record in records}) == 14, 'Duplicate fixture identity')
+    require({arm: sum(row['task']['arm'] == arm for row in records) for arm in ARMS}
+            == {arm: 2 for arm in ARMS}, 'Expected the declared two fixtures per available arm')
+    require(sha(REG_PATH) == REG_SHA, 'Original AR registration changed')
+    registration = read(REG_PATH)
+    require(registration['source_code_commit'] == SOURCE_COMMIT
+            and registration['scientific_scope'] == 'normal-acquisition-only', 'Original registration role differs')
+    global_pins = {str(manifest_path): manifest_sha, str(REG_PATH): REG_SHA,
+                   str(R_PATH): R_SHA, str(C_PATH): C_SHA, str(AP_PATH): AP_SHA}
+    for relative, info in manifest['files'].items():
+        pin_add(global_pins, contained(fixtures, relative), info)
+    verify(global_pins)
+    rows = []
+    for record in records:
+        name = record['fixture_id']
+        directory = contained(fixtures, name)
+        require(read(directory / 'fixture.json') == record
+                and record['exact_stored_delta_and_trace_verified'] is True
+                and record['original_validator_verified_full_graph_mapping'] is True
+                and record['full_canonical_KC_count'] == 4064 and record['full_candidate_edge_count'] == 14232,
+                'Fixture lacks original full mapping/reference evidence')
+        pins = dict(global_pins)
+        for path, info in read(directory / 'source-file-pins.json').items():
+            pin_add(pins, path, info)
+        task = record['task']
+        key = 'task-' + hashlib.sha256(task['task_id'].encode()).hexdigest()
+        brain_name = key + '--brain'
+        job_path = EXP / 'jobs' / (brain_name + '.json')
+        process_path = EXP / 'receipts' / brain_name / 'process.json'
+        authority_path = EXP / 'jobs' / (key + '.authority.json')
+        require(all(str(p) in pins for p in (job_path, process_path, authority_path)),
+                'Original brain job/process/authority not bound by exported source pins')
+        verify({str(p): pins[str(p)] for p in (job_path, process_path, authority_path)})
+        job, process, authority = read(job_path), read(process_path), read(authority_path)
+        require(authority == read(directory / 'authority.json')
+                and sha(authority_path) == record['authority_sha256'], 'Export authority differs from sealed original')
+        require(job['kind'] == 'brain' and job['job_id'] == brain_name
+                and job['schema'] == 'phase4ap-isolated-worker-job-v1'
+                and job['registration_sha256'] == REG_SHA and job['worker_sha256'] == AP_SHA
+                and job['diagnostic_mode'] == 'light', 'Original brain job differs')
+        require(process['complete'] is True and type(process['exit_code']) is int and process['exit_code'] == 0
+                and process['timed_out'] is False and process['exit_observed_by_parent'] is True
+                and process.get('launch_error') is None and process['job_sha256'] == pins[str(job_path)]
+                and process['entry_id'] == brain_name and process['registration_sha256'] == REG_SHA
+                and process['argv'][0] == str(ORIGINAL_PYTHON) and '-B' in process['argv'],
+                'Original brain has no authenticated successful fresh exec')
+        require(job['sources'] == {'runtime_light': {'path': str(R_PATH), 'sha256': R_SHA},
+                                  'runtime_continuation': {'path': str(C_PATH), 'sha256': C_SHA}},
+                'Original brain sources differ')
+        for path, expected in job['input_sha256'].items():
+            pin_add(pins, path, expected)
+        for path, expected in authority['frozen_inputs'].items():
+            pin_add(pins, path, expected)
+        for info in authority['files'].values():
+            pin_add(pins, info['path'], info['sha256'])
+        case = path_checked(job['case_dir'])
+        old = path_checked(job['output_dir'])
+        require(case == EXP / 'cases' / key and old == EXP / 'runs' / key
+                and authority['checkpoint_dir'] == str(old) and authority['epoch_id'] == task['task_id'],
+                'Old brain case/checkpoint/task binding differs')
+        for role, path in (('spec', case / 'spec.json'), ('requests', case / 'requests.npz'),
+                           ('overlay_before', Path(job['overlay_file'])),
+                           ('overlay_manifest_before', Path(job['overlay_manifest']))):
+            require(authority['files'][role] == {'path': str(path), 'sha256': pins[str(path)]},
+                    'Original brain input role differs: ' + role)
+        spec = read(case / 'spec.json')
+        require(spec['steps'] == spec['max_steps'] == 1200 and spec['record_history'] is False
+                and spec['apl_delay_steps'] == 18 and spec['dt_ms'] == .1
+                and spec['within_trial_weight_updates'] is False, 'Replay is not the exact bounded fresh trial')
+        require(not (case / 'arrays.npz').exists(), 'Unexpected neural initial-state override')
+        old_manifest = old / 'checkpoint-manifest.json'
+        pin_add(pins, old_manifest, authority['checkpoint_manifest_sha256'])
+        require(sha(old_manifest) == authority['checkpoint_manifest_sha256'], 'Old checkpoint manifest changed')
+        checkpoint = read(old_manifest)
+        require(checkpoint['schema'] == 'phase4an-checkpoint-v1' and checkpoint['complete'] is True
+                and checkpoint['segment_steps'] == 1200 and checkpoint['global_tick_offset'] == 0
+                and checkpoint['global_next_tick'] == 1200, 'Expected sealed fresh reference checkpoint')
+        for relative, expected in checkpoint['files_sha256'].items():
+            pin_add(pins, contained(old, relative), expected)
+        require(checkpoint['files_sha256']['state.npz'] == authority['files']['state']['sha256'],
+                'Authority state differs from complete checkpoint inventory')
+        rows.append(dict(fixture_id=name, task_id=task['task_id'], case_dir=str(case),
+            overlay_file=job['overlay_file'], overlay_manifest=job['overlay_manifest'],
+            original_checkpoint=str(old), original_checkpoint_manifest_sha256=authority['checkpoint_manifest_sha256'],
+            original_brain_job=str(job_path), original_process_wall_seconds=process['end_to_end_seconds'],
+            pins=pins))
+    # All original and exported bytes are verified before any new GPU work.
+    all_pins = dict(global_pins)
+    for row in rows:
+        for path, expected in row['pins'].items():
+            pin_add(all_pins, path, expected)
+    verify(all_pins)
+    return dict(schema='conditioning-persistent-process-selection-v1', registration_sha256=REG_SHA,
+        fixture_manifest=str(manifest_path), fixture_manifest_sha256=manifest_sha,
+        fixed_count=14, fresh_order=list(range(14)), resident_order=fixture_order(14),
+        selected_before_candidate_execution=True, fixtures=rows, all_pins=all_pins,
+        numerical_implementation='unchanged frozen runtime_light.run_light',
+        neural_reset='original function allocates fresh neuron/APL/queues for every call',
+        request_rng='none during runtime; exact saved requests.npz reused',
+        no_GPU_graph_residency=True, no_generated_overlay_installed=True)
+
+
+def array_evidence(array):
+    return dict(dtype=array.dtype.str, shape=list(array.shape),
+                sha256=hashlib.sha256(array.tobytes(order='C')).hexdigest())
+
+
+def compare_arrays(actual, expected, required):
+    require(set(actual) == set(expected) == set(required), 'Checkpoint array schema differs')
+    result = {}
+    for name in required:
+        left, right = array_evidence(actual[name]), array_evidence(expected[name])
+        result[name] = dict(bitwise_exact=left == right, actual=left, expected=right)
+    return result
+
+
+def compare_checkpoints(current, original, current_dir, original_dir):
+    arrays = dict(state=compare_arrays(current['state'], original['state'], STATE_KEYS),
+                  terminal=compare_arrays(current['terminal'], original['terminal'], TERMINAL_KEYS))
+    summaries = {key: dict(actual=current['summary'].get(key), expected=original['summary'].get(key),
+                          exact=key in current['summary'] and key in original['summary']
+                          and current['summary'][key] == original['summary'][key]) for key in SUMMARY_KEYS}
+    files = {name: dict(actual=sha(current_dir / name), expected=sha(original_dir / name))
+             for name in ('requests.csv', 'finite-audit.json', 'apl-pending-tail.float32.npy')}
+    for item in files.values():
+        item['exact'] = item['actual'] == item['expected']
+    environment_equal = current['summary']['apl_component']['environment'] == original['summary']['apl_component']['environment']
+    exact = (all(item['bitwise_exact'] for group in arrays.values() for item in group.values())
+             and all(item['exact'] for item in summaries.values())
+             and all(item['exact'] for item in files.values()) and environment_equal
+             and current['fresh'] is original['fresh'] is True
+             and current['global_tick_offset'] == original['global_tick_offset'] == 0)
+    return dict(exact=exact, arrays=arrays, summaries=summaries, files=files,
+                original_APL_environment_exact=environment_equal,
+                comparison_scope='all six state arrays, four terminal arrays, requests, finite coverage, APL pending, effective weights and selected summaries')
+
+
+def check_environment():
+    require(sys.dont_write_bytecode and Path(sys.prefix) == ORIGINAL_ENV,
+            'Use the original registered environment Python -B')
+    require(os.environ.get('CUDA_VISIBLE_DEVICES') == GPU
+            and os.environ.get('CUDA_HOME') == '/usr/local/cuda'
+            and os.environ.get('TORCH_CUDA_ARCH_LIST') == '8.9', 'Explicit original 4090 build environment required')
+
+
+def run_worker(job_path, job_sha):
+    """One exec; resident lane shares only original modules/caches, never state."""
+    started = time.perf_counter()
+    check_environment()
+    require('torch' not in sys.modules and 'runtime_light' not in sys.modules, 'Worker must begin as a fresh exec')
+    require(sha(job_path) == job_sha, 'Replay worker job changed')
+    job = read(job_path)
+    require(sha(Path(__file__).absolute()) == job['candidate_source_sha256'], 'Candidate source changed')
+    require(sha(job['selection_file']) == job['selection_sha256'], 'Pinned selection changed')
+    selection = read(job['selection_file'])
+    require(selection['registration_sha256'] == REG_SHA and selection['fixed_count'] == 14, 'Worker selection authority differs')
+    count = 1 if job['lane'] == 'fresh' else 28
+    require(job['lane'] in ('fresh', 'resident') and len(job['runs']) == count, 'Worker lane count differs')
+    if job['lane'] == 'resident':
+        require(job['runs'] == [[direction, index] for direction, index in fixture_order(14)], 'Resident order differs')
+    output = path_checked(job['output_root'])
+    require(output.is_dir() and output.parent == path_checked(job['experiment_root']), 'Worker output root differs')
+    load_started = time.perf_counter()
+    ap = load_source('_pipeline_original_AP', AP_PATH, AP_SHA)
+    runtime = load_source('runtime_light', R_PATH, R_SHA)
+    checkpoint = None
+    initial_module_seconds = time.perf_counter() - load_started
+    records = []
+    for sequence, (direction, index) in enumerate(job['runs']):
+        require(time.time() < job['deadline_unix'], 'Bounded replay wall deadline reached')
+        require(type(index) is int and 0 <= index < 14, 'Invalid fixed fixture index')
+        row = selection['fixtures'][index]
+        trial_started = time.perf_counter()
+        authority_started = time.perf_counter()
+        verify(row['pins'])
+        require(sha(job_path) == job_sha and sha(job['selection_file']) == job['selection_sha256'], 'Worker authority changed')
+        admission = ap._admit_brain()
+        authority_before_seconds = time.perf_counter() - authority_started
+        name = (f'{index:02d}-' if job['lane'] == 'fresh' else f'{sequence:02d}-{direction}-') + row['fixture_id']
+        trial_root = output / name
+        trial_root.mkdir(exist_ok=False)
+        trial_dir = trial_root / 'trial'
+        runtime_started = time.perf_counter()
+        summary = runtime.run_light(Path(row['case_dir']), trial_dir, Path(job['build_root']),
+                                    Path(row['overlay_file']), Path(row['overlay_manifest']))
+        runtime_seconds = time.perf_counter() - runtime_started
+        checkpoint_started = time.perf_counter()
+        if checkpoint is None:
+            checkpoint = load_source('_pipeline_original_checkpoint', C_PATH, C_SHA)
+        seal = checkpoint.seal_checkpoint(trial_dir)
+        current = checkpoint.load_checkpoint(trial_dir, seal['sha256'])
+        original = checkpoint.load_checkpoint(row['original_checkpoint'], row['original_checkpoint_manifest_sha256'])
+        fresh_reference = None
+        if job['lane'] == 'resident':
+            fresh_pin = job['fresh_references'][row['fixture_id']]
+            require(sha(fresh_pin['report']) == fresh_pin['report_sha256'], 'Fresh reference report changed')
+            fresh_reference = checkpoint.load_checkpoint(fresh_pin['checkpoint'], fresh_pin['checkpoint_manifest_sha256'])
+        require(current['summary'] == summary, 'Current sealed summary differs from actual returned summary')
+        checkpoint_seconds = time.perf_counter() - checkpoint_started
+        compare_started = time.perf_counter()
+        environment = ap._environment('brain')
+        ap._verify_precision(environment, summary['apl_component']['environment'])
+        comparison = compare_checkpoints(current, original, trial_dir, Path(row['original_checkpoint']))
+        if fresh_reference is not None:
+            comparison['fresh_reference'] = compare_checkpoints(current, fresh_reference, trial_dir, Path(fresh_pin['checkpoint']))
+            comparison['exact'] = comparison['exact'] and comparison['fresh_reference']['exact']
+        compare_seconds = time.perf_counter() - compare_started
+        io_started = time.perf_counter()
+        save(trial_root / 'comparison.json', comparison)
+        comparison_io_seconds = time.perf_counter() - io_started
+        require(comparison['exact'], 'Brain replay differs from original sealed checkpoint: ' + row['fixture_id'])
+        after_started = time.perf_counter()
+        verify(row['pins'])
+        require(sha(Path(__file__).absolute()) == job['candidate_source_sha256'], 'Candidate source changed during trial')
+        require(sha(job_path) == job_sha and sha(job['selection_file']) == job['selection_sha256'], 'Worker authority changed after trial')
+        authority_after_seconds = time.perf_counter() - after_started
+        report = dict(fixture_id=row['fixture_id'], direction=direction, sequence=sequence,
+            fixed_index=index, lane=job['lane'], exact=True, original_checkpoint=row['original_checkpoint'],
+            original_checkpoint_manifest_sha256=row['original_checkpoint_manifest_sha256'],
+            current_checkpoint=str(trial_dir), current_checkpoint_manifest_sha256=seal['sha256'],
+            original_brain_job=row['original_brain_job'], input_pins_verified_before_and_after=True,
+            compared_array_count=len(STATE_KEYS) + len(TERMINAL_KEYS), comparison_sha256=sha(trial_root / 'comparison.json'),
+            admission=admission, environment=environment,
+            timings=dict(authority_before_seconds=authority_before_seconds, runtime_and_builtin_output_seconds=runtime_seconds,
+                checkpoint_seal_and_load_seconds=checkpoint_seconds, comparison_seconds=compare_seconds,
+                comparison_record_io_seconds=comparison_io_seconds, authority_after_seconds=authority_after_seconds,
+                original_build_or_cache_seconds=summary['build_or_cache_seconds'],
+                original_diagnostic_simulation_seconds=summary['diagnostic_simulation_seconds'],
+                trial_wall_before_report_seconds=time.perf_counter() - trial_started),
+            timing_limit='Original runtime includes its own I/O; it is not instrumented or subtracted. Build/import costs remain in recorded wall time.',
+            process_pid=os.getpid(), process_exit_claimed=False,
+            neural_state_fresh_each_call=True, within_trial_weight_updates=False,
+            only_saved_before_overlay_used=True, generated_delta_installed=False, original_experiment_resumed=False,
+            learning_success_claimed=False, GPU_graph_residency=False)
+        report_started = time.perf_counter()
+        save(trial_root / 'replay-report.json', report)
+        records.append(dict(report=str(trial_root / 'replay-report.json'), sha256=sha(trial_root / 'replay-report.json'),
+            report_io_seconds=time.perf_counter() - report_started,
+            trial_wall_seconds=time.perf_counter() - trial_started, **report))
+        print(json.dumps(dict(lane=job['lane'], fixture=row['fixture_id'], direction=direction, exact=True)), flush=True)
+        # Checkpoints hold owned CPU arrays only; no state is fed to the next run.
+        del current, original, fresh_reference
+    verify(selection['all_pins'])
+    result = dict(complete=True, lane=job['lane'], count=len(records), records=records,
+        process_pid=os.getpid(), initial_module_load_seconds=initial_module_seconds,
+        worker_wall_seconds=time.perf_counter() - started, all_bitwise_exact=True,
+        original_runtime_unchanged=True, fresh_neural_state_every_trial=True,
+        process_exit_independently_observed=False, original_experiment_resumed=False,
+        original_files_modified=False, scientific_learning_pass_claimed=False)
+    save(Path(job['result_file']), result)
+    return result
+
+
+def launch(job, job_path, process_dir, deadline):
+    save(job_path, job)
+    job_sha = sha(job_path)
+    argv = [str(ORIGINAL_PYTHON), '-B', str(Path(__file__).absolute()),
+            '--worker-job', str(job_path), '--worker-job-sha256', job_sha]
+    environment = dict(os.environ, CUDA_VISIBLE_DEVICES=GPU, CUDA_HOME='/usr/local/cuda',
+        MAX_JOBS='2', TORCH_CUDA_ARCH_LIST='8.9', PYTHONDONTWRITEBYTECODE='1',
+        PATH=str(ORIGINAL_ENV / 'bin') + os.pathsep + '/usr/local/cuda/bin' + os.pathsep + os.environ.get('PATH', ''))
+    label = job_path.stem
+    stdout_path, stderr_path = process_dir / (label + '.stdout.log'), process_dir / (label + '.stderr.log')
+    started = time.perf_counter()
+    timeout = deadline - time.time()
+    require(timeout > 0, 'Replay wall budget exhausted before spawn')
+    returncode, timed_out, launch_error = None, False, None
+    process = None
+    terminated_child = False
+
+    def stop_child():
+        nonlocal terminated_child
+        if process is None:
+            return
+        terminated_child = True
+        if process.poll() is None:
+            process.terminate()
+        try:
+            process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            process.kill()
+        process.wait()
+
+    def interrupted(signum, _frame):
+        stop_child()
+        raise KeyboardInterrupt('Replay interrupted by signal ' + str(signum))
+
+    previous_handlers = {signum: signal.getsignal(signum) for signum in (signal.SIGTERM, signal.SIGINT)}
+    try:
+        for signum in previous_handlers:
+            signal.signal(signum, interrupted)
+        with stdout_path.open('xb') as stdout, stderr_path.open('xb') as stderr:
+            process = subprocess.Popen(argv, cwd=Path(__file__).absolute().parent, env=environment,
+                                       stdout=stdout, stderr=stderr)
+            returncode = process.wait(timeout=timeout)
+    except subprocess.TimeoutExpired:
+        timed_out = True
+        stop_child()
+        returncode = process.returncode
+    except OSError as exc:
+        launch_error = f'{type(exc).__name__}: {exc}'
+        stop_child()
+    except BaseException:
+        stop_child()
+        raise
+    finally:
+        for signum, handler in previous_handlers.items():
+            signal.signal(signum, handler)
+    receipt = dict(argv=argv, job_sha256=job_sha, actual_returncode=returncode,
+        timed_out=timed_out, launch_error=launch_error, child_whole_wall_seconds=time.perf_counter() - started,
+        exit_independently_observed=returncode is not None, parent_pid=os.getpid(),
+        child_pid=None if process is None else process.pid,
+        child_terminated_on_failure=terminated_child,
+        process_group_policy='inherits outer run_job owned process group; no nested session',
+        stdout_sha256=sha(stdout_path) if stdout_path.exists() else None,
+        stderr_sha256=sha(stderr_path) if stderr_path.exists() else None,
+        receipt_scope='actual exec process; resident trial reports never claim individual process exits')
+    save(process_dir / (label + '.json'), receipt)
+    require(returncode == 0 and not timed_out and launch_error is None, 'Replay child failed; evidence retained: ' + label)
+    result = read(job['result_file'])
+    require(result['complete'] is True and result['all_bitwise_exact'] is True
+            and result['lane'] == job['lane'] and result['count'] == len(job['runs']), 'Child result incomplete')
+    for row in result['records']:
+        require(sha(row['report']) == row['sha256'], 'Child trial report changed after exit')
+    receipt['result_file'] = job['result_file']
+    receipt['result_sha256'] = sha(job['result_file'])
+    return receipt, result
+
+
+def run(fixtures, manifest_sha, output):
+    started = time.perf_counter()
+    deadline = time.time() + 900
+    require(sys.dont_write_bytecode and Path(sys.prefix) == ORIGINAL_ENV,
+            'Parent must use the original registered environment Python -B')
+    output = path_checked(output)
+    require(not output.exists() and output.parent.is_dir() and not output.is_relative_to(ROOT)
+            and not output.is_relative_to(path_checked(fixtures))
+            and not output.is_relative_to(Path(__file__).absolute().parent), 'Use a fresh output root outside all protected trees')
+    output.mkdir()
+    for name in ('fresh', 'resident', 'jobs', 'processes', 'build', 'sessions'):
+        (output / name).mkdir()
+    try:
+        preparation_started = time.perf_counter()
+        selection = build_selection(fixtures, manifest_sha)
+        selection_path = output / 'selection.json'
+        save(selection_path, selection)
+        candidate_sha = sha(Path(__file__).absolute())
+        save(output / 'authority.json', dict(registration_sha256=REG_SHA, fixture_manifest_sha256=manifest_sha,
+            candidate_source_sha256=candidate_sha, selection_sha256=sha(selection_path),
+            original_interpreter=str(ORIGINAL_PYTHON), gpu_uuid=GPU,
+            fixed_trials=dict(fresh=14, resident_forward=14, resident_reverse=14),
+            wall_budget_seconds=900, deadline_unix=deadline,
+            preparation_seconds=time.perf_counter() - preparation_started,
+            source_pins={str(R_PATH): R_SHA, str(C_PATH): C_SHA, str(AP_PATH): AP_SHA},
+            cold_build_policy='one new shared candidate build directory; first fresh call includes cold build, no warm-up trials',
+            existing_AR_not_resumed=True, numerical_implementation_unchanged=True,
+            created_utc=datetime.now(timezone.utc).isoformat()))
+        common = dict(selection_file=str(selection_path), selection_sha256=sha(selection_path),
+            candidate_source_sha256=candidate_sha, build_root=str(output / 'build'),
+            experiment_root=str(output), deadline_unix=deadline)
+        children, fresh_records = [], []
+        for index in range(14):
+            label = f'fresh-{index:02d}'
+            job = dict(common, lane='fresh', runs=[['fresh', index]], output_root=str(output / 'fresh'),
+                       result_file=str(output / 'sessions' / (label + '.json')))
+            process, result = launch(job, output / 'jobs' / (label + '.json'), output / 'processes', deadline)
+            children.append(process)
+            fresh_records.extend(result['records'])
+        fresh_references = {row['fixture_id']: dict(checkpoint=row['current_checkpoint'],
+            checkpoint_manifest_sha256=row['current_checkpoint_manifest_sha256'],
+            report=row['report'], report_sha256=row['sha256']) for row in fresh_records}
+        job = dict(common, lane='resident', runs=fixture_order(14), output_root=str(output / 'resident'),
+                   fresh_references=fresh_references,
+                   result_file=str(output / 'sessions/resident.json'))
+        process, resident = launch(job, output / 'jobs/resident.json', output / 'processes', deadline)
+        children.append(process)
+        require(time.time() < deadline, 'Replay exceeded bounded wall budget')
+        verify(selection['all_pins'])
+        require(sha(Path(__file__).absolute()) == candidate_sha, 'Candidate source changed')
+        by_fresh = {row['fixture_id']: row for row in fresh_records}
+        paired = []
+        for row in resident['records']:
+            reference = by_fresh[row['fixture_id']]
+            paired.append(dict(fixture_id=row['fixture_id'], direction=row['direction'],
+                fresh_trial_wall_seconds=reference['trial_wall_seconds'],
+                resident_trial_wall_seconds=row['trial_wall_seconds'],
+                fresh_runtime_and_output_seconds=reference['timings']['runtime_and_builtin_output_seconds'],
+                resident_runtime_and_output_seconds=row['timings']['runtime_and_builtin_output_seconds'],
+                both_exact_to_same_original_checkpoint=True))
+        result = dict(status='PASS-UNCHANGED-R-PERSISTENT-PROCESS-REPLAY', complete=True,
+            fixture_count=14, fresh_trial_count=14, resident_trial_count=28, actual_child_processes=len(children),
+            all_bitwise_exact=True, children=children, matched_pairs=paired,
+            fresh_children_whole_wall_seconds=sum(c['child_whole_wall_seconds'] for c in children[:-1]),
+            resident_child_whole_wall_seconds=children[-1]['child_whole_wall_seconds'],
+            wall_seconds=time.perf_counter() - started, original_files_verified_unchanged=True,
+            source_runtime_unchanged=True, neural_state_fresh_every_call=True, GPU_graph_residency=False,
+            original_experiment_resumed=False, generated_overlay_installed=False,
+            scientific_learning_pass_claimed=False,
+            timing_limit='Different lane counts (14 vs 28); use per-fixture pairs. First fresh includes cold extension build. No pure kernel speedup is claimed.',
+            files={str(p.relative_to(output)): sha(p) for p in sorted(output.rglob('*')) if p.is_file()})
+        save(output / 'summary.json', result)
+        return result
+    except BaseException:
+        save(output / 'failure.json', dict(complete=False, traceback=traceback.format_exc(),
+            wall_seconds=time.perf_counter() - started, original_experiment_resumed=False,
+            automatic_retry=False, partial_outputs_retained=True))
+        raise
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--fixtures', type=Path)
+    parser.add_argument('--fixture-manifest-sha256')
+    parser.add_argument('--output', type=Path)
+    parser.add_argument('--worker-job', type=Path, help=argparse.SUPPRESS)
+    parser.add_argument('--worker-job-sha256', help=argparse.SUPPRESS)
+    args = parser.parse_args()
+    if args.worker_job:
+        require(args.worker_job_sha256 and not any((args.fixtures, args.fixture_manifest_sha256, args.output)),
+                'Worker and parent arguments cannot be combined')
+        result = run_worker(args.worker_job, args.worker_job_sha256)
+    else:
+        require(args.fixtures and args.fixture_manifest_sha256 and args.output
+                and not args.worker_job_sha256, 'Require --fixtures --fixture-manifest-sha256 --output')
+        result = run(args.fixtures, args.fixture_manifest_sha256, args.output)
+    print(json.dumps(dict(complete=True, status=result.get('status', 'worker-returned'))), flush=True)
+
+
+if __name__ == '__main__':
+    main()

models/male-cns-lif/conditioning-pipeline-acceleration-v1/finalize.py

@@ -0,0 +1,194 @@
+"""Seal bounded engineering replay evidence; never resume scientific work."""
+from datetime import datetime, timezone
+import hashlib
+import json
+from pathlib import Path
+import statistics
+import subprocess
+
+ROOT = Path('/home/qishizhe/phase4ar-pipeline-acceleration-20261001')
+SOURCE = Path(__file__).absolute().parent
+WORKTREE = SOURCE.parents[2]
+
+
+def require(value, message):
+    if not value:
+        raise ValueError(message)
+
+
+def read(path):
+    return json.loads(path.read_text())
+
+
+def sha(path):
+    h = hashlib.sha256()
+    with path.open('rb') as stream:
+        for block in iter(lambda: stream.read(8 << 20), b''):
+            h.update(block)
+    return h.hexdigest()
+
+
+def save(path, value):
+    with path.open('x') as stream:
+        json.dump(value, stream, indent=2, sort_keys=True, allow_nan=False)
+        stream.write('\n')
+
+
+def stats(values):
+    return dict(count=len(values), median=statistics.median(values), mean=statistics.mean(values),
+                minimum=min(values), maximum=max(values), total=sum(values))
+
+
+def successful_job(label):
+    record = read(ROOT / 'jobs' / (label + '.exit.json'))
+    require(record['observed_exit'] is True and record['exit_code'] == 0
+            and not record.get('stop_reason') and not record['timed_out'], 'Job did not exit successfully: ' + label)
+    return record
+
+
+def check_inventory(root, inventory):
+    for rel, item in inventory.items():
+        path = root / rel
+        require(path.resolve().is_relative_to(root) and not path.is_symlink(), 'Unsafe artifact path')
+        expected = item if isinstance(item, str) else item['sha256']
+        require(sha(path) == expected, 'Artifact changed: ' + str(path))
+        if isinstance(item, dict) and 'bytes' in item:
+            require(path.stat().st_size == item['bytes'], 'Artifact size changed')
+
+
+def main():
+    require(ROOT.is_dir() and not ROOT.is_symlink(), 'New experiment root required')
+    require(not (ROOT / 'final-summary.json').exists(), 'Finalization must not overwrite prior results')
+    jobs = {name: successful_job(name) for name in
+            ('cpu-unit-tests', 'brain-unit-tests', 'cpu-profile-01', 'brain-replay-01')}
+    before, after = [read(ROOT / ('integrity-' + stage + '.json')) for stage in ('before', 'after')]
+    require(before['status'] == after['status'] == 'PASS', 'Pre/post integrity failed')
+    require(after['original']['status'] == 'PASS' and after['original']['files_checked'] == 64034
+            and not after['original']['file_mismatches'] and not after['original']['source_mismatches'], 'Science integrity failed')
+    cpu = read(ROOT / 'cpu-profile/report.json')
+    brain = read(ROOT / 'brain-replay/summary.json')
+    require(cpu['complete'] and cpu['fixtures'] == 14 and cpu['all_child_exits_observed_zero']
+            and cpu['all_full_array_reference_comparisons_passed'] and cpu['all_original_receipts_exact']
+            and cpu['full_AQ_validates_actual_second_pass_E_outputs'], 'CPU regression incomplete')
+    require(brain['complete'] and brain['all_bitwise_exact'] and brain['fresh_trial_count'] == 14
+            and brain['resident_trial_count'] == 28 and brain['actual_child_processes'] == 15, 'Brain regression incomplete')
+    check_inventory(ROOT / 'cpu-profile', cpu['files'])
+    check_inventory(ROOT / 'brain-replay', brain['files'])
+    fresh = [read(ROOT / ('brain-replay/sessions/fresh-%02d.json' % i))['records'][0] for i in range(14)]
+    resident = read(ROOT / 'brain-replay/sessions/resident.json')['records']
+    for record in fresh + resident:
+        require(record['exact'] and record['input_pins_verified_before_and_after']
+                and record['neural_state_fresh_each_call'] and not record['generated_delta_installed'], 'Invalid replay trial')
+    paired = []
+    for first in fresh:
+        others = [r for r in resident if r['fixture_id'] == first['fixture_id']]
+        require(len(others) == 2 and {r['direction'] for r in others} == {'forward', 'reverse'}, 'Incomplete fixed ordering')
+        fresh_runtime = first['timings']['runtime_and_builtin_output_seconds']
+        warm_runtime = statistics.median(r['timings']['runtime_and_builtin_output_seconds'] for r in others)
+        warm_wall = statistics.median(r['trial_wall_seconds'] for r in others)
+        paired.append(dict(fixture_id=first['fixture_id'], fixed_index=first['fixed_index'],
+            first_fixture_cold_build_and_context=first['fixed_index'] == 0,
+            fresh_runtime_seconds=fresh_runtime, resident_runtime_seconds=warm_runtime,
+            runtime_ratio=fresh_runtime / warm_runtime,
+            fresh_trial_wall_seconds=first['trial_wall_seconds'], resident_trial_wall_seconds=warm_wall,
+            trial_wall_ratio=first['trial_wall_seconds'] / warm_wall,
+            fresh_simulation_seconds=first['timings']['original_diagnostic_simulation_seconds'],
+            resident_simulation_seconds=statistics.median(r['timings']['original_diagnostic_simulation_seconds'] for r in others)))
+    # Exclusion is by fixed initialization position, never by observed outcome.
+    # All 42 trials remain in correctness evidence and the full paired table.
+    steady = paired[1:]
+    brain_timing = {name: stats([p[name] for p in steady]) for name in (
+        'fresh_runtime_seconds', 'resident_runtime_seconds', 'runtime_ratio',
+        'fresh_trial_wall_seconds', 'resident_trial_wall_seconds', 'trial_wall_ratio',
+        'fresh_simulation_seconds', 'resident_simulation_seconds')}
+    cold_E = cpu['full_E']['cold_fixed_first']
+    warm_E = [r for r in cpu['full_E']['resident']
+              if r['round_index'] == 1 and r['fixture_id'] == cold_E['fixture_id']]
+    require(len(warm_E) == 1, 'Missing same-fixture E timing')
+    e_pair = dict(fixture_id=cold_E['fixture_id'],
+        cold_API_seconds=cold_E['original_api_seconds'], warm_API_seconds=warm_E[0]['original_api_seconds'],
+        API_ratio=cold_E['original_api_seconds'] / warm_E[0]['original_api_seconds'],
+        sample_warning='One fixed-first cold sample; not a 14-fixture matched cold E study')
+    commit = subprocess.check_output(['git', '-C', str(WORKTREE), 'rev-parse', 'HEAD'], text=True).strip()
+    git_status = subprocess.check_output(['git', '-C', str(WORKTREE), 'status', '--porcelain'], text=True)
+    require(not git_status, 'Candidate worktree must be committed before finalization')
+    result = dict(status='PASS-PERSISTENT-REPLAY-EQUIVALENCE', created_utc=datetime.now(timezone.utc).isoformat(),
+        source_commit=commit, registration_sha256=cpu['registration_sha256'],
+        original_source_commit=cpu['original_source_commit'], fixture_manifest_sha256=cpu['fixture_manifest_sha256'],
+        jobs=jobs, cpu_summary=cpu['summary'], full_E_same_fixture_API_comparison=e_pair,
+        brain_matched_pairs=paired, brain_steady_13_fixture_summary=brain_timing,
+        first_brain_fixture=paired[0],
+        full_brain_regression=dict(fresh=14, resident_forward=14, resident_reverse=14,
+            arrays_per_trial=10, all_bitwise_exact=True, actual_child_exits_observed_zero=15),
+        cpu_regression=dict(cold_U=14, resident_update_plus_independent_verification=42,
+            full_E_cold=1, full_E_resident=28, full_AQ_on_new_E_outputs=14, host_tests=17),
+        integrity=after, scientific_AR_resumed=False, training_epochs_added=0, probes_added=0,
+        production_runtime_promoted=False, scientific_learning_success_claimed=False,
+        limitations=[
+            'Fixed 14 real committed-prefix fixtures only; not the full scientific design.',
+            'Fresh means fresh interpreter, not flushed filesystem caches.',
+            'Brain uses unchanged original 4090 runtime; whole-brain V100 compatibility remains unestablished.',
+            'Original GPU tensors/graph are still allocated and uploaded each trial; no numerical loop rewrite.',
+            'Brain runtime timings include its original output I/O. Trial wall also includes extra audit checks.',
+            'Resident trial audit additionally checks the current fresh reference, making trial-wall boundaries unequal.',
+            'Paired steady timing excludes fixed fixture 0 cold initialization in both lanes; correctness excludes none.',
+            'Independent measured stages are not a combined training pipeline; no end-to-end speedup or revised full-run ETA.',
+            'Full independent AQ still uses a fresh subprocess and all original checks.',
+            'The original stopped scientific run remains at 1033 CPU-verified epochs and 138 probes.',
+            'Integrity covers saved Phase4AR files/sources and previous acceleration files; not a new Phase1-4AQ numerical regression.',
+            'Expected timeout self-test intentionally exits nonzero; it is not a scientific-run failure.'
+        ])
+    save(ROOT / 'final-summary.json', result)
+    s = cpu['summary']
+    b = brain_timing
+    report = f'''# 常驻进程工程回放结果
+
+状态：`PASS-PERSISTENT-REPLAY-EQUIVALENCE`。仅限这次固定回放，不代表学习成功或正式运行时升级。
+
+## 实测
+
+| 测量范围 | 新进程 | 常驻进程 | 说明 |
+|---|---:|---:|---|
+| 原始 CPU 更新 API | {s['cold_U_API_seconds']['median']:.4f} s | {s['resident_warm_U_API_seconds']['median']:.4f} s | 新进程首次 API 包含导入等开销 |
+| 完整更新 API，同一固定案例 | {e_pair['cold_API_seconds']:.4f} s | {e_pair['warm_API_seconds']:.4f} s | 仅一组冷启动对照 |
+| 全脑原始运行函数，13 组配对中位数 | {b['fresh_runtime_seconds']['median']:.4f} s | {b['resident_runtime_seconds']['median']:.4f} s | 含原有输出；排除固定首例的初始化 |
+
+完整更新常驻 14 组中位耗时：{s['original_full_E_warm_roundtrip_seconds']['median']:.4f} s。
+完整独立验证仍需：{s['original_full_AQ_subprocess_wall_seconds']['median']:.4f} s（14 组中位数）。
+全脑运行函数同案例配对倍率中位数：{b['runtime_ratio']['median']:.3f}×，不是整轮训练加速倍率。
+
+## 一致性与保护
+
+- 17 项主机测试通过。
+- CPU：14 次冷启动更新、42 次独立双进程更新/重算、29 次完整更新、14 次完整独立验证通过。
+- 全脑：14 次新进程、正序 14 次与逆序 14 次常驻回放；所有脉冲、状态、延迟队列和请求等一致，10 个数组逐位相同。
+- 64,034 个原实验文件与 16 个注册源码重新校验通过；之前 659 个加速产物和 13 个源码保持不变。
+- 原 Phase4AR 仍停止于 1,033 轮 CPU 校验训练与 138 次 probe，没有新增训练或安装新权重。
+
+## 边界与下一步
+
+本次全脑测试使用原 RTX 4090 环境，没有证明全脑已能迁移到 V100。此前 V100 约 3.4 ms 的成绩仅属于 eligibility/update 模块。
+常驻进程复用的是解释器、模块和 CUDA 上下文；每轮神经状态仍由原始函数重新分配。
+当前仍保留完整验证、图和权重上传、记录写盘。下一步应在新的可审计流水线中验证整轮开销，不能把本报告的独立阶段相加当作实测训练速度。
+
+源码提交：`{commit}`。完整逐例耗时、实际进程退出、来源校验见 `final-summary.json` 和各 lane 报告。
+'''
+    with (ROOT / 'RESULTS.md').open('x') as stream:
+        stream.write(report)
+    files = {str(path.relative_to(ROOT)): dict(bytes=path.stat().st_size, sha256=sha(path))
+             for path in sorted(ROOT.rglob('*')) if path.is_file()}
+    source_files = {path.name: sha(path) for path in sorted(SOURCE.iterdir()) if path.is_file()}
+    manifest = dict(schema='conditioning-persistent-replay-artifacts-v1', source_commit=commit,
+        root=str(ROOT), files=files, source_files=source_files,
+        self_hash_policy='This manifest excludes itself and SHA256SUMS; SHA256SUMS includes the manifest.')
+    save(ROOT / 'artifact-manifest.json', manifest)
+    with (ROOT / 'SHA256SUMS').open('x') as stream:
+        for rel, item in files.items():
+            stream.write(item['sha256'] + '  ' + rel + '\n')
+        stream.write(sha(ROOT / 'artifact-manifest.json') + '  artifact-manifest.json\n')
+    print(json.dumps(dict(status=result['status'], files=len(files), source_commit=commit,
+        total_bytes=sum(v['bytes'] for v in files.values()), brain=brain_timing, CPU=cpu['summary']), indent=2))
+
+
+if __name__ == '__main__':
+    main()

models/male-cns-lif/conditioning-pipeline-acceleration-v1/prepost.py

@@ -0,0 +1,51 @@
+"""Verify previous independent engineering artifacts and original saved science."""
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import subprocess
+import sys
+import time
+
+BASE = Path('/home/qishizhe/phase4ar-pipeline-acceleration-20261001')
+OLD = Path('/home/qishizhe/phase4ar-v100-acceleration-20261001')
+OLD_SOURCE = Path(__file__).resolve().parent.parent / 'conditioning-acceleration-v1'
+OLD_MANIFEST_SHA = '6efdec34c96cdc79f786b91bd7a99b0e8ef64d0c4dcfa525646c82659a77d44f'
+FIXTURE_SHA = '481df128d39bf28e5984a6f2e5757f83d45cb7a6136f8d2843ecc0a67eca437b'
+
+def sha(path):
+    h = hashlib.sha256()
+    with Path(path).open('rb') as f:
+        for b in iter(lambda:f.read(8 << 20), b''): h.update(b)
+    return h.hexdigest()
+
+p = argparse.ArgumentParser()
+p.add_argument('--stage', choices=('before','after'), required=True)
+a = p.parse_args()
+BASE.mkdir(exist_ok=True)
+assert not BASE.is_symlink()
+report_path = BASE / ('integrity-' + a.stage + '.json')
+assert not report_path.exists()
+start = time.perf_counter()
+assert sha(OLD / 'artifact-manifest.json') == OLD_MANIFEST_SHA
+assert sha(OLD / 'fixtures/manifest.json') == FIXTURE_SHA
+manifest = json.loads((OLD / 'artifact-manifest.json').read_text())
+bad = []
+for rel, item in manifest['files'].items():
+    path = OLD / rel
+    assert path.resolve().is_relative_to(OLD) and not path.is_symlink()
+    if not path.is_file() or path.stat().st_size != item['bytes'] or sha(path) != item['sha256']: bad.append(rel)
+for name, expected in manifest['source_files'].items():
+    if sha(OLD_SOURCE / name) != expected: bad.append('source:' + name)
+assert not bad, bad
+science = BASE / ('original-integrity-' + a.stage + '.json')
+result = subprocess.run([sys.executable, '-B', str(OLD_SOURCE / 'audit_integrity.py'), '--output', str(science)],
+                        capture_output=True, text=True, timeout=120)
+assert result.returncode == 0, result.stdout + result.stderr
+records = json.loads(science.read_text())
+report = dict(status='PASS', previous_engineering_files_checked=len(manifest['files']),
+              previous_engineering_sources_checked=len(manifest['source_files']), original=records,
+              previous_manifest_sha256=OLD_MANIFEST_SHA, fixture_manifest_sha256=FIXTURE_SHA,
+              old_artifacts_modified=False, original_AR_resumed=False, wall_seconds=time.perf_counter()-start)
+with report_path.open('x') as f: json.dump(report, f, indent=2)
+print(json.dumps(report), flush=True)

models/male-cns-lif/conditioning-pipeline-acceleration-v1/profile_original.py

@@ -0,0 +1,770 @@
+"""Read-only profiling of the fixed 14 Phase 4AR update fixtures.
+
+The original Python -B environment and unchanged original U/AM/J sources are
+mandatory. No brain is run, training is resumed, or computed weight installed.
+Outputs are exclusive files under one fresh directory outside frozen inputs.
+
+Unprofiled lanes measure fresh U processes, two separate resident CPU
+processes (U producer and original U.verify_receipt verifier), and fresh full AQ
+validators. A further lane calls unchanged full E in fresh and resident CPU
+processes, retaining all its original checks. The resident verifier does NOT replace AQ checkpoint/graph/source
+validation. Production checks must not be removed on the basis of this replay.
+Separate cProfile runs are diagnostic and excluded from timing comparisons.
+"""
+from __future__ import annotations
+
+import argparse
+import base64
+import cProfile
+from datetime import datetime, timezone
+import hashlib
+import importlib.util
+import json
+import os
+from pathlib import Path, PurePosixPath
+import pstats
+import queue
+import statistics
+import subprocess
+import sys
+import threading
+import time
+
+
+ROOT = Path('/data/digital-drosophila')
+MODEL = ROOT / 'models/male-cns-lif'
+ENV = MODEL / '.venv'
+EXP = ROOT / 'experiments/phase4ar-normal-conditioning'
+REG_SHA = 'b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740'
+COMMIT = '80aeb2093db655329774eff7b32fb6e417b8b40b'
+SOURCE_SHA = dict(
+    conditioning_update_source='96efff678cff910654eb08e86f1a17789e4e5589e340345f419c7027a7d547e2',
+    eligibility_bridge_source='174fb8d14619189e74b095e77a6db18b14c93046dc431c0b55710a5aa2dd2e61',
+    phase4j_source='abb4574da85f00bd9ef61024c65993ef81d42651ff8d8d63c15dd69c6222471e')
+E_PATH = MODEL / 'olfactory-conditioning-lab-v1/conditioning_epoch.py'
+E_SHA = '757935a4815d9f625640df685184ed3fe44a8845323562796da7aa43cbb194e1'
+INPUTS = ('step', 'neuron_idx', 'kc', 'candidate_edge_id', 'candidate_sources',
+          'candidate_targets', 'candidate_compartments', 'delta_before', 'base_candidate')
+OUTPUTS = ('delta_after', 'sampled_trace', 'final_trace')
+REPEATS = 3
+SCHEMA = 'conditioning-pipeline-original-profile-v1'
+CHILDREN = []
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def canonical(value):
+    return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=False, allow_nan=False)
+
+
+def payload_sha(value):
+    return hashlib.sha256(canonical(value).encode()).hexdigest()
+
+
+def unlinked(value):
+    path = Path(value)
+    require(path.is_absolute() and '..' not in path.parts, 'Explicit absolute path required')
+    require(not any(p.is_symlink() or (hasattr(p, 'is_junction') and p.is_junction())
+                    for p in (path, *path.parents)), 'Linked path forbidden: ' + str(path))
+    return path
+
+
+def digest(path):
+    result = hashlib.sha256()
+    with unlinked(path).open('rb') as stream:
+        for data in iter(lambda: stream.read(8 << 20), b''):
+            result.update(data)
+    return result.hexdigest()
+
+
+def identity(path):
+    path = unlinked(path)
+    require(path.is_file(), 'Missing regular file: ' + str(path))
+    size = path.stat().st_size
+    result = dict(sha256=digest(path), bytes=size)
+    require(size == path.stat().st_size, 'File size changed during read')
+    return result
+
+
+def check(path, pin):
+    observed = identity(path)
+    sha = pin if isinstance(pin, str) else pin['sha256']
+    require(observed['sha256'] == sha, 'File SHA differs: ' + str(path))
+    if isinstance(pin, dict) and 'bytes' in pin:
+        require(observed['bytes'] == pin['bytes'], 'File size differs: ' + str(path))
+    return observed
+
+
+def read(path):
+    def pairs(items):
+        result = {}
+        for key, value in items:
+            require(key not in result, 'Duplicate JSON key')
+            result[key] = value
+        return result
+    return json.loads(unlinked(path).read_text(encoding='utf-8'), object_pairs_hook=pairs,
+                      parse_constant=lambda _: (_ for _ in ()).throw(ValueError('Nonfinite JSON')))
+
+
+def save(path, value):
+    with unlinked(path).open('x', encoding='utf-8', newline='\n') as stream:
+        json.dump(value, stream, sort_keys=True, indent=2, ensure_ascii=False, allow_nan=False)
+        stream.write('\n')
+
+
+def contained(root, name):
+    require(type(name) is str and '\\' not in name, 'Invalid relative fixture path')
+    relative = PurePosixPath(name)
+    require(not relative.is_absolute() and str(relative) == name and '..' not in relative.parts
+            and all(':' not in part for part in relative.parts), 'Escaping fixture path')
+    result = unlinked(root / name)
+    require(result.is_relative_to(root), 'Fixture path escaped root')
+    return result
+
+
+def evidence(array):
+    return dict(dtype=array.dtype.str, shape=list(array.shape), nbytes=int(array.nbytes),
+                raw_c_order_sha256=hashlib.sha256(array.tobytes(order='C')).hexdigest())
+
+
+def same(left, right):
+    return left.dtype == right.dtype and left.shape == right.shape and left.tobytes() == right.tobytes()
+
+
+def cpu_start():
+    require(sys.dont_write_bytecode and 'torch' not in sys.modules and 'runtime_light' not in sys.modules,
+            'Fresh Python -B CPU process required')
+    require(Path(sys.prefix) == ENV, 'Use the unchanged original registered .venv')
+    os.environ['CUDA_VISIBLE_DEVICES'] = ''
+    os.environ['PYTHONDONTWRITEBYTECODE'] = '1'
+
+
+def load_source(name, path, sha):
+    raw = unlinked(path).read_bytes()
+    require(hashlib.sha256(raw).hexdigest() == sha and name not in sys.modules, 'Source/module identity differs')
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    exec(compile(raw, str(path), 'exec'), module.__dict__)
+    return module
+
+
+def read_manifest(fixtures, expected):
+    path = fixtures / 'manifest.json'
+    check(path, expected)
+    manifest = read(path)
+    require(manifest['schema'] == 'conditioning-acceleration-fixtures-v1' and manifest['complete'] is True
+            and manifest['registration_sha256'] == REG_SHA and manifest['source_code_commit'] == COMMIT
+            and manifest['fixture_count'] == len(manifest['fixtures']) == 14,
+            'Exact sealed fourteen-fixture authority required')
+    require(len({f['fixture_id'] for f in manifest['fixtures']}) == 14, 'Duplicate fixture identity')
+    require(manifest['selection_sha256'] == manifest['files']['selection.json']['sha256'], 'Selection authority differs')
+    return manifest
+
+
+def verify_suite(fixtures, expected):
+    manifest = read_manifest(fixtures, expected)
+    for relative, pin in manifest['files'].items():
+        check(contained(fixtures, relative), pin)
+    registration = EXP / 'protocol/preregistered.json'
+    check(registration, REG_SHA)
+    reg = read(registration)
+    require(reg['source_code_commit'] == COMMIT, 'Registered scientific source commit differs')
+    original_pins = {str(registration): REG_SHA, **reg['source_sha256']}
+    for entry in manifest['fixtures']:
+        directory = contained(fixtures, entry['fixture_id'])
+        for path, pin in read(directory / 'source-file-pins.json').items():
+            prior = original_pins.get(path)
+            require(prior is None or (prior if isinstance(prior, str) else prior['sha256']) == pin['sha256'],
+                    'Conflicting immutable input pin')
+            original_pins[path] = pin
+        require(entry['exact_stored_delta_and_trace_verified'] is True
+                and entry['full_canonical_KC_count'] == 4064 and entry['full_candidate_edge_count'] == 14232
+                and entry['original_validator_verified_full_graph_mapping'] is True, 'Unvalidated fixture identity')
+    for path, pin in original_pins.items():
+        check(path, pin)
+    validator = MODEL / 'conditioning-execution-v1/validate_update_cpu.py'
+    original_pins[str(validator)] = check(validator, reg['input_sha256'][str(validator)])
+    require(reg['input_sha256'][str(E_PATH)] == E_SHA, 'Registered E source pin differs')
+    original_pins[str(E_PATH)] = check(E_PATH, E_SHA)
+    return manifest, original_pins
+
+
+def fixture_inputs(fixtures, manifest, entry):
+    """Each child independently reads/checks/owns its input and reference arrays."""
+    import numpy as np
+    directory = contained(fixtures, entry['fixture_id'])
+    required = (entry['npz'], entry['command'], entry['fixture_id'] + '/reference-sources.json',
+                entry['fixture_id'] + '/stored-update-receipt.json')
+    for relative in required:
+        check(contained(fixtures, relative), manifest['files'][relative])
+    require(manifest['files'][entry['npz']]['sha256'] == entry['npz_sha256']
+            and manifest['files'][entry['command']]['sha256'] == entry['command_sha256'], 'Fixture entry/file pins differ')
+    with np.load(contained(fixtures, entry['npz']), allow_pickle=False) as archive:
+        arrays = {name: archive[name].copy() for name in archive.files}
+    inputs = {name: arrays[name] for name in INPUTS}
+    require({name: evidence(array) for name, array in inputs.items()} == entry['input_arrays'],
+            'Loaded fixture full input bytes differ')
+    for name, pin in entry['output_arrays'].items():
+        require(evidence(arrays[name]) == pin, 'Loaded fixture reference bytes differ: ' + name)
+    require(len(inputs['kc']) == 4064 and len(inputs['candidate_edge_id']) == 14232,
+            'Incomplete original canonical array identity')
+    command = read(contained(fixtures, entry['command']))
+    require(command['trace_backend'] == 'torch', 'Original Torch CPU backend required')
+    sources = read(directory / 'reference-sources.json')
+    require(set(sources) == set(SOURCE_SHA), 'Unexpected original source roles')
+    for role, pin in sources.items():
+        require(pin['sha256'] == SOURCE_SHA[role], 'Frozen source SHA differs')
+        check(pin['path'], pin['sha256'])
+    kwargs = dict(inputs, **command, bridge_source=sources['eligibility_bridge_source']['path'],
+                  phase4j_source=sources['phase4j_source']['path'])
+    receipt = read(directory / 'stored-update-receipt.json')
+    require(receipt['payload_sha256'] == entry['original_update_payload_sha256'], 'Stored receipt identity differs')
+    for name in OUTPUTS:
+        require(evidence(arrays['reference_' + name]) == receipt['outputs'][name], 'Receipt/reference byte evidence differs')
+    require(same(arrays['reference_delta_after'], arrays['stored_delta_after']), 'Stored delta differs from CPU reference')
+    for array in arrays.values():
+        array.setflags(write=False)
+    return dict(inputs=inputs, arrays=arrays, kwargs=kwargs, sources=sources, receipt=receipt, command=command)
+
+
+def original_locations(fixtures, entry):
+    directory = contained(fixtures, entry['fixture_id'])
+    authority = read(directory / 'authority.json')
+    pins = read(directory / 'source-file-pins.json')
+    authority_paths = [path for path, pin in pins.items()
+                       if path.endswith('.authority.json') and pin['sha256'] == entry['authority_sha256']]
+    require(len(authority_paths) == 1, 'Original authority location is ambiguous')
+    authority_path = authority_paths[0]
+    check(authority_path, entry['authority_sha256'])
+    require(read(authority_path) == authority, 'Copied/original authority differs')
+    task_key = Path(authority_path).name[:-len('.authority.json')]
+    update_dir = EXP / 'updates' / task_key
+    chain_path = update_dir / 'chain-receipt.json'
+    chain_sha = pins[str(chain_path)]['sha256']
+    return authority_path, authority, update_dir, chain_sha
+
+
+def assert_epoch_output(directory, chain, fixture, entry):
+    import numpy as np
+    require(chain['complete'] is True and chain['coordinator_source_sha256'] == E_SHA
+            and chain['authority_sha256'] == entry['authority_sha256']
+            and chain['weights_installed'] is False and chain['brain_executed'] is False
+            and chain['input_and_checkpoint_bytes_reverified'] is True
+            and chain['candidate_endpoints_equal_graph'] is True
+            and chain['KC_equals_supplied_canonical_membership'] is True,
+            'Original full E validation chain incomplete')
+    receipt = read(directory / 'update-receipt.json')
+    require(canonical(receipt) == canonical(fixture['receipt']), 'Full original E receipt differs from sealed CPU reference')
+    with np.load(directory / 'delta-after.npz', allow_pickle=False) as archive:
+        require(set(archive.files) == {'edge_id', 'plastic_delta_mv'}, 'Full E overlay NPZ schema differs')
+        require(same(archive['edge_id'], fixture['inputs']['candidate_edge_id'])
+                and same(archive['plastic_delta_mv'], fixture['arrays']['reference_delta_after']),
+                'Full original E candidate/delta bytes differ')
+    for name in OUTPUTS:
+        require(receipt['outputs'][name] == evidence(fixture['arrays']['reference_' + name]),
+                'Full E trace/delta receipt does not bind full reference bytes')
+    for filename, sha in chain['output_files_sha256'].items():
+        check(directory / filename, sha)
+    return receipt
+
+
+def assert_update(result, fixture):
+    for name in OUTPUTS:
+        require(same(getattr(result, name), fixture['arrays']['reference_' + name]), 'Full array mismatch: ' + name)
+    require(canonical(result.receipt) == canonical(fixture['receipt']), 'Original complete receipt mismatch')
+    require({name: evidence(value) for name, value in fixture['inputs'].items()} == result.receipt['input_arrays'],
+            'Resident input bytes changed')
+    snapshots = fixture['arrays']['reference_snapshots']
+    if fixture['command']['us_tick'] is None:
+        require(snapshots.shape == (0, 4064) and not result.sampled_trace.view('uint32').any(),
+                'No-US snapshot/+0 rule differs')
+    else:
+        require(snapshots.shape == (1, 4064) and same(snapshots[0], result.sampled_trace),
+                'After-current-tick sampled snapshot differs')
+
+
+def pack_array(array):
+    return dict(dtype=array.dtype.str, shape=list(array.shape),
+                data_base64=base64.b64encode(array.tobytes(order='C')).decode('ascii'))
+
+
+def compare_packet(packet, reference):
+    require(packet['dtype'] == reference.dtype.str and packet['shape'] == list(reference.shape),
+            'Producer packet array identity differs')
+    raw = base64.b64decode(packet['data_base64'], validate=True)
+    require(raw == reference.tobytes(order='C'), 'Producer full array bytes differ from independent reference')
+
+
+def verify_response(value, previous, sequence, role):
+    require(value['role'] == role and value['sequence'] == sequence
+            and value['previous_response_sha256'] == previous and value['complete'] is True,
+            'Worker response chain/role differs')
+    expected = payload_sha({key: item for key, item in value.items() if key != 'response_sha256'})
+    require(expected == value['response_sha256'], 'Worker response payload hash differs')
+    return expected
+
+
+def profile_category(filename, name):
+    """Exclusive SELF-time categories; cumulative function rows stay separate."""
+    if 'importlib' in filename or name in ('_imp.create_dynamic', '_imp.exec_dynamic'):
+        return 'module_import'
+    if '::trace-expression-only' in filename or any("'" + op + "'" in name for op in ('mul_', 'add_', 'clamp_max_', 'zero_')):
+        return 'trace_expression_and_tensor_ops'
+    if filename.endswith('/ast.py') or filename.endswith('\\ast.py') or name in ('_load_original', '_load_bridge') or 'builtins.compile' in name:
+        return 'source_parse_compile_load'
+    if name in ('trace_from_events', 'apply_eligibility', 'apply_v2'):
+        return 'trace_apply_python_self'
+    if any(token in name for token in ('read_bytes', 'readinto', 'readall', 'HASH', 'openssl_sha256', '_pinned_bytes', '_evidence')):
+        return 'file_reads_and_hashing'
+    return 'other_validation_arrays_and_runtime'
+
+
+def profile_rows(profiler):
+    rows, categories = [], {}
+    for (filename, line, name), (primitive, calls, own, cumulative, _) in pstats.Stats(profiler).stats.items():
+        category = profile_category(filename, name)
+        categories[category] = categories.get(category, 0.) + own
+        rows.append(dict(file=filename, line=line, function=name, primitive_calls=primitive, calls=calls,
+                         self_seconds=own, cumulative_seconds=cumulative, category=category))
+    return dict(self_time_categories_seconds=categories,
+                functions=sorted(rows, key=lambda row: row['cumulative_seconds'], reverse=True),
+                interpretation='diagnostic Python cProfile overhead included; self categories are exclusive, cumulative rows overlap; not standalone pure-math latency')
+
+
+def worker(fixtures, expected, role, worker_output_root=None):
+    cpu_start()
+    started = time.perf_counter()
+    manifest = read_manifest(fixtures, expected)
+    entries = {entry['fixture_id']: entry for entry in manifest['fixtures']}
+    t = time.perf_counter()
+    import numpy as np
+    numpy_seconds = time.perf_counter() - t
+    first = contained(fixtures, manifest['fixtures'][0]['fixture_id'])
+    check(first / 'reference-sources.json', manifest['files'][manifest['fixtures'][0]['fixture_id'] + '/reference-sources.json'])
+    sources = read(first / 'reference-sources.json')
+    source = sources['conditioning_update_source']
+    require(source['sha256'] == SOURCE_SHA['conditioning_update_source'], 'Original U source differs')
+    t = time.perf_counter()
+    update = load_source('_pipeline_original_U_' + role, source['path'], source['sha256'])
+    source_seconds = time.perf_counter() - t
+    epoch = None
+    epoch_import_seconds = 0.
+    if role == 'epoch':
+        require(worker_output_root is not None and unlinked(worker_output_root).is_dir(), 'Explicit existing full E output root required')
+        t = time.perf_counter()
+        epoch = load_source('_pipeline_original_E', E_PATH, E_SHA)
+        epoch_import_seconds = time.perf_counter() - t
+    print(canonical(dict(event='ready', role=role, pid=os.getpid(), fixture_manifest_sha256=expected,
+        setup_seconds=time.perf_counter() - started, numpy_import_seconds=numpy_seconds,
+        original_U_source_import_seconds=source_seconds, torch_loaded='torch' in sys.modules,
+        original_E_source_import_seconds=epoch_import_seconds,
+        CUDA_VISIBLE_DEVICES='', source_pins=sources)), flush=True)
+    cache, previous, sequence = {}, None, 0
+    producer_previous, producer_sequence, producer_pid = None, 0, None
+    for line in sys.stdin:
+        request = json.loads(line)
+        if request.get('action') == 'stop':
+            break
+        require(request.get('action') in ('run', 'profile'), 'Unknown request action')
+        require(role != 'verifier' or request['action'] == 'run', 'Verifier profiling is not an authorized lane')
+        request_started = time.perf_counter()
+        entry = entries[request['fixture_id']]
+        t = time.perf_counter()
+        cached = request['fixture_id'] in cache
+        if not cached:
+            cache[request['fixture_id']] = fixture_inputs(fixtures, manifest, entry)
+        fixture = cache[request['fixture_id']]
+        load_seconds = time.perf_counter() - t
+        require(fixture['sources'] == sources, 'Fixture source closure differs from resident original module')
+        verify_seconds = 0.
+        packets = None
+        receipt = fixture['receipt']
+        diagnostic = None
+        epoch_output = None
+        if role == 'epoch':
+            require(request['action'] == 'run', 'Full E profiling uses unprofiled original API only')
+            epoch_output = unlinked(request['epoch_output'])
+            require(epoch_output.parent == worker_output_root and not epoch_output.exists(), 'Full E output must be a fresh direct child')
+            authority_path, _, _, _ = original_locations(fixtures, entry)
+            t = time.perf_counter()
+            chain = epoch.postprocess_epoch(authority_path, entry['authority_sha256'], epoch_output)
+            api_seconds = time.perf_counter() - t
+            t = time.perf_counter()
+            receipt = assert_epoch_output(epoch_output, chain, fixture, entry)
+            verify_seconds = time.perf_counter() - t
+        elif role == 'verifier':
+            produced = request['producer_response']
+            producer_sequence += 1
+            producer_previous = verify_response(produced, producer_previous, producer_sequence, 'producer')
+            require(produced['fixture_id'] == request['fixture_id'] and produced['request_id'] == request['request_id'],
+                    'Producer/verifier task pairing differs')
+            if producer_pid is None:
+                producer_pid = produced['pid']
+            require(produced['pid'] == producer_pid and producer_pid != os.getpid(), 'Verifier must be a distinct stable OS process')
+            t = time.perf_counter()
+            require(canonical(produced['receipt']) == canonical(receipt), 'Producer receipt differs from sealed CPU reference')
+            for name in OUTPUTS:
+                compare_packet(produced['arrays'][name], fixture['arrays']['reference_' + name])
+            packet_seconds = time.perf_counter() - t
+            t = time.perf_counter()
+            require(update.verify_receipt(produced['receipt'], **fixture['kwargs']) is True, 'Original U receipt verification failed')
+            api_seconds = time.perf_counter() - t
+            verify_seconds = packet_seconds
+        else:
+            profiler = cProfile.Profile() if request['action'] == 'profile' else None
+            t = time.perf_counter()
+            if profiler:
+                profiler.enable()
+            try:
+                result = update.update_epoch(**fixture['kwargs'])
+            finally:
+                if profiler:
+                    profiler.disable()
+            api_seconds = time.perf_counter() - t
+            t = time.perf_counter()
+            assert_update(result, fixture)
+            packets = {name: pack_array(getattr(result, name)) for name in OUTPUTS}
+            verify_seconds = time.perf_counter() - t
+            receipt = result.receipt
+            if profiler:
+                diagnostic = profile_rows(profiler)
+        import torch
+        require(not torch.cuda.is_initialized() and os.environ['CUDA_VISIBLE_DEVICES'] == '', 'CPU worker initialized CUDA')
+        require({name: evidence(array) for name, array in fixture['inputs'].items()} == entry['input_arrays'],
+                'Resident inputs differ after call')
+        sequence += 1
+        response = dict(schema=SCHEMA + '-response', complete=True, role=role, pid=os.getpid(), sequence=sequence,
+            previous_response_sha256=previous, request_id=request['request_id'], fixture_id=request['fixture_id'],
+            cached_inputs=cached, input_load_verify_seconds=load_seconds, original_api_seconds=api_seconds,
+            reference_checks_and_packet_seconds=verify_seconds, worker_request_seconds=time.perf_counter() - request_started,
+            full_array_reference_exact=True, original_receipt_exact=True, input_bytes_unchanged=True,
+            cuda_initialized=False, receipt=receipt, arrays=packets, cprofile=diagnostic,
+            epoch_output=None if epoch_output is None else str(epoch_output),
+            independently_verified_producer_response_sha256=producer_previous if role == 'verifier' else None,
+            versions=dict(python=sys.version, numpy=np.__version__, torch=torch.__version__),
+            verification_scope=('unchanged full E.postprocess_epoch including all original source/graph/checkpoint checks; exact delta bytes and full receipt trace hashes'
+                if role == 'epoch' else 'independent original U.verify_receipt recomputation plus exact full producer-array/reference comparison; NOT full AQ graph/checkpoint validation'
+                if role == 'verifier' else 'unchanged original U.update_epoch; all output array bytes equal sealed CPU reference'))
+        response['response_sha256'] = payload_sha(response)
+        previous = response['response_sha256']
+        print(canonical(response), flush=True)
+    for fixture in cache.values():
+        for source in fixture['sources'].values():
+            check(source['path'], source['sha256'])
+    check(fixtures / 'manifest.json', expected)
+
+
+class Child:
+    def __init__(self, output, name, fixtures, expected, role, worker_output_root=None):
+        self.name, self.output, self.role = name, output, role
+        self.previous, self.sequence, self.closed = None, 0, False
+        self.started = time.perf_counter()
+        self.stderr = (output / (name + '.stderr.log')).open('xb')
+        self.responses = (output / (name + '.responses.jsonl')).open('x', encoding='utf-8', newline='\n')
+        self.argv = [sys.executable, '-B', str(Path(__file__).absolute()), '--fixtures', str(fixtures),
+                     '--fixture-manifest-sha256', expected, '--worker', role]
+        if worker_output_root is not None:
+            self.argv += ['--worker-output-root', str(worker_output_root)]
+        self.process = subprocess.Popen(self.argv, cwd=output, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+            stderr=self.stderr, text=True, encoding='utf-8', bufsize=1,
+            env=dict(os.environ, CUDA_VISIBLE_DEVICES='', PYTHONDONTWRITEBYTECODE='1'))
+        CHILDREN.append(self)
+        self.lines = queue.Queue()
+        def pump():
+            try:
+                for line in self.process.stdout:
+                    self.lines.put(line)
+            finally:
+                self.lines.put(None)
+        self.reader = threading.Thread(target=pump, daemon=True)
+        self.reader.start()
+        self.ready = self._read()
+        require(self.ready['event'] == 'ready' and self.ready['role'] == role
+                and self.ready['pid'] == self.process.pid and self.ready['fixture_manifest_sha256'] == expected
+                and self.ready['torch_loaded'] is False, 'Fresh CPU worker startup differs')
+        self.startup_wall = time.perf_counter() - self.started
+
+    def _read(self):
+        try:
+            line = self.lines.get(timeout=120)
+        except queue.Empty as error:
+            raise TimeoutError(self.name + ' response exceeded 120 seconds') from error
+        require(bool(line), self.name + ' exited without a complete response; inspect stderr')
+        self.responses.write(line)
+        self.responses.flush()
+        return json.loads(line)
+
+    def request(self, value):
+        started = time.perf_counter()
+        self.process.stdin.write(canonical(value) + '\n')
+        self.process.stdin.flush()
+        response = self._read()
+        wall = time.perf_counter() - started
+        self.sequence += 1
+        self.previous = verify_response(response, self.previous, self.sequence, self.role)
+        require(response['pid'] == self.process.pid and response['fixture_id'] == value['fixture_id']
+                and response['request_id'] == value['request_id'], 'Worker response pairing differs')
+        return response, wall
+
+    def close(self):
+        if self.closed:
+            return self.receipt
+        self.process.stdin.write(canonical(dict(action='stop')) + '\n')
+        self.process.stdin.flush()
+        self.process.stdin.close()
+        code = self.process.wait(timeout=30)
+        self.reader.join(timeout=2)
+        self.process.stdout.close()
+        self.stderr.close()
+        self.responses.close()
+        self.receipt = dict(argv=self.argv, pid=self.process.pid, exit_code=code,
+            actual_exit_observed=True, startup_wall_seconds=self.startup_wall,
+            process_wall_seconds=time.perf_counter() - self.started, ready=self.ready,
+            responses=self.sequence, final_response_sha256=self.previous,
+            stdout_sha256=digest(self.output / (self.name + '.responses.jsonl')),
+            stderr_sha256=digest(self.output / (self.name + '.stderr.log')))
+        save(self.output / (self.name + '-process.json'), self.receipt)
+        self.closed = True
+        require(code == 0, self.name + ' failed; output retained')
+        return self.receipt
+
+    def abort(self):
+        """Only this exact spawned child is stopped; partial evidence is retained."""
+        if self.closed:
+            return
+        terminate_sent = False
+        kill_sent = False
+        if self.process.poll() is None:
+            self.process.terminate()
+            terminate_sent = True
+        try:
+            code = self.process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            self.process.kill()
+            kill_sent = True
+            code = self.process.wait(timeout=30)
+        self.reader.join(timeout=2)
+        for stream in (self.process.stdin, self.process.stdout, self.stderr, self.responses):
+            if stream is not None and not stream.closed:
+                stream.close()
+        save(self.output / (self.name + '-abort-process.json'), dict(argv=self.argv, pid=self.process.pid,
+             actual_exit_observed=True, exit_code=code, terminate_sent=terminate_sent, kill_sent=kill_sent,
+             partial_evidence_retained=True, automatic_retry=False))
+        self.closed = True
+
+
+def cleanup_children():
+    errors = []
+    for child in reversed(CHILDREN):
+        try:
+            child.abort()
+        except Exception as error:
+            errors.append(type(error).__name__ + ': ' + str(error))
+    require(not errors, 'Child cleanup errors: ' + '; '.join(errors))
+
+
+def compact_response(response, wall):
+    return {**{key: value for key, value in response.items() if key not in ('arrays', 'receipt', 'cprofile')},
+            'original_receipt_payload_sha256': response['receipt']['payload_sha256'],
+            'parent_roundtrip_seconds': wall}
+
+
+def distribution(values):
+    require(bool(values), 'Empty timing distribution')
+    return dict(count=len(values), minimum=min(values), median=statistics.median(values),
+                maximum=max(values), sum=sum(values), mean=statistics.mean(values))
+
+
+def full_validation(fixtures, entry, output, reg, produced_update_dir):
+    directory = contained(fixtures, entry['fixture_id'])
+    authority_path, _, historical_update_dir, _ = original_locations(fixtures, entry)
+    update_dir = unlinked(produced_update_dir)
+    require(update_dir.is_dir() and update_dir != historical_update_dir
+            and not update_dir.is_relative_to(EXP), 'Full AQ must validate newly produced E artifacts outside AR')
+    filenames = ('chain-receipt.json', 'update-receipt.json', 'delta-after.npz', 'overlay-manifest.json')
+    require(set(path.name for path in update_dir.iterdir()) == set(filenames), 'New E output inventory differs')
+    update_hashes = {name: digest(update_dir / name) for name in filenames}
+    chain_sha = update_hashes['chain-receipt.json']
+    validator = MODEL / 'conditioning-execution-v1/validate_update_cpu.py'
+    check(validator, reg['input_sha256'][str(validator)])
+    receipt_path = output / (entry['fixture_id'] + '.validation.json')
+    argv = [sys.executable, '-B', str(validator), '--authority', authority_path,
+        '--authority-sha256', entry['authority_sha256'], '--update-dir', str(update_dir),
+        '--chain-sha256', chain_sha, '--receipt', str(receipt_path)]
+    started = time.perf_counter()
+    with (output / (entry['fixture_id'] + '.stdout.log')).open('xb') as stdout, \
+            (output / (entry['fixture_id'] + '.stderr.log')).open('xb') as stderr:
+        process = subprocess.run(argv, cwd=output, stdout=stdout, stderr=stderr,
+            env=dict(os.environ, CUDA_VISIBLE_DEVICES='', PYTHONDONTWRITEBYTECODE='1'), timeout=120, check=False)
+    wall = time.perf_counter() - started
+    record = dict(fixture_id=entry['fixture_id'], argv=argv, exit_code=process.returncode,
+                  actual_exit_observed=True, subprocess_wall_seconds=wall,
+                  validated_update_dir=str(update_dir), validated_new_E_artifact=True,
+                  update_files_sha256=update_hashes)
+    save(output / (entry['fixture_id'] + '.process.json'), record)
+    require(process.returncode == 0, 'Original AQ validation failed; outputs retained')
+    expected = read(directory / 'fresh-cpu-validation.json')
+    # E's new NPZ/container hashes may differ while its scientific array bytes
+    # match. Only these independently observed output-file bindings may vary.
+    expected.update(update_files_sha256=update_hashes,
+                    after_overlay_sha256=update_hashes['delta-after.npz'],
+                    after_manifest_sha256=update_hashes['overlay-manifest.json'])
+    require(read(receipt_path) == expected,
+            'Fresh full AQ receipt differs from original scientific/source fields and new E file bindings')
+    require(update_hashes == {name: digest(update_dir / name) for name in filenames}, 'New E artifacts changed during full AQ validation')
+    record['full_original_AQ_receipt_exact_to_expected_binding'] = True
+    record['receipt_sha256'] = digest(receipt_path)
+    return record
+
+
+def profile(fixtures, expected, output, repeats):
+    cpu_start()
+    require(repeats == REPEATS, 'This fixed engineering experiment requires exactly three resident passes')
+    started = time.perf_counter()
+    fixtures, output = unlinked(fixtures), unlinked(output)
+    own = identity(Path(__file__).absolute())
+    manifest, original_pins = verify_suite(fixtures, expected)
+    protected = {fixtures, EXP, MODEL, *[Path(path).parent for path in original_pins]}
+    require(not output.exists() and output.parent.is_dir()
+            and not any(output.is_relative_to(parent) for parent in protected),
+            'Output must be a fresh independent directory with an existing parent')
+    output.mkdir()
+    save(output / 'experiment.json', dict(schema=SCHEMA, fixture_manifest_sha256=expected,
+        fixture_order=[entry['fixture_id'] for entry in manifest['fixtures']], repeats=repeats,
+        selection='all previously sealed 14 fixtures, fixed existing manifest order, no outcome selection',
+        original_source_commit=COMMIT, registration_sha256=REG_SHA,
+        source_pins=original_pins, implementation_source=dict(path=str(Path(__file__).absolute()), **own),
+        scope='read-only fixed-input engineering replay; no installation, brain, training or learning claim',
+        resident_verifier_scope='original U.verify_receipt only; cannot substitute for original AQ full graph/checkpoint validator'))
+    cold_dir, resident_dir, aq_dir, diagnostic_dir, epoch_dir = [output / name for name in ('cold', 'resident', 'full-aq', 'diagnostic', 'full-E')]
+    for directory in (cold_dir, resident_dir, aq_dir, diagnostic_dir, epoch_dir):
+        directory.mkdir()
+    cold = []
+    for entry in manifest['fixtures']:
+        child = Child(cold_dir, entry['fixture_id'], fixtures, expected, 'producer')
+        response, wall = child.request(dict(action='run', request_id='cold/' + entry['fixture_id'], fixture_id=entry['fixture_id']))
+        exit_receipt = child.close()
+        cold.append(dict(compact_response(response, wall), process=exit_receipt))
+        print(canonical(dict(lane='cold-original-U', fixture_id=entry['fixture_id'], complete=True)), flush=True)
+    producer = Child(resident_dir, 'producer', fixtures, expected, 'producer')
+    verifier = Child(resident_dir, 'verifier', fixtures, expected, 'verifier')
+    require(producer.process.pid != verifier.process.pid, 'Independent verifier process required')
+    resident = []
+    for round_index in range(repeats):
+        for entry in manifest['fixtures']:
+            request = dict(action='run', request_id=f'round-{round_index:02d}/' + entry['fixture_id'], fixture_id=entry['fixture_id'])
+            pair_started = time.perf_counter()
+            produced, producer_wall = producer.request(request)
+            verified, verifier_wall = verifier.request(dict(request, producer_response=produced))
+            require(verified['independently_verified_producer_response_sha256'] == produced['response_sha256'],
+                    'Independent verifier receipt chain mismatch')
+            resident.append(dict(round_index=round_index, fixture_id=entry['fixture_id'],
+                producer=compact_response(produced, producer_wall), verifier=compact_response(verified, verifier_wall),
+                pair_parent_wall_seconds=time.perf_counter() - pair_started))
+        print(canonical(dict(lane='resident-separate-original-U-and-verifier', round_index=round_index, complete=True)), flush=True)
+    producer_exit, verifier_exit = producer.close(), verifier.close()
+    epoch_artifacts = epoch_dir / 'new-updates'
+    epoch_artifacts.mkdir()
+    first = manifest['fixtures'][0]
+    epoch_cold_worker = Child(epoch_dir, 'cold-first', fixtures, expected, 'epoch', epoch_artifacts)
+    epoch_cold_response, epoch_cold_wall = epoch_cold_worker.request(dict(action='run', request_id='full-E-cold/' + first['fixture_id'],
+        fixture_id=first['fixture_id'], epoch_output=str(epoch_artifacts / ('cold-' + first['fixture_id']))))
+    epoch_cold_exit = epoch_cold_worker.close()
+    epoch_cold = dict(compact_response(epoch_cold_response, epoch_cold_wall), process=epoch_cold_exit)
+    print(canonical(dict(lane='fresh-full-original-E', fixture_id=first['fixture_id'], complete=True)), flush=True)
+    epoch_worker = Child(epoch_dir, 'resident', fixtures, expected, 'epoch', epoch_artifacts)
+    epoch_resident = []
+    for round_index in range(2):
+        for entry in manifest['fixtures']:
+            response, wall = epoch_worker.request(dict(action='run', request_id=f'full-E-{round_index:02d}/' + entry['fixture_id'],
+                fixture_id=entry['fixture_id'], epoch_output=str(epoch_artifacts / f'round-{round_index:02d}-{entry["fixture_id"]}')))
+            epoch_resident.append(dict(round_index=round_index, **compact_response(response, wall)))
+            print(canonical(dict(lane='resident-full-original-E', round_index=round_index,
+                                 fixture_id=entry['fixture_id'], complete=True)), flush=True)
+    epoch_exit = epoch_worker.close()
+    full = []
+    reg = read(EXP / 'protocol/preregistered.json')
+    for entry in manifest['fixtures']:
+        full.append(full_validation(fixtures, entry, aq_dir, reg,
+                                    epoch_artifacts / f'round-01-{entry["fixture_id"]}'))
+        print(canonical(dict(lane='full-original-AQ', fixture_id=entry['fixture_id'], complete=True)), flush=True)
+    # Independent diagnostics: first call includes cold Torch import; another
+    # full fixed pass has warm imports. These calls never enter speed medians.
+    diagnostic = Child(diagnostic_dir, 'profiler', fixtures, expected, 'producer')
+    diagnostics = []
+    first = manifest['fixtures'][0]
+    schedule = [('cold-fixed-first', first), *[('warm-fixed-all', entry) for entry in manifest['fixtures']]]
+    for index, (temperature, entry) in enumerate(schedule):
+        response, wall = diagnostic.request(dict(action='profile', request_id=f'profile-{index:02d}/' + entry['fixture_id'],
+                                                fixture_id=entry['fixture_id']))
+        record = dict(temperature=temperature, **compact_response(response, wall), cprofile=response['cprofile'])
+        save(diagnostic_dir / f'{index:02d}-{entry["fixture_id"]}.json', record)
+        diagnostics.append(dict(temperature=temperature, fixture_id=entry['fixture_id'],
+            profile_file=f'diagnostic/{index:02d}-{entry["fixture_id"]}.json',
+            self_time_categories_seconds=response['cprofile']['self_time_categories_seconds']))
+    diagnostic_exit = diagnostic.close()
+    warm = [row for row in resident if row['round_index'] > 0]
+    summary = dict(
+        cold_U_subprocess_wall_seconds=distribution([row['process']['process_wall_seconds'] for row in cold]),
+        cold_U_API_seconds=distribution([row['original_api_seconds'] for row in cold]),
+        cold_worker_startup_wall_seconds=distribution([row['process']['startup_wall_seconds'] for row in cold]),
+        cold_input_load_verify_seconds=distribution([row['input_load_verify_seconds'] for row in cold]),
+        resident_warm_U_API_seconds=distribution([row['producer']['original_api_seconds'] for row in warm]),
+        resident_warm_verify_API_seconds=distribution([row['verifier']['original_api_seconds'] for row in warm]),
+        resident_warm_pair_roundtrip_seconds=distribution([row['pair_parent_wall_seconds'] for row in warm]),
+        original_full_E_warm_API_seconds=distribution([row['original_api_seconds'] for row in epoch_resident if row['round_index'] == 1]),
+        original_full_E_warm_roundtrip_seconds=distribution([row['parent_roundtrip_seconds'] for row in epoch_resident if row['round_index'] == 1]),
+        original_full_E_cold_first_API_seconds=epoch_cold['original_api_seconds'],
+        original_full_E_cold_first_process_wall_seconds=epoch_cold['process']['process_wall_seconds'],
+        original_full_AQ_subprocess_wall_seconds=distribution([row['subprocess_wall_seconds'] for row in full]))
+    for path, pin in original_pins.items():
+        check(path, pin)
+    verify_suite(fixtures, expected)
+    check(Path(__file__).absolute(), own)
+    report = dict(schema=SCHEMA, complete=True, created_utc=datetime.now(timezone.utc).isoformat(),
+        registration_sha256=REG_SHA, original_source_commit=COMMIT, fixture_manifest_sha256=expected,
+        fixtures=14, resident_passes=repeats, warm_passes_in_summary=[1, 2], cold=cold, resident=resident,
+        full_E=dict(cold_fixed_first=epoch_cold, resident=epoch_resident, resident_passes=2,
+                    historical_process_seconds={entry['fixture_id']: entry['historical_process_seconds']['update'] for entry in manifest['fixtures']}),
+        full_AQ=full, diagnostic=diagnostics, process_exits=dict(producer=producer_exit, verifier=verifier_exit,
+            profiler=diagnostic_exit, full_E_resident=epoch_exit, full_E_cold_first=epoch_cold_exit),
+        summary=summary, total_wall_seconds=time.perf_counter() - started,
+        limitations=['Fixed inputs replayed; no dependency is advanced and no produced weight is installed.',
+                    'Resident original U verification omits full AQ checkpoint/graph hashing and cannot replace that validation in production.',
+                    'cProfile is diagnostic only, with overhead; its cumulative function times overlap.',
+                    'Full E resident retains every original validation check; stage times are not a measured complete brain/E/AQ pipeline.',
+                    'Cold denotes a fresh Python process, not a flushed operating-system page cache.',
+                    'CPU workload conditions are observed by the caller; these lanes execute serially.'],
+        original_files_modified=False, brain_executed=False, training_executed=False, weights_installed=False,
+        all_full_array_reference_comparisons_passed=True, all_original_receipts_exact=True,
+        independent_resident_verifier_process=True, all_child_exits_observed_zero=True,
+        full_AQ_validates_actual_second_pass_E_outputs=True,
+        files={str(path.relative_to(output)): identity(path) for path in sorted(output.rglob('*')) if path.is_file()})
+    save(output / 'report.json', report)
+    print(canonical(dict(complete=True, report=str(output / 'report.json'), summary=summary)), flush=True)
+    return report
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--fixtures', type=Path, required=True)
+    parser.add_argument('--fixture-manifest-sha256', required=True)
+    parser.add_argument('--output', type=Path)
+    parser.add_argument('--repeats', type=int, choices=(REPEATS,), default=REPEATS)
+    parser.add_argument('--worker', choices=('producer', 'verifier', 'epoch'), help=argparse.SUPPRESS)
+    parser.add_argument('--worker-output-root', type=Path, help=argparse.SUPPRESS)
+    args = parser.parse_args()
+    if args.worker:
+        require(args.output is None, 'Worker writes only its parent-controlled protocol streams')
+        worker(unlinked(args.fixtures), args.fixture_manifest_sha256, args.worker,
+               None if args.worker_output_root is None else unlinked(args.worker_output_root))
+    else:
+        require(args.output is not None, '--output is required')
+        try:
+            profile(args.fixtures, args.fixture_manifest_sha256, args.output, args.repeats)
+        finally:
+            cleanup_children()

models/male-cns-lif/conditioning-pipeline-acceleration-v1/run_job.py

@@ -0,0 +1,80 @@
+"""New pipeline experiment process receipts, with exclusive output and no retries."""
+import argparse
+from datetime import datetime, timezone
+import json
+import os
+from pathlib import Path
+import re
+import shutil
+import signal
+import subprocess
+import time
+
+ROOT = Path('/home/qishizhe/phase4ar-pipeline-acceleration-20261001')
+
+def output_bytes():
+    total = 0
+    for f in ROOT.rglob('*'):
+        try:
+            if f.is_file() and not f.is_symlink(): total += f.stat().st_size
+        except FileNotFoundError:
+            pass  # Concurrent compiler temporary file removal, not a payload.
+    return total
+
+def stop_group(proc):
+    try: os.killpg(proc.pid, signal.SIGTERM)
+    except ProcessLookupError: pass
+    try: proc.wait(timeout=5)
+    except subprocess.TimeoutExpired: pass
+    try: os.killpg(proc.pid, signal.SIGKILL)
+    except ProcessLookupError: pass
+    return proc.wait()
+
+p = argparse.ArgumentParser()
+p.add_argument('--label', required=True)
+p.add_argument('--timeout', type=int, default=900)
+p.add_argument('command', nargs=argparse.REMAINDER)
+a = p.parse_args()
+assert re.fullmatch(r'[a-z0-9-]+', a.label) and a.command and 0 < a.timeout <= 900
+assert ROOT.is_dir() and not ROOT.is_symlink()
+assert shutil.disk_usage(ROOT).free >= 100 * (1 << 30)
+out = ROOT / 'jobs'
+out.mkdir(exist_ok=True)
+start = time.perf_counter()
+record = dict(label=a.label, command=a.command, scope='independent engineering replay only',
+              started_utc=datetime.now(timezone.utc).isoformat(), scientific_AR_resumed=False)
+with (out / (a.label + '.start.json')).open('x') as f: json.dump(record, f, indent=2)
+with (out / (a.label + '.stdout.log')).open('x') as stdout, (out / (a.label + '.stderr.log')).open('x') as stderr:
+    proc = None
+    try:
+        # All children belong to a dedicated group created by THIS invocation.
+        # On stop, terminate this group only, never unrelated services/science.
+        proc = subprocess.Popen(a.command, stdout=stdout, stderr=stderr, start_new_session=True,
+                                env={**os.environ, 'PYTHONDONTWRITEBYTECODE':'1'})
+        record.update(pid=proc.pid, process_group=proc.pid)
+        stop_reason = None
+        while True:
+            try:
+                proc.wait(timeout=5)
+                break
+            except subprocess.TimeoutExpired:
+                if time.perf_counter() - start > a.timeout: stop_reason = 'wall_timeout'
+                elif shutil.disk_usage(ROOT).free < 100 * (1 << 30): stop_reason = 'minimum_disk_reserve'
+                elif output_bytes() > 2 * (1 << 30):
+                    stop_reason = 'output_cap'
+                if stop_reason:
+                    break
+        if not stop_reason and output_bytes() > 2 * (1 << 30): stop_reason = 'output_cap'
+        if stop_reason or proc.returncode != 0: stop_group(proc)
+        record.update(exit_code=proc.returncode, observed_exit=True,
+                      timed_out=stop_reason == 'wall_timeout', stop_reason=stop_reason)
+    except OSError as error:
+        rc = None if proc is None else stop_group(proc)
+        record.update(exit_code=rc, observed_exit=proc is not None, timed_out=False, launch_error=str(error))
+    except BaseException:
+        if proc is not None: stop_group(proc)
+        raise
+record.update(wall_seconds=time.perf_counter()-start, finished_utc=datetime.now(timezone.utc).isoformat())
+with (out / (a.label + '.exit.json')).open('x') as f: json.dump(record, f, indent=2)
+print(json.dumps(record), flush=True)
+raise SystemExit(record['exit_code'] if record['observed_exit'] and not record.get('stop_reason') else 124)

models/male-cns-lif/conditioning-pipeline-acceleration-v1/test_brain_replay.py

@@ -0,0 +1,161 @@
+"""Host-only authority, exact-comparison, ordering and process receipt tests."""
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+import numpy as np
+
+import brain_replay as replay
+
+
+class ReplayTests(unittest.TestCase):
+    def test_fixed_forward_reverse_order(self):
+        result = replay.fixture_order(14)
+        self.assertEqual(len(result), 28)
+        self.assertEqual(result[:14], [('forward', i) for i in range(14)])
+        self.assertEqual(result[14:], [('reverse', i) for i in range(13, -1, -1)])
+        for count in (0, 13, 15):
+            with self.assertRaises(ValueError):
+                replay.fixture_order(count)
+
+    def test_exact_comparison_detects_signed_zero_dtype_shape_and_bit_changes(self):
+        expected = {'v': np.array([0., 1.], np.float64)}
+        self.assertTrue(replay.compare_arrays(expected, expected, ('v',))['v']['bitwise_exact'])
+        for array in (np.array([-0., 1.], np.float64), np.array([0., 1.], np.float32),
+                      np.array([[0., 1.]], np.float64),
+                      np.array([0., np.nextafter(1., 2.)], np.float64)):
+            self.assertFalse(replay.compare_arrays({'v': array}, expected, ('v',))['v']['bitwise_exact'])
+        with self.assertRaisesRegex(ValueError, 'schema'):
+            replay.compare_arrays({}, expected, ('v',))
+
+    def test_checkpoint_comparison_includes_all_arrays_requests_and_environment(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            actual_dir, old_dir = root / 'actual', root / 'old'
+            actual_dir.mkdir()
+            old_dir.mkdir()
+            for name in ('requests.csv', 'finite-audit.json', 'apl-pending-tail.float32.npy'):
+                (actual_dir / name).write_bytes(b'fixed exact reference')
+                (old_dir / name).write_bytes(b'fixed exact reference')
+            def record():
+                return dict(state={name: np.zeros(2, np.float64 if name in ('v', 'g') else np.int32)
+                                   for name in replay.STATE_KEYS},
+                    terminal={'spike_ring': np.zeros((19, 2), np.uint8),
+                              'apl_state': np.zeros(2, np.float32),
+                              'apl_pending': np.zeros((18, 2), np.float32),
+                              'next_tick': np.asarray(1200, np.int64)},
+                    summary={**{key: 'same' for key in replay.SUMMARY_KEYS},
+                             'apl_component': {'environment': {'torch': 'fixed-original'}}},
+                    fresh=True, global_tick_offset=0)
+            actual, original = record(), record()
+            self.assertTrue(replay.compare_checkpoints(actual, original, actual_dir, old_dir)['exact'])
+            actual['terminal']['spike_ring'][0, 1] = 1
+            self.assertFalse(replay.compare_checkpoints(actual, original, actual_dir, old_dir)['exact'])
+            actual = record()
+            actual['summary']['apl_component']['environment']['torch'] = 'different'
+            self.assertFalse(replay.compare_checkpoints(actual, original, actual_dir, old_dir)['exact'])
+            actual = record()
+            actual['summary']['effective_weights_raw_sha256'] = 'different'
+            self.assertFalse(replay.compare_checkpoints(actual, original, actual_dir, old_dir)['exact'])
+            actual = record()
+            (actual_dir / 'requests.csv').write_bytes(b'different acceptance')
+            self.assertFalse(replay.compare_checkpoints(actual, original, actual_dir, old_dir)['exact'])
+
+    def test_json_and_pin_authority_rejects_ambiguity_and_mutation(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            value = root / 'value.json'
+            value.write_text('{"key":1,"key":2}', encoding='utf-8')
+            with self.assertRaisesRegex(ValueError, 'Duplicate'):
+                replay.read(value)
+            value.write_text('{"key":NaN}', encoding='utf-8')
+            with self.assertRaisesRegex(ValueError, 'Nonfinite'):
+                replay.read(value)
+            value.write_text('{"key":1}', encoding='utf-8')
+            pins = {}
+            replay.pin_add(pins, value, replay.sha(value))
+            replay.verify(pins)
+            with self.assertRaisesRegex(ValueError, 'Conflicting'):
+                replay.pin_add(pins, value, 'f' * 64)
+            value.write_text('{"key":2}', encoding='utf-8')
+            with self.assertRaisesRegex(ValueError, 'changed'):
+                replay.verify(pins)
+            with self.assertRaisesRegex(ValueError, 'leaves'):
+                replay.contained(root, str(root.parent / 'outside'))
+
+    def test_loader_executes_only_verified_bytes_and_cannot_rebind_module(self):
+        with tempfile.TemporaryDirectory() as directory:
+            source = Path(directory) / 'source.py'
+            source.write_text('value = 42\n', encoding='utf-8')
+            name = '_brain_replay_host_test_unique_module'
+            try:
+                with self.assertRaisesRegex(ValueError, 'Unverified'):
+                    replay.load_source(name, source, '0' * 64)
+                self.assertNotIn(name, sys.modules)
+                module = replay.load_source(name, source, replay.sha(source))
+                self.assertEqual(module.value, 42)
+                with self.assertRaisesRegex(ValueError, 'repeated'):
+                    replay.load_source(name, source, replay.sha(source))
+            finally:
+                sys.modules.pop(name, None)
+
+    def test_parent_environment_is_original_only(self):
+        with mock.patch.object(replay.sys, 'dont_write_bytecode', False):
+            with self.assertRaisesRegex(ValueError, 'original registered'):
+                replay.check_environment()
+
+
+class ProcessReceiptTests(unittest.TestCase):
+    def paths(self, root):
+        for name in ('jobs', 'processes'):
+            (root / name).mkdir()
+        report_path = root / 'report.json'
+        replay.save(report_path, {'exact': True})
+        result_path = root / 'result.json'
+        replay.save(result_path, dict(complete=True, all_bitwise_exact=True, lane='fresh', count=1,
+            records=[dict(report=str(report_path), sha256=replay.sha(report_path))]))
+        return dict(lane='fresh', runs=[['fresh', 0]], result_file=str(result_path)), root / 'jobs/fresh.json', root / 'processes'
+
+    def test_child_receipt_requires_actual_return_and_keeps_outer_group(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            job, job_path, process_dir = self.paths(root)
+            process = mock.Mock(pid=4321, returncode=0)
+            process.wait.return_value = 0
+            with mock.patch('brain_replay.subprocess.Popen', return_value=process) as popen:
+                receipt, result = replay.launch(job, job_path, process_dir, replay.time.time() + 10)
+            self.assertTrue(receipt['exit_independently_observed'])
+            self.assertEqual(receipt['actual_returncode'], 0)
+            self.assertEqual(receipt['child_pid'], 4321)
+            self.assertNotIn('start_new_session', popen.call_args.kwargs)
+            self.assertEqual(popen.call_args.kwargs['env']['CUDA_VISIBLE_DEVICES'], replay.GPU)
+            self.assertEqual(popen.call_args.args[0][0], str(replay.ORIGINAL_PYTHON))
+            self.assertEqual(replay.read(process_dir / 'fresh.json')['actual_returncode'], 0)
+            self.assertTrue(result['all_bitwise_exact'])
+
+    def test_timeout_stops_child_retains_real_failure_receipt_and_never_retries(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            job, job_path, process_dir = self.paths(root)
+            process = mock.Mock(pid=4321, returncode=-15)
+            process.wait.side_effect = [subprocess.TimeoutExpired('mock child', 1), -15, -15]
+            process.poll.return_value = None
+            with mock.patch('brain_replay.subprocess.Popen', return_value=process) as popen:
+                with self.assertRaisesRegex(ValueError, 'child failed'):
+                    replay.launch(job, job_path, process_dir, replay.time.time() + 10)
+            self.assertEqual(popen.call_count, 1)
+            process.terminate.assert_called_once()
+            receipt = replay.read(process_dir / 'fresh.json')
+            self.assertTrue(receipt['timed_out'])
+            self.assertTrue(receipt['child_terminated_on_failure'])
+            self.assertEqual(receipt['actual_returncode'], -15)
+
+
+if __name__ == '__main__':
+    unittest.main()

models/male-cns-lif/conditioning-pipeline-acceleration-v1/test_profile_original.py

@@ -0,0 +1,100 @@
+"""Authority, full-byte IPC and cleanup tests without original production runs."""
+import base64
+import importlib.util
+from pathlib import Path
+import tempfile
+import unittest
+
+import numpy as np
+
+
+SCRIPT = Path(__file__).with_name('profile_original.py')
+SPEC = importlib.util.spec_from_file_location('test_original_profile_module', SCRIPT)
+P = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(P)
+
+
+class BoundaryTests(unittest.TestCase):
+    def test_array_packet_uses_raw_signed_zero_bytes(self):
+        reference = np.asarray([0., 1.], dtype=np.float32)
+        P.compare_packet(P.pack_array(reference), reference)
+        changed = np.asarray([-0., 1.], dtype=np.float32)
+        with self.assertRaisesRegex(ValueError, 'full array bytes'):
+            P.compare_packet(P.pack_array(changed), reference)
+
+    def test_packet_dtype_and_shape_are_not_repaired(self):
+        reference = np.asarray([1.], dtype=np.float32)
+        for array in (reference.astype(np.float64), reference.reshape(1, 1)):
+            with self.assertRaisesRegex(ValueError, 'identity'):
+                P.compare_packet(P.pack_array(array), reference)
+
+    def test_response_chain_binds_all_output_bytes_and_role(self):
+        response = dict(role='producer', sequence=1, previous_response_sha256=None, complete=True,
+                        arrays={'delta_after': P.pack_array(np.zeros(3, np.float32))})
+        response['response_sha256'] = P.payload_sha(response)
+        self.assertEqual(P.verify_response(response, None, 1, 'producer'), response['response_sha256'])
+        with self.assertRaisesRegex(ValueError, 'chain/role'):
+            P.verify_response(response, None, 1, 'verifier')
+        response['arrays']['delta_after']['data_base64'] = base64.b64encode(b'bad').decode()
+        with self.assertRaisesRegex(ValueError, 'payload hash'):
+            P.verify_response(response, None, 1, 'producer')
+
+    def test_response_chain_reordering_rejected(self):
+        response = dict(role='producer', sequence=2, previous_response_sha256='a' * 64, complete=True)
+        response['response_sha256'] = P.payload_sha(response)
+        with self.assertRaisesRegex(ValueError, 'chain/role'):
+            P.verify_response(response, 'b' * 64, 2, 'producer')
+
+    def test_manifest_paths_cannot_escape(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary).resolve()
+            for name in ('../other', '/absolute', 'foo\\bar', 'x/../bar', 'C:/windows'):
+                with self.assertRaises(ValueError):
+                    P.contained(root, name)
+            self.assertEqual(P.contained(root, 'valid/input.npz'), root / 'valid/input.npz')
+
+    def test_output_writes_are_exclusive(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            path = Path(temporary).resolve() / 'result.json'
+            P.save(path, {'complete': True})
+            original = path.read_bytes()
+            with self.assertRaises(FileExistsError):
+                P.save(path, {'complete': False})
+            self.assertEqual(path.read_bytes(), original)
+
+    def test_mismatching_source_pin_rejected(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            path = Path(temporary).resolve() / 'source.py'
+            path.write_text('raise AssertionError("must not run")', encoding='utf-8')
+            with self.assertRaisesRegex(ValueError, 'identity'):
+                P.load_source('untrusted_original_profile_test', path, '0' * 64)
+
+    def test_profile_categories_do_not_use_cumulative_totals(self):
+        self.assertEqual(P.profile_category('/usr/lib/python3.10/ast.py', 'dump'), 'source_parse_compile_load')
+        self.assertEqual(P.profile_category('/frozen/phase4j.py::trace-expression-only', '<module>'),
+                         'trace_expression_and_tensor_ops')
+        self.assertEqual(P.profile_category('/frozen/bridge.py', 'trace_from_events'), 'trace_apply_python_self')
+
+
+class CleanupTests(unittest.TestCase):
+    def test_cleanup_attempts_every_owned_child_after_failure(self):
+        calls = []
+        class Good:
+            def abort(self):
+                calls.append('good')
+        class Bad:
+            def abort(self):
+                calls.append('bad')
+                raise RuntimeError('simulated abort error')
+        original = list(P.CHILDREN)
+        try:
+            P.CHILDREN[:] = [Good(), Bad()]
+            with self.assertRaisesRegex(ValueError, 'cleanup errors'):
+                P.cleanup_children()
+            self.assertEqual(calls, ['bad', 'good'])
+        finally:
+            P.CHILDREN[:] = original
+
+
+if __name__ == '__main__':
+    unittest.main()

models/male-cns-lif/conditioning-pipeline-acceleration-v1/timeout_fixture.py

@@ -0,0 +1,8 @@
+"""Safety self-test only: a child/grandchild sleep tree to terminate by own group."""
+import subprocess
+import sys
+import time
+
+child = subprocess.Popen([sys.executable, '-B', '-c', 'import time; time.sleep(90)'])
+print(child.pid, flush=True)
+time.sleep(90)

registry/acceleration-20261001/README.md

@@ -0,0 +1,43 @@
+# CPU / GPU 方案保存 — 2026-10-01
+
+用户要求保存当前方案并上传，之后再继续。**原 Phase4AR 保持停止，未训练、未安装新权重，未进入下一科学阶段。**
+
+## 保存内容
+
+| 方案 | 代码 | 状态 |
+|---|---|---|
+| 原 CPU 更新与独立验证 | `models/male-cns-lif/olfactory-conditioning-lab-v1/`、`conditioning-interface-v2/` | 注册实现保留，未替换 |
+| V100/4090 eligibility 更新原型 | `models/male-cns-lif/conditioning-acceleration-v1/` | 固定案例逐位回放 PASS，不是全脑已迁移到 V100 |
+| CPU 常驻与 4090 全脑常驻 | `models/male-cns-lif/conditioning-pipeline-acceleration-v1/` | 42 次全脑精确回放 PASS，不是已验收生产运行时 |
+
+本目录的 `gpu/`、`pipeline/` 保存原报告、manifest 与完整性说明的原字节副本；`publication-catalog.json` 逐项记录公开归档成员和有意排除项。完整数值回放、请求、状态和诊断回执封装在 `artifacts/acceleration-20261001/` 的两个 Git LFS 归档中。
+
+代码版本：GPU 核心 `221e1f13f758ebe8d9f188bab976c361f7cacf45`；常驻回放封存 `018f038c7857c7e0236dd7408a680458520d92ce`。原科学登记源码 `80aeb2093db655329774eff7b32fb6e417b8b40b` 不变。
+
+原科学现场停在 1,033 轮已提交且 CPU 校验的训练、138 个已提交 probe。完整科学执行、独立学习 gate 未完成；本次性能成果不代表学会关联记忆。
+
+## 来源、许可与排除
+
+MaleCNS v1.0 原数据来源为 [官方数据页](https://male-cns.janelia.org/download/)，既有许可审计为 CC BY 4.0。署名保留 Male CNS collaboration：FlyEM/HHMI Janelia、University of Cambridge、MRC Laboratory of Molecular Biology、Google Research 及原论文作者。本项目进行了既有 neuron-only 过滤/重编号和模型模拟；本次只原字节复制已生成的回放数据，不重新推导或修改科学数值。
+
+嗅觉输入来源链中的 DoOR.data 2.0.1（commit `eea72d64b42a4e91dafe822cf0b5204de33f8d34`）维持 CC BY-SA 4.0，作者 Daniel Münch、C. Giovanni Galizia、Shouwen Ma、Martin Strauch、Anja Nissler。涉及其派生输入的成员保留此 ShareAlike/署名约束；不将其许可泛化至无关代码。[DoOR 论文](https://doi.org/10.1038/srep21841)。Shiu 作者源码维持其原 MIT 声明；本项目是 adapted dynamics，不是严格原模型复现。
+
+原资源许可证据及上游 notices 在 `codex/lfs-public-resources` 的 `registry/publication-20261001/`，固定发布提交 `5b1d1b7`。本次没有打包 NVIDIA SDK、CuPy/PyTorch 环境、FlyVis、论文全文或其他服务。软件没有被擅自统一换证，仍适用仓库 NOTICE 和各上游声明。
+
+明确排除：虚拟环境、CUDA 编译缓存/中间产物/二进制、安装下载日志。完整原实验（包括失败与编译诊断）仍原样留在服务器；原 sealed manifest 包含未上传缓存的哈希。因此公开归档应使用 **publication-catalog.json** 校验，不能要求原始全目录 SHA 清单在省略缓存的副本中全部通过。没有丢弃科学失败案例。
+
+旧原始/参考大数据不重复上传，它们在 `codex/lfs-public-resources`。本次发布不是全服务器或全部历史科学目录灾备，也没有打包已停止 AR 的所有 64,034 个现场文件。
+
+## 恢复与验证（不运行模型）
+
+在新目录 clone 本分支，安装 Git LFS，执行：
+
+```sh
+git lfs pull --include='artifacts/acceleration-20261001/**'
+python3 -B tools/acceleration-publication/archive_results.py verify
+```
+
+验证器只读流式校验归档 SHA、成员集合、每个成员字节数与 SHA，不解包、不运行模型。
+如需解包，只解到新建空目录；不得覆盖 `/data/digital-drosophila` 或直接运行旧封存脚本。性能原型依赖固定科学源与历史输入，不能只 clone 就自动恢复正式训练。
+
+`delivery.json` 只在真实远端 push、独立新 LFS store 下载和完整成员验证成功后写入。没有该回执时，不能把打包完成称为异机恢复已通过。

registry/acceleration-20261001/delivery.json

@@ -0,0 +1,40 @@
+{
+  "branch": "codex/v100-conditioning-acceleration",
+  "catalog_sha256": "28071f276848ea60149f21a9794653486b404670a58b34d97b1aaae742095245",
+  "complete_training_restore": false,
+  "data_commit": "f2de8797372b2d7558a0547e450928fdc231b860",
+  "downloaded_LFS_objects": 2,
+  "downloaded_bytes": 76447085,
+  "fresh_download_proven": true,
+  "fsck_exit_code": 0,
+  "groups": {
+    "gpu": {
+      "archive_bytes": 1679158,
+      "files": 614,
+      "original_bytes": 13242628,
+      "sha256": "50acdc85342a2c79c3516e50ee4542b909813d179518451edaaf2d94150c534b",
+      "verified": true
+    },
+    "pipeline": {
+      "archive_bytes": 74767927,
+      "files": 1066,
+      "original_bytes": 103062185,
+      "sha256": "fdc39013d71fb7d14313d8249c929601a8a7050cc2eac88b733d692bbe1b6b42",
+      "verified": true
+    }
+  },
+  "historical_scientific_gate_reexecuted": false,
+  "initial_LFS_objects": 0,
+  "pass_all": true,
+  "pull_exit_code": 0,
+  "remote": "ssh://git@192.168.10.31:2222/qishizhe/digital-drosophila.git",
+  "schema": "acceleration-fresh-remote-delivery-v1",
+  "scientific_experiments_run": 0,
+  "scope": "Remote Git commit, two actual LFS downloads, complete public archive contents and 22 sealed code files; not all external scientific dependencies",
+  "sealed_source_files_checked": 22,
+  "training_resumed": false,
+  "transport": "Previously audited LAN-pinned HTTPS adapter, verified TLS and SSH short-lived authorization",
+  "verification": "Full streamed members, no extraction or model execution",
+  "verified_utc": "2026-10-01T07:46:04.143650+00:00",
+  "wall_seconds": 3.1022417009999117
+}

registry/acceleration-20261001/gpu/RESULTS.md

@@ -0,0 +1,29 @@
+# V100 conditioning acceleration — engineering replay result
+
+Status: **PASS-ELIGIBILITY-UPDATE-REPLAY-EQUIVALENCE**. This is not a learning result or a production-training promotion.
+
+Benchmark code commit: `221e1f13f758ebe8d9f188bab976c361f7cacf45`.
+
+| Device | Real-fixture replay median (prep + transfers + comparison) | Resident CUDA kernel median |
+|---|---:|---:|
+| Tesla V100-SXM2-16GB (v100a-02) | 3.430 ms | 0.122 ms |
+| Tesla V100-SXM2-16GB (v100b-01) | 3.344 ms | 0.122 ms |
+| NVIDIA GeForce RTX 4090 (rtx4090-01) | 3.327 ms | 0.074 ms |
+
+Each GPU passed14sealed real fixtures +16fixed synthetic cases, with sampled trace, final trace, allUS snapshots and delta byte-identical to the original independent CPU oracle. Six invalid inputs were rejected on each GPU.
+
+CPU warm reference includes the original API's repeated provenance checks and AST parsing; it is only one warm sample perfixture. GPU authenticates the source and complete anatomical mapping once. Therefore ratios in JSON describe API implementation replay, not pure hardware acceleration.
+
+The CUDA kernels preserve every timestep, float32 separate round-to-nearest operations, exact US timing, noUS zeros, compartment/frozen/D0 identity and the depression floor. No gain/learning-rate/tau/threshold/connectome/sign changes. No dense time×neuron matrix.
+
+A new candidate-only CuPy environment and explicit CUDA12.6 nvcc compilation are used. Original science and ComfyUI environments are unchanged. All three ComfyUI queues were checked before each fixture; no services were stopped.
+
+Integrity: 64034 saved files, 3103901058 bytes, 16 registered source files checked; no mismatch. This is the saved Phase4AR inventory, not a new Phase1–4AQ numerical regression.
+
+Phase4AR remains stopped at1033/30000CPU-verified epochs and138/3920probes. No weights were installed and no training was resumed.
+
+Next: a separately validated persistent-worker pipeline and end-to-end benchmark. This local optimization does not justify dividing the9-day estimate by the kernel speedup. Independent-seed V100 parallelism is not yet measured.
+
+Preserved failures: candidate packaging incompatibility (--report unsupported bypip22); first CuPy compile FTZ flag conflict (before any kernel ran). Both were corrected only in the independent branch.
+
+Compiler references: [CuPy precompiled RawModule](https://docs.cupy.dev/en/v13.6.0/reference/generated/cupy.RawModule.html), [CUDA12.6 compiler options](https://docs.nvidia.com/cuda/archive/12.6.3/cuda-compiler-driver-nvcc/index.html).

registry/acceleration-20261001/gpu/SHA256SUMS

@@ -0,0 +1,660 @@
+b63b6d799a83f46c3c69805cfbec316537b06ae7f8e4b63703c9b02575c11cc1  RESULTS.md
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  candidate-freeze.stderr.log
+8ddcbb332825939eb1e091d87a6f73459de707defedb93654727662a0d4e2f0e  candidate-freeze.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  create-venv.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  create-venv.stdout.log
+e3cc62cc576238a0d08ebbcfcfb151ba5c6f4bfe4891c3b46c39f66e1ccd5d21  create-worktree.stderr.log
+8960fa67e787f4103b0ae3dfb1d17d6133754ae9c97244877b148ebba1a302af  create-worktree.stdout.log
+1687fe1688fffa492da67c2a638aff8062fb73dfc9c35931342f7b9bb005d37f  cupy-cache-4090/eligibility-nvcc/c26699b5e4dde91a432b9dc12a348e137c3c290dd9335e9b27785ea9ec9f1ec8/build-receipt.json
+41e670729a7d787b5327f5ae0934bc58147bb7d92f98c43973d68c81c3c56ba7  cupy-cache-4090/eligibility-nvcc/c26699b5e4dde91a432b9dc12a348e137c3c290dd9335e9b27785ea9ec9f1ec8/compile-command.json
+51948332982f31fc0d6612158542ad093a0a728669d4b5c296ec5ccd07ec77b6  cupy-cache-4090/eligibility-nvcc/c26699b5e4dde91a432b9dc12a348e137c3c290dd9335e9b27785ea9ec9f1ec8/compiler-identity.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  cupy-cache-4090/eligibility-nvcc/c26699b5e4dde91a432b9dc12a348e137c3c290dd9335e9b27785ea9ec9f1ec8/compiler.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  cupy-cache-4090/eligibility-nvcc/c26699b5e4dde91a432b9dc12a348e137c3c290dd9335e9b27785ea9ec9f1ec8/compiler.stdout.log
+e6b87f94e8e7c1a5edd09299c15731f5682e1a8b9b689155d615025b37c3a0b2  cupy-cache-4090/eligibility-nvcc/c26699b5e4dde91a432b9dc12a348e137c3c290dd9335e9b27785ea9ec9f1ec8/eligibility.cpp1.ii
+d91416da2badd78eef607dd5fc261162d05cdb79189237e0ded8554785eddf66  cupy-cache-4090/eligibility-nvcc/c26699b5e4dde91a432b9dc12a348e137c3c290dd9335e9b27785ea9ec9f1ec8/eligibility.cu
+03ebf12750449e7b99dff31db4cb70e5f49e4819c753b673c43be244d320d40b  cupy-cache-4090/eligibility-nvcc/c26699b5e4dde91a432b9dc12a348e137c3c290dd9335e9b27785ea9ec9f1ec8/eligibility.cubin
+c5649b5b5bd2b001266af9a4f599237f756e0abb364be2d92f5fc72b10ead562  cupy-cache-4090/eligibility-nvcc/c26699b5e4dde91a432b9dc12a348e137c3c290dd9335e9b27785ea9ec9f1ec8/eligibility.cudafe1.c
+debb1845f7a23e6a8e351b2f240d30e629ca66a82285f85e4af8558dc14456df  cupy-cache-4090/eligibility-nvcc/c26699b5e4dde91a432b9dc12a348e137c3c290dd9335e9b27785ea9ec9f1ec8/eligibility.cudafe1.gpu
+a32a96aeddc2ddb97bea81426c4892237a3756f994360ba2f53e43ee28e73915  cupy-cache-4090/eligibility-nvcc/c26699b5e4dde91a432b9dc12a348e137c3c290dd9335e9b27785ea9ec9f1ec8/eligibility.cudafe1.stub.c
+9400013920a21185d1c277ee98a62c33659c7cbd4334d75c33ffe71d9486173a  cupy-cache-4090/eligibility-nvcc/c26699b5e4dde91a432b9dc12a348e137c3c290dd9335e9b27785ea9ec9f1ec8/eligibility.module_id
+b1464ec5c35a33a4b26b6726a0a9e3d38626d09c2f2c073b7b4a52071cedf47f  cupy-cache-4090/eligibility-nvcc/c26699b5e4dde91a432b9dc12a348e137c3c290dd9335e9b27785ea9ec9f1ec8/eligibility.ptx
+e79530a1bddad4ccd3cee9fb123a1c74fcb31cfa9dcf16b4d658b648290eb6e5  cupy-cache-v100a/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/build-receipt.json
+d3795422398083d596ac14e849651e420d8a7783459e97b716f3f030c408aac6  cupy-cache-v100a/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/compile-command.json
+7f442f9e5a883861cec21f6b0539fb8cbba6f5ca81dd9613a841b8cc1bf1767f  cupy-cache-v100a/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/compiler-identity.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  cupy-cache-v100a/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/compiler.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  cupy-cache-v100a/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/compiler.stdout.log
+e3fe0937285d9ce97be26ad25080291cc6fdb55ae0204ebaef33e79ccb31e20c  cupy-cache-v100a/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.cpp1.ii
+d91416da2badd78eef607dd5fc261162d05cdb79189237e0ded8554785eddf66  cupy-cache-v100a/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.cu
+812362ec496914d948e3bbafab3febafb01a5af9f91cdf0aa1c52efd6f76aeab  cupy-cache-v100a/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.cubin
+685c3336b57137584e97a44690889f4d76f18dbd19c47c1f473fd183852e131d  cupy-cache-v100a/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.cudafe1.c
+72fbd9b61bd45f97b49ccb3b3175b1fb0225c12d3cb58b4fc81c5532f5269203  cupy-cache-v100a/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.cudafe1.gpu
+aa0746bf3d2c596e9dc24f9a4192e18024bd65f8b65f04bef8440f7f175eab00  cupy-cache-v100a/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.cudafe1.stub.c
+5765dba7d94e57db96df0b36300efe7b4767f283f2e08e07b8a3b5af79768a87  cupy-cache-v100a/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.module_id
+45a7cc53c2d488cff4c012f3b57fdb0dc4644f8e221f81a54bc7805878bc1fc6  cupy-cache-v100a/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.ptx
+f65343fc1406047f75072fe9be50c6e97a7f69e7a60a53a51a5fd7d66d0f9b2f  cupy-cache-v100b/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/build-receipt.json
+7dbf5552fa4d5d7530692b7d5b05b643fea96648bfdf8bebd9a5cbe2aa4625dc  cupy-cache-v100b/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/compile-command.json
+7f442f9e5a883861cec21f6b0539fb8cbba6f5ca81dd9613a841b8cc1bf1767f  cupy-cache-v100b/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/compiler-identity.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  cupy-cache-v100b/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/compiler.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  cupy-cache-v100b/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/compiler.stdout.log
+b5e707bffb848e57191ce029e3f8decf55b9531b3edbbe7e10d8d64523c193c0  cupy-cache-v100b/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.cpp1.ii
+d91416da2badd78eef607dd5fc261162d05cdb79189237e0ded8554785eddf66  cupy-cache-v100b/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.cu
+812362ec496914d948e3bbafab3febafb01a5af9f91cdf0aa1c52efd6f76aeab  cupy-cache-v100b/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.cubin
+a4009f94f1839fed9e136e7e7f2e83a2a93b4758b61b533d16cb8faafcaf1382  cupy-cache-v100b/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.cudafe1.c
+11fc13fae5097a0dfb0580ae21de5d4820ce14abd06b289bc4381b6fade8f879  cupy-cache-v100b/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.cudafe1.gpu
+583af03a0f2f6de36a11e8c7a823b5624b3d6afcc4f005ebf0e91046fc3d23fb  cupy-cache-v100b/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.cudafe1.stub.c
+444a6ec9096efd45b32931ca90225146ac84b5dbbc5202ee0a37ef26fead346e  cupy-cache-v100b/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.module_id
+45a7cc53c2d488cff4c012f3b57fdb0dc4644f8e221f81a54bc7805878bc1fc6  cupy-cache-v100b/eligibility-nvcc/6020224e345a164954bb922d05bd2aa9d89677bf427c34dac24f75400d404458/eligibility.ptx
+06df3158d0329dc925ecd7ceabe47f7c83ee8974f4fd959516411e82ed0dc34b  environment-authority.json
+794855bb5509c4773378f7023219574f90e1bc393d48570161c9e024a91e7eb9  final-summary.json
+b5b896ac413d5fcbd8510e553993884a3e941d10f2a4bbbf25f7ccb4bc263781  fixtures/00-cs_only/authority.json
+e70005480e1d88131e9b41c6acda1c5fa0454ec2d9a1c4cdb80c08150cbe89dc  fixtures/00-cs_only/command.json
+9dfe7afae9438a9df33f32ab8f982d1e24ed5d9a5c72329cfedd65403d25dbe9  fixtures/00-cs_only/fixture.json
+6e4f6c0ccdad03049c75e056a4222e87c7b1f1d3f90bffb59a1b77ec4b363843  fixtures/00-cs_only/fixture.npz
+5aa38f581478835ef2c2bb25218556959195ea1b913eb5167b837b276475c84c  fixtures/00-cs_only/fresh-cpu-validation.json
+2a8d5e9b0072e40d69e46258ff8ced3379f3e72bd9d86e49caaa74918a00be42  fixtures/00-cs_only/inputs.npz
+9e72a3b9c88f74278273f551a2231fd4fedab085393bf2e36103295c397aa0e3  fixtures/00-cs_only/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  fixtures/00-cs_only/reference-sources.json
+f9d18b20bf096f8bae6b1ddf23c12925a36caf4b7f8bcf17e7cca9e1afd4793c  fixtures/00-cs_only/reference-timing.json
+d0a74fa23c5d8c8634218ad9124b95d3ec893563bcfc9d283a124c6de4e4d33e  fixtures/00-cs_only/reference-update-receipt.json
+fe4a3481bb9921e6efec04bfe9803d7adc085ed0b2452c50e224f570e880ae2f  fixtures/00-cs_only/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/00-cs_only/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/00-cs_only/reference.stdout.log
+d3ff59060963eb84cb2dda4f4f316eb946c97f710e6b2b6ef082d66d70ac8a37  fixtures/00-cs_only/source-file-pins.json
+d0a74fa23c5d8c8634218ad9124b95d3ec893563bcfc9d283a124c6de4e4d33e  fixtures/00-cs_only/stored-update-receipt.json
+827ea67796351b5056ae332dc6bed2da973c07ad09a44b4566c370b806e7dc19  fixtures/00-cs_only/validation-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/00-cs_only/validation.stderr.log
+79366a956d3006c4bbb9a48da59e8f79ea207ab6549cb34d715210d5fd92a52c  fixtures/00-cs_only/validation.stdout.log
+5da791ac50bafc884861d137cea12dc8bee0108ada5a9456065ba222ad33bf32  fixtures/01-cs_only/authority.json
+e70005480e1d88131e9b41c6acda1c5fa0454ec2d9a1c4cdb80c08150cbe89dc  fixtures/01-cs_only/command.json
+8af9cfc908858418e04f88d2206237e4fa6b45353a1f57132a1165c764f7e187  fixtures/01-cs_only/fixture.json
+d287a9b1e06de8ddf0fb333546061b490151b87dec2b6c51a1789866603036a2  fixtures/01-cs_only/fixture.npz
+3469c42449c07bdb85beb2ae7cf5546d6d479108f1945909424e59f0c810bbe7  fixtures/01-cs_only/fresh-cpu-validation.json
+86734415f81985e39d9f4ea17aa6f89f72e28932d9359f4c75562e6264996adc  fixtures/01-cs_only/inputs.npz
+a88decbeaa6f64bd82d13ae7ae79822dd99057f17e3975eca4f7aa600223e203  fixtures/01-cs_only/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  fixtures/01-cs_only/reference-sources.json
+816e6d4fa5d3e590f4f8c3b2e40a56f9817a98bc85ca2ea3b0cd36a0d608a121  fixtures/01-cs_only/reference-timing.json
+9c13fcf9dfded5a222c35abf6550cf4dc47dd1d431cee4332613fd5ec020c1f8  fixtures/01-cs_only/reference-update-receipt.json
+99fc0c344a075642c0965404dfb950463c3aab00527ad7879b073ac334defe95  fixtures/01-cs_only/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/01-cs_only/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/01-cs_only/reference.stdout.log
+bfc93d51dedfbd37f522459b043f6469923ed892cdab47c1ee131701218166e3  fixtures/01-cs_only/source-file-pins.json
+9c13fcf9dfded5a222c35abf6550cf4dc47dd1d431cee4332613fd5ec020c1f8  fixtures/01-cs_only/stored-update-receipt.json
+e8ed3f58c4d81dcff62a1202ddc8343677680b1116279b5d9e47c5d212ad4249  fixtures/01-cs_only/validation-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/01-cs_only/validation.stderr.log
+cde3a215d29fcdc0c889deca76866e2973d0012170d58cef67959a547b9444e1  fixtures/01-cs_only/validation.stdout.log
+718fad35b01ffe406db72247ba747c9f5a9d7abbaab466bb4cbefbd6c934c384  fixtures/02-d_zero/authority.json
+8109c880fdbfbeda8b696e85fe012afcb1bb05fd4c8feb1b5a142dc98e06c3b9  fixtures/02-d_zero/command.json
+137bb20671520146709129180fa42858004a576cfe00186b855c1e1cb2e3620c  fixtures/02-d_zero/fixture.json
+d7219694f4b13600509ba76282ef2935ccef2a5bb69516d6322dba719c3681ee  fixtures/02-d_zero/fixture.npz
+4616d9adc5e7050c4b8458a4874df6399874406ab28efccd17fa3476354b3efe  fixtures/02-d_zero/fresh-cpu-validation.json
+e5407ce4f164ab242773f50abaa5434956a7c0e08d5090532bd35bb806754950  fixtures/02-d_zero/inputs.npz
+c8dd355352a81c870405283b2c9957f138e8c9af738d1cb94cc7ad395bcfd800  fixtures/02-d_zero/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  fixtures/02-d_zero/reference-sources.json
+c5f86afa7e42971c033116b61da0719bb5e9cc0cfe7b23d0fcdc331593285648  fixtures/02-d_zero/reference-timing.json
+dc1a5801b2250c391e5500b211b94538f72e45a1ac7474a368ba5475e976e0c7  fixtures/02-d_zero/reference-update-receipt.json
+b1fe5cb9af21e4fbc7ed758346342c8122c17422aabc2bc31f185ce45f29a8f9  fixtures/02-d_zero/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/02-d_zero/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/02-d_zero/reference.stdout.log
+f673086b818779a939b32b841f72055363f257fce66a8c94f660ac7bdc6ef8df  fixtures/02-d_zero/source-file-pins.json
+dc1a5801b2250c391e5500b211b94538f72e45a1ac7474a368ba5475e976e0c7  fixtures/02-d_zero/stored-update-receipt.json
+f18a2388498445c7f72b7a6ca6ca18bb293fe1f60547e6c97ebd30b60ba829cd  fixtures/02-d_zero/validation-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/02-d_zero/validation.stderr.log
+5081f11464fc48a0c2aac7b71462708a194249d16d4e1ff7d94fd4443ecaba63  fixtures/02-d_zero/validation.stdout.log
+d62ddd05588f89c9c7e3666d8d1a06653ac6e7301aecdcd4fcbfe026760c1581  fixtures/03-d_zero/authority.json
+e70005480e1d88131e9b41c6acda1c5fa0454ec2d9a1c4cdb80c08150cbe89dc  fixtures/03-d_zero/command.json
+8cdfd61b466a26c87bebc8b428f2d2c2d216a7d66d99729667b12e60cfa4aca8  fixtures/03-d_zero/fixture.json
+1e08c6c2ab7fb4ed5464446011c20753326609855661747b4f2e957ea2180a7d  fixtures/03-d_zero/fixture.npz
+294dd3720cc72a4d5744f83dcfe589e0a18ecdd3f1d445ff4dd03088beb0ea5a  fixtures/03-d_zero/fresh-cpu-validation.json
+b381836e7174025d8d3713ef5c9f37e3ffd1c7ec34f4f05c2e7d86257641d796  fixtures/03-d_zero/inputs.npz
+7566258ccbcaf7080fda56719203b73d015e0df181ccf5b8edfeb073c889009e  fixtures/03-d_zero/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  fixtures/03-d_zero/reference-sources.json
+8f6a15f0e152e4d16590f7c5da3890a8d4518a4da17c36d8ae9fea0ea3d5a625  fixtures/03-d_zero/reference-timing.json
+a1bb3e238c5f45cdc9b4d3a812cd5c71ed66fe0172ebb7ac9f6e3dee07ecb340  fixtures/03-d_zero/reference-update-receipt.json
+14053ba60590e38277a400cc73e12f6e5a78c3db2724052b999b9fa3181e03d5  fixtures/03-d_zero/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/03-d_zero/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/03-d_zero/reference.stdout.log
+afb38d3677cb67a31e88cbbaa1a00abaaa41a2227720e7f22558a2e8ef1d4fb2  fixtures/03-d_zero/source-file-pins.json
+a1bb3e238c5f45cdc9b4d3a812cd5c71ed66fe0172ebb7ac9f6e3dee07ecb340  fixtures/03-d_zero/stored-update-receipt.json
+c4b94d65276d73f45a1e20e89e97f09404ade36cece532d4258fb61c834487df  fixtures/03-d_zero/validation-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/03-d_zero/validation.stderr.log
+e9cb098fe3d6d02d20b3ad02e51f56609fbef2c187aa3c415b854f698c4183ff  fixtures/03-d_zero/validation.stdout.log
+f67885668e1f76c9ce055cf8b9b393af069661e0ffaa17b2b64c31e6b769b8af  fixtures/04-dan_only/authority.json
+5f54ab41b5a3e4bd77808e88b336bf5114653fa89ff7e1b17317f3318029070c  fixtures/04-dan_only/command.json
+92d70150d60543d57d3b0e74c9253c8a5ee8c433172b47eb78119db67381fcc8  fixtures/04-dan_only/fixture.json
+d3308593b3dd900cd87b3d70f1d763e28915717a1da591d6bb0e18c3ad8418ff  fixtures/04-dan_only/fixture.npz
+57c223e70bc779649ce8d96ef6007168b87037ca50b0dd0ed697d1d5d7bdf84d  fixtures/04-dan_only/fresh-cpu-validation.json
+ee57193b3f6474ad17ec5ac5685521e221f4fb79dbe4c5e8a5efb48ce459f303  fixtures/04-dan_only/inputs.npz
+15f84dff3673d35cb8940a1a243c13de32f03be36368424cebe8a5b68ef3c83f  fixtures/04-dan_only/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  fixtures/04-dan_only/reference-sources.json
+34014232cc53e9a7720cd82a6368bb67b881cf50fb688257093b627c29b202e4  fixtures/04-dan_only/reference-timing.json
+46dce947920ebca0041fe77929b1d1f24d7ba8f87bdfd89d599204be826760b8  fixtures/04-dan_only/reference-update-receipt.json
+e1e6a5ea847c37973ad7918030ecd24a4c303f3b07c06bd54c6585343514e213  fixtures/04-dan_only/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/04-dan_only/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/04-dan_only/reference.stdout.log
+9e38d6ddfc2a1021815f8d0d4bc3e27c6e946e28a7ed0a347ed8c9dabb83a076  fixtures/04-dan_only/source-file-pins.json
+46dce947920ebca0041fe77929b1d1f24d7ba8f87bdfd89d599204be826760b8  fixtures/04-dan_only/stored-update-receipt.json
+c56b76617f2d5fce49a4a614b73da5e064334f282e139f2be757bff73e64b38c  fixtures/04-dan_only/validation-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/04-dan_only/validation.stderr.log
+5b7daadc46ae9f508c260fcb1310f06ee7e9a4a93a2d10319228192d933f7a24  fixtures/04-dan_only/validation.stdout.log
+696ba064308fe574821e8a40890528903c0f8db06b87a20820066ab026f63750  fixtures/05-dan_only/authority.json
+5f54ab41b5a3e4bd77808e88b336bf5114653fa89ff7e1b17317f3318029070c  fixtures/05-dan_only/command.json
+82b493cec2b6f26c93acd1f1341c31b09d91ead227ac71db48367efe56be2863  fixtures/05-dan_only/fixture.json
+d3308593b3dd900cd87b3d70f1d763e28915717a1da591d6bb0e18c3ad8418ff  fixtures/05-dan_only/fixture.npz
+e83e1fbcc9f9a89135ba803d88b7e435b5899cd36bdeb0099133c8a510314a2e  fixtures/05-dan_only/fresh-cpu-validation.json
+ee57193b3f6474ad17ec5ac5685521e221f4fb79dbe4c5e8a5efb48ce459f303  fixtures/05-dan_only/inputs.npz
+a9485620b134ca73d1c6b4c46975a477cf32722179576e89caa0eb0648a6046e  fixtures/05-dan_only/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  fixtures/05-dan_only/reference-sources.json
+fd6699c19db6ca4b27a4cdbb6ee56da53cd0d959bbe33c691b45f8433d590fbb  fixtures/05-dan_only/reference-timing.json
+46dce947920ebca0041fe77929b1d1f24d7ba8f87bdfd89d599204be826760b8  fixtures/05-dan_only/reference-update-receipt.json
+e1e6a5ea847c37973ad7918030ecd24a4c303f3b07c06bd54c6585343514e213  fixtures/05-dan_only/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/05-dan_only/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/05-dan_only/reference.stdout.log
+c8932db5e698569c7f503b177e0bcadb7691dbb3a6bb7bf95f5d489457ed43a4  fixtures/05-dan_only/source-file-pins.json
+46dce947920ebca0041fe77929b1d1f24d7ba8f87bdfd89d599204be826760b8  fixtures/05-dan_only/stored-update-receipt.json
+58c01661634cf16f9bdf49d6097afa70b70654ff977192e9257e011bebd4c288  fixtures/05-dan_only/validation-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/05-dan_only/validation.stderr.log
+f2e7bc6dee034c030ec8ae2893bbae152ffc8dca380e32ebea866492990e2669  fixtures/05-dan_only/validation.stdout.log
+7487ac6f63347e8ce7b196f07101813b2760e6d9f361939ea1e7ddb324b4e4f4  fixtures/06-frozen/authority.json
+012e31724d4a9dca3f530f279883a2c17a99404587c0584fb35c9eda0c12666f  fixtures/06-frozen/command.json
+af37cec01333aa06f859f190b97ace01063b0ff1a3d9473cc07ab2b747ed33c1  fixtures/06-frozen/fixture.json
+d7219694f4b13600509ba76282ef2935ccef2a5bb69516d6322dba719c3681ee  fixtures/06-frozen/fixture.npz
+ea0f77c89a347692c8e9c2b3a194a8b908c097721ac22fa6796f5c5e000097e0  fixtures/06-frozen/fresh-cpu-validation.json
+e5407ce4f164ab242773f50abaa5434956a7c0e08d5090532bd35bb806754950  fixtures/06-frozen/inputs.npz
+da80362f8972cca5d4b927cbc3ab1251ced691b50e769f310f36e5e99eaf1af8  fixtures/06-frozen/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  fixtures/06-frozen/reference-sources.json
+a078623ccc1a0b321744aff5c6f00c574dd3505a90b78d10014e7bda19d2a161  fixtures/06-frozen/reference-timing.json
+7fcefce05842bd93fa60010f33756f867a6f3bb85cb7d7d62664e57f1643e60b  fixtures/06-frozen/reference-update-receipt.json
+b1fe5cb9af21e4fbc7ed758346342c8122c17422aabc2bc31f185ce45f29a8f9  fixtures/06-frozen/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/06-frozen/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/06-frozen/reference.stdout.log
+acd0f42558d85dd990d83b53c2f1b610cea6c50c55576587623f64def58024d5  fixtures/06-frozen/source-file-pins.json
+7fcefce05842bd93fa60010f33756f867a6f3bb85cb7d7d62664e57f1643e60b  fixtures/06-frozen/stored-update-receipt.json
+92b433ca642efc2163a12649a9e02dd6128149d45498630378375d99db3202f0  fixtures/06-frozen/validation-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/06-frozen/validation.stderr.log
+a110e0445eb65dea2b689f5f275171e28940ecf82cf464421da623050dfb869f  fixtures/06-frozen/validation.stdout.log
+a7855b86c84a2af95aa64069c7f37939a156e294076f28d7afd659368d5ac270  fixtures/07-frozen/authority.json
+012e31724d4a9dca3f530f279883a2c17a99404587c0584fb35c9eda0c12666f  fixtures/07-frozen/command.json
+923609c1b873fdd8757146c7339512c7fe2c0e39a4b122a63312eccd5e8148e0  fixtures/07-frozen/fixture.json
+b33364a02b8e517a5616e787dc52fed707c7a02c8e766c8db8bdd5e3519c3afe  fixtures/07-frozen/fixture.npz
+793f5051607d210034579d6c5e8f735d82ef827ad0b4466fb1ba8ab32492fd42  fixtures/07-frozen/fresh-cpu-validation.json
+21ee0894422caac5a92651b36ca1a41ef7af40ace492dc5fd50a8ace6d409841  fixtures/07-frozen/inputs.npz
+42d9c3edee3f4e6c92a5cf18c5bc8000d6896a7ad67c05a5a83cf4822f5a930e  fixtures/07-frozen/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  fixtures/07-frozen/reference-sources.json
+7552171339f179d7d5afd95afa620846955e9c4bf4d7929b76e2122c15f6f0a6  fixtures/07-frozen/reference-timing.json
+dbc34e8d314e6ccf4d62984fdc50b5f3e86097959b73c24f6051b860508261d7  fixtures/07-frozen/reference-update-receipt.json
+05d2075865314133458d2960786cd1d8d9056e5cdd808192be9edf580f13655c  fixtures/07-frozen/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/07-frozen/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/07-frozen/reference.stdout.log
+77d8e1d43d886b91d20a7557c0f33c296440ec0847c239eafb3c92a933d81000  fixtures/07-frozen/source-file-pins.json
+dbc34e8d314e6ccf4d62984fdc50b5f3e86097959b73c24f6051b860508261d7  fixtures/07-frozen/stored-update-receipt.json
+007d19099619f51a2f21ce2ba0365633b6cb8fc5ee9ad1969e51ae9a2954d890  fixtures/07-frozen/validation-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/07-frozen/validation.stderr.log
+5db3aa7d39e24ba994f2ddeb018cbeb3e73dce4e62093f0f2ac49d811355840a  fixtures/07-frozen/validation.stdout.log
+057370d91fcd3a596a615aca686801e4ac010e3347c86e0f8625392b3d321ca6  fixtures/08-paired/authority.json
+5f54ab41b5a3e4bd77808e88b336bf5114653fa89ff7e1b17317f3318029070c  fixtures/08-paired/command.json
+9cc866bda3686db4bbaa777f17adddcb081c809c2fb0cba5e0a837c318583e51  fixtures/08-paired/fixture.json
+66255125ed61c996339b4ca86262a47144f606f1349ce9fe42ca9b14a599f195  fixtures/08-paired/fixture.npz
+bd648d6aa9f76215566a0212ff58122bbfd27b3b3a7ccb1001293d11ce7fe26f  fixtures/08-paired/fresh-cpu-validation.json
+e5407ce4f164ab242773f50abaa5434956a7c0e08d5090532bd35bb806754950  fixtures/08-paired/inputs.npz
+0399337c02a9db5a0328384d46070177a008976b614b12a03d8635966bc7f7d0  fixtures/08-paired/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  fixtures/08-paired/reference-sources.json
+cae6d6a80eae901d0b8c9147347f4b8aca59939f3f9cb4328d3958b71aa49825  fixtures/08-paired/reference-timing.json
+d0a660b4e87a786275852c1d759e2750f42d18b354780a2e4a1036b3b3be5056  fixtures/08-paired/reference-update-receipt.json
+67c2e3bb5b59ded42969dd1e13fcb9a3d17465a4b15e139bd004ed77587df018  fixtures/08-paired/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/08-paired/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/08-paired/reference.stdout.log
+6f8448d6f2bccaece46a6ff5e16302b026e1ed87e449168752f82d2b5b44f5db  fixtures/08-paired/source-file-pins.json
+d0a660b4e87a786275852c1d759e2750f42d18b354780a2e4a1036b3b3be5056  fixtures/08-paired/stored-update-receipt.json
+1b11a6ebde1ec534783f63f1f551726e0ca7dfb381f4603cc38f38aeaf6d695c  fixtures/08-paired/validation-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/08-paired/validation.stderr.log
+bb7f511871ca2d89e632377ebd182996b7e8d11fda563a7bf72009cb0c4a7a55  fixtures/08-paired/validation.stdout.log
+fa75f7a56761529ea409aad47616384728b1aeff8c007f5d1cf365cb387047fb  fixtures/09-paired/authority.json
+e70005480e1d88131e9b41c6acda1c5fa0454ec2d9a1c4cdb80c08150cbe89dc  fixtures/09-paired/command.json
+8b649bc8271cd89e8e5c549f8f76bad7d2e97129aace586e6bf4dce4d2a49179  fixtures/09-paired/fixture.json
+291659396044089facc673b23ccacea8905263a3978e5a5af320bf50828e2d07  fixtures/09-paired/fixture.npz
+a5db3c2e0ebb90c53150226d891618a88b760da928b6273f56fbc4b09755ae38  fixtures/09-paired/fresh-cpu-validation.json
+7e4690296c8801897084c73b30be490132535abe6f0e1b2d5b140efa99c8bc5d  fixtures/09-paired/inputs.npz
+7d1b54e446799eecbabe55b352b500b5edc2881c1d0399992aafd804d254991d  fixtures/09-paired/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  fixtures/09-paired/reference-sources.json
+6f9328a89809745eb510096c1fda0242dc6144b909cc9c64a195a9ce460e40b8  fixtures/09-paired/reference-timing.json
+e3ece81002439b3dae1b921ecebc528db3554bd1cb374e336a9af70c555bc01e  fixtures/09-paired/reference-update-receipt.json
+48ebec28571a205c0f374df12677cb585ae594429ece26e3c4bad6068e017cdd  fixtures/09-paired/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/09-paired/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/09-paired/reference.stdout.log
+a6cfba42d04e28ad99f92cedc60b39cb196be677a10ac30415aa530087f381c6  fixtures/09-paired/source-file-pins.json
+e3ece81002439b3dae1b921ecebc528db3554bd1cb374e336a9af70c555bc01e  fixtures/09-paired/stored-update-receipt.json
+09bd4c8f83c489dbeb074a57490d368aad3b63347e01f8b84e12a4c11e11c66d  fixtures/09-paired/validation-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/09-paired/validation.stderr.log
+bcdb6d7e895a404daf7ef9815b394ea94e74a2c9f5cfce06c36830a33338476a  fixtures/09-paired/validation.stdout.log
+e179f065522cc30505b7dd5d5d6adc41a10d7b3aa49e48a65afbc620ebf48c3f  fixtures/10-random_reward/authority.json
+5f54ab41b5a3e4bd77808e88b336bf5114653fa89ff7e1b17317f3318029070c  fixtures/10-random_reward/command.json
+0f587ac75a5486250b45e9ab624aa3e71db035a3149c09102e9892ed3f269b82  fixtures/10-random_reward/fixture.json
+66255125ed61c996339b4ca86262a47144f606f1349ce9fe42ca9b14a599f195  fixtures/10-random_reward/fixture.npz
+18e1d5c11b07b4f25d8ccc08e0e4928da4f7851dd063645a0cd83e2c91a3e677  fixtures/10-random_reward/fresh-cpu-validation.json
+e5407ce4f164ab242773f50abaa5434956a7c0e08d5090532bd35bb806754950  fixtures/10-random_reward/inputs.npz
+58d5571bd571120146d208182eccc564f13979d3f9d07c43c4cc922b54b9ae6d  fixtures/10-random_reward/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  fixtures/10-random_reward/reference-sources.json
+64b4e11de2bb2225c7f46bdcae32220011896181f19a58ef2dccecd6d70be0bb  fixtures/10-random_reward/reference-timing.json
+d0a660b4e87a786275852c1d759e2750f42d18b354780a2e4a1036b3b3be5056  fixtures/10-random_reward/reference-update-receipt.json
+67c2e3bb5b59ded42969dd1e13fcb9a3d17465a4b15e139bd004ed77587df018  fixtures/10-random_reward/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/10-random_reward/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/10-random_reward/reference.stdout.log
+8f3acaa47501dacccc6609bc505ec7e3783ebec729900c217392168bf9c1b079  fixtures/10-random_reward/source-file-pins.json
+d0a660b4e87a786275852c1d759e2750f42d18b354780a2e4a1036b3b3be5056  fixtures/10-random_reward/stored-update-receipt.json
+1462b51d4d1503eb3c991a0865b8fb7e54a10587b42f5b506b6b77aa2fd368cb  fixtures/10-random_reward/validation-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/10-random_reward/validation.stderr.log
+c901e914fb8e0ba84a3c491a3128940ef3a0c554243743b70647106fea119e80  fixtures/10-random_reward/validation.stdout.log
+ce2d98f1c6071b381c92dfb2c50582eea755cdfa794badf5b07f42922304c15d  fixtures/11-random_reward/authority.json
+e70005480e1d88131e9b41c6acda1c5fa0454ec2d9a1c4cdb80c08150cbe89dc  fixtures/11-random_reward/command.json
+b7ac9446d02b8e532997f994a17730f8bb7477bc495b639508bc095cab66b4be  fixtures/11-random_reward/fixture.json
+74175c25f3315988ffec266a865c54793a2f7ce3a0679b9e8544f79c074568cf  fixtures/11-random_reward/fixture.npz
+d02cfb073c2921f246004ca3f7434c2347431533d284ddb2488c551149d6d4f4  fixtures/11-random_reward/fresh-cpu-validation.json
+62b9ef6e3add910e998d11d4e419eeabf5cc8d3b25cc1a0105ab6ea3784fc4c7  fixtures/11-random_reward/inputs.npz
+cae2fcf6ff67ffbc5b9ba627160961d5e63f33b1611f3d6759ace9c25233eaa9  fixtures/11-random_reward/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  fixtures/11-random_reward/reference-sources.json
+b2eebcbee7bac6b2dd941f55fbe66bb2d5320a2068c7f060990aa2d1ad235b03  fixtures/11-random_reward/reference-timing.json
+93aaedd62b47bf35bee3e3201c52851fddde077633d630e808acf97bfa995c0b  fixtures/11-random_reward/reference-update-receipt.json
+0878210890008fecf0c355d72d1bb0802cb59582f74d12634f17a7e8b8ec5fd8  fixtures/11-random_reward/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/11-random_reward/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/11-random_reward/reference.stdout.log
+c40c79d39688c3e4f538d2197f394510b25ef6a318e667fdfae0ece3a45315d2  fixtures/11-random_reward/source-file-pins.json
+93aaedd62b47bf35bee3e3201c52851fddde077633d630e808acf97bfa995c0b  fixtures/11-random_reward/stored-update-receipt.json
+ab403457fc63c968982a77efd7d6f399753dcccdff6509626af4d97cf07487a6  fixtures/11-random_reward/validation-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/11-random_reward/validation.stderr.log
+b5f610a73a30b3bd959b540f3f1b5678e20c562b9006dd28d90c46f99be75cab  fixtures/11-random_reward/validation.stdout.log
+8f81bcbfec893382cffb93402ac5322f89f27a0bfe2187cdaf2a02a701f7fb16  fixtures/12-unpaired/authority.json
+5f54ab41b5a3e4bd77808e88b336bf5114653fa89ff7e1b17317f3318029070c  fixtures/12-unpaired/command.json
+34f7744236017411b411953913b97d2f93cda8e49077eb52489961cb78fb99b6  fixtures/12-unpaired/fixture.json
+d3308593b3dd900cd87b3d70f1d763e28915717a1da591d6bb0e18c3ad8418ff  fixtures/12-unpaired/fixture.npz
+c96a21414fffb685ad2b2d53d4b8f3e9596e551435d99a3aef075bd608f0cd67  fixtures/12-unpaired/fresh-cpu-validation.json
+ee57193b3f6474ad17ec5ac5685521e221f4fb79dbe4c5e8a5efb48ce459f303  fixtures/12-unpaired/inputs.npz
+ad8b8accece3042091dd9857acc8a668188383fc469f5c23060cfb0c93e2a02c  fixtures/12-unpaired/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  fixtures/12-unpaired/reference-sources.json
+7d5bc3c18d55a0473e0d1440722a649e9fc1d174499960a7488bce2cb9965014  fixtures/12-unpaired/reference-timing.json
+46dce947920ebca0041fe77929b1d1f24d7ba8f87bdfd89d599204be826760b8  fixtures/12-unpaired/reference-update-receipt.json
+e1e6a5ea847c37973ad7918030ecd24a4c303f3b07c06bd54c6585343514e213  fixtures/12-unpaired/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/12-unpaired/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/12-unpaired/reference.stdout.log
+5b487868ddb4e1a9fe8fd341d745664aaf2092a485dc8dde4506938aeb9ab3c7  fixtures/12-unpaired/source-file-pins.json
+46dce947920ebca0041fe77929b1d1f24d7ba8f87bdfd89d599204be826760b8  fixtures/12-unpaired/stored-update-receipt.json
+ed46a6b6702b1a618bca80f6045cbd93d25f557ecbf31e97c240d8dd53f95ace  fixtures/12-unpaired/validation-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/12-unpaired/validation.stderr.log
+0db4b969fb0a29e589b28fec3e512ab1392fd5cd8c95b821abe53d55e9b07526  fixtures/12-unpaired/validation.stdout.log
+01bc256b74fd303427aa06d05fc1750cc5440bb77b3be9e062638910d1f61c4c  fixtures/13-unpaired/authority.json
+5f54ab41b5a3e4bd77808e88b336bf5114653fa89ff7e1b17317f3318029070c  fixtures/13-unpaired/command.json
+2812c35533dc5ce3f7fdb138168635e7ce80b84cfaa8d7cbf9602a435daf4074  fixtures/13-unpaired/fixture.json
+d3308593b3dd900cd87b3d70f1d763e28915717a1da591d6bb0e18c3ad8418ff  fixtures/13-unpaired/fixture.npz
+12fa68d0ac45173871ffcd5774966c5717f0bfc3e1d7e209f021ff4aa162a648  fixtures/13-unpaired/fresh-cpu-validation.json
+ee57193b3f6474ad17ec5ac5685521e221f4fb79dbe4c5e8a5efb48ce459f303  fixtures/13-unpaired/inputs.npz
+24362f7fbada424ebdeaa908cc30699ac63d6acfcece8e43450f7d52217d122b  fixtures/13-unpaired/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  fixtures/13-unpaired/reference-sources.json
+ab5697a371aa02738e3b6742f7dc44ed4f2d4f9062c16074b943f2f792bad155  fixtures/13-unpaired/reference-timing.json
+46dce947920ebca0041fe77929b1d1f24d7ba8f87bdfd89d599204be826760b8  fixtures/13-unpaired/reference-update-receipt.json
+e1e6a5ea847c37973ad7918030ecd24a4c303f3b07c06bd54c6585343514e213  fixtures/13-unpaired/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/13-unpaired/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/13-unpaired/reference.stdout.log
+197659c8588422095e1da0a6c58a642418afcbeb0f853019400bdd5118e6784a  fixtures/13-unpaired/source-file-pins.json
+46dce947920ebca0041fe77929b1d1f24d7ba8f87bdfd89d599204be826760b8  fixtures/13-unpaired/stored-update-receipt.json
+b524ebb33b92491dd2c1e1d78a758ea45d9f7afdfa36c1d06abece88dd6b0214  fixtures/13-unpaired/validation-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  fixtures/13-unpaired/validation.stderr.log
+012fe210b8db03eb760759af24d05f19ba9fe5a232d47634901f34827e5ff3ec  fixtures/13-unpaired/validation.stdout.log
+481df128d39bf28e5984a6f2e5757f83d45cb7a6136f8d2843ecc0a67eca437b  fixtures/manifest.json
+dda00d3eea57924cfdadf376238d28a07c88f04eb5e9253c44d9217b8a55ce3c  fixtures/original-source-pins.json
+204fd74217e6f498c2f45b228e1162226cf051502429d04f8d2e10a1f309ab11  fixtures/selection.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  install-candidate-attempt-02.stderr.log
+da70074a63465cbc7f9e8d6e6eaca43b6300f869f63ceea25b1a08251c69b7a4  install-candidate-attempt-02.stdout.log
+572bfe5d57ec3c97dd6dc9985c4e8116b010fbbeb7dfd5b5fe79e4bc2c80384e  install-candidate.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  install-candidate.stdout.log
+b35dd6c1f26644b688f87ce57ce03c33413d781707978a3979299654361c4fd1  integrity-after-gpu.json
+e3bb382e3b751e00090aa91d704864ba9cd623fb239f215719ad23680510b713  integrity-before-gpu.json
+1c22c3f133a18d8d18ed6beefb88f72165593492b886550668a353c753373365  jobs/export-real-01.exit.json
+138dd4fd23a0d3d0e34594478aa050dd410e18286739297067938895c7b77659  jobs/export-real-01.start.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  jobs/export-real-01.stderr.log
+7d16c3f01af58bded4a2b78d689ba0cc155e676dbd88a32b7e7e8f5dea69c3f6  jobs/export-real-01.stdout.log
+2eb69ff6a51b724d93fb80f439f31b3a0c84e613dd47082c4489e4ae08629c09  jobs/export-synthetic-01.exit.json
+338d241f6f21da1c7b9dc7652b258b20494aa87f88a6fe4b2fb30e82026991e1  jobs/export-synthetic-01.start.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  jobs/export-synthetic-01.stderr.log
+8ceb3408d2ddcdde3e007f62d9e13bf98e322d3818eb8f0395f737d2350ffe53  jobs/export-synthetic-01.stdout.log
+c29eec1b1dc9f798e1bdc466b01f17f790696a3fad1219dc8cebf28205abbff2  jobs/host-tests-01.exit.json
+236962124fb87c6b8cf871312d04b20d4a8f52ac3b3981c68a7fdace16e3da37  jobs/host-tests-01.start.json
+14d932e6256e9fbfad47cbbf6aa6479eb986584a7125e8ab21be2719ae7c2496  jobs/host-tests-01.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  jobs/host-tests-01.stdout.log
+94f122d95c52a8b7f9335c865b2c9d37d2be1bf02fde8a303d80d58e5da32def  jobs/host-tests-02.exit.json
+4910b406c26fa43091ee404dd2632a810fd6ab530933e69a17d96fb7b4f57f7d  jobs/host-tests-02.start.json
+0cde35a092720dec38eff7edc0c3b872663c0dd65d11822f3c52a72dcdc1fefc  jobs/host-tests-02.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  jobs/host-tests-02.stdout.log
+d46f60ada1c6a869ad7ff79e17f79e1fe01c8398df9cd9dcde5d687515cc7c39  jobs/integrity-after-gpu.exit.json
+83430c5ef2c5615ce1234dab67bbb17276a75617256b6a716151d3cf8a72c2f3  jobs/integrity-after-gpu.start.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  jobs/integrity-after-gpu.stderr.log
+8a858236678507c28e50c884d177c59fa1a2908665f54992cca183fc86624943  jobs/integrity-after-gpu.stdout.log
+a43f4de683412d83e20523659045bb17aed3ba43571918d1babedea344da82fb  jobs/integrity-before-gpu.exit.json
+1352324714e5e9cce1202373eedcebbdc4d17ff36b63feb84959312e5d60b0d6  jobs/integrity-before-gpu.start.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  jobs/integrity-before-gpu.stderr.log
+7f8e95d7180bc972443b09a7326088eb72aa73103c3703a463867e0771f9938a  jobs/integrity-before-gpu.stdout.log
+cc3d84f8ec0e6d20fd0a3bc782b2270e84a5872c2ca04064970044ad52ee8482  jobs/rtx4090-01.exit.json
+18954abcab8bdad71944787684339fce9923f556dbfea091d81b13a3ab942ee3  jobs/rtx4090-01.start.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  jobs/rtx4090-01.stderr.log
+b99c5c217549ae72f2882f46a7205da9007f6541642b7e0e01954e5053372d88  jobs/rtx4090-01.stdout.log
+47ded46a1fad855509ecf5bff96c98b571611f3e10df4e1df71fa490ada1190c  jobs/v100a-01.exit.json
+d69a93fd7e3aacb5b688237366487d19af64931d1067a2f909c5e87bd73ebc1a  jobs/v100a-01.start.json
+a532b6e3d6e7011e3681588541da75dd0fb2f4913cc2f277e9c88c5c0f0c1fc3  jobs/v100a-01.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  jobs/v100a-01.stdout.log
+824fdba4d8fc4306a8dc48c377c34b2159587d752eebef691956df4823722c18  jobs/v100a-02.exit.json
+8835334a42e0b7fd305f6b3886d3c0e4f866c81e6377ba5b857d6aed767d0190  jobs/v100a-02.start.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  jobs/v100a-02.stderr.log
+6d598f73d21fef88ff9e58ca3dc85d31f3ebf9bbe33a3aaea4f608a79564f3a6  jobs/v100a-02.stdout.log
+f015698a70d1b1ba563ac31b25ca2c6d2096773217cd4702b97dcf451031f509  jobs/v100b-01.exit.json
+737007acddabee4d61626da4f91007a95033c53dde069f33ca363009a203996c  jobs/v100b-01.start.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  jobs/v100b-01.stderr.log
+a74268f5e402ed4874f2b468da84bd45586a8f2931a7bb2eee80678a42c0dd5a  jobs/v100b-01.stdout.log
+666e072ad4592eb528a39bb6933c048c09a6dd47ca58318bfded6a8fb6f69422  pip-install-report.json
+06c7b73058cb06a976acb62a5e6e88a2479b214e6e28d98bb793ea50197bf2e6  rtx4090-01/authority.json
+62a173c9891cfbd159d236b54785170b16bf0a4deeae487ee1e04bbbcbb7a546  rtx4090-01/fixtures--00-cs_only.json
+392cd9b4e8547e8f256e53aedecb7d570c5beff1fb180775233039c1100bfbb1  rtx4090-01/fixtures--01-cs_only.json
+29d45624a4710b1fac0bf5db3df67e0d8af48567af28d539f8dca45f09b3759f  rtx4090-01/fixtures--02-d_zero.json
+b3915ce2a35795d99ff47824a932ce949ee8ac16f0afde8283c6ef3e293357dd  rtx4090-01/fixtures--03-d_zero.json
+6b1310903f362ed6cef9052e70266b0b47bf8a743bf96a3e1035bacfa921e45f  rtx4090-01/fixtures--04-dan_only.json
+410dfe35a7599460546f7f828b4152b94828bf90c250428ac7d2ec75ac63aa39  rtx4090-01/fixtures--05-dan_only.json
+ca257675fe44bc8cfb80813c0307b9fa8312c417cf3bbfc5820e27c035fcbcf2  rtx4090-01/fixtures--06-frozen.json
+8e2a1e17160ec4e98fd7c999487d6af9cb6bd8c0d96dce6852d88a3fe60fe1d9  rtx4090-01/fixtures--07-frozen.json
+0a5098376d5debb76af8e27d4404816c50545e0c8a158282d1d56465416a4ac2  rtx4090-01/fixtures--08-paired.json
+19ac2720c3ccac3819eceffae745710c3698ed090a879cd42f59d62471fd5d71  rtx4090-01/fixtures--09-paired.json
+55dd2071b19e4fd39680d5db2fdba7884033754b054e0a89440e09e346863de0  rtx4090-01/fixtures--10-random_reward.json
+9f72359d9526047c7842e5428a1092e7bec96905a8b02269490a999add75a296  rtx4090-01/fixtures--11-random_reward.json
+5bd5e68710774c575fbb2fb9cae6b72faff2c292b198560b1857b3bc36e858a9  rtx4090-01/fixtures--12-unpaired.json
+03a10ccc4006346b8e7d6404963d26f6eded2af48aa292962c3ef7dccf06d727  rtx4090-01/fixtures--13-unpaired.json
+d06c602fc1950f1f63f7b79e98e3fbeef2a291811c91fc7ffdaab5acfd9ea3f4  rtx4090-01/invalid-input-rejections.json
+377cb655e5b6e5816ccca3b5a03c481021afc3da64879af9be72c207e88639c7  rtx4090-01/summary.json
+810b8abe7145f7dc19bf34707a5169b480a3dfc4cfd02d8f5b3c8bf0c38cad98  rtx4090-01/synthetic--00-empty-us900.json
+38dca8b89791113c5e9efa7f27e91614bc4894620ae26801c6951a043a0e406a  rtx4090-01/synthetic--01-non-kc-only.json
+213056b418992bf44112b2ebd6ecce755e62923496ad52e69b3d7ff9cbec079b  rtx4090-01/synthetic--02-no-us-mixed.json
+bd7a8c8f9482b29c91a0579c8d2b642e975a1a24b3ad7ad8432ef7c217a83010  rtx4090-01/synthetic--03-us-first-tick.json
+1eca5ac08300083f71022aaeaf1d1acee8c79481fea0c0a01dd453965f1f7dca  rtx4090-01/synthetic--04-us-final-tick.json
+e18bed6dc301d969b37b15d3478afeb919da7d503373f5010200eecde669c555  rtx4090-01/synthetic--05-before-on-after-us900.json
+56b3085d4cceaf9dc2ae720f82ba9a63b105c943fc84fd20321bffd9070eee15  rtx4090-01/synthetic--06-d-zero-existing-delta.json
+7c85511eb4ffd833824a1d8a65f30aa1cd651c247008987d23492e7e5f4be4c7  rtx4090-01/synthetic--07-frozen-existing-delta.json
+00f7eb4f9857c078e755d88ae7f4ebb067c279ace1fde074f2e30f6cb9d7c24e  rtx4090-01/synthetic--08-compartment-0.json
+be8d410ca8a05661da851e981d5f18d84c09c08cf6d01beaa2cd62ed43805a67  rtx4090-01/synthetic--09-compartment-1.json
+dfbf57fc6a4259a5a0bd18d33f81d26b91976e39d6960b31be63c0008f008213  rtx4090-01/synthetic--10-compartment-2.json
+cd145d7bf7ce147043f0b401cdeea67c63a8ae45e130e4c6d71056c0250fbe08  rtx4090-01/synthetic--11-compartment-3.json
+f14e69b5293cb81cdc2cf6f4d895372acfdee80954c6ff3b29031abb536e00d3  rtx4090-01/synthetic--12-already-at-floor.json
+779a4d8111fa64524958e923f75c0d6076ccf6262b9ed67e99cedc16c7afd09a  rtx4090-01/synthetic--13-one-ulp-above-floor.json
+71d98467108c65e9e8c4a2fb13a7c755bba733aa346f3fb77eec14ac12ee5c14  rtx4090-01/synthetic--14-seeded-sparse-717.json
+6f082a0715e8c2af13573b508bb272ac0413c4ccda3b2aa3cb079b1f143b95a8  rtx4090-01/synthetic--15-seeded-sparse-20261001.json
+b35e3641470bbe1d8d208b93bddd9d74ecd2e48e3bd0c73ce53e1a6f2bf32a3e  synthetic/00-empty-us900/command.json
+511508f571c29e01cc9b52b012195aa6b2443854c6edeeb415323d5e28cb17cb  synthetic/00-empty-us900/fixture.json
+9a289591eda1c68ff8ae704b484f2437a7b290dd3f9dc56195b233f00c4e5344  synthetic/00-empty-us900/fixture.npz
+85e6aa97b72c7a8cfaca125d6772395d9f2d53f8627569c26c5d38fde7d5609d  synthetic/00-empty-us900/inputs.npz
+05957f0944ba8edacbe4335ac2d944a11570adb2eaa26bd81d221bc8a073f964  synthetic/00-empty-us900/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/00-empty-us900/reference-sources.json
+55e17e61d8c1da77906844dd7a58ac347d91e0420c7388cb1a8e35d3536b1c66  synthetic/00-empty-us900/reference-timing.json
+51cca308034c90e648311bc449d07210d6cce4c37779219c87571578af9d864a  synthetic/00-empty-us900/reference-update-receipt.json
+e1e6a5ea847c37973ad7918030ecd24a4c303f3b07c06bd54c6585343514e213  synthetic/00-empty-us900/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/00-empty-us900/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/00-empty-us900/reference.stdout.log
+b35e3641470bbe1d8d208b93bddd9d74ecd2e48e3bd0c73ce53e1a6f2bf32a3e  synthetic/01-non-kc-only/command.json
+d39cbc1610bf09a1431c2b59fcae0d271e7c21e8b41f95494d3b15b08dd215e9  synthetic/01-non-kc-only/fixture.json
+f0cf6ac6a9218d3e470f8f7570214c188eea8d8863461a03e9bb7388791da22d  synthetic/01-non-kc-only/fixture.npz
+5560a2a7382ac6e45de8d129079763cf8f074062e5aae188a5742f5151b6c99e  synthetic/01-non-kc-only/inputs.npz
+9b6b8185a64eaa8fbfd73456479605ae4a1359d9f5dc28d9691eeef3d9f45d8b  synthetic/01-non-kc-only/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/01-non-kc-only/reference-sources.json
+70a43186e9d1c23f0ec76ebadd7c9b3ccbf273c3cf572e65ae3f8e5a568fa7d8  synthetic/01-non-kc-only/reference-timing.json
+21de55c0c71087fffe5c4f87b20ce5ee1c5119c07f60ddccee1b939ba65a9367  synthetic/01-non-kc-only/reference-update-receipt.json
+e1e6a5ea847c37973ad7918030ecd24a4c303f3b07c06bd54c6585343514e213  synthetic/01-non-kc-only/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/01-non-kc-only/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/01-non-kc-only/reference.stdout.log
+eb98ecda2554a459c199b2ca238a79df8e323da37f039f939cfb64c4709cbe91  synthetic/02-no-us-mixed/command.json
+7fc01d5f06cf3306c828997573fc97e7cfde4959a820d45ec95e13ce8d26a3f0  synthetic/02-no-us-mixed/fixture.json
+7ba6cba3abaa7c1ce89380722f471bd7516650efd16ee685a199b0dc9a81312d  synthetic/02-no-us-mixed/fixture.npz
+6a0bcfa9cd11236e2cd3160f343e24725b6cdeac1121d8ef119194c24557f031  synthetic/02-no-us-mixed/inputs.npz
+0b3ab40391034acb03a142a0b731870ac046d1314520a6d6843eaa2794495a9b  synthetic/02-no-us-mixed/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/02-no-us-mixed/reference-sources.json
+c4356ea8a998303b3d1ff02e6e548550f02178d73e254096d03a0a9d69f27ef3  synthetic/02-no-us-mixed/reference-timing.json
+6fe439df410bc3b43d613b5bf09cc3617ed34e1ab1411e7a26e57a5de5730273  synthetic/02-no-us-mixed/reference-update-receipt.json
+701ad21f5e762c8c3e619d001b6d1941262441d83e31255e1f7f2bb4a0b6ef30  synthetic/02-no-us-mixed/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/02-no-us-mixed/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/02-no-us-mixed/reference.stdout.log
+6131b2db05c0e76d7667ec0788c069a307479fa7d64abb4448caa9ab8b26199d  synthetic/03-us-first-tick/command.json
+e3b04e52cbce0182d2adfcd989976cd46fc3942b4aff2b147a1971798f52c788  synthetic/03-us-first-tick/fixture.json
+e643d7ef1c9dc9177db35aedc254165feb6a0829aafc36858504e290df7182f8  synthetic/03-us-first-tick/fixture.npz
+677a5b156a06a73c4c165193b601df49c8de3141b2d0727df74ade3aad471ae9  synthetic/03-us-first-tick/inputs.npz
+c50311e064c535f8c60dcaa92213e5447d5770c6fef199aea43ed0fda59811d0  synthetic/03-us-first-tick/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/03-us-first-tick/reference-sources.json
+56231139ced0455cb1328973218265980ce82c013a46bf09b24624b97c9d1d25  synthetic/03-us-first-tick/reference-timing.json
+5520acd45f8d0a1820be7278d10f82bc50650b1b2836bcde7e418037309bc5a9  synthetic/03-us-first-tick/reference-update-receipt.json
+1c15f393e3791d5f0398af980d5eb447613066ede583bef29ef9a0da90014884  synthetic/03-us-first-tick/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/03-us-first-tick/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/03-us-first-tick/reference.stdout.log
+6d393eae689c30f60a7ca2acc535662ca0f65622a6bb680e93cfc72a2d86dc20  synthetic/04-us-final-tick/command.json
+98e785ccbd8fca8c7f62895f6af77200e836e60df0c9a3d8e4006dc99b15f9cd  synthetic/04-us-final-tick/fixture.json
+7aba2418b1fdeab69c5ef40824ae09335308245e7cda15bbe8a54ff27343531d  synthetic/04-us-final-tick/fixture.npz
+677a5b156a06a73c4c165193b601df49c8de3141b2d0727df74ade3aad471ae9  synthetic/04-us-final-tick/inputs.npz
+b58dc9fe89b8f35fbeb2d0e102ad26ccf03f09d0189ba27a85abd904a070c2b9  synthetic/04-us-final-tick/multiple-reference-process.json
+4839dadc4e59a259a513b1e4b5ddb7c0592d67431d8d9e55f98ba7b16aecc262  synthetic/04-us-final-tick/multiple-reference.json
+74ad903e255b1c994b54b9ce40aab028834767f108642fdb79c040b8962c3624  synthetic/04-us-final-tick/multiple-reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/04-us-final-tick/multiple-reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/04-us-final-tick/multiple-reference.stdout.log
+559e4a243cd5e1733829a1b2856df41c2bdb4365c7b8e077da434ceeee51ab0b  synthetic/04-us-final-tick/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/04-us-final-tick/reference-sources.json
+0418611a857f0574ea38f1560baf98208064b89d3d6ec3a05dfc1b41ff0cf9ed  synthetic/04-us-final-tick/reference-timing.json
+2c5069f28c0b76ea44461bddccdd9f96438ed835d764fece406b576ab0a4cba4  synthetic/04-us-final-tick/reference-update-receipt.json
+313840cc5c2b254af78dfe6a4adb99966ab7df9def81981325b55b0dc894904f  synthetic/04-us-final-tick/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/04-us-final-tick/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/04-us-final-tick/reference.stdout.log
+e4c982051bb849815a2b83181be97b53e1859907b991b95bfd4690697af39807  synthetic/04-us-final-tick/trace-command-steps.json
+b35e3641470bbe1d8d208b93bddd9d74ecd2e48e3bd0c73ce53e1a6f2bf32a3e  synthetic/05-before-on-after-us900/command.json
+95779e30e1def183be4f5a1d7f5ad5bd9673cf799b00b8c240959f4cea0bee91  synthetic/05-before-on-after-us900/fixture.json
+fbb07f9350e6c84d994522cc651d20492ec7aca7ce9906821a6964133bd4fdd8  synthetic/05-before-on-after-us900/fixture.npz
+6a0bcfa9cd11236e2cd3160f343e24725b6cdeac1121d8ef119194c24557f031  synthetic/05-before-on-after-us900/inputs.npz
+c89ac59e5aebba6052a02660291bb5f549c7ad2b887ce78996839067862a9bf8  synthetic/05-before-on-after-us900/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/05-before-on-after-us900/reference-sources.json
+a6ecd56b2355683dffc0ce461fd71c5917e8509fa861057fa7023ea56bbbed5c  synthetic/05-before-on-after-us900/reference-timing.json
+6b460f343303a080ff5f93986ec73af67241a0c8a34ce98de2095235885b2acb  synthetic/05-before-on-after-us900/reference-update-receipt.json
+aa7405dfd95c772c2a4c1516e359e44da227cd023cb2c0a7c7bc8c6e94a97f57  synthetic/05-before-on-after-us900/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/05-before-on-after-us900/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/05-before-on-after-us900/reference.stdout.log
+8d0528b432de998d651df7862a6e7f729c6510326cfe2091dbe2f39b68b6bcd9  synthetic/06-d-zero-existing-delta/command.json
+508c304d4d9906ae8d86b9fc5999f0a0988eb9f97fe96e2556a788718d27ac85  synthetic/06-d-zero-existing-delta/fixture.json
+aee196d0f3135489bcdb44fd8038c0db3fa55899e4347ba41aee009364cad09e  synthetic/06-d-zero-existing-delta/fixture.npz
+d7a9d21490ba1d1ab802c7c427d21637e72bd2450e22a91bf67a481af0dde669  synthetic/06-d-zero-existing-delta/inputs.npz
+9b275e432ca51466d423094a2faf4dcea98e9f33c03debe0720b34b351744590  synthetic/06-d-zero-existing-delta/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/06-d-zero-existing-delta/reference-sources.json
+dbb3fcf28f9d8761fe94bccd8f4908501fc7bf8baa9b78c1513bcf8be64f967e  synthetic/06-d-zero-existing-delta/reference-timing.json
+8aada5cac82c95961b6d362c5aea987ba759693d7ca27ef211c85160dd8a95cc  synthetic/06-d-zero-existing-delta/reference-update-receipt.json
+8a95cd87fb05348436bf3b95b8487b7b963fd5b849f0467dd61a2efea4ae5ead  synthetic/06-d-zero-existing-delta/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/06-d-zero-existing-delta/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/06-d-zero-existing-delta/reference.stdout.log
+ea2a1c748b5f5494e493135032a13ac76f5827c35903b6c99ea2bdc43edf5591  synthetic/07-frozen-existing-delta/command.json
+c59e94d8ea6e9beb5a14a1ba71ca5c1a0baed949c049c7d0db3445a1917811e3  synthetic/07-frozen-existing-delta/fixture.json
+aee196d0f3135489bcdb44fd8038c0db3fa55899e4347ba41aee009364cad09e  synthetic/07-frozen-existing-delta/fixture.npz
+d7a9d21490ba1d1ab802c7c427d21637e72bd2450e22a91bf67a481af0dde669  synthetic/07-frozen-existing-delta/inputs.npz
+9ed1abb56c1a731ecf7f3c8aeb127d097854826e2630fbc072b07889f557cf35  synthetic/07-frozen-existing-delta/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/07-frozen-existing-delta/reference-sources.json
+4ea633afbe7358274d22b6ca984914274a70a77f8c96fab4ce840a804f366264  synthetic/07-frozen-existing-delta/reference-timing.json
+edc7ef799e27f254a0781cdff6062c2900b87618d7d11b3697f5433c0a20b468  synthetic/07-frozen-existing-delta/reference-update-receipt.json
+8a95cd87fb05348436bf3b95b8487b7b963fd5b849f0467dd61a2efea4ae5ead  synthetic/07-frozen-existing-delta/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/07-frozen-existing-delta/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/07-frozen-existing-delta/reference.stdout.log
+b35e3641470bbe1d8d208b93bddd9d74ecd2e48e3bd0c73ce53e1a6f2bf32a3e  synthetic/08-compartment-0/command.json
+acef4efe1569358a4d68859ebe625c76e3490a85f8ae60d32ac9e8e1e9f0b658  synthetic/08-compartment-0/fixture.json
+13593e4495c227a371255cff31806f3e17e6561fa22d89ba81dcd22963e85648  synthetic/08-compartment-0/fixture.npz
+9b9298ca0f81f15feebba2773e59cbbdc848d3d41ec8be8bce00dc0856198389  synthetic/08-compartment-0/inputs.npz
+ba92ef45a2782dd349cc10028fd562038005c9adb9cf1070850584e732d95772  synthetic/08-compartment-0/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/08-compartment-0/reference-sources.json
+c83aa21eadf447f3e9881d6b387e933151384a4d1c94e9313efd7db7e61e4be5  synthetic/08-compartment-0/reference-timing.json
+b9c0f63144fc16e292b8cff2ded3bcbcd7893bd387d62aedeeaf37265c8b3cab  synthetic/08-compartment-0/reference-update-receipt.json
+7a4283d73e202db93a145b10c4f34edf62497938ca1044829b9ca0ce0f5d3619  synthetic/08-compartment-0/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/08-compartment-0/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/08-compartment-0/reference.stdout.log
+29fb25fa7b54889eaf9668bd5ec5313603da1d05e4ac57da30adf110f78ca058  synthetic/09-compartment-1/command.json
+8117aafd691419706307280f19dde57d6ceff4ab28b2a82141582bc7bc72d382  synthetic/09-compartment-1/fixture.json
+6a456ba8f13ac8beca8a94ec9de074ad1dbaceeeb483b0da58239006e793ab67  synthetic/09-compartment-1/fixture.npz
+9b9298ca0f81f15feebba2773e59cbbdc848d3d41ec8be8bce00dc0856198389  synthetic/09-compartment-1/inputs.npz
+bc2e4d67284c003d12437833a8a28d63d30b5476535ab15e34df2b7572329013  synthetic/09-compartment-1/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/09-compartment-1/reference-sources.json
+f9b166aa904097a388eb944476a6514dc041e072968ad700fc2de31a407469e0  synthetic/09-compartment-1/reference-timing.json
+20a7a3a02d9d8055314e65c7f09de488798b394b0033af7e155deb9978316255  synthetic/09-compartment-1/reference-update-receipt.json
+fdc015e6299bbc718810406b3df7b1fafac8d6eb41acb8e52b0a2fa456da8b5f  synthetic/09-compartment-1/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/09-compartment-1/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/09-compartment-1/reference.stdout.log
+5cb3364f3b8be8aa85a35936296ac74b780002a6ecc9b8e0d73067b0f16a0e1b  synthetic/10-compartment-2/command.json
+957cc144442a06a83500d076643fd51542d33c422384b64c030e16ad712a3d39  synthetic/10-compartment-2/fixture.json
+3cdf931bdbeec427ca09ab594dd34cdde9c04db6f85b1858c96a71c09f7e8891  synthetic/10-compartment-2/fixture.npz
+9b9298ca0f81f15feebba2773e59cbbdc848d3d41ec8be8bce00dc0856198389  synthetic/10-compartment-2/inputs.npz
+3c7b4d64f012d3ea2e3573da375526ff483112c9f10f261830daaa97430f3d51  synthetic/10-compartment-2/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/10-compartment-2/reference-sources.json
+6aa3d830a790352f12c683e93d53ab3039f53d65758f4766e582b94cbfe9d5c6  synthetic/10-compartment-2/reference-timing.json
+f9a90882ff074748465e285b13a0a89d1f486bb1a72dac11cfe133915b026915  synthetic/10-compartment-2/reference-update-receipt.json
+8f32636d547cf8c616778cf7f77387a08f8d8f786b0d402ba70df932779f9451  synthetic/10-compartment-2/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/10-compartment-2/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/10-compartment-2/reference.stdout.log
+5f54ab41b5a3e4bd77808e88b336bf5114653fa89ff7e1b17317f3318029070c  synthetic/11-compartment-3/command.json
+493b451b25f3a9736cf687b7a10787b2838f52b600e00253e4cd0e573dae2ea5  synthetic/11-compartment-3/fixture.json
+2604e203e2fdac9a7638a37caa643f2da61a0cc4720a7d521b211bc87d9e8f49  synthetic/11-compartment-3/fixture.npz
+9b9298ca0f81f15feebba2773e59cbbdc848d3d41ec8be8bce00dc0856198389  synthetic/11-compartment-3/inputs.npz
+34b48bc690c285b75e6450c259cf4975d1f0981d0cff1197648a0f3ee87f0200  synthetic/11-compartment-3/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/11-compartment-3/reference-sources.json
+df6ef026e2a89c3a59e1fb1607b6a611277f4b8ebade80d5d7e97de7449ea89a  synthetic/11-compartment-3/reference-timing.json
+6732aa221d4a880f56de1868b7654c884a0d26b908366804116de302192495a8  synthetic/11-compartment-3/reference-update-receipt.json
+67b25ae8d66f6e395273f5474339aab69269c37261d837a933330f942c6243dd  synthetic/11-compartment-3/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/11-compartment-3/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/11-compartment-3/reference.stdout.log
+b35e3641470bbe1d8d208b93bddd9d74ecd2e48e3bd0c73ce53e1a6f2bf32a3e  synthetic/12-already-at-floor/command.json
+e7d09dcf325b47ee08371645941640a2abacad4777591791d3a2cb0dbfd1bae2  synthetic/12-already-at-floor/fixture.json
+b4c0f8106381eaa83a6042e703be369ba4e1821e9b6ac4053882a1064d3cfcaf  synthetic/12-already-at-floor/fixture.npz
+5a1258fe9844b716f33c4ecdbc595bf4b436956476954ddd4cde8d4310509474  synthetic/12-already-at-floor/inputs.npz
+854d3eba812535bd0810321329402e178c2abb703b846d94dbeae5dffa793edd  synthetic/12-already-at-floor/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/12-already-at-floor/reference-sources.json
+cd11a55c130b9698553086cf055dab83358bf8ab8f228bd6bec6165954d7cec3  synthetic/12-already-at-floor/reference-timing.json
+de44bbf4a1337f45f9e4efcd8a273da1a7d0fdcf30b0efdd030d9bfa7e316ef4  synthetic/12-already-at-floor/reference-update-receipt.json
+8a1db1b6202ab37e493fffd7317d35060e573d69971b1784227b908fed5e2189  synthetic/12-already-at-floor/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/12-already-at-floor/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/12-already-at-floor/reference.stdout.log
+b35e3641470bbe1d8d208b93bddd9d74ecd2e48e3bd0c73ce53e1a6f2bf32a3e  synthetic/13-one-ulp-above-floor/command.json
+eef1d36daabc3c62903a8a37c7d97d9fab151093b0e8ce414657d0025d616d56  synthetic/13-one-ulp-above-floor/fixture.json
+f026e6530cb4965b1c290f93aeb9448ac25c0b664e26efac150f9123c22d9999  synthetic/13-one-ulp-above-floor/fixture.npz
+8187c2e9523a02c81e3815e5ab339a69a9f7c5ac5dad94769240d195e99601db  synthetic/13-one-ulp-above-floor/inputs.npz
+44f428a36acc735ff46fcd58ab86bd1fa45202666f10a2e6a55ffbfea91dbec9  synthetic/13-one-ulp-above-floor/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/13-one-ulp-above-floor/reference-sources.json
+9b82a4656d3fe3d36ce601881ee01ad8138be065c838e049b172a226c9e7811b  synthetic/13-one-ulp-above-floor/reference-timing.json
+3d1ea8d98acacc80c6ab9b060edf6a7e61900e14edeb9f4c2d1ccfb1eedf8677  synthetic/13-one-ulp-above-floor/reference-update-receipt.json
+2288a2514901e2ba4a40f0e474ba93f6fe0358949eb07b7c192bbd1abf103a9d  synthetic/13-one-ulp-above-floor/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/13-one-ulp-above-floor/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/13-one-ulp-above-floor/reference.stdout.log
+b35e3641470bbe1d8d208b93bddd9d74ecd2e48e3bd0c73ce53e1a6f2bf32a3e  synthetic/14-seeded-sparse-717/command.json
+d06599fccf25b62dadaec05439cc371ae879bd863ea65fd0d11f7330b1c14aba  synthetic/14-seeded-sparse-717/fixture.json
+da53fa054834070a2dce17d33589d6affea01a1d14d53734d9022f4dca0e0243  synthetic/14-seeded-sparse-717/fixture.npz
+61c6cc8e7fe97b845a99665669631a88061087cab107a4b0ed6bdd76ac1b23e6  synthetic/14-seeded-sparse-717/inputs.npz
+c1d74e401b7cb9c1b69b703e91e7dc1e7902e1d43fe021717aeb2055ea6f4dda  synthetic/14-seeded-sparse-717/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/14-seeded-sparse-717/reference-sources.json
+dc359baaabaaa5b5c3938e382e78b259544fd9fa12023a84d4d40c9f595b5e50  synthetic/14-seeded-sparse-717/reference-timing.json
+f0d80b1b90dae1eeac376d31e18dee7adf99c77b592f90543e87c80d35d24223  synthetic/14-seeded-sparse-717/reference-update-receipt.json
+ad0b806eb7af62b97c118bf6d9930d34560b2940a3a8094ca7937628a5450427  synthetic/14-seeded-sparse-717/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/14-seeded-sparse-717/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/14-seeded-sparse-717/reference.stdout.log
+b35e3641470bbe1d8d208b93bddd9d74ecd2e48e3bd0c73ce53e1a6f2bf32a3e  synthetic/15-seeded-sparse-20261001/command.json
+6b8556a227c4d59be17ca5df9452298f83788c0d508683884d8d98d5087c8f07  synthetic/15-seeded-sparse-20261001/fixture.json
+490f4a9077eb391075d7ab2d815e578b099f5a8dc369cea60b83dceee7a537b9  synthetic/15-seeded-sparse-20261001/fixture.npz
+12326122901b8c4fe0e3681a60c9bb20547e96df5f194b0aab9b791689547ae4  synthetic/15-seeded-sparse-20261001/inputs.npz
+7f0272f7ae6991d2e26384b0d0f904a4e0f7c0af6035f856a040451e1fa3a417  synthetic/15-seeded-sparse-20261001/reference-process.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/15-seeded-sparse-20261001/reference-sources.json
+8bb52188b8ade787d9e6ffd6c431fc195649ee3f3eb82e5b41fe4d7c9d33f744  synthetic/15-seeded-sparse-20261001/reference-timing.json
+e7c84ab8a4e778c0188b8ce5cfc12e22a31b07ff3e8a2d9e09dc4f53c43eb6f6  synthetic/15-seeded-sparse-20261001/reference-update-receipt.json
+0f08302f390afa422aedd5a21523782a7e5f81ba3de6f9337335d84b726b4426  synthetic/15-seeded-sparse-20261001/reference.npz
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/15-seeded-sparse-20261001/reference.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/15-seeded-sparse-20261001/reference.stdout.log
+b35e3641470bbe1d8d208b93bddd9d74ecd2e48e3bd0c73ce53e1a6f2bf32a3e  synthetic/invalid/00-duplicate-events.json
+a140bc2aa043601cc23bfee61789612c6d4980ae936e6634bb21fa7240238592  synthetic/invalid/00-duplicate-events.npz
+b35e3641470bbe1d8d208b93bddd9d74ecd2e48e3bd0c73ce53e1a6f2bf32a3e  synthetic/invalid/01-unsorted-events.json
+381b2cb091178ecc04fbdc8d126fb8923af7c9b47c2ce0120f9fd8340529354e  synthetic/invalid/01-unsorted-events.npz
+b35e3641470bbe1d8d208b93bddd9d74ecd2e48e3bd0c73ce53e1a6f2bf32a3e  synthetic/invalid/02-out-of-range-tick.json
+4df43f8a5997243dcaa6fcba79232f89d73a8f7b1beabb2c6b0e72d309101280  synthetic/invalid/02-out-of-range-tick.npz
+b35e3641470bbe1d8d208b93bddd9d74ecd2e48e3bd0c73ce53e1a6f2bf32a3e  synthetic/invalid/03-negative-zero-delta.json
+7e703ae325ad566b7587a41f92199dd2ad4259a48445d46dc04a482489666f8d  synthetic/invalid/03-negative-zero-delta.npz
+b35e3641470bbe1d8d208b93bddd9d74ecd2e48e3bd0c73ce53e1a6f2bf32a3e  synthetic/invalid/04-non-kc-candidate-source.json
+44ce0f662887c09ea595625d7559b408c46844e9d6831163ce18388a56365651  synthetic/invalid/04-non-kc-candidate-source.npz
+b35e3641470bbe1d8d208b93bddd9d74ecd2e48e3bd0c73ce53e1a6f2bf32a3e  synthetic/invalid/05-unsorted-kc.json
+969014364818757800193802297221c3ca2769d2abf9617a4cd3da6f6ace3d53  synthetic/invalid/05-unsorted-kc.npz
+6d7c2dce81d6a4d8382ae846f947d1978a388a277241c29076203f0c92211eb0  synthetic/invalid/invalid-selection.json
+4542ec5a5ddf28f2c72fbeabf22cbee170fdd4a5a1db886738d5e469c008231a  synthetic/invalid/original-rejection-process.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/invalid/original-rejection.stderr.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  synthetic/invalid/original-rejection.stdout.log
+780f4b54868527db6e074f55e6da9fe712c06b03926ab431561db53a513855ed  synthetic/invalid/original-rejections.json
+df5b094bd8d43b0705637dafdc3091b1e98e4c6bc331fed6279b6662e883f157  synthetic/invalid/reference-sources.json
+8dd58cb8ac90040ef0b9c747b2225fa7c0f905ce6f5dd4042aef457d6b1e213d  synthetic/manifest.json
+6bdd7589b203aaf0ec4e112657f538dd8bfe6b68d0e871af7e44bdaf2ae8e358  synthetic/selection.json
+5000b9ed536ab7cbed1da8622d728410135d3543faa9ae5f517d348d9dc12774  synthetic/template-binding.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  upgrade-candidate-pip.stderr.log
+c99ae4b96c48cb984b85f7897c6ff7e5ac9896fbbb62cbab17551254e058c082  upgrade-candidate-pip.stdout.log
+b966ace3825626c4b7f450f0a8f6489794b67af39c6ce878bb6546da7db45d1a  upload-location-copies/export_fixtures.py
+15c46f3cbd7e4c5cf1b889150c2d142842e867af8a961dce2fe3537207999a99  upload-location-copies/launch_job.py
+68ea78f61408fc799a8f08fa644120660cac36b9920df1c91a0b6b57692ea58a  upload-location-copies/test_export_fixtures.py
+3fb541a53d69399e03bda0af8e02360f6e1d0471d8fdd35b6473435e0c71e95c  v100a-01/authority.json
+c20f28de4aefb3d08aa9f75699d34d620dd5097fe99c6b1b8297a3359e1e49c6  v100a-01/failure.json
+88803dac0aba8ae4d190e6582ac142a9eb7499c6f0f6d4794b336f0bcd8732fc  v100a-02/authority.json
+5593a3b06be42553cff08c9c219953efd33cdb6f21ae7c573d592b4d10139635  v100a-02/fixtures--00-cs_only.json
+ce484754b351f96e453b45f42f2686b7e7165ce7ff5ab9b175dd1120c7264db0  v100a-02/fixtures--01-cs_only.json
+efe694f3b3f712aa25019b2b5d57f369a684909f0e0e7c14040297362b746aa2  v100a-02/fixtures--02-d_zero.json
+0513bbc6b466e9bc5b28637e8758f6a74bdb0abb6995f0b258649376a270dba8  v100a-02/fixtures--03-d_zero.json
+b0c9eeeb6624c815dc44052137eb269389a4d18bdac86bcc52a85347a6398f9a  v100a-02/fixtures--04-dan_only.json
+dec6238ff5936c95208793dfc61cd11ac044db9f99102fcc78b1a9cf27d5a49e  v100a-02/fixtures--05-dan_only.json
+c0508088d8d9a52fb6872f9057315eec312f37631f163917a8aa168847671b43  v100a-02/fixtures--06-frozen.json
+5eb1b1cd764ab0349d7336f91040878912a8bd7fc01fabfa363fe9a600527fe0  v100a-02/fixtures--07-frozen.json
+705ae0a21c3f0e364d8e0d4314920becee92524e64ef46bf3e7becf0d5d0d271  v100a-02/fixtures--08-paired.json
+6035b5551465850eb413a26fd1fc68e5b572b083fe5bb0d5f9f39eaa796a9544  v100a-02/fixtures--09-paired.json
+85ee73e7d0b15d0f37fd651d3c3cfe683559a4a03ddf4d8f71638dac382d85d4  v100a-02/fixtures--10-random_reward.json
+a3503de7e99edd5215b241184375748e68f9e62e487c50d97e640ff0b6f272b8  v100a-02/fixtures--11-random_reward.json
+c3f160b79dbd81e3ef2032ead3075e401769c12940161e5fa077b20a81ab26a2  v100a-02/fixtures--12-unpaired.json
+4383c2d5fede73b899bf93ea902ba7606b2ae9ac8244554e8feb86e7b51ec797  v100a-02/fixtures--13-unpaired.json
+d06c602fc1950f1f63f7b79e98e3fbeef2a291811c91fc7ffdaab5acfd9ea3f4  v100a-02/invalid-input-rejections.json
+221095febd8af92e5aba4663c82da8826578d7480b5bea9e08c008972986b164  v100a-02/summary.json
+e81efce736479c5c8af66ed284887b6f56f0cbf6e63991be7340406ca27c1d7f  v100a-02/synthetic--00-empty-us900.json
+91e42ae01d7bf35a378418c55c10395b3f1f5dfe6e65f56b5882f19a164bc520  v100a-02/synthetic--01-non-kc-only.json
+cdcc411aedf73b30bb76425ace04f4cc634f7e60e5284b7e62104bafc3282f5c  v100a-02/synthetic--02-no-us-mixed.json
+696599852b8b06c53614c8bc561bcae1fdcecef3d9f5c1a3702a7065c157db82  v100a-02/synthetic--03-us-first-tick.json
+cd2e079e7ef0b2e59056f4f57dc0cdaa0e37e969a516e3da5b0774864a6c86bb  v100a-02/synthetic--04-us-final-tick.json
+292a576dab1f516f853cd61401689363688cb19c668ad6de2a8ab2d1a14bc08c  v100a-02/synthetic--05-before-on-after-us900.json
+f377a37d6a92d1d04942eeb7401a186086fa6e83394f291bef13ea8ed43afdd3  v100a-02/synthetic--06-d-zero-existing-delta.json
+e649e330f5f949466ab100e269f2bc775f20373e711ff0deedf35c3410fda527  v100a-02/synthetic--07-frozen-existing-delta.json
+2764345af2d74bc4471012595613fc685aaeab206864e92c14273f7b62109a6b  v100a-02/synthetic--08-compartment-0.json
+59fcb0ddc9632392859126c0a32026df8b549c3a0135c38c30749424bf5ac42a  v100a-02/synthetic--09-compartment-1.json
+8fe48a6458c343a484731ac557069d82cdce0658bcfd3fc76ffbbcd2df81fd17  v100a-02/synthetic--10-compartment-2.json
+4b1667dfd7eece57a98e7217f25837084622d24408c10904044a54c3f3c392c1  v100a-02/synthetic--11-compartment-3.json
+af893b9f83a29be3481eb37d052d224f1a57a5ab9f1cc5e6b1915f26129b17a6  v100a-02/synthetic--12-already-at-floor.json
+37c18dbc87865f4e56731298e9c46268f3980f20e6af8a365f5d07ef14e0e1dc  v100a-02/synthetic--13-one-ulp-above-floor.json
+c1df69852fdcb21e06f733b965b0ed810fda06d6500ddb454a0b5e26fab37ba7  v100a-02/synthetic--14-seeded-sparse-717.json
+b92d52939eb56b79c630af5088990f669422af2f3aaac358ebb66a72336538fd  v100a-02/synthetic--15-seeded-sparse-20261001.json
+64cb0be8d51813d6415fd650936dc4763f408ebe103c0c552b707afbb5e2dc1f  v100b-01/authority.json
+724bcb80d05bca9bc15b42cbaba2838ba5fbb1445400f8c5085febb2d71591a9  v100b-01/fixtures--00-cs_only.json
+a9f96c0493301d603dbdaab5a52fbe069c9f51f164ee11007db897e2af387ff1  v100b-01/fixtures--01-cs_only.json
+fe5c0069357004aeb18304b3b4e6e987aaf4e206479cd9f7315829f0ebcf12ef  v100b-01/fixtures--02-d_zero.json
+78fc226e1d4c7baaf3d3fd005344e6d9589df71cfec8e540c0aa2f196e5c0fbc  v100b-01/fixtures--03-d_zero.json
+058b7f31e3c381232cd505bebc4af2d4b3edf6f508172daf32b11f4cb4cbb32e  v100b-01/fixtures--04-dan_only.json
+0098aadabd51941d24383fc28770191709ecf28970b9118b0584d90a8de08e60  v100b-01/fixtures--05-dan_only.json
+d735f73a811bf2329d89bb5bc9b790d5c97f7fb955d97c5f7cc4583f3da66b62  v100b-01/fixtures--06-frozen.json
+9ce5dd746d0bce1b76b61254f38a6c11cd142a4e3c5c392a23119923d4d6d405  v100b-01/fixtures--07-frozen.json
+7d0023c2493cc6237dfe5c4afaf4f09cd599b7d8203506f031a9829cf34f82df  v100b-01/fixtures--08-paired.json
+fc8f9d8b7d65ddf5091a996775750391401e6c39ca0bba1ae72c85d0f93312c2  v100b-01/fixtures--09-paired.json
+5b94b2a06012f4fe1d8c5a9dc1afa8f84599f437050c90195698b46fe9cbc6ea  v100b-01/fixtures--10-random_reward.json
+49a03a0c4083013a12150a2e5e8183fdd07dc52aa86cebc0202878238723560e  v100b-01/fixtures--11-random_reward.json
+8bb0190a0d8127a98e2a2ab666bd0088d2e980ec551dcada3c19f36c4aef25c7  v100b-01/fixtures--12-unpaired.json
+62dd935445e76dd74922134633212d035b2f0fc838c63c504e6b54b46d02ed92  v100b-01/fixtures--13-unpaired.json
+d06c602fc1950f1f63f7b79e98e3fbeef2a291811c91fc7ffdaab5acfd9ea3f4  v100b-01/invalid-input-rejections.json
+efec9a44ffd1ef441152cc091b3a4801aa0ca11fafd25e8ff41f3a652bad56e7  v100b-01/summary.json
+ddac272c00c4b59ba1655aebad95a714986447bb600ac71513fed8221bcd098a  v100b-01/synthetic--00-empty-us900.json
+cd1f3f2d2c356e142c84719ceea224e2e7656871fc4640a906d5f899e813e40f  v100b-01/synthetic--01-non-kc-only.json
+8e4bbaaef9c0ed1a2bb15030a9f63cc25b15904a106d1f86d0df67f15855cbe8  v100b-01/synthetic--02-no-us-mixed.json
+c9cebe2da04e389aa447b9d7a963a41abd00483f0aa3a5ab8056af4ae6d3d811  v100b-01/synthetic--03-us-first-tick.json
+5abeff90afc27c87f85d614c49a641bb30f43e5baa4ce8af83689113c7cb0d23  v100b-01/synthetic--04-us-final-tick.json
+4c1e6459fc79173bd1b4632cae85952814a8830bb47b2df1400edc28be7ba2be  v100b-01/synthetic--05-before-on-after-us900.json
+c6d4ad242e5b161d4313e35afc1c6bb43eb7609a5e940cad228c5e9ba767460b  v100b-01/synthetic--06-d-zero-existing-delta.json
+69fa71c05cc8b7225c30a281cfed8d996c0aa936df03f3f2e202906ad96fc3f7  v100b-01/synthetic--07-frozen-existing-delta.json
+27584931bf81f1f7626315913f3603f65f3312a0261b168df9eea8719cb181db  v100b-01/synthetic--08-compartment-0.json
+1ae17daa8f3972eed7d0a7be0471da24c1068b62187dee0117d1175ca605ccaf  v100b-01/synthetic--09-compartment-1.json
+0392356066c68924c4c06a9b0fac47a7bef87f8feb7a20bb36e55dcd6984e7d0  v100b-01/synthetic--10-compartment-2.json
+893e197df233d6a14c509d6d76b1d1f22b7c5e0ea5d293e735b7779c8144019e  v100b-01/synthetic--11-compartment-3.json
+cc643dbc8a39fe62f08bd16019036ceeb155b95e08990b5698ea2d60f2c1e42e  v100b-01/synthetic--12-already-at-floor.json
+181b158d1acf072259b4be3a33e61602180193119cd34947919b38d64d0af1c8  v100b-01/synthetic--13-one-ulp-above-floor.json
+a4b60169a9a2400196207fa3fea8f85ee554725cddaefa7acb23f5bd7b7693ee  v100b-01/synthetic--14-seeded-sparse-717.json
+e144a917aea30f01be01fd623f5437535211d4a4a4fe407f4fa8d17652033963  v100b-01/synthetic--15-seeded-sparse-20261001.json
+6efdec34c96cdc79f786b91bd7a99b0e8ef64d0c4dcfa525646c82659a77d44f  artifact-manifest.json

registry/acceleration-20261001/gpu/final-summary.json

@@ -0,0 +1,160 @@
+{
+  "benchmark_candidate_commit": "221e1f13f758ebe8d9f188bab976c361f7cacf45",
+  "created_utc": "2026-10-01T06:43:12.585942+00:00",
+  "devices": [
+    {
+      "benchmark_wall_seconds": 3.823799389999749,
+      "bitwise_exact": true,
+      "context_initialization_seconds": 0.21562433999997666,
+      "cpu_baseline_sample_warning": "One cold plus ONE warm original API sample per fixture; GPU 3 warmups +20 repeats per fixture.",
+      "device": {
+        "compute_capability": "70",
+        "cupy_version": "13.6.0",
+        "driver_version": "580.178.04",
+        "driver_version_runtime": 13000,
+        "initialization_seconds": 0.21562433999997666,
+        "memory_total_mib": "16384",
+        "memory_used_mib": "918",
+        "name": "Tesla V100-SXM2-16GB",
+        "numpy_version": "2.2.6",
+        "pci_bus_id": "00000000:24:00.0",
+        "python_version": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]",
+        "runtime_name": "Tesla V100-SXM2-16GB",
+        "runtime_pci_bus_id": "0000:24:00.0",
+        "runtime_version": 12090,
+        "utilization_percent": "0",
+        "uuid": "GPU-a745fd30-4ca8-2370-09f6-2d374ac866dc"
+      },
+      "first_use_compile_seconds": 0.5175303470000472,
+      "invalid_inputs_rejected": 6,
+      "mean_real_fixture_candidate_replay_seconds": 0.0030653400000021846,
+      "median_real_fixture_candidate_replay_seconds": 0.0034301260000120237,
+      "median_real_fixture_cpu_cold_update_api_seconds": 1.3763328334998732,
+      "median_real_fixture_cpu_original_update_api_seconds": 0.10878832900016278,
+      "median_real_fixture_resident_kernel_seconds": 0.00012198399752378464,
+      "observed_cuda_pool_reserved_peak_bytes": 367616,
+      "original_update_api_to_candidate_replay_ratio": 31.81186385112393,
+      "positive_fixtures": 30,
+      "ratio_warning": "Different API overhead boundaries: original U checks/AST every call; candidate authenticates sources/mapping once. NOT pure CPU/GPU hardware ratio.",
+      "real_fixture_count": 14,
+      "result_sha256": "221095febd8af92e5aba4663c82da8826578d7480b5bea9e08c008972986b164",
+      "run": "v100a-02"
+    },
+    {
+      "benchmark_wall_seconds": 3.6053910950004138,
+      "bitwise_exact": true,
+      "context_initialization_seconds": 0.21543903399970077,
+      "cpu_baseline_sample_warning": "One cold plus ONE warm original API sample per fixture; GPU 3 warmups +20 repeats per fixture.",
+      "device": {
+        "compute_capability": "70",
+        "cupy_version": "13.6.0",
+        "driver_version": "580.178.04",
+        "driver_version_runtime": 13000,
+        "initialization_seconds": 0.21543903399970077,
+        "memory_total_mib": "16384",
+        "memory_used_mib": "312",
+        "name": "Tesla V100-SXM2-16GB",
+        "numpy_version": "2.2.6",
+        "pci_bus_id": "00000000:25:00.0",
+        "python_version": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]",
+        "runtime_name": "Tesla V100-SXM2-16GB",
+        "runtime_pci_bus_id": "0000:25:00.0",
+        "runtime_version": 12090,
+        "utilization_percent": "0",
+        "uuid": "GPU-0f0ff6ed-bf1f-50ea-c244-b4566eccc66a"
+      },
+      "first_use_compile_seconds": 0.34027977499999906,
+      "invalid_inputs_rejected": 6,
+      "mean_real_fixture_candidate_replay_seconds": 0.002988729749956422,
+      "median_real_fixture_candidate_replay_seconds": 0.0033436992500810447,
+      "median_real_fixture_cpu_cold_update_api_seconds": 1.3763328334998732,
+      "median_real_fixture_cpu_original_update_api_seconds": 0.10878832900016278,
+      "median_real_fixture_resident_kernel_seconds": 0.00012160000205039978,
+      "observed_cuda_pool_reserved_peak_bytes": 367616,
+      "original_update_api_to_candidate_replay_ratio": 32.71325311168391,
+      "positive_fixtures": 30,
+      "ratio_warning": "Different API overhead boundaries: original U checks/AST every call; candidate authenticates sources/mapping once. NOT pure CPU/GPU hardware ratio.",
+      "real_fixture_count": 14,
+      "result_sha256": "efec9a44ffd1ef441152cc091b3a4801aa0ca11fafd25e8ff41f3a652bad56e7",
+      "run": "v100b-01"
+    },
+    {
+      "benchmark_wall_seconds": 3.542117918999793,
+      "bitwise_exact": true,
+      "context_initialization_seconds": 0.24383461099978376,
+      "cpu_baseline_sample_warning": "One cold plus ONE warm original API sample per fixture; GPU 3 warmups +20 repeats per fixture.",
+      "device": {
+        "compute_capability": "89",
+        "cupy_version": "13.6.0",
+        "driver_version": "580.178.04",
+        "driver_version_runtime": 13000,
+        "initialization_seconds": 0.24383461099978376,
+        "memory_total_mib": "49140",
+        "memory_used_mib": "396",
+        "name": "NVIDIA GeForce RTX 4090",
+        "numpy_version": "2.2.6",
+        "pci_bus_id": "00000000:81:00.0",
+        "python_version": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]",
+        "runtime_name": "NVIDIA GeForce RTX 4090",
+        "runtime_pci_bus_id": "0000:81:00.0",
+        "runtime_version": 12090,
+        "utilization_percent": "0",
+        "uuid": "GPU-79f3a85d-adce-7833-7003-6488140ca596"
+      },
+      "first_use_compile_seconds": 0.3366978859999108,
+      "invalid_inputs_rejected": 6,
+      "mean_real_fixture_candidate_replay_seconds": 0.002947911642812479,
+      "median_real_fixture_candidate_replay_seconds": 0.00332674724984372,
+      "median_real_fixture_cpu_cold_update_api_seconds": 1.3763328334998732,
+      "median_real_fixture_cpu_original_update_api_seconds": 0.10878832900016278,
+      "median_real_fixture_resident_kernel_seconds": 7.372800260782241e-05,
+      "observed_cuda_pool_reserved_peak_bytes": 367616,
+      "original_update_api_to_candidate_replay_ratio": 32.80226555755503,
+      "positive_fixtures": 30,
+      "ratio_warning": "Different API overhead boundaries: original U checks/AST every call; candidate authenticates sources/mapping once. NOT pure CPU/GPU hardware ratio.",
+      "real_fixture_count": 14,
+      "result_sha256": "377cb655e5b6e5816ccca3b5a03c481021afc3da64879af9be72c207e88639c7",
+      "run": "rtx4090-01"
+    }
+  ],
+  "fixes_preserved": [
+    "Initial candidate pip22 lacked--report; upgraded pip only in new venv",
+    "First GPU compile rejected conflictingFTZ options; no kernel executed; explicit nvcc compilation retains original precision"
+  ],
+  "frozen_integrity": {
+    "bytes_checked": 3103901058,
+    "created_utc": "2026-10-01T06:43:10.470895+00:00",
+    "file_mismatches": [],
+    "files_checked": 64034,
+    "inventory_sha256": "d7b675b0d0d4647d8fe2fcf9616b9a599e5bc3c15565e604e0d66a046afb835a",
+    "original_experiment_resumed": false,
+    "original_git_head": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+    "original_git_status": "",
+    "probes_completed_unchanged": 138,
+    "registered_science_commit": "80aeb2093db655329774eff7b32fb6e417b8b40b",
+    "registration_sha256": "b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740",
+    "scope": "Saved Phase4AR experiment/control files and registered source files; NOT a new Phase1-4AQ numerical regression",
+    "source_mismatches": [],
+    "sources_checked": 16,
+    "status": "PASS",
+    "training_epochs_cpu_verified_unchanged": 1033,
+    "wall_seconds": 4.8638160139998945
+  },
+  "full_brain_gpu_event_equivalence_tested": false,
+  "full_training_acceleration_measured": false,
+  "learned_candidate_created": false,
+  "limitations": [
+    "Replay module only, not a production training backend",
+    "The sampled committed prefix covers7arms but only available physiological/PAM15/reinforce_A subset",
+    "Repeated kernel calculations reset state and replay identical saved inputs, not additional learning trials",
+    "Original CPU verification remains independent and required",
+    "No simultaneous two-V100 training/scheduling benchmark; devices tested separately",
+    "Original9.07-day estimate is not replaced by this component benchmark"
+  ],
+  "next_work": "Separately validate persistent training/update/verification workers and complete chain timing before authorizing a new scientific execution version",
+  "original_experiment_resumed": false,
+  "report_code_commit": "221e1f13f758ebe8d9f188bab976c361f7cacf45",
+  "scientific_experiment_status": "STOPPED, unchanged:1033/30000 CPU-verified training epochs and138/3920 probes",
+  "status": "PASS-ELIGIBILITY-UPDATE-REPLAY-EQUIVALENCE",
+  "weights_installed": false
+}

registry/acceleration-20261001/pack-verification.json

@@ -0,0 +1,21 @@
+{
+  "catalog_sha256": "28071f276848ea60149f21a9794653486b404670a58b34d97b1aaae742095245",
+  "groups": {
+    "gpu": {
+      "archive_bytes": 1679158,
+      "files": 614,
+      "original_bytes": 13242628,
+      "sha256": "50acdc85342a2c79c3516e50ee4542b909813d179518451edaaf2d94150c534b",
+      "verified": true
+    },
+    "pipeline": {
+      "archive_bytes": 74767927,
+      "files": 1066,
+      "original_bytes": 103062185,
+      "sha256": "fdc39013d71fb7d14313d8249c929601a8a7050cc2eac88b733d692bbe1b6b42",
+      "verified": true
+    }
+  },
+  "pass_all": true,
+  "verification": "Full streamed members, no extraction or model execution"
+}

registry/acceleration-20261001/pipeline/RESULTS.md

@@ -0,0 +1,31 @@
+# 常驻进程工程回放结果
+
+状态：`PASS-PERSISTENT-REPLAY-EQUIVALENCE`。仅限这次固定回放，不代表学习成功或正式运行时升级。
+
+## 实测
+
+| 测量范围 | 新进程 | 常驻进程 | 说明 |
+|---|---:|---:|---|
+| 原始 CPU 更新 API | 1.3480 s | 0.1182 s | 新进程首次 API 包含导入等开销 |
+| 完整更新 API，同一固定案例 | 3.7089 s | 2.3424 s | 仅一组冷启动对照 |
+| 全脑原始运行函数，13 组配对中位数 | 5.9825 s | 3.7222 s | 含原有输出；排除固定首例的初始化 |
+
+完整更新常驻 14 组中位耗时：2.3483 s。
+完整独立验证仍需：3.6435 s（14 组中位数）。
+全脑运行函数同案例配对倍率中位数：1.620×，不是整轮训练加速倍率。
+
+## 一致性与保护
+
+- 17 项主机测试通过。
+- CPU：14 次冷启动更新、42 次独立双进程更新/重算、29 次完整更新、14 次完整独立验证通过。
+- 全脑：14 次新进程、正序 14 次与逆序 14 次常驻回放；所有脉冲、状态、延迟队列和请求等一致，10 个数组逐位相同。
+- 64,034 个原实验文件与 16 个注册源码重新校验通过；之前 659 个加速产物和 13 个源码保持不变。
+- 原 Phase4AR 仍停止于 1,033 轮 CPU 校验训练与 138 次 probe，没有新增训练或安装新权重。
+
+## 边界与下一步
+
+本次全脑测试使用原 RTX 4090 环境，没有证明全脑已能迁移到 V100。此前 V100 约 3.4 ms 的成绩仅属于 eligibility/update 模块。
+常驻进程复用的是解释器、模块和 CUDA 上下文；每轮神经状态仍由原始函数重新分配。
+当前仍保留完整验证、图和权重上传、记录写盘。下一步应在新的可审计流水线中验证整轮开销，不能把本报告的独立阶段相加当作实测训练速度。
+
+源码提交：`018f038c7857c7e0236dd7408a680458520d92ce`。完整逐例耗时、实际进程退出、来源校验见 `final-summary.json` 和各 lane 报告。

registry/acceleration-20261001/pipeline/final-summary.json

@@ -0,0 +1,532 @@
+{
+  "brain_matched_pairs": [
+    {
+      "first_fixture_cold_build_and_context": true,
+      "fixed_index": 0,
+      "fixture_id": "00-cs_only",
+      "fresh_runtime_seconds": 65.35286720699969,
+      "fresh_simulation_seconds": 2.614504967999892,
+      "fresh_trial_wall_seconds": 67.3396666159997,
+      "resident_runtime_seconds": 4.829426256000261,
+      "resident_simulation_seconds": 2.4258526345001883,
+      "resident_trial_wall_seconds": 7.01521050700012,
+      "runtime_ratio": 13.532221788416964,
+      "trial_wall_ratio": 9.599094218028796
+    },
+    {
+      "first_fixture_cold_build_and_context": false,
+      "fixed_index": 1,
+      "fixture_id": "01-cs_only",
+      "fresh_runtime_seconds": 5.984003917999871,
+      "fresh_simulation_seconds": 2.593902593999701,
+      "fresh_trial_wall_seconds": 8.017140279999694,
+      "resident_runtime_seconds": 3.7571635549998064,
+      "resident_simulation_seconds": 2.295868848999362,
+      "resident_trial_wall_seconds": 5.915995811999892,
+      "runtime_ratio": 1.5926918885489347,
+      "trial_wall_ratio": 1.355163278469177
+    },
+    {
+      "first_fixture_cold_build_and_context": false,
+      "fixed_index": 2,
+      "fixture_id": "02-d_zero",
+      "fresh_runtime_seconds": 5.9979634660003285,
+      "fresh_simulation_seconds": 2.5769733950000955,
+      "fresh_trial_wall_seconds": 8.022121797000182,
+      "resident_runtime_seconds": 3.751296795000144,
+      "resident_simulation_seconds": 2.2797322554997663,
+      "resident_trial_wall_seconds": 5.890771792999658,
+      "runtime_ratio": 1.5989040040752356,
+      "trial_wall_ratio": 1.3618116740718642
+    },
+    {
+      "first_fixture_cold_build_and_context": false,
+      "fixed_index": 3,
+      "fixture_id": "03-d_zero",
+      "fresh_runtime_seconds": 5.982476725000197,
+      "fresh_simulation_seconds": 2.5773725859999104,
+      "fresh_trial_wall_seconds": 8.00832260900006,
+      "resident_runtime_seconds": 3.7547762260001036,
+      "resident_simulation_seconds": 2.319585893000294,
+      "resident_trial_wall_seconds": 5.895358800500162,
+      "runtime_ratio": 1.5932978065574956,
+      "trial_wall_ratio": 1.358411401240012
+    },
+    {
+      "first_fixture_cold_build_and_context": false,
+      "fixed_index": 4,
+      "fixture_id": "04-dan_only",
+      "fresh_runtime_seconds": 4.749538970000685,
+      "fresh_simulation_seconds": 1.3650442850002946,
+      "fresh_trial_wall_seconds": 6.727319513999646,
+      "resident_runtime_seconds": 2.529837508000128,
+      "resident_simulation_seconds": 1.1021227920000456,
+      "resident_trial_wall_seconds": 4.626612702999864,
+      "runtime_ratio": 1.877408709049959,
+      "trial_wall_ratio": 1.4540485547099495
+    },
+    {
+      "first_fixture_cold_build_and_context": false,
+      "fixed_index": 5,
+      "fixture_id": "05-dan_only",
+      "fresh_runtime_seconds": 4.794270962000155,
+      "fresh_simulation_seconds": 1.3635098229997311,
+      "fresh_trial_wall_seconds": 6.785381824000069,
+      "resident_runtime_seconds": 2.5495016239997312,
+      "resident_simulation_seconds": 1.0964573165001639,
+      "resident_trial_wall_seconds": 4.630903192000005,
+      "runtime_ratio": 1.8804737823538882,
+      "trial_wall_ratio": 1.4652394020505497
+    },
+    {
+      "first_fixture_cold_build_and_context": false,
+      "fixed_index": 6,
+      "fixture_id": "06-frozen",
+      "fresh_runtime_seconds": 5.943664408000586,
+      "fresh_simulation_seconds": 2.537586863000797,
+      "fresh_trial_wall_seconds": 7.968554020000738,
+      "resident_runtime_seconds": 3.739337917499597,
+      "resident_simulation_seconds": 2.274588298999788,
+      "resident_trial_wall_seconds": 5.863817397000275,
+      "runtime_ratio": 1.5894964667902942,
+      "trial_wall_ratio": 1.3589362492899544
+    },
+    {
+      "first_fixture_cold_build_and_context": false,
+      "fixed_index": 7,
+      "fixture_id": "07-frozen",
+      "fresh_runtime_seconds": 6.110534065999673,
+      "fresh_simulation_seconds": 2.582069095999941,
+      "fresh_trial_wall_seconds": 8.228193209999517,
+      "resident_runtime_seconds": 3.7222462010004165,
+      "resident_simulation_seconds": 2.302735479000148,
+      "resident_trial_wall_seconds": 5.8500312219998705,
+      "runtime_ratio": 1.641625442281965,
+      "trial_wall_ratio": 1.4065212471099697
+    },
+    {
+      "first_fixture_cold_build_and_context": false,
+      "fixed_index": 8,
+      "fixture_id": "08-paired",
+      "fresh_runtime_seconds": 6.045053863999783,
+      "fresh_simulation_seconds": 2.56315154099957,
+      "fresh_trial_wall_seconds": 8.07308078099959,
+      "resident_runtime_seconds": 3.7187771884996437,
+      "resident_simulation_seconds": 2.292921604500407,
+      "resident_trial_wall_seconds": 5.844987367499925,
+      "runtime_ratio": 1.6255488182228754,
+      "trial_wall_ratio": 1.381197301792063
+    },
+    {
+      "first_fixture_cold_build_and_context": false,
+      "fixed_index": 9,
+      "fixture_id": "09-paired",
+      "fresh_runtime_seconds": 6.0329436539996095,
+      "fresh_simulation_seconds": 2.578432846999931,
+      "fresh_trial_wall_seconds": 8.06702318600037,
+      "resident_runtime_seconds": 3.752024064000125,
+      "resident_simulation_seconds": 2.3125394145004066,
+      "resident_trial_wall_seconds": 5.875522780999745,
+      "runtime_ratio": 1.6079171005016797,
+      "trial_wall_ratio": 1.3729881555540036
+    },
+    {
+      "first_fixture_cold_build_and_context": false,
+      "fixed_index": 10,
+      "fixture_id": "10-random_reward",
+      "fresh_runtime_seconds": 5.9459936279999965,
+      "fresh_simulation_seconds": 2.5486168549996364,
+      "fresh_trial_wall_seconds": 7.969415038999614,
+      "resident_runtime_seconds": 3.741656974500529,
+      "resident_simulation_seconds": 2.2819819735000237,
+      "resident_trial_wall_seconds": 5.869267663999835,
+      "runtime_ratio": 1.5891338165208806,
+      "trial_wall_ratio": 1.3578210255908747
+    },
+    {
+      "first_fixture_cold_build_and_context": false,
+      "fixed_index": 11,
+      "fixture_id": "11-random_reward",
+      "fresh_runtime_seconds": 6.022653824999907,
+      "fresh_simulation_seconds": 2.577513352999631,
+      "fresh_trial_wall_seconds": 8.047795367000617,
+      "resident_runtime_seconds": 3.7174769284997637,
+      "resident_simulation_seconds": 2.3056816289999915,
+      "resident_trial_wall_seconds": 5.856069947500146,
+      "runtime_ratio": 1.6200917829046022,
+      "trial_wall_ratio": 1.3742655806965012
+    },
+    {
+      "first_fixture_cold_build_and_context": false,
+      "fixed_index": 12,
+      "fixture_id": "12-unpaired",
+      "fresh_runtime_seconds": 4.770189471999402,
+      "fresh_simulation_seconds": 1.3640906330001599,
+      "fresh_trial_wall_seconds": 6.746124274999602,
+      "resident_runtime_seconds": 2.5186805469998035,
+      "resident_simulation_seconds": 1.1082154464997984,
+      "resident_trial_wall_seconds": 4.599120383999889,
+      "runtime_ratio": 1.8939239744720884,
+      "trial_wall_ratio": 1.4668292437982342
+    },
+    {
+      "first_fixture_cold_build_and_context": false,
+      "fixed_index": 13,
+      "fixture_id": "13-unpaired",
+      "fresh_runtime_seconds": 4.788546644000235,
+      "fresh_simulation_seconds": 1.3511515399995915,
+      "fresh_trial_wall_seconds": 6.774379648000831,
+      "resident_runtime_seconds": 2.5566162760001134,
+      "resident_simulation_seconds": 1.1084074525001597,
+      "resident_trial_wall_seconds": 4.625984206500107,
+      "runtime_ratio": 1.8730017050083203,
+      "trial_wall_ratio": 1.4644191042593597
+    }
+  ],
+  "brain_steady_13_fixture_summary": {
+    "fresh_runtime_seconds": {
+      "count": 13,
+      "maximum": 6.110534065999673,
+      "mean": 5.628294892461572,
+      "median": 5.982476725000197,
+      "minimum": 4.749538970000685,
+      "total": 73.16783360200043
+    },
+    "fresh_simulation_seconds": {
+      "count": 13,
+      "maximum": 2.593902593999701,
+      "mean": 2.198416570076845,
+      "median": 2.56315154099957,
+      "minimum": 1.3511515399995915,
+      "total": 28.57941541099899
+    },
+    "fresh_trial_wall_seconds": {
+      "count": 13,
+      "maximum": 8.228193209999517,
+      "mean": 7.648834734615425,
+      "median": 8.00832260900006,
+      "minimum": 6.727319513999646,
+      "total": 99.43485155000053
+    },
+    "resident_runtime_seconds": {
+      "count": 13,
+      "maximum": 3.7571635549998064,
+      "mean": 3.3699532157692236,
+      "median": 3.7222462010004165,
+      "minimum": 2.5186805469998035,
+      "total": 43.809391804999905
+    },
+    "resident_simulation_seconds": {
+      "count": 13,
+      "maximum": 2.319585893000294,
+      "mean": 1.9292952618846426,
+      "median": 2.2819819735000237,
+      "minimum": 1.0964573165001639,
+      "total": 25.080838404500355
+    },
+    "resident_trial_wall_seconds": {
+      "count": 13,
+      "maximum": 5.915995811999892,
+      "mean": 5.4880340976922595,
+      "median": 5.856069947500146,
+      "minimum": 4.599120383999889,
+      "total": 71.34444326999937
+    },
+    "runtime_ratio": {
+      "count": 13,
+      "maximum": 1.8939239744720884,
+      "mean": 1.69103963825294,
+      "median": 1.6200917829046022,
+      "minimum": 1.5891338165208806,
+      "total": 21.98351529728822
+    },
+    "trial_wall_ratio": {
+      "count": 13,
+      "maximum": 1.4668292437982342,
+      "mean": 1.3982809398948086,
+      "median": 1.3742655806965012,
+      "minimum": 1.355163278469177,
+      "total": 18.177652218632513
+    }
+  },
+  "cpu_regression": {
+    "cold_U": 14,
+    "full_AQ_on_new_E_outputs": 14,
+    "full_E_cold": 1,
+    "full_E_resident": 28,
+    "host_tests": 17,
+    "resident_update_plus_independent_verification": 42
+  },
+  "cpu_summary": {
+    "cold_U_API_seconds": {
+      "count": 14,
+      "maximum": 1.3637360310003714,
+      "mean": 1.349338465785747,
+      "median": 1.3479703455000163,
+      "minimum": 1.3283745310000086,
+      "sum": 18.890738521000458
+    },
+    "cold_U_subprocess_wall_seconds": {
+      "count": 14,
+      "maximum": 1.8981196659997295,
+      "mean": 1.885562129142792,
+      "median": 1.8844832749996385,
+      "minimum": 1.8637141089993747,
+      "sum": 26.397869807999086
+    },
+    "cold_input_load_verify_seconds": {
+      "count": 14,
+      "maximum": 0.010746739999376587,
+      "mean": 0.009368129571612371,
+      "median": 0.00954562650031221,
+      "minimum": 0.008100717999695917,
+      "sum": 0.1311538140025732
+    },
+    "cold_worker_startup_wall_seconds": {
+      "count": 14,
+      "maximum": 0.10847249400012515,
+      "mean": 0.10693613914281741,
+      "median": 0.10691448550051064,
+      "minimum": 0.10573622599986265,
+      "sum": 1.4971059479994437
+    },
+    "original_full_AQ_subprocess_wall_seconds": {
+      "count": 14,
+      "maximum": 3.668942025999968,
+      "mean": 3.643564634214207,
+      "median": 3.6435176954996678,
+      "minimum": 3.618401282999912,
+      "sum": 51.009904878998896
+    },
+    "original_full_E_cold_first_API_seconds": 3.7089290359999723,
+    "original_full_E_cold_first_process_wall_seconds": 4.24782893199972,
+    "original_full_E_warm_API_seconds": {
+      "count": 14,
+      "maximum": 2.4132408899995426,
+      "mean": 2.3535953922856345,
+      "median": 2.3438503964998745,
+      "minimum": 2.2940232779992584,
+      "sum": 32.950335491998885
+    },
+    "original_full_E_warm_roundtrip_seconds": {
+      "count": 14,
+      "maximum": 2.4179386750001868,
+      "mean": 2.358171566214488,
+      "median": 2.348314214000311,
+      "minimum": 2.2985241940004926,
+      "sum": 33.01440192700284
+    },
+    "resident_warm_U_API_seconds": {
+      "count": 28,
+      "maximum": 0.17676272300013807,
+      "mean": 0.13507185135706226,
+      "median": 0.11820473399984621,
+      "minimum": 0.11332106000008935,
+      "sum": 3.782011837997743
+    },
+    "resident_warm_pair_roundtrip_seconds": {
+      "count": 28,
+      "maximum": 0.3602939359998345,
+      "mean": 0.27662439482141316,
+      "median": 0.24055810749996454,
+      "minimum": 0.22945901599996432,
+      "sum": 7.745483054999568
+    },
+    "resident_warm_verify_API_seconds": {
+      "count": 28,
+      "maximum": 0.17938798499926634,
+      "mean": 0.13211264517862478,
+      "median": 0.1128409300004023,
+      "minimum": 0.10732271400047466,
+      "sum": 3.699154065001494
+    }
+  },
+  "created_utc": "2026-10-01T07:19:11.514183+00:00",
+  "first_brain_fixture": {
+    "first_fixture_cold_build_and_context": true,
+    "fixed_index": 0,
+    "fixture_id": "00-cs_only",
+    "fresh_runtime_seconds": 65.35286720699969,
+    "fresh_simulation_seconds": 2.614504967999892,
+    "fresh_trial_wall_seconds": 67.3396666159997,
+    "resident_runtime_seconds": 4.829426256000261,
+    "resident_simulation_seconds": 2.4258526345001883,
+    "resident_trial_wall_seconds": 7.01521050700012,
+    "runtime_ratio": 13.532221788416964,
+    "trial_wall_ratio": 9.599094218028796
+  },
+  "fixture_manifest_sha256": "481df128d39bf28e5984a6f2e5757f83d45cb7a6136f8d2843ecc0a67eca437b",
+  "full_E_same_fixture_API_comparison": {
+    "API_ratio": 1.5833984849811464,
+    "cold_API_seconds": 3.7089290359999723,
+    "fixture_id": "00-cs_only",
+    "sample_warning": "One fixed-first cold sample; not a 14-fixture matched cold E study",
+    "warm_API_seconds": 2.3423851110001124
+  },
+  "full_brain_regression": {
+    "actual_child_exits_observed_zero": 15,
+    "all_bitwise_exact": true,
+    "arrays_per_trial": 10,
+    "fresh": 14,
+    "resident_forward": 14,
+    "resident_reverse": 14
+  },
+  "integrity": {
+    "fixture_manifest_sha256": "481df128d39bf28e5984a6f2e5757f83d45cb7a6136f8d2843ecc0a67eca437b",
+    "old_artifacts_modified": false,
+    "original": {
+      "bytes_checked": 3103901058,
+      "created_utc": "2026-10-01T07:17:32.838570+00:00",
+      "file_mismatches": [],
+      "files_checked": 64034,
+      "inventory_sha256": "d7b675b0d0d4647d8fe2fcf9616b9a599e5bc3c15565e604e0d66a046afb835a",
+      "original_experiment_resumed": false,
+      "original_git_head": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+      "original_git_status": "",
+      "probes_completed_unchanged": 138,
+      "registered_science_commit": "80aeb2093db655329774eff7b32fb6e417b8b40b",
+      "registration_sha256": "b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740",
+      "scope": "Saved Phase4AR experiment/control files and registered source files; NOT a new Phase1-4AQ numerical regression",
+      "source_mismatches": [],
+      "sources_checked": 16,
+      "status": "PASS",
+      "training_epochs_cpu_verified_unchanged": 1033,
+      "wall_seconds": 5.062658503000421
+    },
+    "original_AR_resumed": false,
+    "previous_engineering_files_checked": 659,
+    "previous_engineering_sources_checked": 13,
+    "previous_manifest_sha256": "6efdec34c96cdc79f786b91bd7a99b0e8ef64d0c4dcfa525646c82659a77d44f",
+    "status": "PASS",
+    "wall_seconds": 5.197849371999837
+  },
+  "jobs": {
+    "brain-replay-01": {
+      "command": [
+        "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+        "-B",
+        "/home/qishizhe/digital-drosophila-v100-acceleration/models/male-cns-lif/conditioning-pipeline-acceleration-v1/brain_replay.py",
+        "--fixtures",
+        "/home/qishizhe/phase4ar-v100-acceleration-20261001/fixtures",
+        "--fixture-manifest-sha256",
+        "481df128d39bf28e5984a6f2e5757f83d45cb7a6136f8d2843ecc0a67eca437b",
+        "--output",
+        "/home/qishizhe/phase4ar-pipeline-acceleration-20261001/brain-replay"
+      ],
+      "exit_code": 0,
+      "finished_utc": "2026-10-01T07:17:05.441907+00:00",
+      "label": "brain-replay-01",
+      "observed_exit": true,
+      "pid": 35046,
+      "process_group": 35046,
+      "scientific_AR_resumed": false,
+      "scope": "independent engineering replay only",
+      "started_utc": "2026-10-01T07:11:17.781251+00:00",
+      "stop_reason": null,
+      "timed_out": false,
+      "wall_seconds": 347.66065984800025
+    },
+    "brain-unit-tests": {
+      "command": [
+        "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+        "-B",
+        "-m",
+        "unittest",
+        "discover",
+        "-s",
+        "/home/qishizhe/digital-drosophila-v100-acceleration/models/male-cns-lif/conditioning-pipeline-acceleration-v1",
+        "-p",
+        "test_brain_replay.py",
+        "-v"
+      ],
+      "exit_code": 0,
+      "finished_utc": "2026-10-01T07:08:49.205842+00:00",
+      "label": "brain-unit-tests",
+      "observed_exit": true,
+      "pid": 34762,
+      "process_group": 34762,
+      "scientific_AR_resumed": false,
+      "scope": "independent engineering replay only",
+      "started_utc": "2026-10-01T07:08:49.035004+00:00",
+      "stop_reason": null,
+      "timed_out": false,
+      "wall_seconds": 0.17084325300038472
+    },
+    "cpu-profile-01": {
+      "command": [
+        "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+        "-B",
+        "/home/qishizhe/digital-drosophila-v100-acceleration/models/male-cns-lif/conditioning-pipeline-acceleration-v1/profile_original.py",
+        "--fixtures",
+        "/home/qishizhe/phase4ar-v100-acceleration-20261001/fixtures",
+        "--fixture-manifest-sha256",
+        "481df128d39bf28e5984a6f2e5757f83d45cb7a6136f8d2843ecc0a67eca437b",
+        "--output",
+        "/home/qishizhe/phase4ar-pipeline-acceleration-20261001/cpu-profile",
+        "--repeats",
+        "3"
+      ],
+      "exit_code": 0,
+      "finished_utc": "2026-10-01T07:08:22.538896+00:00",
+      "label": "cpu-profile-01",
+      "observed_exit": true,
+      "pid": 27868,
+      "process_group": 27868,
+      "scientific_AR_resumed": false,
+      "scope": "independent engineering replay only",
+      "started_utc": "2026-10-01T07:05:31.857063+00:00",
+      "stop_reason": null,
+      "timed_out": false,
+      "wall_seconds": 170.68183461700028
+    },
+    "cpu-unit-tests": {
+      "command": [
+        "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+        "-B",
+        "-m",
+        "unittest",
+        "discover",
+        "-s",
+        "/home/qishizhe/digital-drosophila-v100-acceleration/models/male-cns-lif/conditioning-pipeline-acceleration-v1",
+        "-p",
+        "test_profile_original.py",
+        "-v"
+      ],
+      "exit_code": 0,
+      "finished_utc": "2026-10-01T07:01:44.742692+00:00",
+      "label": "cpu-unit-tests",
+      "observed_exit": true,
+      "pid": 27719,
+      "process_group": 27719,
+      "scientific_AR_resumed": false,
+      "scope": "independent engineering replay only",
+      "started_utc": "2026-10-01T07:01:44.577624+00:00",
+      "stop_reason": null,
+      "timed_out": false,
+      "wall_seconds": 0.165072402000078
+    }
+  },
+  "limitations": [
+    "Fixed 14 real committed-prefix fixtures only; not the full scientific design.",
+    "Fresh means fresh interpreter, not flushed filesystem caches.",
+    "Brain uses unchanged original 4090 runtime; whole-brain V100 compatibility remains unestablished.",
+    "Original GPU tensors/graph are still allocated and uploaded each trial; no numerical loop rewrite.",
+    "Brain runtime timings include its original output I/O. Trial wall also includes extra audit checks.",
+    "Resident trial audit additionally checks the current fresh reference, making trial-wall boundaries unequal.",
+    "Paired steady timing excludes fixed fixture 0 cold initialization in both lanes; correctness excludes none.",
+    "Independent measured stages are not a combined training pipeline; no end-to-end speedup or revised full-run ETA.",
+    "Full independent AQ still uses a fresh subprocess and all original checks.",
+    "The original stopped scientific run remains at 1033 CPU-verified epochs and 138 probes.",
+    "Integrity covers saved Phase4AR files/sources and previous acceleration files; not a new Phase1-4AQ numerical regression.",
+    "Expected timeout self-test intentionally exits nonzero; it is not a scientific-run failure."
+  ],
+  "original_source_commit": "80aeb2093db655329774eff7b32fb6e417b8b40b",
+  "probes_added": 0,
+  "production_runtime_promoted": false,
+  "registration_sha256": "b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740",
+  "scientific_AR_resumed": false,
+  "scientific_learning_success_claimed": false,
+  "source_commit": "018f038c7857c7e0236dd7408a680458520d92ce",
+  "status": "PASS-PERSISTENT-REPLAY-EQUIVALENCE",
+  "training_epochs_added": 0
+}

registry/acceleration-20261001/source-protection.json

@@ -0,0 +1,19 @@
+{
+  "status": "PASS",
+  "created_utc": "2026-10-01T07:46:35.326466+00:00",
+  "files_checked": 64034,
+  "bytes_checked": 3103901058,
+  "inventory_sha256": "d7b675b0d0d4647d8fe2fcf9616b9a599e5bc3c15565e604e0d66a046afb835a",
+  "registration_sha256": "b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740",
+  "registered_science_commit": "80aeb2093db655329774eff7b32fb6e417b8b40b",
+  "sources_checked": 16,
+  "file_mismatches": [],
+  "source_mismatches": [],
+  "original_git_head": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+  "original_git_status": "",
+  "wall_seconds": 5.024687475000064,
+  "scope": "Saved Phase4AR experiment/control files and registered source files; NOT a new Phase1-4AQ numerical regression",
+  "training_epochs_cpu_verified_unchanged": 1033,
+  "probes_completed_unchanged": 138,
+  "original_experiment_resumed": false
+}

registry/branch-consolidation-20261001/SHA256SUMS

@@ -0,0 +1,13 @@
+92971baaa32a1698f300938827b8f2067d66604106a60ad6c3331a1ea77b75e5  registry/branch-consolidation-20261001/archive-recovery.json
+e4d767d20e338f2128e59d9cb7cc849639d6329ecb946c714e170a883a01e80b  registry/branch-consolidation-20261001/completion.json
+ea6a4f41e0d3dfff97a628781ed763b1028a9048c5446fb7dff335d2441cc858  registry/branch-consolidation-20261001/merge-audit-final.json
+c10e8a1941946480acee7f168f68ea4796d22e987a8225058871b5062ddaba45  registry/branch-consolidation-20261001/merge-audit.json
+8d1367b6326e2165fb11564dd25ba90e6b5ee526a914f5f143fc7ac03002a53a  registry/branch-consolidation-20261001/plan.json
+203a02aa6bec59db3a645d8c639e3d13186e8841048b46f00451b76b6227b20a  registry/branch-consolidation-20261001/remote-cleanup.json
+4d2ba2306801462539766348d93600f984f324f2b8a9020e90af7bb402aba34e  registry/branch-consolidation-20261001/source-protection-final.json
+81a33f1c4371e1013fbb5a2d997cb5c6c0c1dc115efb8b2db098a20a9683661f  registry/branch-consolidation-20261001/source-protection.json
+36f8d0519937ecf42869f364cc4a6a2a7f86443a40dab5800f2bf271f681fc1b  tools/branch-consolidation/manage_refs.py
+54f17a3cd3636d8a7231ae6180100b4010a19a8ce1d46c175a4e8b692f608c2c  tools/branch-consolidation/seal_receipt.py
+7e74da3b46d16d29d31d6da05b4b8b74992a2bc35342775267c5a1890880ea2f  tools/branch-consolidation/verify_merge.py
+b342f80fa91b73a1d5af3672cada52e015bcc8e4c093652270dee504aa10cbd7  docs/30-reproducibility/main-restore.md
+993291500e4bf30cefb275bdf7cc1c1ff989e736475977a85449d85306d8dcdf  docs/40-operations/branches-20261001.md

registry/branch-consolidation-20261001/archive-recovery.json

@@ -0,0 +1,38 @@
+{
+  "created_utc": "2026-10-01T08:53:52.387081+00:00",
+  "fresh_remote_recovery_path": "/home/qishizhe/digital-drosophila-branch-recovery-20261001.git",
+  "git_fsck_pass": true,
+  "lfs_payload_downloaded": false,
+  "old_remote_branches_deleted": false,
+  "pass_all": true,
+  "recovered_commits": {
+    "archive/2026-10-01/apl-pn-scope-audit": "d6843e675dec5ae38a06f2ba70d74836aea53ace",
+    "archive/2026-10-01/lfs-public-resources": "5b1d1b72d7683b5c3dcc1f78b408e1d9dd2832ac",
+    "archive/2026-10-01/lif-author-semantics-lab": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+    "archive/2026-10-01/lif-semantics-audit": "5008cd85ca11750f23ce7bc001e8e821763b7501",
+    "archive/2026-10-01/project-bootstrap": "3981628ff893132a8148668aa94726886dba57a3",
+    "archive/2026-10-01/terminal-scope-diagnostic": "3213aada793740961885ba525494e95f019be6f8",
+    "archive/2026-10-01/v100-conditioning-acceleration": "4436241976887d8cc10088b0d44bc7ed70978fe6"
+  },
+  "remote": "ssh://git@192.168.10.31:2222/qishizhe/digital-drosophila.git",
+  "remote_default_before": "refs/heads/codex/project-bootstrap",
+  "remote_heads_before": {
+    "refs/heads/codex/apl-pn-scope-audit": "d6843e675dec5ae38a06f2ba70d74836aea53ace",
+    "refs/heads/codex/lfs-public-resources": "5b1d1b72d7683b5c3dcc1f78b408e1d9dd2832ac",
+    "refs/heads/codex/lif-author-semantics-lab": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+    "refs/heads/codex/lif-semantics-audit": "5008cd85ca11750f23ce7bc001e8e821763b7501",
+    "refs/heads/codex/project-bootstrap": "3981628ff893132a8148668aa94726886dba57a3",
+    "refs/heads/codex/terminal-scope-diagnostic": "3213aada793740961885ba525494e95f019be6f8",
+    "refs/heads/codex/v100-conditioning-acceleration": "4436241976887d8cc10088b0d44bc7ed70978fe6"
+  },
+  "schema": "branch-consolidation-ref-audit-v1",
+  "tags": {
+    "archive/2026-10-01/apl-pn-scope-audit": "d6843e675dec5ae38a06f2ba70d74836aea53ace",
+    "archive/2026-10-01/lfs-public-resources": "5b1d1b72d7683b5c3dcc1f78b408e1d9dd2832ac",
+    "archive/2026-10-01/lif-author-semantics-lab": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+    "archive/2026-10-01/lif-semantics-audit": "5008cd85ca11750f23ce7bc001e8e821763b7501",
+    "archive/2026-10-01/project-bootstrap": "3981628ff893132a8148668aa94726886dba57a3",
+    "archive/2026-10-01/terminal-scope-diagnostic": "3213aada793740961885ba525494e95f019be6f8",
+    "archive/2026-10-01/v100-conditioning-acceleration": "4436241976887d8cc10088b0d44bc7ed70978fe6"
+  }
+}

registry/branch-consolidation-20261001/completion.json

@@ -0,0 +1,55 @@
+{
+  "all_old_tips_recoverable_and_ancestors_of_main": true,
+  "archived_tags": 7,
+  "created_utc": "2026-10-01T08:58:00.393849+00:00",
+  "final_receipt_publication": "This report is committed after the integration commit; containing Git commit is the receipt publication revision.",
+  "integration_commit": "9fde10d970474bf4223dec7536c396d3afaccbe3",
+  "lfs_objects_deleted": false,
+  "lfs_payloads_reuploaded": false,
+  "lfs_verification_scope": "Original pointers preserved; authenticated availability checked. Prior fresh-download hash verification receipts remain unchanged.",
+  "local_branches_preserved": true,
+  "model_or_science_changes": false,
+  "remote_branches": 1,
+  "remote_default": "main",
+  "removed_remote_branch_refs": 7,
+  "schema": "branch-consolidation-completion-v1",
+  "scientific_execution": false,
+  "source_protection": {
+    "bytes_checked": 3103901058,
+    "created_utc": "2026-10-01T08:56:09.890381+00:00",
+    "file_mismatches": [],
+    "files_checked": 64034,
+    "inventory_sha256": "d7b675b0d0d4647d8fe2fcf9616b9a599e5bc3c15565e604e0d66a046afb835a",
+    "original_experiment_resumed": false,
+    "original_git_head": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+    "original_git_status": "",
+    "probes_completed_unchanged": 138,
+    "registered_science_commit": "80aeb2093db655329774eff7b32fb6e417b8b40b",
+    "registration_sha256": "b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740",
+    "scope": "Saved Phase4AR experiment/control files and registered source files; NOT a new Phase1-4AQ numerical regression",
+    "source_mismatches": [],
+    "sources_checked": 16,
+    "status": "PASS",
+    "training_epochs_cpu_verified_unchanged": 1033,
+    "wall_seconds": 4.999353606001023
+  },
+  "source_worktrees": {
+    "/data/digital-drosophila": {
+      "branch": "codex/lif-author-semantics-lab",
+      "head": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+      "status": ""
+    },
+    "/home/qishizhe/digital-drosophila-v100-acceleration": {
+      "branch": "codex/v100-conditioning-acceleration",
+      "head": "018f038c7857c7e0236dd7408a680458520d92ce",
+      "status": ""
+    }
+  },
+  "staged_publication_guard": {
+    "files": 12690,
+    "issues": [],
+    "logical_bytes": 121522918,
+    "pass": true
+  },
+  "status": "PASS"
+}

registry/branch-consolidation-20261001/merge-audit-final.json

@@ -0,0 +1,898 @@
+{
+  "allowed_existing_changes": [
+    ".gitattributes",
+    ".gitignore",
+    "CURRENT.md",
+    "README.md",
+    "docs/40-operations/branches-20261001.md"
+  ],
+  "artifact_paths": 181,
+  "lfs_availability": {
+    "all_download_actions_available": true,
+    "batches": 2,
+    "payloads_redownloaded": false,
+    "scope": "Authenticated read-only LFS availability; full byte validation remains the unchanged prior fresh-download receipts",
+    "unique_bytes": 9893620059,
+    "unique_objects": 169
+  },
+  "lfs_pointer_paths": 171,
+  "merge_base": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+  "model_tool_registry_artifact_bytes_unchanged": true,
+  "new_paths": [
+    "docs/30-reproducibility/main-restore.md",
+    "registry/branch-consolidation-20261001/archive-recovery.json",
+    "registry/branch-consolidation-20261001/merge-audit.json",
+    "registry/branch-consolidation-20261001/plan.json",
+    "tools/branch-consolidation/manage_refs.py",
+    "tools/branch-consolidation/verify_merge.py"
+  ],
+  "parents": [
+    "4436241976887d8cc10088b0d44bc7ed70978fe6",
+    "5b1d1b72d7683b5c3dcc1f78b408e1d9dd2832ac"
+  ],
+  "pass_all": true,
+  "pointers": {
+    "artifacts/acceleration-20261001/gpu.tar.zst": {
+      "bytes": 1679158,
+      "git_blob": "0f185c43ecd1225f043aa31adbb6b7829bf8cbf2",
+      "oid": "50acdc85342a2c79c3516e50ee4542b909813d179518451edaaf2d94150c534b"
+    },
+    "artifacts/acceleration-20261001/pipeline.tar.zst": {
+      "bytes": 74767927,
+      "git_blob": "65ddc7bfa98b8f177c795bb91884d41454586e29",
+      "oid": "fdc39013d71fb7d14313d8249c929601a8a7050cc2eac88b733d692bbe1b6b42"
+    },
+    "artifacts/lfs-smoke/publication-probe.bin": {
+      "bytes": 263,
+      "git_blob": "14e759036eebe61c3e7a8fbaedce459d0e52b0fa",
+      "oid": "93e0e6c4ca4fdc123c21b859ba97d8bd73670eb9c90d04ce9a431d822b5393c5"
+    },
+    "artifacts/public-resources-20261001/celltype-explorer/exclusions.jsonl.gz": {
+      "bytes": 144,
+      "git_blob": "09e234a4297969c928bb654374a3047a59c7dcdf",
+      "oid": "c1bca109b61e53327fa7e01128a411d8ea328972593168c3ad6e1202dfdddc9c"
+    },
+    "artifacts/public-resources-20261001/celltype-explorer/members.jsonl.gz": {
+      "bytes": 421593,
+      "git_blob": "cd5607573bf3ae0a51ece3f3a052397f1b0a0f63",
+      "oid": "8a51d3b4138bad12a520f8d1a12d54673416017d15fd1b1bcc49ed385da005bb"
+    },
+    "artifacts/public-resources-20261001/celltype-explorer/payload-000000.bin": {
+      "bytes": 67108864,
+      "git_blob": "bd8c136dcd35737e121c5ba7625a55d887c0ec89",
+      "oid": "6f5830463b8a0077ae89e550ca45275d57cf7e81813c42bf66f89d13a42c03ee"
+    },
+    "artifacts/public-resources-20261001/celltype-explorer/payload-000001.bin": {
+      "bytes": 10862890,
+      "git_blob": "8b2713753746e96e714f55a813a87b591050d8a6",
+      "oid": "6b80b0133af06279bd30561f35042b679bd392b9236ee519d1e7ed9c4e85fb6a"
+    },
+    "artifacts/public-resources-20261001/door-data/exclusions.jsonl.gz": {
+      "bytes": 147,
+      "git_blob": "42e420697802f0ca1ce7f5a611411cdb31d1c71e",
+      "oid": "82627a482fd6adfc3abf4f83a30158fd8371b4532f425f7eb3b03044eb7e1367"
+    },
+    "artifacts/public-resources-20261001/door-data/members.jsonl.gz": {
+      "bytes": 9486,
+      "git_blob": "ab7591b84fc9593dc93240eb4d85af5c7b259859",
+      "oid": "ef13db49577b3b3d1c7c31aab117d911a2decc5a80ead66b6a350c43d16374b4"
+    },
+    "artifacts/public-resources-20261001/door-data/payload-000000.bin": {
+      "bytes": 901984,
+      "git_blob": "19555f614f64e96c7d80be33a7c1558198a3d95f",
+      "oid": "64d415a1ea9f5c2fe09005ce1c2bb27eb45510fad27ad3c39cf0001e6f525fd1"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/exclusions.jsonl.gz": {
+      "bytes": 219,
+      "git_blob": "d9c55185336648c6280d4bad02e1e3506dabec39",
+      "oid": "0909f401f73ca15301ea2be92a5e7c66cf79d9d4f8bbe5449f82c2980d6d3e80"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/members.jsonl.gz": {
+      "bytes": 3639,
+      "git_blob": "1ba7548bebb67676fbc7a99dc71cf9d2db0cc2ab",
+      "oid": "fe399bea661cdd018e53a5ea58bc46a64d2f94fb09d1dec40f8a956789204627"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000000.bin": {
+      "bytes": 67108864,
+      "git_blob": "b69d887bbb82cc7ad15ee0874d4c42060063547d",
+      "oid": "a65619004cdc36e594bdca344d1fe51ac86fb719159f70a2ba0fb21c763f9c04"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000001.bin": {
+      "bytes": 67108864,
+      "git_blob": "7aced7ba1c85c8549352ed019cf6fb6c1dc95e4d",
+      "oid": "cca9eedbc44b20be736317745ee12e8c06bf0e1aafc7815b74bc6aa27cef5be5"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000002.bin": {
+      "bytes": 67108864,
+      "git_blob": "ef373282a813d588058622a59c14ea8e1d0d3f94",
+      "oid": "e395b23867e74b7579aed8eeb927e373c86d77433962a0f89ac198aeca4f8470"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000003.bin": {
+      "bytes": 67108864,
+      "git_blob": "ac6d8315736893607c5367f89310f5877802e8b8",
+      "oid": "e47d83eba2875f963add02ab697cb6386dd8fe4a5f33b96db5a321986a276774"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000004.bin": {
+      "bytes": 67108864,
+      "git_blob": "769b6f74cef3fdedad5815e38b7883883690cfa5",
+      "oid": "4d4bdff46071f05c29ac34cd9081204739317bef5ab862d612d2c7a82c3d5bca"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000005.bin": {
+      "bytes": 67108864,
+      "git_blob": "bc672ab43e90810ebb53fc799bf84d6a1d947ab4",
+      "oid": "4f82611c41e868faa6ea06d7bd275df90f712e3f5eb14296117e39c3bf6c95c0"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000006.bin": {
+      "bytes": 67108864,
+      "git_blob": "f34f6eb0d4264e6b6b9b8c147bc2eea551c3aab0",
+      "oid": "4cbfb164c194db8c54eadef4d039240d98b0f5be8e20e4005be08bd2d2f6ab5d"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000007.bin": {
+      "bytes": 67108864,
+      "git_blob": "636780a7aa4695e7048f5ee049e625aa3fe7fc78",
+      "oid": "9ba4adfe64d73d0ceb249ab25215734f58b0d8b38d11f22676fd93f68e83df68"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000008.bin": {
+      "bytes": 67108864,
+      "git_blob": "11b4bd27f807293143ae87448308e104e0356a93",
+      "oid": "8f388376c6e9d3b7abaff219b00d669ea88db1bf5cd48381db9354598102b345"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000009.bin": {
+      "bytes": 31352355,
+      "git_blob": "75cc67bb548b4e94d67f10bf69023bd3073b5fe3",
+      "oid": "e1ac638f1d640de9e85b82d9526d6f729f78239e66c5c024e0037144adf7f003"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/exclusions.jsonl.gz": {
+      "bytes": 135,
+      "git_blob": "65ee80ddca5cde591a2728533ec3f62cb0e8a700",
+      "oid": "887492a8f75af6be4e71b6f5aa12506cef3d8e3a7363b3c6a50064da93b9b4a1"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/members.jsonl.gz": {
+      "bytes": 1009,
+      "git_blob": "f1d777d57f3874b67a976fcf2c189ad73cfa4b6b",
+      "oid": "e963adede9d937effbf5519ae9717938a2b3324aecc1c28338800007f7003404"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000000.bin": {
+      "bytes": 67108864,
+      "git_blob": "1d7b75a438e8d3cd76de66e2ce87257be73db5bb",
+      "oid": "5527fc251d23c23209cf16c8831aedefcceb6d1e927a4eaf9ebed182fd5481ff"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000001.bin": {
+      "bytes": 67108864,
+      "git_blob": "1f0f13ffc504e721405adefbe5cf687f2562558d",
+      "oid": "4793d00b3d6b3506d16e21f3f3775bc70c23c70cd5be03b6733350328519a3c0"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000002.bin": {
+      "bytes": 67108864,
+      "git_blob": "fa31a68267dcf65bb07c40be8863d42c68d46923",
+      "oid": "a78930db08134f72e97306df7256bd8b0b533611fe9a08459f1c6289eb47624e"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000003.bin": {
+      "bytes": 67108864,
+      "git_blob": "748f9117687e60ab529c28d4ed28ebede6e3cf40",
+      "oid": "54fc4943c3d644e1765a7cbdacf0629db1ddefde4f17035729417242930064a9"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000004.bin": {
+      "bytes": 67108864,
+      "git_blob": "e1920897dc73e921e41d8a9364bc7668db17da42",
+      "oid": "7bb2deb3dd7d3f7064c096c8915bb3eff7f880a009628f6ee6c5e14dce939668"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000005.bin": {
+      "bytes": 67108864,
+      "git_blob": "d510b5c4e5e06204b800e91c4db4c2a4d891ade9",
+      "oid": "d1aac9ec93c77f901c98c7343fd3713c746faf855096e9d7e6da897491c513df"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000006.bin": {
+      "bytes": 67108864,
+      "git_blob": "004c1d6ef14926b0d69d2bf2ee578b0cb2eb9a5a",
+      "oid": "29f40919b04405609643b3a5a2beb749aacbf5525cf90a60d75fa3f0a283435e"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000007.bin": {
+      "bytes": 67108864,
+      "git_blob": "b330586398d4fb3d5430056aa851496be14ac093",
+      "oid": "b3936a86da8636e5ba6d7a25f4d8d3b34eadc769e74817d67c7aefe2e9879e68"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000008.bin": {
+      "bytes": 67108864,
+      "git_blob": "f9ffc16535fc8a76bed275471284f920be87a1a1",
+      "oid": "47e2e7cfde2bc01d41de53ba933683faf4fa4dc57c3d80f07d8edb75dc1916d3"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000009.bin": {
+      "bytes": 67108864,
+      "git_blob": "233a14ce3b1c4032341bff70ea3866920a264913",
+      "oid": "ab37af43abeeb3434b0660fb5bfb185e7c0db07916b2a2233a2db083f66ea2b9"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000010.bin": {
+      "bytes": 67108864,
+      "git_blob": "2296a326b6c9741ff9876deaaaa19f630088dff1",
+      "oid": "bdbf00683b8940fb513fef121559e8e449d84972e03df2d4698d06e0dcc28efa"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000011.bin": {
+      "bytes": 67108864,
+      "git_blob": "884ecf37372792ce6dae1d1b4c7cdefe7f418760",
+      "oid": "a3ee35cae393b29d0366aebcad7f63a8ad578b61e0a93e773595dfdfe6848bbe"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000012.bin": {
+      "bytes": 28959790,
+      "git_blob": "fdf9e40c25c1baa9d43c4b87c60f9d9f1cdbb0fa",
+      "oid": "7fbe5733e328f5a989fec3ffd78819c62ac53a32e099579492cd82766322e82a"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/exclusions.jsonl.gz": {
+      "bytes": 20,
+      "git_blob": "1c35409ae4793732668f75c463c9722b3aedc07c",
+      "oid": "9ceffb7310338057cfe71a4ae1e2c98d2c485d81cdef906532a801f457a38d64"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/members.jsonl.gz": {
+      "bytes": 10023755,
+      "git_blob": "e7b5dd566bfa5da5f4d01dbfb93e93e2534698e0",
+      "oid": "1dcc1bac912889118e2a34211b4c43b2b0af871c8b76b97ede31db88ce67a961"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000000.bin": {
+      "bytes": 67108864,
+      "git_blob": "304278d54740a55ef0287157cbd338e4173a01ae",
+      "oid": "1f21099a6411dec6c0b1f5eba48618de749ac6ec7f18b18d7521fe75b7fe32e9"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000001.bin": {
+      "bytes": 67108864,
+      "git_blob": "1c0626b01e8a9e0b1da9a0715290feb49d9dc2c0",
+      "oid": "a749bcac2abeb5f8621603d81a069a96b63cc5e12dbb87b51744b5838c25bab5"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000002.bin": {
+      "bytes": 67108864,
+      "git_blob": "c4ebb418a529c2cf80eb0702d9ef3da8265c6d3a",
+      "oid": "8bacba0b7452c99f2a8e57b17f72604671d78faed5dbc39cf800b148a9a3476b"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000003.bin": {
+      "bytes": 67108864,
+      "git_blob": "171a8b118676c2f14e334d93ade9f53d958e35c1",
+      "oid": "0e226842328b68a4ce86bdb612379047c44a535c6d4b5eb8aa97ed0fccccede4"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000004.bin": {
+      "bytes": 67108864,
+      "git_blob": "ef9c5684e74c14a5fe30bc6bf503c7745e22a668",
+      "oid": "19559779bbd8f305c690ccb1c5a2a03b53bdee0e2afe3f6dca1faf2926ae1143"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000005.bin": {
+      "bytes": 67108864,
+      "git_blob": "f6304845575462e3315f180e780f38113c3af70c",
+      "oid": "f9441d9484184e90d3b962b9b32ef80e8daa1944ca67d11e691fda715eb4908f"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000006.bin": {
+      "bytes": 67108864,
+      "git_blob": "2fee0e3b9664936f882dce6efe5cd5ec7c9df9d1",
+      "oid": "c022c80fe76fbbe69602755de5ea74b97db9ee56db280d6c9ec863ba3c1ff332"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000007.bin": {
+      "bytes": 67108864,
+      "git_blob": "4d2eed4978aeef824eff8355781caec4d03b932a",
+      "oid": "12370abe8bbe6fee58be01d6b2204b64c54a7eada3988a367de9451b910ae3e1"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000008.bin": {
+      "bytes": 67108864,
+      "git_blob": "01dfb02c029244fca41fd77fff92462f1f58fbac",
+      "oid": "f7d5d2b8f699f15466e6fabcefc398b21f142d23c5ad173020add2461e32d27e"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000009.bin": {
+      "bytes": 67108864,
+      "git_blob": "10623bdbafe0bac6260c8b5c4d7ce7ed12d4e8e8",
+      "oid": "4e70530845d6e86b037cd7dc7d0d7a5bf544263f99893a6836525b92a5b142d4"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000010.bin": {
+      "bytes": 67108864,
+      "git_blob": "520e73df93975633da51b97f136f07aa0ddd3aba",
+      "oid": "9ce176c8fcaef8671815c5b4f3366c233632be1ac313ab6f351f7f93cd2f0072"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000011.bin": {
+      "bytes": 67108864,
+      "git_blob": "d1f8fd74b2eb676ccd36956c646150f508123ff9",
+      "oid": "12f4d9d507494cd85f17583fa9665f20b68f928db1125668d9bfc462fc0f66a5"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000012.bin": {
+      "bytes": 67108864,
+      "git_blob": "3094f061e35815742991c111d645e8fabec771da",
+      "oid": "39e8403e3fd8ea71e281034b346da33511d1ec1c236b1f16929113d4cec53e6d"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000013.bin": {
+      "bytes": 67108864,
+      "git_blob": "3f451d645dfb57402d75132df2d0f9a9eacc3bae",
+      "oid": "979bb9d50a5b44608ce6ace417dec67236072d027fab79cf9b0255ed39c08020"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000014.bin": {
+      "bytes": 67108864,
+      "git_blob": "586190bbb62b6daa7c5e8d26691a8fb9c1d5a55b",
+      "oid": "b029a7948ae6c23916fcd81c3b9bf1a260f2c9d8659b53b7f5e556384349f21f"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000015.bin": {
+      "bytes": 67108864,
+      "git_blob": "6dd7054e14bdba92eabed05da013625f086d1348",
+      "oid": "c26d6139d8e1a51ffabe1a06a13c2061a5928e168a961930d9d195a25b6ab620"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000016.bin": {
+      "bytes": 67108864,
+      "git_blob": "385371fc8a45236ae6cdf32f22aa41ca1e49d29d",
+      "oid": "98b5853bc02c4bd0bf1598fdfd1c52f55628660047fb4977f1f8eaf02e70b603"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000017.bin": {
+      "bytes": 67108864,
+      "git_blob": "7542ed313b9a52b32e318d2420fb68668b36656f",
+      "oid": "789d6ad66acddd2aaa750d4c27d55be897f0c9a935c0c1837d9e46c2f916d0b3"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000018.bin": {
+      "bytes": 67108864,
+      "git_blob": "e96574ba4baa34169f2eb733676254f47a69ddb0",
+      "oid": "907c4ae7690a13663e8a489ec229f436e329823b7fb1c1e68228338388754ec7"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000019.bin": {
+      "bytes": 67108864,
+      "git_blob": "0bc017c7a9f30159473b90ae906e51f3f78664cb",
+      "oid": "c28d51fdf23a630eaf2506276da19d34c609a6b5448afdedd2efea25e4602b06"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000020.bin": {
+      "bytes": 67108864,
+      "git_blob": "4e2f35715ae3ea318d1d06c59203d2fdc34f0cfa",
+      "oid": "2d1be9e0abfd4604b55bfd0c8e740ee58bb153d126a81aa08126fecdc0057150"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000021.bin": {
+      "bytes": 67108864,
+      "git_blob": "3ad329dbccf78e9102ae00f6b989f465740583d0",
+      "oid": "f9725762b7fb5e0cc5a896c8b63ceb816faa246aeba4a3082b9eaf492cbe97c5"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000022.bin": {
+      "bytes": 67108864,
+      "git_blob": "14f4c477434a1d4708fd1c4a78c6ba963fc47b11",
+      "oid": "72e90497e9e6fbf586e3659d4e023f47a8f3942ac10bce1fe314659f16568160"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000023.bin": {
+      "bytes": 67108864,
+      "git_blob": "a41e451a2a6d0599e18201fa08c6b36340ab4707",
+      "oid": "2fd9ba58a4f2acbb5fbbb023cb100a1bcc0079c7c490d25c2c63bd46441aa08e"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000024.bin": {
+      "bytes": 67108864,
+      "git_blob": "6b5e299ff6eeb015ee2fd4620eb62344cfed822d",
+      "oid": "ead438094c5a9d4b5550ebc95ec583d8e7cd1d84b601e549d50c4ab9a5e9818b"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000025.bin": {
+      "bytes": 67108864,
+      "git_blob": "4e323bf1371f2619d6e7bed98edeab7857a2dc20",
+      "oid": "97b32a95ca08c4b69908c93a7ce40606a9597cd9f2eb47f9447cc4a93cb6eab2"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000026.bin": {
+      "bytes": 67108864,
+      "git_blob": "027ac3048fca4dcfe873c99d3bf72499a940e530",
+      "oid": "6f985c609b0f1f3538b7b7407da46c2983781552cec9e12e5ca9b5ba5d1ceca9"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000027.bin": {
+      "bytes": 67108864,
+      "git_blob": "ed54f94e0fdfef74f7c7a1f927d98ce4947acb10",
+      "oid": "7465e4aff8c0ad68fcbb201815828a5198611c18c8fb2cdfdaf4ba7b2a6b2456"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000028.bin": {
+      "bytes": 67108864,
+      "git_blob": "ba19b753481999cc4aa0b5c90eb16bf6a6d17630",
+      "oid": "7a3ba5b63ac70b19e54cce3e9f90038caae01e992fe81a45b7ddb370dcbf125e"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000029.bin": {
+      "bytes": 67108864,
+      "git_blob": "42e7a5241d43e01fc895c63d7b301b255eb971be",
+      "oid": "c9fafa0218befdebb42d19ff7f720e18b392c742ff45e39b64018c41a31a1530"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000030.bin": {
+      "bytes": 67108864,
+      "git_blob": "3dca0857b141fe2a82d60bd24531f588ee398d0d",
+      "oid": "aac2f55805490cfa5e42bbd7cc169a83a40132f269d64315ebb2aec6dafc5a96"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000031.bin": {
+      "bytes": 67108864,
+      "git_blob": "b81af5de591b74e80348d2f4f5b7eff67425812f",
+      "oid": "c362980ebf871332f8fc05f5f72ccce8ed13319c596039a960cd0450e7f09a78"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000032.bin": {
+      "bytes": 67108864,
+      "git_blob": "f897bcbe419b8a2f38ec90c783040c21ba6770fb",
+      "oid": "52272e69c6b23bc0951f6cd4e824c357ccb13d3bb781cd68591a8a5476540229"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000033.bin": {
+      "bytes": 67108864,
+      "git_blob": "b1018df1ab072d59b9ce7b79f52baf9d078492df",
+      "oid": "c3ada974de03b55ce956d6af4f5d9238f2e1ab7ad2bd81265eb9a7bf883e65e1"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000034.bin": {
+      "bytes": 67108864,
+      "git_blob": "12eb2bc0bc45b67132dd21a2fb9cd772b6d3639e",
+      "oid": "7aa8cf11b2d356a45e2608295deeb6443bdcf83427a8b71e6da758e2cfed9e2d"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000035.bin": {
+      "bytes": 67108864,
+      "git_blob": "8b8b2358ee54bee7c9b4eed3f11c627c40d26d4e",
+      "oid": "0edc84c74eebcc6d1375bfe5e09e8933221b025cfd4ce98539a574c1b26c6cf4"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000036.bin": {
+      "bytes": 67108864,
+      "git_blob": "12e1e2c88335f52d9103797ac767188fe0c6e4b4",
+      "oid": "ad237a494101cd4a392d0a29406b217673ecdfe1ac999f9ee76bcb99dd449840"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000037.bin": {
+      "bytes": 67108864,
+      "git_blob": "814d377e605548b56f22fb84d56496a91cdc49fd",
+      "oid": "fa89d550c2b9674ed8e01a1443d355c01cfebae2394a92f21999e09598159249"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000038.bin": {
+      "bytes": 67108864,
+      "git_blob": "d61e72bd9916179c09ad8dfa3ce694a6629a4fd7",
+      "oid": "c22cd72daba6848f000d39c6c9e0f500c47c2a97c59bf4d01cb485c4542504af"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000039.bin": {
+      "bytes": 67108864,
+      "git_blob": "e102023cdeb4aba6aeafe72c8d4d02f32e9d551a",
+      "oid": "9c3cb5c9db5915ec11ddd25f01c09a68bd493f2fa7e01a2832cf6b13bd034169"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000040.bin": {
+      "bytes": 67108864,
+      "git_blob": "86e95090ecbd81b12b06b9180db95d7016c7adac",
+      "oid": "52f9bf010556a9c231771c36697c257059d1200f42b021811568e5ad8aaa81c8"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000041.bin": {
+      "bytes": 8813521,
+      "git_blob": "84214d1441baf932089b403ac669b382447ea870",
+      "oid": "3bd8789f041905e31bf669c2e9877dc19e92108dc721fa7db4c6f4a1fea2a850"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/exclusions.jsonl.gz": {
+      "bytes": 20,
+      "git_blob": "1c35409ae4793732668f75c463c9722b3aedc07c",
+      "oid": "9ceffb7310338057cfe71a4ae1e2c98d2c485d81cdef906532a801f457a38d64"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/members.jsonl.gz": {
+      "bytes": 512,
+      "git_blob": "59b601e0ac09ebd00c5e15e06808e3e74ba2e180",
+      "oid": "cfe2adcc93576eeea4100b847016bd5484338f449d4755dc7071c4c621d4d6df"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000000.bin": {
+      "bytes": 67108864,
+      "git_blob": "dedf1b58a1672ea8b49fc438f705633fcbc5d99e",
+      "oid": "a507fb9917a63f6221d97780727831735bcf419bb6d36b17546f2be04e8f6b6b"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000001.bin": {
+      "bytes": 67108864,
+      "git_blob": "2b84019d1e33f79060a23af8c9690b080cdd8472",
+      "oid": "1d804d88517d49483b02b6136f155730bc886939872208dfe9afadc9d4ae154c"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000002.bin": {
+      "bytes": 67108864,
+      "git_blob": "2606fbc2b2b97d8d0115a5ac70c91f8f524309e6",
+      "oid": "506edaf9d3b21358da114e736e36eb2467d9e465e02e22b9844e2ef6d1125606"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000003.bin": {
+      "bytes": 67108864,
+      "git_blob": "02d1b472ec88e368cb758202bf700037a904a8a8",
+      "oid": "a49499b604f9769bea207ec2ec73ca65cc692389cf093eb2b206f8f355a40883"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000004.bin": {
+      "bytes": 67108864,
+      "git_blob": "de80491cdce038f32d74db1c6810baaa0581e4d2",
+      "oid": "cb0d6ee2cd988a45ac198653aa01883d79b62f178ce68284f66633f89623d05f"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000005.bin": {
+      "bytes": 67108864,
+      "git_blob": "2eb94b490bb6291e88e6f3f340a72aae82db59b1",
+      "oid": "33736340ba66093bc66c94981e517c223e46b6853d3b688f609abd6656c1b64a"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000006.bin": {
+      "bytes": 67108864,
+      "git_blob": "f87bb82d9728c2a4d89cbf1c6187d46820ee6aac",
+      "oid": "1cec62f5de3779beddc26800d99a8e0263c171cf3a0796a8775e083ad72a5267"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000007.bin": {
+      "bytes": 67108864,
+      "git_blob": "e48868aa2bb4a4abb07f55ef72eefc083c2cc427",
+      "oid": "ff9ca8cb58c6566ab39b955649bd599919f93f65d241979f78852ba6bd45f465"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000008.bin": {
+      "bytes": 67108864,
+      "git_blob": "a3b972b91778fecfcbc51c9b1a421d4a0a900a70",
+      "oid": "c2710524d019452db8832dbe8f258fcca38bea899400342056f2646a75c1540d"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000009.bin": {
+      "bytes": 67108864,
+      "git_blob": "4fbe561d626c433393336045e1b2b1e273967975",
+      "oid": "ccdffd7293b05ed912e3acc749f8ed8c7769c135c4fa20db2f4fef4783157c6e"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000010.bin": {
+      "bytes": 67108864,
+      "git_blob": "0e780b82f0177a890102b4a299fe6b99947ef414",
+      "oid": "ebccfe2d5b5c3b60ef0b5bb9503d7849d2693ec82138ac937a585eef1654dd6b"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000011.bin": {
+      "bytes": 67108864,
+      "git_blob": "efea0bd97f35681d6ef9a8b5aa53b9f918516811",
+      "oid": "66f265f69bc110d28e679e0aa6390cdc28cff00cafc863a9055acd91daea8b66"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000012.bin": {
+      "bytes": 67108864,
+      "git_blob": "c058a6cce94e54babbcc35bd80783e117e94f0eb",
+      "oid": "f9e3084ccee597a8d6163dbf8452a53a5f74ee8bd2c26e0c7017be7d33ebf562"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000013.bin": {
+      "bytes": 67108864,
+      "git_blob": "84cc7bc319102829028a893a8dde08a56b627316",
+      "oid": "d07691bd973949900c41fb4c2e4cc4d6b10eeef256ff8b128fc5dbfadd875d1c"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000014.bin": {
+      "bytes": 67108864,
+      "git_blob": "0e3a11a6ec608a1713ff1eff45fe529303cee97b",
+      "oid": "ac78fa1d2882bbee5727993d29a7bce7f2a163ad6d8d74125b98b7a0c09c4c76"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000015.bin": {
+      "bytes": 67108864,
+      "git_blob": "fd8293817c834c5c657a22c1808ef772a5c056cb",
+      "oid": "b2b14acffeff84cdcc8c4cac4b1725eb63666f67c4aa42e324743aad471251d2"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000016.bin": {
+      "bytes": 67108864,
+      "git_blob": "2cff8263046aabb0bfa06163692a2c532a126f76",
+      "oid": "5c903aeb8cf971578901c19e5656143e66ed34e5b39207f11a811652f99ec8b2"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000017.bin": {
+      "bytes": 67108864,
+      "git_blob": "370f1e8475604f6ce9e3e2b2da9035f96e906fc4",
+      "oid": "0f249896dd016c094e02a7e031d381835536add9f48d34a2d71085f79fdcb988"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000018.bin": {
+      "bytes": 67108864,
+      "git_blob": "138c59ea1386df84a5113dab18c4b4752ba7368b",
+      "oid": "3124cdac2b3cbd389e7d1970be7ab67ebeb420290bb19901fa65a75410cf86ee"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000019.bin": {
+      "bytes": 67108864,
+      "git_blob": "6b91c64497b5024777bfb046de6df9c740f995a6",
+      "oid": "178eb19d998fd2196b60820fcc8b31ddc250163c4df0d1502f7b4b99d98cd469"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000020.bin": {
+      "bytes": 67108864,
+      "git_blob": "28e684e2fae68545007f5185b6527195c57e0a0a",
+      "oid": "fa6b1a53f097da8386bb68af7ce3cc30f03278a1f4d8f7239808b201cd7a749c"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000021.bin": {
+      "bytes": 67108864,
+      "git_blob": "c5228a301d8bb86748d2a39d3c04aae2110ad213",
+      "oid": "131d6da773eee65ca0f1c7428c08482f79221081aacdee26ec0007459978ab16"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000022.bin": {
+      "bytes": 67108864,
+      "git_blob": "817e11f53fb52240b82bb57857e925951544346f",
+      "oid": "8d1154d7162a57d0f57468d504b8f130772ef8559eb841d99d00bac02405535c"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000023.bin": {
+      "bytes": 67108864,
+      "git_blob": "342693405a630602759cbf49f1d58996bfc44fb2",
+      "oid": "d797d536a090d75a979e142e8b3d7a253692ba4f279582c3dbbcf574e94642fd"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000024.bin": {
+      "bytes": 67108864,
+      "git_blob": "d525da073255ee29105dc6d95d253ae1a41e6a21",
+      "oid": "e28242563a376b4edecda075b9ba24ff1f7c372321ea5820bc362be6bddfa3dd"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000025.bin": {
+      "bytes": 67108864,
+      "git_blob": "d440eed7c2fd5f0652579ffcd9276eb869c04c63",
+      "oid": "6d66b8a69f3c6c1ef5fd2f6dd635a1d405fb6999adb28fb51bf376fbf91ad292"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000026.bin": {
+      "bytes": 67108864,
+      "git_blob": "3299d1777566dd414fc9ea9896687be6d4d8317e",
+      "oid": "f4da405b1b1834faf55e94c49e557ecffbbd3455104d3d3d956bf23da6e74550"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000027.bin": {
+      "bytes": 67108864,
+      "git_blob": "1f2a49ed783da65cd0e27881cc34787622a964d4",
+      "oid": "bd88c43e8e8f27b6d40d17eb7b2b43fc33b09fb2b2a49eb089a59daabcaa1483"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000028.bin": {
+      "bytes": 67108864,
+      "git_blob": "8af8e27b389e5ed30b0afaa6976875c4491019ef",
+      "oid": "087c13ee0798fb19382ecf652512b59d8bc4e0092ef1bd24fec6bc638475cb68"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000029.bin": {
+      "bytes": 67108864,
+      "git_blob": "5d37fdf14011fbbefbe06825b8a9a64dc0bc42c8",
+      "oid": "026226ebc7d0e57df8871078cfe878c6464ad5abd676face2e0d35c8e736807b"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000030.bin": {
+      "bytes": 67108864,
+      "git_blob": "97bd90c4c99cd8a31789bf2aa5e0943f4658595c",
+      "oid": "94a6b0ad920335163651eac7b016ff3e918680c9108a28a270dc28092f322fc3"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000031.bin": {
+      "bytes": 67108864,
+      "git_blob": "4509a576c833fef9ad5db1dd03fab044a6ea8841",
+      "oid": "b433bd088cb2bf076e962192be72700ff6ba6127b357bf0e7f5793e6a8edba56"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000032.bin": {
+      "bytes": 67108864,
+      "git_blob": "c89addda02ebc93122f8c03c07227a6a9ba28e02",
+      "oid": "01991f0a6738ade443755b67a5ad3dccc07ff6ac70a1553fe671ad6560b15909"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000033.bin": {
+      "bytes": 67108864,
+      "git_blob": "fd07c6f7edc5f582cd75d7a5ca5f161505ee73e3",
+      "oid": "11c0f36233a8b8256139235f57acef96297180946e0ad6ff7645f61fe4c79559"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000034.bin": {
+      "bytes": 67108864,
+      "git_blob": "98fcf853c73c643a84271172995c54a8dcc38204",
+      "oid": "13c2d2d78eb40c7324d9bc42cabe17a5f60dca49e6f5fe5fb17c4960edbec039"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000035.bin": {
+      "bytes": 67108864,
+      "git_blob": "09f2bdc9494d2dd05481824ec8b081dd1b3f771f",
+      "oid": "ab813823e7faa5c4f972c8fe774695d90dc0c778115afd1420c1d40897a152b0"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000036.bin": {
+      "bytes": 67108864,
+      "git_blob": "5bd6a82f21f904fc28b9c867af5b472f19114dc8",
+      "oid": "c1c5f242a17d885118a4c601b8b233632c53355916584c4b9fc600e0c3115ff2"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000037.bin": {
+      "bytes": 67108864,
+      "git_blob": "928a33dc99b010622fb3aa1f760eece4e4b6a5a6",
+      "oid": "a65e7d1a0ed2a2b3320e2af65ae72b2f523298f59f05f9ba917c0d2ba57fe528"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000038.bin": {
+      "bytes": 67108864,
+      "git_blob": "feaa0d58f8bad1edfda285a0456167067fce48ea",
+      "oid": "47605ee88b47821758f28b25b3912c25397fd32239c972243004d14457f72c82"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000039.bin": {
+      "bytes": 67108864,
+      "git_blob": "ea6c8d5ca1a12e9a61afa5d15f4adeff8fd78e26",
+      "oid": "2290a53b9cfffaa1a0ebb6cab41ec195c3d16c1d1b347941d21e4fe8f9998627"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000040.bin": {
+      "bytes": 67108864,
+      "git_blob": "11477a4c68c0bb716ebab1b4b8d598c107a28087",
+      "oid": "256844cea01953996a0ac87f18979cf6d35ed56786a5485f48ad2cb3c1360ece"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000041.bin": {
+      "bytes": 67108864,
+      "git_blob": "e42fe72490fa2a38c84db158f7aef7f8ce4c011f",
+      "oid": "3dc3f7b6d3303d91e350057dc27ecf0d02b857d33d8eaa2eef3a4bfe7f40eeab"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000042.bin": {
+      "bytes": 67108864,
+      "git_blob": "1738c3aedbd7140a8d54427e037d2bafe3073bce",
+      "oid": "def2c14f8c533dc0baf4426ff32de64e2f26272403462d3ed014b2b74b3fb52d"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000043.bin": {
+      "bytes": 67108864,
+      "git_blob": "f4c65681fdf0e313811f6d31400c8b8566966b3f",
+      "oid": "6110a1367894ddd26909ddca5c4568f6bb5545b4468e40811b02c3a696b3f151"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000044.bin": {
+      "bytes": 67108864,
+      "git_blob": "5cbc2d48ad41ab9f06fe9f0571d5f248ecde2688",
+      "oid": "b0742985cb8f65d244b9ce49cb14f777d0daee4d75b79193d73f94dd2fc50345"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000045.bin": {
+      "bytes": 67108864,
+      "git_blob": "5ddcfff4f462a30bdb7a303a5b1ada82d9d7ba33",
+      "oid": "1d8671e30380134313dedac85e6ea51a47ff7de3ba9b5f235208c913a3d28672"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000046.bin": {
+      "bytes": 67108864,
+      "git_blob": "de832d330ec009513a225c48f5d0c0beb19e753c",
+      "oid": "3157bce6ca069dada4f95ca8149a0ca431b72423bb2a2c182409b72c1b143b80"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000047.bin": {
+      "bytes": 67108864,
+      "git_blob": "a4995f53e8760be07c24a99426a91e40d0d178bc",
+      "oid": "c00cf2634c0f50c1abe4502192d541ff6bd9169acca2d6bc8fe50100efcff9bd"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000048.bin": {
+      "bytes": 67108864,
+      "git_blob": "19a22b1cf764d45e8416aa30c4c14a8b9bf12bca",
+      "oid": "fd836db27d1f3906cf6514596cbdeab7290643660614ad7e449ac95d79bd0082"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000049.bin": {
+      "bytes": 67108864,
+      "git_blob": "cfe7d68546f2d741a852128d792cd01e5a0609b5",
+      "oid": "05d52812c5b77ff9a3441a5e72fe7ed0ceb6d236981b2d4cc85c98ce91d866e8"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000050.bin": {
+      "bytes": 67108864,
+      "git_blob": "b59f4ad1b4993e45f70975ba362a005fd916a61c",
+      "oid": "018ba52c09e1105bbf2c828cac95fd544a94ce7b464c8000d1a6c9609e3cf0dc"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000051.bin": {
+      "bytes": 67108864,
+      "git_blob": "1c1651960177ad28ebf6507599963240414f4ec8",
+      "oid": "c18f6dff39bb44a210f3e05281a8780f9130d83680cd1d3ad4456335f25b9c0a"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000052.bin": {
+      "bytes": 67108864,
+      "git_blob": "a9b24d3614b8659befe55e6afcd6ab33621ed6ee",
+      "oid": "c888efc1ef75dd48c41bb2ec18cc4d223b5a12f3a7fe83a0abff6c99ebf1407c"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000053.bin": {
+      "bytes": 67108864,
+      "git_blob": "17a77ed5f68782a6dbe6e8da36cbfbfe03e6b50b",
+      "oid": "6f9cd36795720489c8ef52e600394eb92fc8d4d9dcb5049bfcc89914acfa20af"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000054.bin": {
+      "bytes": 67108864,
+      "git_blob": "56b6cbc07fea93dacdecdbcd8e0125f08c7aa053",
+      "oid": "90421f2d11d14f8004c592664921437ff64001cfe929e6de0bcbd0e24e9610ee"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000055.bin": {
+      "bytes": 67108864,
+      "git_blob": "1c09152a10fce5dc327066e5b7b8674daaa7842e",
+      "oid": "73a1a0eb0b473e842e5bae81331257ef89090b9af6538676375bb5757ae3c589"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000056.bin": {
+      "bytes": 67108864,
+      "git_blob": "c8a9c1f913ebc2c230f68fd7646173153526ed24",
+      "oid": "7b4fb640cc128ac0438186012b622db4246359cdf098c3e874e1af5b4add28f1"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000057.bin": {
+      "bytes": 67108864,
+      "git_blob": "d0478934976bfbae6a910989449b694d80b228aa",
+      "oid": "acd914306dce998276452979904e04d405a492a8c81340f209f3224def906722"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000058.bin": {
+      "bytes": 67108864,
+      "git_blob": "2234cf752b925de409850d781c40120f17135d90",
+      "oid": "f15627615ef7579d01f21e5a35c321bbc6599d66847e11e37440c12dbfb7b676"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000059.bin": {
+      "bytes": 67108864,
+      "git_blob": "ac821671744f5d0eff06c40977d185e2b12e5d12",
+      "oid": "df6d02884bb8b3c313b279cb1f63f00c2ebc39340f6a298b17be6a1d4b9b5fc1"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000060.bin": {
+      "bytes": 67108864,
+      "git_blob": "7f367abb4cf0a74ceab3ed7a8a650237fe26fe54",
+      "oid": "3f0a9827926d381ef0eb09569de9c133a24f88b6c4e2e07bbf582e7259a261b3"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000061.bin": {
+      "bytes": 67108864,
+      "git_blob": "ec9ca6d15bb5098ef539fc236cf89dde1c529c3f",
+      "oid": "2419ad28f6dce0b26b34432f6f9933a7850755a68c1d19191cc13e590bc3689f"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000062.bin": {
+      "bytes": 67108864,
+      "git_blob": "d6e03d74381e6f0747b7dc07394d213e0ebca13b",
+      "oid": "03b39ee51f20fa8d801e0b6606fda6c1be8625de19a30cc28efa4e60a52ef1be"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000063.bin": {
+      "bytes": 67108864,
+      "git_blob": "be21eaa2fa6c014dff1e090981c9e6703464d50d",
+      "oid": "bbb58825d3b6b18f9c120d3abaf8729f694ddf8e3d00ea7cd831bdc9ae3f63fb"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000064.bin": {
+      "bytes": 67108864,
+      "git_blob": "44bb6a485846b23002797681f08d9a519b222e94",
+      "oid": "835c49d7ad41c233d0e20e59f5ad87deb31c7dff3662db996a52f3c60a4ca616"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000065.bin": {
+      "bytes": 67108864,
+      "git_blob": "f1720e545c3c2d64fdc79fe4abf095715af831dd",
+      "oid": "53129c4320559e8dc1959a8fdcd7d756f68b2d82acc8ca6681f4aa691969f906"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000066.bin": {
+      "bytes": 67108864,
+      "git_blob": "dec6ee75103a3ef6068eb52b5c3e8082b721dda0",
+      "oid": "6a03395293e454e95163444c04a77961bfde9f71daf902911906566b7df4eab1"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000067.bin": {
+      "bytes": 67108864,
+      "git_blob": "c823ccd2192de9cea0b556f082366e1333ab5e1b",
+      "oid": "419e60c582a4c8f119f9a958f33ef88164fa334c38e7c47163f03d761d89e4dd"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000068.bin": {
+      "bytes": 67108864,
+      "git_blob": "090228b509ad9824a1683b469b453396d202ea65",
+      "oid": "26222b3988412e52c10bd2a8cddd5b0a54409f16aa5e2367f9e6c3606760221d"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000069.bin": {
+      "bytes": 67108864,
+      "git_blob": "92f032817e8a677e6311e9ecb3e48f034c478ea6",
+      "oid": "661e862287f8283794e812d5484dfc77651e6a9c44be2122f10b25e702dbf52d"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000070.bin": {
+      "bytes": 67108864,
+      "git_blob": "a34011143ca449af5765764ef1ebf0a99ba015ee",
+      "oid": "71de14c9a34cfed409f74d825c88a8b473cd509b1dd2619fe8d5a11da131bee0"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000071.bin": {
+      "bytes": 67108864,
+      "git_blob": "7bb6a296c74800afc32b623bfa63df312d50ddca",
+      "oid": "7c8b878109bae512ed7f411055d974e0669a31da88b561e87e4fbacbadb96375"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000072.bin": {
+      "bytes": 67108864,
+      "git_blob": "2cbf313125ee233cd703545354dea70b2e9a4a86",
+      "oid": "c75a839c07a242aa09dc0603b46cefd87ac79bfc6776dd4707f425f4afd143df"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000073.bin": {
+      "bytes": 67108864,
+      "git_blob": "80754a728b907e593b13dbeb9ea3002a78ea1e40",
+      "oid": "af98e9729afc0d1406b7531e135ab4d932c34f9c38df81636026fdfe461fc400"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000074.bin": {
+      "bytes": 67108864,
+      "git_blob": "3b5e3397dfcd341314e4672763afe04bf961e141",
+      "oid": "8de906c2956b66594902536069870c6f4bfaa8221cae561a6f7a00ea9b3ab338"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000075.bin": {
+      "bytes": 30040253,
+      "git_blob": "819495f28df56d5d40198f25be2fa709c6b07f4c",
+      "oid": "98714008fee0cffd305c8e7b45d74d224033d013f7ea7a1759eb160ca0fff2f1"
+    },
+    "artifacts/public-resources-20261001/shiu-author-model-source/exclusions.jsonl.gz": {
+      "bytes": 20,
+      "git_blob": "1c35409ae4793732668f75c463c9722b3aedc07c",
+      "oid": "9ceffb7310338057cfe71a4ae1e2c98d2c485d81cdef906532a801f457a38d64"
+    },
+    "artifacts/public-resources-20261001/shiu-author-model-source/members.jsonl.gz": {
+      "bytes": 349,
+      "git_blob": "5255a1c3bcd8d5dee99da2a141dbea8a0f1926ea",
+      "oid": "2907be4f7d1a8f1017f91bda6e5ead381b8c67b85498f5378765d696f89d4b0c"
+    },
+    "artifacts/public-resources-20261001/shiu-author-model-source/payload-000000.bin": {
+      "bytes": 6828,
+      "git_blob": "f232dbe857338e8568c11d2eda162853158b39e5",
+      "oid": "4da352d80e4bf251dfec771935da93f5a9f3cef302c85e90991fafa14a072e2b"
+    },
+    "artifacts/public-resources-20261001/visualpathways/exclusions.jsonl.gz": {
+      "bytes": 218,
+      "git_blob": "ba39cbc1c01c2bd56e52eca5ad9748f715e61f1c",
+      "oid": "9c029262724580ef20981316c6f7e9c99d345e1171067f16c5d580c742809a8c"
+    },
+    "artifacts/public-resources-20261001/visualpathways/members.jsonl.gz": {
+      "bytes": 292178,
+      "git_blob": "d5426fbd8cd668b67fa16935f4e7cf1f3c223777",
+      "oid": "335401c3f6cb5b3868b899599bcd7b439c1983a627d97a598a95e9c8d44ad81c"
+    },
+    "artifacts/public-resources-20261001/visualpathways/payload-000000.bin": {
+      "bytes": 67108864,
+      "git_blob": "d04ed630add6224a87c0bc48a70473568a387dac",
+      "oid": "7f8bb35dcb565c16ff1bf642e079c54c71e27e05cccaa5915c1d1e3c9e7d0700"
+    },
+    "artifacts/public-resources-20261001/visualpathways/payload-000001.bin": {
+      "bytes": 67108864,
+      "git_blob": "b4bba7c798407330ca3cc2428c890ff5b8d27f79",
+      "oid": "7181f79ec2615a84f33b394abf22454b72d2fddfb0e40e9c5e1590fe1ba64d7a"
+    },
+    "artifacts/public-resources-20261001/visualpathways/payload-000002.bin": {
+      "bytes": 67108864,
+      "git_blob": "88a361aafe0ae8f98d4031ea0366051c98a0025d",
+      "oid": "9dc076afd8cd8ebbbdda6f1ef24a41598e5db9fb0a98de8b5b765b4b0a8d2934"
+    },
+    "artifacts/public-resources-20261001/visualpathways/payload-000003.bin": {
+      "bytes": 67108864,
+      "git_blob": "5fde6ec1b0c39c9237d0b201e2e0f05c7110b845",
+      "oid": "be03beac2472e6dc76a5705440296f88a8f6e15ea43f541df402c7b6c85cfdc6"
+    },
+    "artifacts/public-resources-20261001/visualpathways/payload-000004.bin": {
+      "bytes": 67108864,
+      "git_blob": "1f00ec92f1ff4b4ebc015ce1bb725149240fc1fa",
+      "oid": "0c801486169d0594471518a75b11b040acb1a2dd8904e9365fa7b7b667fc4a09"
+    },
+    "artifacts/public-resources-20261001/visualpathways/payload-000005.bin": {
+      "bytes": 67108864,
+      "git_blob": "16d9b6284c8e30be01ee6452a4d66a212555fe1f",
+      "oid": "4f387b9e6b47f06871ce1b32e265b3a1ae2d78e06d7955a3fa8ed7cfc1d2a0a7"
+    },
+    "artifacts/public-resources-20261001/visualpathways/payload-000006.bin": {
+      "bytes": 31805270,
+      "git_blob": "7314b8a57934ad336c7d89b5ad54f30fe574869e",
+      "oid": "edb0ffa74e646712485a0d5fd2819ef14345c637beeaa5ca811ae3e71a06ea82"
+    }
+  },
+  "schema": "main-integration-audit-v1",
+  "scientific_execution": false,
+  "source_worktree_integrity_requires_separate_audit": true,
+  "source_worktree_write_operations_by_this_tool": false,
+  "staged_original_blobs_checked": 12674,
+  "staged_tree": "caf5b8661d9d03743169c1a49cd7a6530964e815",
+  "verified_utc": "2026-10-01T08:54:10.356524+00:00"
+}

registry/branch-consolidation-20261001/merge-audit.json

@@ -0,0 +1,894 @@
+{
+  "allowed_existing_changes": [
+    ".gitattributes",
+    ".gitignore",
+    "CURRENT.md",
+    "README.md",
+    "docs/40-operations/branches-20261001.md"
+  ],
+  "artifact_paths": 181,
+  "lfs_availability": {
+    "all_download_actions_available": true,
+    "batches": 2,
+    "payloads_redownloaded": false,
+    "scope": "Authenticated read-only LFS availability; full byte validation remains the unchanged prior fresh-download receipts",
+    "unique_bytes": 9893620059,
+    "unique_objects": 169
+  },
+  "lfs_pointer_paths": 171,
+  "merge_base": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+  "model_tool_registry_artifact_bytes_unchanged": true,
+  "new_paths": [
+    "docs/30-reproducibility/main-restore.md",
+    "registry/branch-consolidation-20261001/plan.json",
+    "tools/branch-consolidation/verify_merge.py"
+  ],
+  "parents": [
+    "4436241976887d8cc10088b0d44bc7ed70978fe6",
+    "5b1d1b72d7683b5c3dcc1f78b408e1d9dd2832ac"
+  ],
+  "pass_all": true,
+  "pointers": {
+    "artifacts/acceleration-20261001/gpu.tar.zst": {
+      "bytes": 1679158,
+      "git_blob": "0f185c43ecd1225f043aa31adbb6b7829bf8cbf2",
+      "oid": "50acdc85342a2c79c3516e50ee4542b909813d179518451edaaf2d94150c534b"
+    },
+    "artifacts/acceleration-20261001/pipeline.tar.zst": {
+      "bytes": 74767927,
+      "git_blob": "65ddc7bfa98b8f177c795bb91884d41454586e29",
+      "oid": "fdc39013d71fb7d14313d8249c929601a8a7050cc2eac88b733d692bbe1b6b42"
+    },
+    "artifacts/lfs-smoke/publication-probe.bin": {
+      "bytes": 263,
+      "git_blob": "14e759036eebe61c3e7a8fbaedce459d0e52b0fa",
+      "oid": "93e0e6c4ca4fdc123c21b859ba97d8bd73670eb9c90d04ce9a431d822b5393c5"
+    },
+    "artifacts/public-resources-20261001/celltype-explorer/exclusions.jsonl.gz": {
+      "bytes": 144,
+      "git_blob": "09e234a4297969c928bb654374a3047a59c7dcdf",
+      "oid": "c1bca109b61e53327fa7e01128a411d8ea328972593168c3ad6e1202dfdddc9c"
+    },
+    "artifacts/public-resources-20261001/celltype-explorer/members.jsonl.gz": {
+      "bytes": 421593,
+      "git_blob": "cd5607573bf3ae0a51ece3f3a052397f1b0a0f63",
+      "oid": "8a51d3b4138bad12a520f8d1a12d54673416017d15fd1b1bcc49ed385da005bb"
+    },
+    "artifacts/public-resources-20261001/celltype-explorer/payload-000000.bin": {
+      "bytes": 67108864,
+      "git_blob": "bd8c136dcd35737e121c5ba7625a55d887c0ec89",
+      "oid": "6f5830463b8a0077ae89e550ca45275d57cf7e81813c42bf66f89d13a42c03ee"
+    },
+    "artifacts/public-resources-20261001/celltype-explorer/payload-000001.bin": {
+      "bytes": 10862890,
+      "git_blob": "8b2713753746e96e714f55a813a87b591050d8a6",
+      "oid": "6b80b0133af06279bd30561f35042b679bd392b9236ee519d1e7ed9c4e85fb6a"
+    },
+    "artifacts/public-resources-20261001/door-data/exclusions.jsonl.gz": {
+      "bytes": 147,
+      "git_blob": "42e420697802f0ca1ce7f5a611411cdb31d1c71e",
+      "oid": "82627a482fd6adfc3abf4f83a30158fd8371b4532f425f7eb3b03044eb7e1367"
+    },
+    "artifacts/public-resources-20261001/door-data/members.jsonl.gz": {
+      "bytes": 9486,
+      "git_blob": "ab7591b84fc9593dc93240eb4d85af5c7b259859",
+      "oid": "ef13db49577b3b3d1c7c31aab117d911a2decc5a80ead66b6a350c43d16374b4"
+    },
+    "artifacts/public-resources-20261001/door-data/payload-000000.bin": {
+      "bytes": 901984,
+      "git_blob": "19555f614f64e96c7d80be33a7c1558198a3d95f",
+      "oid": "64d415a1ea9f5c2fe09005ce1c2bb27eb45510fad27ad3c39cf0001e6f525fd1"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/exclusions.jsonl.gz": {
+      "bytes": 219,
+      "git_blob": "d9c55185336648c6280d4bad02e1e3506dabec39",
+      "oid": "0909f401f73ca15301ea2be92a5e7c66cf79d9d4f8bbe5449f82c2980d6d3e80"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/members.jsonl.gz": {
+      "bytes": 3639,
+      "git_blob": "1ba7548bebb67676fbc7a99dc71cf9d2db0cc2ab",
+      "oid": "fe399bea661cdd018e53a5ea58bc46a64d2f94fb09d1dec40f8a956789204627"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000000.bin": {
+      "bytes": 67108864,
+      "git_blob": "b69d887bbb82cc7ad15ee0874d4c42060063547d",
+      "oid": "a65619004cdc36e594bdca344d1fe51ac86fb719159f70a2ba0fb21c763f9c04"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000001.bin": {
+      "bytes": 67108864,
+      "git_blob": "7aced7ba1c85c8549352ed019cf6fb6c1dc95e4d",
+      "oid": "cca9eedbc44b20be736317745ee12e8c06bf0e1aafc7815b74bc6aa27cef5be5"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000002.bin": {
+      "bytes": 67108864,
+      "git_blob": "ef373282a813d588058622a59c14ea8e1d0d3f94",
+      "oid": "e395b23867e74b7579aed8eeb927e373c86d77433962a0f89ac198aeca4f8470"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000003.bin": {
+      "bytes": 67108864,
+      "git_blob": "ac6d8315736893607c5367f89310f5877802e8b8",
+      "oid": "e47d83eba2875f963add02ab697cb6386dd8fe4a5f33b96db5a321986a276774"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000004.bin": {
+      "bytes": 67108864,
+      "git_blob": "769b6f74cef3fdedad5815e38b7883883690cfa5",
+      "oid": "4d4bdff46071f05c29ac34cd9081204739317bef5ab862d612d2c7a82c3d5bca"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000005.bin": {
+      "bytes": 67108864,
+      "git_blob": "bc672ab43e90810ebb53fc799bf84d6a1d947ab4",
+      "oid": "4f82611c41e868faa6ea06d7bd275df90f712e3f5eb14296117e39c3bf6c95c0"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000006.bin": {
+      "bytes": 67108864,
+      "git_blob": "f34f6eb0d4264e6b6b9b8c147bc2eea551c3aab0",
+      "oid": "4cbfb164c194db8c54eadef4d039240d98b0f5be8e20e4005be08bd2d2f6ab5d"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000007.bin": {
+      "bytes": 67108864,
+      "git_blob": "636780a7aa4695e7048f5ee049e625aa3fe7fc78",
+      "oid": "9ba4adfe64d73d0ceb249ab25215734f58b0d8b38d11f22676fd93f68e83df68"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000008.bin": {
+      "bytes": 67108864,
+      "git_blob": "11b4bd27f807293143ae87448308e104e0356a93",
+      "oid": "8f388376c6e9d3b7abaff219b00d669ea88db1bf5cd48381db9354598102b345"
+    },
+    "artifacts/public-resources-20261001/malecns-processed/payload-000009.bin": {
+      "bytes": 31352355,
+      "git_blob": "75cc67bb548b4e94d67f10bf69023bd3073b5fe3",
+      "oid": "e1ac638f1d640de9e85b82d9526d6f729f78239e66c5c024e0037144adf7f003"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/exclusions.jsonl.gz": {
+      "bytes": 135,
+      "git_blob": "65ee80ddca5cde591a2728533ec3f62cb0e8a700",
+      "oid": "887492a8f75af6be4e71b6f5aa12506cef3d8e3a7363b3c6a50064da93b9b4a1"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/members.jsonl.gz": {
+      "bytes": 1009,
+      "git_blob": "f1d777d57f3874b67a976fcf2c189ad73cfa4b6b",
+      "oid": "e963adede9d937effbf5519ae9717938a2b3324aecc1c28338800007f7003404"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000000.bin": {
+      "bytes": 67108864,
+      "git_blob": "1d7b75a438e8d3cd76de66e2ce87257be73db5bb",
+      "oid": "5527fc251d23c23209cf16c8831aedefcceb6d1e927a4eaf9ebed182fd5481ff"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000001.bin": {
+      "bytes": 67108864,
+      "git_blob": "1f0f13ffc504e721405adefbe5cf687f2562558d",
+      "oid": "4793d00b3d6b3506d16e21f3f3775bc70c23c70cd5be03b6733350328519a3c0"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000002.bin": {
+      "bytes": 67108864,
+      "git_blob": "fa31a68267dcf65bb07c40be8863d42c68d46923",
+      "oid": "a78930db08134f72e97306df7256bd8b0b533611fe9a08459f1c6289eb47624e"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000003.bin": {
+      "bytes": 67108864,
+      "git_blob": "748f9117687e60ab529c28d4ed28ebede6e3cf40",
+      "oid": "54fc4943c3d644e1765a7cbdacf0629db1ddefde4f17035729417242930064a9"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000004.bin": {
+      "bytes": 67108864,
+      "git_blob": "e1920897dc73e921e41d8a9364bc7668db17da42",
+      "oid": "7bb2deb3dd7d3f7064c096c8915bb3eff7f880a009628f6ee6c5e14dce939668"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000005.bin": {
+      "bytes": 67108864,
+      "git_blob": "d510b5c4e5e06204b800e91c4db4c2a4d891ade9",
+      "oid": "d1aac9ec93c77f901c98c7343fd3713c746faf855096e9d7e6da897491c513df"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000006.bin": {
+      "bytes": 67108864,
+      "git_blob": "004c1d6ef14926b0d69d2bf2ee578b0cb2eb9a5a",
+      "oid": "29f40919b04405609643b3a5a2beb749aacbf5525cf90a60d75fa3f0a283435e"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000007.bin": {
+      "bytes": 67108864,
+      "git_blob": "b330586398d4fb3d5430056aa851496be14ac093",
+      "oid": "b3936a86da8636e5ba6d7a25f4d8d3b34eadc769e74817d67c7aefe2e9879e68"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000008.bin": {
+      "bytes": 67108864,
+      "git_blob": "f9ffc16535fc8a76bed275471284f920be87a1a1",
+      "oid": "47e2e7cfde2bc01d41de53ba933683faf4fa4dc57c3d80f07d8edb75dc1916d3"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000009.bin": {
+      "bytes": 67108864,
+      "git_blob": "233a14ce3b1c4032341bff70ea3866920a264913",
+      "oid": "ab37af43abeeb3434b0660fb5bfb185e7c0db07916b2a2233a2db083f66ea2b9"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000010.bin": {
+      "bytes": 67108864,
+      "git_blob": "2296a326b6c9741ff9876deaaaa19f630088dff1",
+      "oid": "bdbf00683b8940fb513fef121559e8e449d84972e03df2d4698d06e0dcc28efa"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000011.bin": {
+      "bytes": 67108864,
+      "git_blob": "884ecf37372792ce6dae1d1b4c7cdefe7f418760",
+      "oid": "a3ee35cae393b29d0366aebcad7f63a8ad578b61e0a93e773595dfdfe6848bbe"
+    },
+    "artifacts/public-resources-20261001/malecns-raw-core/payload-000012.bin": {
+      "bytes": 28959790,
+      "git_blob": "fdf9e40c25c1baa9d43c4b87c60f9d9f1cdbb0fa",
+      "oid": "7fbe5733e328f5a989fec3ffd78819c62ac53a32e099579492cd82766322e82a"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/exclusions.jsonl.gz": {
+      "bytes": 20,
+      "git_blob": "1c35409ae4793732668f75c463c9722b3aedc07c",
+      "oid": "9ceffb7310338057cfe71a4ae1e2c98d2c485d81cdef906532a801f457a38d64"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/members.jsonl.gz": {
+      "bytes": 10023755,
+      "git_blob": "e7b5dd566bfa5da5f4d01dbfb93e93e2534698e0",
+      "oid": "1dcc1bac912889118e2a34211b4c43b2b0af871c8b76b97ede31db88ce67a961"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000000.bin": {
+      "bytes": 67108864,
+      "git_blob": "304278d54740a55ef0287157cbd338e4173a01ae",
+      "oid": "1f21099a6411dec6c0b1f5eba48618de749ac6ec7f18b18d7521fe75b7fe32e9"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000001.bin": {
+      "bytes": 67108864,
+      "git_blob": "1c0626b01e8a9e0b1da9a0715290feb49d9dc2c0",
+      "oid": "a749bcac2abeb5f8621603d81a069a96b63cc5e12dbb87b51744b5838c25bab5"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000002.bin": {
+      "bytes": 67108864,
+      "git_blob": "c4ebb418a529c2cf80eb0702d9ef3da8265c6d3a",
+      "oid": "8bacba0b7452c99f2a8e57b17f72604671d78faed5dbc39cf800b148a9a3476b"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000003.bin": {
+      "bytes": 67108864,
+      "git_blob": "171a8b118676c2f14e334d93ade9f53d958e35c1",
+      "oid": "0e226842328b68a4ce86bdb612379047c44a535c6d4b5eb8aa97ed0fccccede4"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000004.bin": {
+      "bytes": 67108864,
+      "git_blob": "ef9c5684e74c14a5fe30bc6bf503c7745e22a668",
+      "oid": "19559779bbd8f305c690ccb1c5a2a03b53bdee0e2afe3f6dca1faf2926ae1143"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000005.bin": {
+      "bytes": 67108864,
+      "git_blob": "f6304845575462e3315f180e780f38113c3af70c",
+      "oid": "f9441d9484184e90d3b962b9b32ef80e8daa1944ca67d11e691fda715eb4908f"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000006.bin": {
+      "bytes": 67108864,
+      "git_blob": "2fee0e3b9664936f882dce6efe5cd5ec7c9df9d1",
+      "oid": "c022c80fe76fbbe69602755de5ea74b97db9ee56db280d6c9ec863ba3c1ff332"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000007.bin": {
+      "bytes": 67108864,
+      "git_blob": "4d2eed4978aeef824eff8355781caec4d03b932a",
+      "oid": "12370abe8bbe6fee58be01d6b2204b64c54a7eada3988a367de9451b910ae3e1"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000008.bin": {
+      "bytes": 67108864,
+      "git_blob": "01dfb02c029244fca41fd77fff92462f1f58fbac",
+      "oid": "f7d5d2b8f699f15466e6fabcefc398b21f142d23c5ad173020add2461e32d27e"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000009.bin": {
+      "bytes": 67108864,
+      "git_blob": "10623bdbafe0bac6260c8b5c4d7ce7ed12d4e8e8",
+      "oid": "4e70530845d6e86b037cd7dc7d0d7a5bf544263f99893a6836525b92a5b142d4"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000010.bin": {
+      "bytes": 67108864,
+      "git_blob": "520e73df93975633da51b97f136f07aa0ddd3aba",
+      "oid": "9ce176c8fcaef8671815c5b4f3366c233632be1ac313ab6f351f7f93cd2f0072"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000011.bin": {
+      "bytes": 67108864,
+      "git_blob": "d1f8fd74b2eb676ccd36956c646150f508123ff9",
+      "oid": "12f4d9d507494cd85f17583fa9665f20b68f928db1125668d9bfc462fc0f66a5"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000012.bin": {
+      "bytes": 67108864,
+      "git_blob": "3094f061e35815742991c111d645e8fabec771da",
+      "oid": "39e8403e3fd8ea71e281034b346da33511d1ec1c236b1f16929113d4cec53e6d"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000013.bin": {
+      "bytes": 67108864,
+      "git_blob": "3f451d645dfb57402d75132df2d0f9a9eacc3bae",
+      "oid": "979bb9d50a5b44608ce6ace417dec67236072d027fab79cf9b0255ed39c08020"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000014.bin": {
+      "bytes": 67108864,
+      "git_blob": "586190bbb62b6daa7c5e8d26691a8fb9c1d5a55b",
+      "oid": "b029a7948ae6c23916fcd81c3b9bf1a260f2c9d8659b53b7f5e556384349f21f"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000015.bin": {
+      "bytes": 67108864,
+      "git_blob": "6dd7054e14bdba92eabed05da013625f086d1348",
+      "oid": "c26d6139d8e1a51ffabe1a06a13c2061a5928e168a961930d9d195a25b6ab620"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000016.bin": {
+      "bytes": 67108864,
+      "git_blob": "385371fc8a45236ae6cdf32f22aa41ca1e49d29d",
+      "oid": "98b5853bc02c4bd0bf1598fdfd1c52f55628660047fb4977f1f8eaf02e70b603"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000017.bin": {
+      "bytes": 67108864,
+      "git_blob": "7542ed313b9a52b32e318d2420fb68668b36656f",
+      "oid": "789d6ad66acddd2aaa750d4c27d55be897f0c9a935c0c1837d9e46c2f916d0b3"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000018.bin": {
+      "bytes": 67108864,
+      "git_blob": "e96574ba4baa34169f2eb733676254f47a69ddb0",
+      "oid": "907c4ae7690a13663e8a489ec229f436e329823b7fb1c1e68228338388754ec7"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000019.bin": {
+      "bytes": 67108864,
+      "git_blob": "0bc017c7a9f30159473b90ae906e51f3f78664cb",
+      "oid": "c28d51fdf23a630eaf2506276da19d34c609a6b5448afdedd2efea25e4602b06"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000020.bin": {
+      "bytes": 67108864,
+      "git_blob": "4e2f35715ae3ea318d1d06c59203d2fdc34f0cfa",
+      "oid": "2d1be9e0abfd4604b55bfd0c8e740ee58bb153d126a81aa08126fecdc0057150"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000021.bin": {
+      "bytes": 67108864,
+      "git_blob": "3ad329dbccf78e9102ae00f6b989f465740583d0",
+      "oid": "f9725762b7fb5e0cc5a896c8b63ceb816faa246aeba4a3082b9eaf492cbe97c5"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000022.bin": {
+      "bytes": 67108864,
+      "git_blob": "14f4c477434a1d4708fd1c4a78c6ba963fc47b11",
+      "oid": "72e90497e9e6fbf586e3659d4e023f47a8f3942ac10bce1fe314659f16568160"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000023.bin": {
+      "bytes": 67108864,
+      "git_blob": "a41e451a2a6d0599e18201fa08c6b36340ab4707",
+      "oid": "2fd9ba58a4f2acbb5fbbb023cb100a1bcc0079c7c490d25c2c63bd46441aa08e"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000024.bin": {
+      "bytes": 67108864,
+      "git_blob": "6b5e299ff6eeb015ee2fd4620eb62344cfed822d",
+      "oid": "ead438094c5a9d4b5550ebc95ec583d8e7cd1d84b601e549d50c4ab9a5e9818b"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000025.bin": {
+      "bytes": 67108864,
+      "git_blob": "4e323bf1371f2619d6e7bed98edeab7857a2dc20",
+      "oid": "97b32a95ca08c4b69908c93a7ce40606a9597cd9f2eb47f9447cc4a93cb6eab2"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000026.bin": {
+      "bytes": 67108864,
+      "git_blob": "027ac3048fca4dcfe873c99d3bf72499a940e530",
+      "oid": "6f985c609b0f1f3538b7b7407da46c2983781552cec9e12e5ca9b5ba5d1ceca9"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000027.bin": {
+      "bytes": 67108864,
+      "git_blob": "ed54f94e0fdfef74f7c7a1f927d98ce4947acb10",
+      "oid": "7465e4aff8c0ad68fcbb201815828a5198611c18c8fb2cdfdaf4ba7b2a6b2456"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000028.bin": {
+      "bytes": 67108864,
+      "git_blob": "ba19b753481999cc4aa0b5c90eb16bf6a6d17630",
+      "oid": "7a3ba5b63ac70b19e54cce3e9f90038caae01e992fe81a45b7ddb370dcbf125e"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000029.bin": {
+      "bytes": 67108864,
+      "git_blob": "42e7a5241d43e01fc895c63d7b301b255eb971be",
+      "oid": "c9fafa0218befdebb42d19ff7f720e18b392c742ff45e39b64018c41a31a1530"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000030.bin": {
+      "bytes": 67108864,
+      "git_blob": "3dca0857b141fe2a82d60bd24531f588ee398d0d",
+      "oid": "aac2f55805490cfa5e42bbd7cc169a83a40132f269d64315ebb2aec6dafc5a96"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000031.bin": {
+      "bytes": 67108864,
+      "git_blob": "b81af5de591b74e80348d2f4f5b7eff67425812f",
+      "oid": "c362980ebf871332f8fc05f5f72ccce8ed13319c596039a960cd0450e7f09a78"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000032.bin": {
+      "bytes": 67108864,
+      "git_blob": "f897bcbe419b8a2f38ec90c783040c21ba6770fb",
+      "oid": "52272e69c6b23bc0951f6cd4e824c357ccb13d3bb781cd68591a8a5476540229"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000033.bin": {
+      "bytes": 67108864,
+      "git_blob": "b1018df1ab072d59b9ce7b79f52baf9d078492df",
+      "oid": "c3ada974de03b55ce956d6af4f5d9238f2e1ab7ad2bd81265eb9a7bf883e65e1"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000034.bin": {
+      "bytes": 67108864,
+      "git_blob": "12eb2bc0bc45b67132dd21a2fb9cd772b6d3639e",
+      "oid": "7aa8cf11b2d356a45e2608295deeb6443bdcf83427a8b71e6da758e2cfed9e2d"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000035.bin": {
+      "bytes": 67108864,
+      "git_blob": "8b8b2358ee54bee7c9b4eed3f11c627c40d26d4e",
+      "oid": "0edc84c74eebcc6d1375bfe5e09e8933221b025cfd4ce98539a574c1b26c6cf4"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000036.bin": {
+      "bytes": 67108864,
+      "git_blob": "12e1e2c88335f52d9103797ac767188fe0c6e4b4",
+      "oid": "ad237a494101cd4a392d0a29406b217673ecdfe1ac999f9ee76bcb99dd449840"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000037.bin": {
+      "bytes": 67108864,
+      "git_blob": "814d377e605548b56f22fb84d56496a91cdc49fd",
+      "oid": "fa89d550c2b9674ed8e01a1443d355c01cfebae2394a92f21999e09598159249"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000038.bin": {
+      "bytes": 67108864,
+      "git_blob": "d61e72bd9916179c09ad8dfa3ce694a6629a4fd7",
+      "oid": "c22cd72daba6848f000d39c6c9e0f500c47c2a97c59bf4d01cb485c4542504af"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000039.bin": {
+      "bytes": 67108864,
+      "git_blob": "e102023cdeb4aba6aeafe72c8d4d02f32e9d551a",
+      "oid": "9c3cb5c9db5915ec11ddd25f01c09a68bd493f2fa7e01a2832cf6b13bd034169"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000040.bin": {
+      "bytes": 67108864,
+      "git_blob": "86e95090ecbd81b12b06b9180db95d7016c7adac",
+      "oid": "52f9bf010556a9c231771c36697c257059d1200f42b021811568e5ad8aaa81c8"
+    },
+    "artifacts/public-resources-20261001/malecns-swc/payload-000041.bin": {
+      "bytes": 8813521,
+      "git_blob": "84214d1441baf932089b403ac669b382447ea870",
+      "oid": "3bd8789f041905e31bf669c2e9877dc19e92108dc721fa7db4c6f4a1fea2a850"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/exclusions.jsonl.gz": {
+      "bytes": 20,
+      "git_blob": "1c35409ae4793732668f75c463c9722b3aedc07c",
+      "oid": "9ceffb7310338057cfe71a4ae1e2c98d2c485d81cdef906532a801f457a38d64"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/members.jsonl.gz": {
+      "bytes": 512,
+      "git_blob": "59b601e0ac09ebd00c5e15e06808e3e74ba2e180",
+      "oid": "cfe2adcc93576eeea4100b847016bd5484338f449d4755dc7071c4c621d4d6df"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000000.bin": {
+      "bytes": 67108864,
+      "git_blob": "dedf1b58a1672ea8b49fc438f705633fcbc5d99e",
+      "oid": "a507fb9917a63f6221d97780727831735bcf419bb6d36b17546f2be04e8f6b6b"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000001.bin": {
+      "bytes": 67108864,
+      "git_blob": "2b84019d1e33f79060a23af8c9690b080cdd8472",
+      "oid": "1d804d88517d49483b02b6136f155730bc886939872208dfe9afadc9d4ae154c"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000002.bin": {
+      "bytes": 67108864,
+      "git_blob": "2606fbc2b2b97d8d0115a5ac70c91f8f524309e6",
+      "oid": "506edaf9d3b21358da114e736e36eb2467d9e465e02e22b9844e2ef6d1125606"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000003.bin": {
+      "bytes": 67108864,
+      "git_blob": "02d1b472ec88e368cb758202bf700037a904a8a8",
+      "oid": "a49499b604f9769bea207ec2ec73ca65cc692389cf093eb2b206f8f355a40883"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000004.bin": {
+      "bytes": 67108864,
+      "git_blob": "de80491cdce038f32d74db1c6810baaa0581e4d2",
+      "oid": "cb0d6ee2cd988a45ac198653aa01883d79b62f178ce68284f66633f89623d05f"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000005.bin": {
+      "bytes": 67108864,
+      "git_blob": "2eb94b490bb6291e88e6f3f340a72aae82db59b1",
+      "oid": "33736340ba66093bc66c94981e517c223e46b6853d3b688f609abd6656c1b64a"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000006.bin": {
+      "bytes": 67108864,
+      "git_blob": "f87bb82d9728c2a4d89cbf1c6187d46820ee6aac",
+      "oid": "1cec62f5de3779beddc26800d99a8e0263c171cf3a0796a8775e083ad72a5267"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000007.bin": {
+      "bytes": 67108864,
+      "git_blob": "e48868aa2bb4a4abb07f55ef72eefc083c2cc427",
+      "oid": "ff9ca8cb58c6566ab39b955649bd599919f93f65d241979f78852ba6bd45f465"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000008.bin": {
+      "bytes": 67108864,
+      "git_blob": "a3b972b91778fecfcbc51c9b1a421d4a0a900a70",
+      "oid": "c2710524d019452db8832dbe8f258fcca38bea899400342056f2646a75c1540d"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000009.bin": {
+      "bytes": 67108864,
+      "git_blob": "4fbe561d626c433393336045e1b2b1e273967975",
+      "oid": "ccdffd7293b05ed912e3acc749f8ed8c7769c135c4fa20db2f4fef4783157c6e"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000010.bin": {
+      "bytes": 67108864,
+      "git_blob": "0e780b82f0177a890102b4a299fe6b99947ef414",
+      "oid": "ebccfe2d5b5c3b60ef0b5bb9503d7849d2693ec82138ac937a585eef1654dd6b"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000011.bin": {
+      "bytes": 67108864,
+      "git_blob": "efea0bd97f35681d6ef9a8b5aa53b9f918516811",
+      "oid": "66f265f69bc110d28e679e0aa6390cdc28cff00cafc863a9055acd91daea8b66"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000012.bin": {
+      "bytes": 67108864,
+      "git_blob": "c058a6cce94e54babbcc35bd80783e117e94f0eb",
+      "oid": "f9e3084ccee597a8d6163dbf8452a53a5f74ee8bd2c26e0c7017be7d33ebf562"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000013.bin": {
+      "bytes": 67108864,
+      "git_blob": "84cc7bc319102829028a893a8dde08a56b627316",
+      "oid": "d07691bd973949900c41fb4c2e4cc4d6b10eeef256ff8b128fc5dbfadd875d1c"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000014.bin": {
+      "bytes": 67108864,
+      "git_blob": "0e3a11a6ec608a1713ff1eff45fe529303cee97b",
+      "oid": "ac78fa1d2882bbee5727993d29a7bce7f2a163ad6d8d74125b98b7a0c09c4c76"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000015.bin": {
+      "bytes": 67108864,
+      "git_blob": "fd8293817c834c5c657a22c1808ef772a5c056cb",
+      "oid": "b2b14acffeff84cdcc8c4cac4b1725eb63666f67c4aa42e324743aad471251d2"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000016.bin": {
+      "bytes": 67108864,
+      "git_blob": "2cff8263046aabb0bfa06163692a2c532a126f76",
+      "oid": "5c903aeb8cf971578901c19e5656143e66ed34e5b39207f11a811652f99ec8b2"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000017.bin": {
+      "bytes": 67108864,
+      "git_blob": "370f1e8475604f6ce9e3e2b2da9035f96e906fc4",
+      "oid": "0f249896dd016c094e02a7e031d381835536add9f48d34a2d71085f79fdcb988"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000018.bin": {
+      "bytes": 67108864,
+      "git_blob": "138c59ea1386df84a5113dab18c4b4752ba7368b",
+      "oid": "3124cdac2b3cbd389e7d1970be7ab67ebeb420290bb19901fa65a75410cf86ee"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000019.bin": {
+      "bytes": 67108864,
+      "git_blob": "6b91c64497b5024777bfb046de6df9c740f995a6",
+      "oid": "178eb19d998fd2196b60820fcc8b31ddc250163c4df0d1502f7b4b99d98cd469"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000020.bin": {
+      "bytes": 67108864,
+      "git_blob": "28e684e2fae68545007f5185b6527195c57e0a0a",
+      "oid": "fa6b1a53f097da8386bb68af7ce3cc30f03278a1f4d8f7239808b201cd7a749c"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000021.bin": {
+      "bytes": 67108864,
+      "git_blob": "c5228a301d8bb86748d2a39d3c04aae2110ad213",
+      "oid": "131d6da773eee65ca0f1c7428c08482f79221081aacdee26ec0007459978ab16"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000022.bin": {
+      "bytes": 67108864,
+      "git_blob": "817e11f53fb52240b82bb57857e925951544346f",
+      "oid": "8d1154d7162a57d0f57468d504b8f130772ef8559eb841d99d00bac02405535c"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000023.bin": {
+      "bytes": 67108864,
+      "git_blob": "342693405a630602759cbf49f1d58996bfc44fb2",
+      "oid": "d797d536a090d75a979e142e8b3d7a253692ba4f279582c3dbbcf574e94642fd"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000024.bin": {
+      "bytes": 67108864,
+      "git_blob": "d525da073255ee29105dc6d95d253ae1a41e6a21",
+      "oid": "e28242563a376b4edecda075b9ba24ff1f7c372321ea5820bc362be6bddfa3dd"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000025.bin": {
+      "bytes": 67108864,
+      "git_blob": "d440eed7c2fd5f0652579ffcd9276eb869c04c63",
+      "oid": "6d66b8a69f3c6c1ef5fd2f6dd635a1d405fb6999adb28fb51bf376fbf91ad292"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000026.bin": {
+      "bytes": 67108864,
+      "git_blob": "3299d1777566dd414fc9ea9896687be6d4d8317e",
+      "oid": "f4da405b1b1834faf55e94c49e557ecffbbd3455104d3d3d956bf23da6e74550"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000027.bin": {
+      "bytes": 67108864,
+      "git_blob": "1f2a49ed783da65cd0e27881cc34787622a964d4",
+      "oid": "bd88c43e8e8f27b6d40d17eb7b2b43fc33b09fb2b2a49eb089a59daabcaa1483"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000028.bin": {
+      "bytes": 67108864,
+      "git_blob": "8af8e27b389e5ed30b0afaa6976875c4491019ef",
+      "oid": "087c13ee0798fb19382ecf652512b59d8bc4e0092ef1bd24fec6bc638475cb68"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000029.bin": {
+      "bytes": 67108864,
+      "git_blob": "5d37fdf14011fbbefbe06825b8a9a64dc0bc42c8",
+      "oid": "026226ebc7d0e57df8871078cfe878c6464ad5abd676face2e0d35c8e736807b"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000030.bin": {
+      "bytes": 67108864,
+      "git_blob": "97bd90c4c99cd8a31789bf2aa5e0943f4658595c",
+      "oid": "94a6b0ad920335163651eac7b016ff3e918680c9108a28a270dc28092f322fc3"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000031.bin": {
+      "bytes": 67108864,
+      "git_blob": "4509a576c833fef9ad5db1dd03fab044a6ea8841",
+      "oid": "b433bd088cb2bf076e962192be72700ff6ba6127b357bf0e7f5793e6a8edba56"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000032.bin": {
+      "bytes": 67108864,
+      "git_blob": "c89addda02ebc93122f8c03c07227a6a9ba28e02",
+      "oid": "01991f0a6738ade443755b67a5ad3dccc07ff6ac70a1553fe671ad6560b15909"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000033.bin": {
+      "bytes": 67108864,
+      "git_blob": "fd07c6f7edc5f582cd75d7a5ca5f161505ee73e3",
+      "oid": "11c0f36233a8b8256139235f57acef96297180946e0ad6ff7645f61fe4c79559"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000034.bin": {
+      "bytes": 67108864,
+      "git_blob": "98fcf853c73c643a84271172995c54a8dcc38204",
+      "oid": "13c2d2d78eb40c7324d9bc42cabe17a5f60dca49e6f5fe5fb17c4960edbec039"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000035.bin": {
+      "bytes": 67108864,
+      "git_blob": "09f2bdc9494d2dd05481824ec8b081dd1b3f771f",
+      "oid": "ab813823e7faa5c4f972c8fe774695d90dc0c778115afd1420c1d40897a152b0"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000036.bin": {
+      "bytes": 67108864,
+      "git_blob": "5bd6a82f21f904fc28b9c867af5b472f19114dc8",
+      "oid": "c1c5f242a17d885118a4c601b8b233632c53355916584c4b9fc600e0c3115ff2"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000037.bin": {
+      "bytes": 67108864,
+      "git_blob": "928a33dc99b010622fb3aa1f760eece4e4b6a5a6",
+      "oid": "a65e7d1a0ed2a2b3320e2af65ae72b2f523298f59f05f9ba917c0d2ba57fe528"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000038.bin": {
+      "bytes": 67108864,
+      "git_blob": "feaa0d58f8bad1edfda285a0456167067fce48ea",
+      "oid": "47605ee88b47821758f28b25b3912c25397fd32239c972243004d14457f72c82"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000039.bin": {
+      "bytes": 67108864,
+      "git_blob": "ea6c8d5ca1a12e9a61afa5d15f4adeff8fd78e26",
+      "oid": "2290a53b9cfffaa1a0ebb6cab41ec195c3d16c1d1b347941d21e4fe8f9998627"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000040.bin": {
+      "bytes": 67108864,
+      "git_blob": "11477a4c68c0bb716ebab1b4b8d598c107a28087",
+      "oid": "256844cea01953996a0ac87f18979cf6d35ed56786a5485f48ad2cb3c1360ece"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000041.bin": {
+      "bytes": 67108864,
+      "git_blob": "e42fe72490fa2a38c84db158f7aef7f8ce4c011f",
+      "oid": "3dc3f7b6d3303d91e350057dc27ecf0d02b857d33d8eaa2eef3a4bfe7f40eeab"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000042.bin": {
+      "bytes": 67108864,
+      "git_blob": "1738c3aedbd7140a8d54427e037d2bafe3073bce",
+      "oid": "def2c14f8c533dc0baf4426ff32de64e2f26272403462d3ed014b2b74b3fb52d"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000043.bin": {
+      "bytes": 67108864,
+      "git_blob": "f4c65681fdf0e313811f6d31400c8b8566966b3f",
+      "oid": "6110a1367894ddd26909ddca5c4568f6bb5545b4468e40811b02c3a696b3f151"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000044.bin": {
+      "bytes": 67108864,
+      "git_blob": "5cbc2d48ad41ab9f06fe9f0571d5f248ecde2688",
+      "oid": "b0742985cb8f65d244b9ce49cb14f777d0daee4d75b79193d73f94dd2fc50345"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000045.bin": {
+      "bytes": 67108864,
+      "git_blob": "5ddcfff4f462a30bdb7a303a5b1ada82d9d7ba33",
+      "oid": "1d8671e30380134313dedac85e6ea51a47ff7de3ba9b5f235208c913a3d28672"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000046.bin": {
+      "bytes": 67108864,
+      "git_blob": "de832d330ec009513a225c48f5d0c0beb19e753c",
+      "oid": "3157bce6ca069dada4f95ca8149a0ca431b72423bb2a2c182409b72c1b143b80"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000047.bin": {
+      "bytes": 67108864,
+      "git_blob": "a4995f53e8760be07c24a99426a91e40d0d178bc",
+      "oid": "c00cf2634c0f50c1abe4502192d541ff6bd9169acca2d6bc8fe50100efcff9bd"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000048.bin": {
+      "bytes": 67108864,
+      "git_blob": "19a22b1cf764d45e8416aa30c4c14a8b9bf12bca",
+      "oid": "fd836db27d1f3906cf6514596cbdeab7290643660614ad7e449ac95d79bd0082"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000049.bin": {
+      "bytes": 67108864,
+      "git_blob": "cfe7d68546f2d741a852128d792cd01e5a0609b5",
+      "oid": "05d52812c5b77ff9a3441a5e72fe7ed0ceb6d236981b2d4cc85c98ce91d866e8"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000050.bin": {
+      "bytes": 67108864,
+      "git_blob": "b59f4ad1b4993e45f70975ba362a005fd916a61c",
+      "oid": "018ba52c09e1105bbf2c828cac95fd544a94ce7b464c8000d1a6c9609e3cf0dc"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000051.bin": {
+      "bytes": 67108864,
+      "git_blob": "1c1651960177ad28ebf6507599963240414f4ec8",
+      "oid": "c18f6dff39bb44a210f3e05281a8780f9130d83680cd1d3ad4456335f25b9c0a"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000052.bin": {
+      "bytes": 67108864,
+      "git_blob": "a9b24d3614b8659befe55e6afcd6ab33621ed6ee",
+      "oid": "c888efc1ef75dd48c41bb2ec18cc4d223b5a12f3a7fe83a0abff6c99ebf1407c"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000053.bin": {
+      "bytes": 67108864,
+      "git_blob": "17a77ed5f68782a6dbe6e8da36cbfbfe03e6b50b",
+      "oid": "6f9cd36795720489c8ef52e600394eb92fc8d4d9dcb5049bfcc89914acfa20af"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000054.bin": {
+      "bytes": 67108864,
+      "git_blob": "56b6cbc07fea93dacdecdbcd8e0125f08c7aa053",
+      "oid": "90421f2d11d14f8004c592664921437ff64001cfe929e6de0bcbd0e24e9610ee"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000055.bin": {
+      "bytes": 67108864,
+      "git_blob": "1c09152a10fce5dc327066e5b7b8674daaa7842e",
+      "oid": "73a1a0eb0b473e842e5bae81331257ef89090b9af6538676375bb5757ae3c589"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000056.bin": {
+      "bytes": 67108864,
+      "git_blob": "c8a9c1f913ebc2c230f68fd7646173153526ed24",
+      "oid": "7b4fb640cc128ac0438186012b622db4246359cdf098c3e874e1af5b4add28f1"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000057.bin": {
+      "bytes": 67108864,
+      "git_blob": "d0478934976bfbae6a910989449b694d80b228aa",
+      "oid": "acd914306dce998276452979904e04d405a492a8c81340f209f3224def906722"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000058.bin": {
+      "bytes": 67108864,
+      "git_blob": "2234cf752b925de409850d781c40120f17135d90",
+      "oid": "f15627615ef7579d01f21e5a35c321bbc6599d66847e11e37440c12dbfb7b676"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000059.bin": {
+      "bytes": 67108864,
+      "git_blob": "ac821671744f5d0eff06c40977d185e2b12e5d12",
+      "oid": "df6d02884bb8b3c313b279cb1f63f00c2ebc39340f6a298b17be6a1d4b9b5fc1"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000060.bin": {
+      "bytes": 67108864,
+      "git_blob": "7f367abb4cf0a74ceab3ed7a8a650237fe26fe54",
+      "oid": "3f0a9827926d381ef0eb09569de9c133a24f88b6c4e2e07bbf582e7259a261b3"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000061.bin": {
+      "bytes": 67108864,
+      "git_blob": "ec9ca6d15bb5098ef539fc236cf89dde1c529c3f",
+      "oid": "2419ad28f6dce0b26b34432f6f9933a7850755a68c1d19191cc13e590bc3689f"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000062.bin": {
+      "bytes": 67108864,
+      "git_blob": "d6e03d74381e6f0747b7dc07394d213e0ebca13b",
+      "oid": "03b39ee51f20fa8d801e0b6606fda6c1be8625de19a30cc28efa4e60a52ef1be"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000063.bin": {
+      "bytes": 67108864,
+      "git_blob": "be21eaa2fa6c014dff1e090981c9e6703464d50d",
+      "oid": "bbb58825d3b6b18f9c120d3abaf8729f694ddf8e3d00ea7cd831bdc9ae3f63fb"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000064.bin": {
+      "bytes": 67108864,
+      "git_blob": "44bb6a485846b23002797681f08d9a519b222e94",
+      "oid": "835c49d7ad41c233d0e20e59f5ad87deb31c7dff3662db996a52f3c60a4ca616"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000065.bin": {
+      "bytes": 67108864,
+      "git_blob": "f1720e545c3c2d64fdc79fe4abf095715af831dd",
+      "oid": "53129c4320559e8dc1959a8fdcd7d756f68b2d82acc8ca6681f4aa691969f906"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000066.bin": {
+      "bytes": 67108864,
+      "git_blob": "dec6ee75103a3ef6068eb52b5c3e8082b721dda0",
+      "oid": "6a03395293e454e95163444c04a77961bfde9f71daf902911906566b7df4eab1"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000067.bin": {
+      "bytes": 67108864,
+      "git_blob": "c823ccd2192de9cea0b556f082366e1333ab5e1b",
+      "oid": "419e60c582a4c8f119f9a958f33ef88164fa334c38e7c47163f03d761d89e4dd"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000068.bin": {
+      "bytes": 67108864,
+      "git_blob": "090228b509ad9824a1683b469b453396d202ea65",
+      "oid": "26222b3988412e52c10bd2a8cddd5b0a54409f16aa5e2367f9e6c3606760221d"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000069.bin": {
+      "bytes": 67108864,
+      "git_blob": "92f032817e8a677e6311e9ecb3e48f034c478ea6",
+      "oid": "661e862287f8283794e812d5484dfc77651e6a9c44be2122f10b25e702dbf52d"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000070.bin": {
+      "bytes": 67108864,
+      "git_blob": "a34011143ca449af5765764ef1ebf0a99ba015ee",
+      "oid": "71de14c9a34cfed409f74d825c88a8b473cd509b1dd2619fe8d5a11da131bee0"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000071.bin": {
+      "bytes": 67108864,
+      "git_blob": "7bb6a296c74800afc32b623bfa63df312d50ddca",
+      "oid": "7c8b878109bae512ed7f411055d974e0669a31da88b561e87e4fbacbadb96375"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000072.bin": {
+      "bytes": 67108864,
+      "git_blob": "2cbf313125ee233cd703545354dea70b2e9a4a86",
+      "oid": "c75a839c07a242aa09dc0603b46cefd87ac79bfc6776dd4707f425f4afd143df"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000073.bin": {
+      "bytes": 67108864,
+      "git_blob": "80754a728b907e593b13dbeb9ea3002a78ea1e40",
+      "oid": "af98e9729afc0d1406b7531e135ab4d932c34f9c38df81636026fdfe461fc400"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000074.bin": {
+      "bytes": 67108864,
+      "git_blob": "3b5e3397dfcd341314e4672763afe04bf961e141",
+      "oid": "8de906c2956b66594902536069870c6f4bfaa8221cae561a6f7a00ea9b3ab338"
+    },
+    "artifacts/public-resources-20261001/malecns-synaptic-partners/payload-000075.bin": {
+      "bytes": 30040253,
+      "git_blob": "819495f28df56d5d40198f25be2fa709c6b07f4c",
+      "oid": "98714008fee0cffd305c8e7b45d74d224033d013f7ea7a1759eb160ca0fff2f1"
+    },
+    "artifacts/public-resources-20261001/shiu-author-model-source/exclusions.jsonl.gz": {
+      "bytes": 20,
+      "git_blob": "1c35409ae4793732668f75c463c9722b3aedc07c",
+      "oid": "9ceffb7310338057cfe71a4ae1e2c98d2c485d81cdef906532a801f457a38d64"
+    },
+    "artifacts/public-resources-20261001/shiu-author-model-source/members.jsonl.gz": {
+      "bytes": 349,
+      "git_blob": "5255a1c3bcd8d5dee99da2a141dbea8a0f1926ea",
+      "oid": "2907be4f7d1a8f1017f91bda6e5ead381b8c67b85498f5378765d696f89d4b0c"
+    },
+    "artifacts/public-resources-20261001/shiu-author-model-source/payload-000000.bin": {
+      "bytes": 6828,
+      "git_blob": "f232dbe857338e8568c11d2eda162853158b39e5",
+      "oid": "4da352d80e4bf251dfec771935da93f5a9f3cef302c85e90991fafa14a072e2b"
+    },
+    "artifacts/public-resources-20261001/visualpathways/exclusions.jsonl.gz": {
+      "bytes": 218,
+      "git_blob": "ba39cbc1c01c2bd56e52eca5ad9748f715e61f1c",
+      "oid": "9c029262724580ef20981316c6f7e9c99d345e1171067f16c5d580c742809a8c"
+    },
+    "artifacts/public-resources-20261001/visualpathways/members.jsonl.gz": {
+      "bytes": 292178,
+      "git_blob": "d5426fbd8cd668b67fa16935f4e7cf1f3c223777",
+      "oid": "335401c3f6cb5b3868b899599bcd7b439c1983a627d97a598a95e9c8d44ad81c"
+    },
+    "artifacts/public-resources-20261001/visualpathways/payload-000000.bin": {
+      "bytes": 67108864,
+      "git_blob": "d04ed630add6224a87c0bc48a70473568a387dac",
+      "oid": "7f8bb35dcb565c16ff1bf642e079c54c71e27e05cccaa5915c1d1e3c9e7d0700"
+    },
+    "artifacts/public-resources-20261001/visualpathways/payload-000001.bin": {
+      "bytes": 67108864,
+      "git_blob": "b4bba7c798407330ca3cc2428c890ff5b8d27f79",
+      "oid": "7181f79ec2615a84f33b394abf22454b72d2fddfb0e40e9c5e1590fe1ba64d7a"
+    },
+    "artifacts/public-resources-20261001/visualpathways/payload-000002.bin": {
+      "bytes": 67108864,
+      "git_blob": "88a361aafe0ae8f98d4031ea0366051c98a0025d",
+      "oid": "9dc076afd8cd8ebbbdda6f1ef24a41598e5db9fb0a98de8b5b765b4b0a8d2934"
+    },
+    "artifacts/public-resources-20261001/visualpathways/payload-000003.bin": {
+      "bytes": 67108864,
+      "git_blob": "5fde6ec1b0c39c9237d0b201e2e0f05c7110b845",
+      "oid": "be03beac2472e6dc76a5705440296f88a8f6e15ea43f541df402c7b6c85cfdc6"
+    },
+    "artifacts/public-resources-20261001/visualpathways/payload-000004.bin": {
+      "bytes": 67108864,
+      "git_blob": "1f00ec92f1ff4b4ebc015ce1bb725149240fc1fa",
+      "oid": "0c801486169d0594471518a75b11b040acb1a2dd8904e9365fa7b7b667fc4a09"
+    },
+    "artifacts/public-resources-20261001/visualpathways/payload-000005.bin": {
+      "bytes": 67108864,
+      "git_blob": "16d9b6284c8e30be01ee6452a4d66a212555fe1f",
+      "oid": "4f387b9e6b47f06871ce1b32e265b3a1ae2d78e06d7955a3fa8ed7cfc1d2a0a7"
+    },
+    "artifacts/public-resources-20261001/visualpathways/payload-000006.bin": {
+      "bytes": 31805270,
+      "git_blob": "7314b8a57934ad336c7d89b5ad54f30fe574869e",
+      "oid": "edb0ffa74e646712485a0d5fd2819ef14345c637beeaa5ca811ae3e71a06ea82"
+    }
+  },
+  "schema": "main-integration-audit-v1",
+  "scientific_execution": false,
+  "source_worktrees_modified": false,
+  "staged_original_blobs_checked": 12674,
+  "staged_tree": "6b662d0f1c122d0ab86f6b07d53e76943f9035f0",
+  "verified_utc": "2026-10-01T08:51:08.308553+00:00"
+}

registry/branch-consolidation-20261001/plan.json

@@ -0,0 +1,25 @@
+{
+  "schema": "branch-consolidation-plan-v1",
+  "remote": "ssh://git@192.168.10.31:2222/qishizhe/digital-drosophila.git",
+  "target_branch": "main",
+  "archive_tag_prefix": "archive/2026-10-01/",
+  "authorization": "User explicitly selected main consolidation, archive tags before remote branch cleanup, and preservation of existing server worktrees.",
+  "branches": {
+    "codex/project-bootstrap": "3981628ff893132a8148668aa94726886dba57a3",
+    "codex/apl-pn-scope-audit": "d6843e675dec5ae38a06f2ba70d74836aea53ace",
+    "codex/terminal-scope-diagnostic": "3213aada793740961885ba525494e95f019be6f8",
+    "codex/lif-semantics-audit": "5008cd85ca11750f23ce7bc001e8e821763b7501",
+    "codex/lif-author-semantics-lab": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+    "codex/lfs-public-resources": "5b1d1b72d7683b5c3dcc1f78b408e1d9dd2832ac",
+    "codex/v100-conditioning-acceleration": "4436241976887d8cc10088b0d44bc7ed70978fe6"
+  },
+  "merge_parents": ["4436241976887d8cc10088b0d44bc7ed70978fe6", "5b1d1b72d7683b5c3dcc1f78b408e1d9dd2832ac"],
+  "allowed_existing_file_changes": [".gitattributes", ".gitignore", "README.md", "CURRENT.md", "docs/40-operations/branches-20261001.md"],
+  "new_paths": ["docs/30-reproducibility/main-restore.md", "tools/branch-consolidation/", "registry/branch-consolidation-20261001/"],
+  "expected_artifact_paths": 181,
+  "expected_lfs_pointer_paths": 171,
+  "preserve_existing_worktrees": true,
+  "delete_lfs_objects": false,
+  "scientific_execution": false,
+  "allow_history_rewrite": false
+}

registry/branch-consolidation-20261001/remote-cleanup.json

@@ -0,0 +1,33 @@
+{
+  "all_old_tips_ancestors_of_main": true,
+  "created_utc": "2026-10-01T08:55:25.347213+00:00",
+  "deleted_remote_branch_refs": {
+    "refs/heads/codex/apl-pn-scope-audit": "d6843e675dec5ae38a06f2ba70d74836aea53ace",
+    "refs/heads/codex/lfs-public-resources": "5b1d1b72d7683b5c3dcc1f78b408e1d9dd2832ac",
+    "refs/heads/codex/lif-author-semantics-lab": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+    "refs/heads/codex/lif-semantics-audit": "5008cd85ca11750f23ce7bc001e8e821763b7501",
+    "refs/heads/codex/project-bootstrap": "3981628ff893132a8148668aa94726886dba57a3",
+    "refs/heads/codex/terminal-scope-diagnostic": "3213aada793740961885ba525494e95f019be6f8",
+    "refs/heads/codex/v100-conditioning-acceleration": "4436241976887d8cc10088b0d44bc7ed70978fe6"
+  },
+  "lfs_objects_deleted": false,
+  "local_branches_deleted": false,
+  "main_commit": "9fde10d970474bf4223dec7536c396d3afaccbe3",
+  "pass_all": true,
+  "preserved_archive_tags": {
+    "archive/2026-10-01/apl-pn-scope-audit": "d6843e675dec5ae38a06f2ba70d74836aea53ace",
+    "archive/2026-10-01/lfs-public-resources": "5b1d1b72d7683b5c3dcc1f78b408e1d9dd2832ac",
+    "archive/2026-10-01/lif-author-semantics-lab": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+    "archive/2026-10-01/lif-semantics-audit": "5008cd85ca11750f23ce7bc001e8e821763b7501",
+    "archive/2026-10-01/project-bootstrap": "3981628ff893132a8148668aa94726886dba57a3",
+    "archive/2026-10-01/terminal-scope-diagnostic": "3213aada793740961885ba525494e95f019be6f8",
+    "archive/2026-10-01/v100-conditioning-acceleration": "4436241976887d8cc10088b0d44bc7ed70978fe6"
+  },
+  "remaining_remote_heads": {
+    "main": "9fde10d970474bf4223dec7536c396d3afaccbe3"
+  },
+  "remote": "ssh://git@192.168.10.31:2222/qishizhe/digital-drosophila.git",
+  "remote_default": "refs/heads/main",
+  "schema": "branch-consolidation-ref-audit-v1",
+  "source_worktrees_write_operations": false
+}

registry/branch-consolidation-20261001/source-protection-final.json

@@ -0,0 +1,19 @@
+{
+  "status": "PASS",
+  "created_utc": "2026-10-01T08:56:09.890381+00:00",
+  "files_checked": 64034,
+  "bytes_checked": 3103901058,
+  "inventory_sha256": "d7b675b0d0d4647d8fe2fcf9616b9a599e5bc3c15565e604e0d66a046afb835a",
+  "registration_sha256": "b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740",
+  "registered_science_commit": "80aeb2093db655329774eff7b32fb6e417b8b40b",
+  "sources_checked": 16,
+  "file_mismatches": [],
+  "source_mismatches": [],
+  "original_git_head": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+  "original_git_status": "",
+  "wall_seconds": 4.999353606001023,
+  "scope": "Saved Phase4AR experiment/control files and registered source files; NOT a new Phase1-4AQ numerical regression",
+  "training_epochs_cpu_verified_unchanged": 1033,
+  "probes_completed_unchanged": 138,
+  "original_experiment_resumed": false
+}

registry/branch-consolidation-20261001/source-protection.json

@@ -0,0 +1,19 @@
+{
+  "status": "PASS",
+  "created_utc": "2026-10-01T08:54:17.339094+00:00",
+  "files_checked": 64034,
+  "bytes_checked": 3103901058,
+  "inventory_sha256": "d7b675b0d0d4647d8fe2fcf9616b9a599e5bc3c15565e604e0d66a046afb835a",
+  "registration_sha256": "b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740",
+  "registered_science_commit": "80aeb2093db655329774eff7b32fb6e417b8b40b",
+  "sources_checked": 16,
+  "file_mismatches": [],
+  "source_mismatches": [],
+  "original_git_head": "09187e4d4d67badf1b418c5f211258ca5d8fb328",
+  "original_git_status": "",
+  "wall_seconds": 5.005429710001408,
+  "scope": "Saved Phase4AR experiment/control files and registered source files; NOT a new Phase1-4AQ numerical regression",
+  "training_epochs_cpu_verified_unchanged": 1033,
+  "probes_completed_unchanged": 138,
+  "original_experiment_resumed": false
+}

tools/acceleration-publication/archive_results.py

@@ -0,0 +1,183 @@
+"""Read-only source packing and streamed verification for exact replay evidence."""
+import argparse
+from datetime import datetime, timezone
+import hashlib
+import io
+import json
+from pathlib import Path
+import re
+import shutil
+import subprocess
+import tarfile
+
+SOURCE_CODE = Path('/home/qishizhe/digital-drosophila-v100-acceleration/models/male-cns-lif')
+GROUPS = {
+    'gpu': (Path('/home/qishizhe/phase4ar-v100-acceleration-20261001'),
+            '6efdec34c96cdc79f786b91bd7a99b0e8ef64d0c4dcfa525646c82659a77d44f',
+            'conditioning-acceleration-v1'),
+    'pipeline': (Path('/home/qishizhe/phase4ar-pipeline-acceleration-20261001'),
+                 '4c598f51e927b3145891db42d9bb345c52d4aaa3b3a05ac257b207fff90cace4',
+                 'conditioning-pipeline-acceleration-v1'),
+}
+REGISTRY = Path('registry/acceleration-20261001')
+ARTIFACTS = Path('artifacts/acceleration-20261001')
+INSTALL_LOGS = {
+    'create-venv.stdout.log', 'create-venv.stderr.log',
+    'install-candidate.stdout.log', 'install-candidate.stderr.log',
+    'install-candidate-attempt-02.stdout.log', 'install-candidate-attempt-02.stderr.log',
+    'upgrade-candidate-pip.stdout.log', 'upgrade-candidate-pip.stderr.log',
+}
+SECRET_RULES = [
+    rb'-----BEGIN (?:OPENSSH |RSA |EC )?PRIVATE KEY-----',
+    rb'(?:gh[pousr]_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{30,}|AKIA[A-Z0-9]{16})',
+    rb'https?://[^\s/]+:[^\s/@]+@',
+]
+
+
+def require(value, message):
+    if not value:
+        raise ValueError(message)
+
+
+def sha(path):
+    digest = hashlib.sha256()
+    with path.open('rb') as stream:
+        for block in iter(lambda: stream.read(8 << 20), b''):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def ident(path):
+    return dict(bytes=path.stat().st_size, sha256=sha(path))
+
+
+def save(path, obj):
+    with path.open('x') as stream:
+        json.dump(obj, stream, indent=2, sort_keys=True, allow_nan=False)
+        stream.write('\n')
+
+
+def excluded(name):
+    if name.startswith(('cupy-cache-', 'brain-replay/build/')):
+        return 'Rebuildable compiler cache/SDK intermediates, not a scientific result'
+    if name in INSTALL_LOGS:
+        return 'Environment installation output; versions and wheel report retained'
+    return None
+
+
+def scan_text(path):
+    if path.suffix.lower() not in ('.json', '.jsonl', '.log', '.md', '.txt', '.csv', '.py', '.cu', '.diff'):
+        return
+    require(path.stat().st_size <= 25 * (1 << 20), 'Oversized text requires manual review')
+    data = path.read_bytes()
+    for rule in SECRET_RULES:
+        require(not re.search(rule, data), 'Potential credential marker: ' + path.name)
+
+
+def pack(root):
+    require(root == Path('/home/qishizhe/digital-drosophila-acceleration-publication-20261001'), 'Independent publication clone required')
+    require((root / '.git').is_dir() and not root.is_symlink(), 'Ordinary independent clone required')
+    registry, artifacts = root / REGISTRY, root / ARTIFACTS
+    registry.mkdir(parents=True, exist_ok=True)
+    artifacts.mkdir(parents=True, exist_ok=False)
+    catalog = dict(schema='acceleration-publication-v1', created_utc=datetime.now(timezone.utc).isoformat(),
+        numerical_changes=False, training_resumed=False, complete_training_restore=False,
+        scope='Two completed independent engineering experiments, not the full stopped scientific run', groups={})
+    for group, (source, expected_manifest, code_dir) in GROUPS.items():
+        require(sha(source / 'artifact-manifest.json') == expected_manifest, 'Sealed source manifest changed')
+        manifest = json.loads((source / 'artifact-manifest.json').read_text())
+        for name, expected in manifest['source_files'].items():
+            require(sha(SOURCE_CODE / code_dir / name) == expected, 'Sealed source code changed')
+            require(sha(root / 'models/male-cns-lif' / code_dir / name) == expected, 'Published source differs')
+        members, omitted = {}, {}
+        for name, expected in manifest['files'].items():
+            path = source / name
+            require(path.resolve().is_relative_to(source) and not path.is_symlink(), 'Unsafe source path')
+            require(ident(path) == expected, 'Sealed input file changed: ' + name)
+            reason = excluded(name)
+            if reason:
+                omitted[name] = dict(expected, reason=reason)
+            else:
+                scan_text(path)
+                members[group + '/' + name] = dict(expected, source_relative=name)
+        for name in ('artifact-manifest.json', 'SHA256SUMS'):
+            require(group + '/' + name not in members, 'Duplicate source control file')
+            members[group + '/' + name] = dict(ident(source / name), source_relative=name)
+        archive = artifacts / (group + '.tar.zst')
+        with archive.open('xb') as destination:
+            compressor = subprocess.Popen(['zstd', '-q', '-T2', '-3', '-c'], stdin=subprocess.PIPE, stdout=destination)
+            try:
+                with tarfile.open(fileobj=compressor.stdin, mode='w|', format=tarfile.PAX_FORMAT) as tar:
+                    for name, item in sorted(members.items()):
+                        path = source / item['source_relative']
+                        info = tarfile.TarInfo(name)
+                        info.size, info.mode, info.mtime = item['bytes'], 0o644, 0
+                        with path.open('rb') as stream:
+                            tar.addfile(info, stream)
+                        require(ident(path) == {k: item[k] for k in ('bytes', 'sha256')}, 'Input changed during packing')
+                compressor.stdin.close()
+                require(compressor.wait(timeout=120) == 0, 'Compression failed')
+            finally:
+                if compressor.poll() is None:
+                    compressor.kill()
+                    compressor.wait()
+        target = registry / group
+        target.mkdir(exist_ok=False)
+        for name in ('RESULTS.md', 'final-summary.json', 'artifact-manifest.json', 'SHA256SUMS'):
+            shutil.copyfile(source / name, target / name)
+            require(sha(source / name) == sha(target / name), 'Summary copy differs')
+        catalog['groups'][group] = dict(source_root=str(source), source_manifest_sha256=expected_manifest,
+            source_files=manifest['source_files'], archive=str(archive.relative_to(root)), **ident(archive),
+            member_count=len(members), member_bytes=sum(x['bytes'] for x in members.values()),
+            members=members, excluded=omitted, excluded_count=len(omitted))
+    save(registry / 'publication-catalog.json', catalog)
+    result = verify(root)
+    save(registry / 'pack-verification.json', result)
+    print(json.dumps(dict(complete=True, groups=result['groups'], source_files_modified=False), indent=2))
+
+
+def verify(root):
+    catalog_path = root / REGISTRY / 'publication-catalog.json'
+    catalog = json.loads(catalog_path.read_text())
+    require(catalog['schema'] == 'acceleration-publication-v1', 'Wrong publication catalog')
+    results = {}
+    for group, info in catalog['groups'].items():
+        archive = root / info['archive']
+        require(archive.resolve().is_relative_to(root / ARTIFACTS) and not archive.is_symlink(), 'Unsafe archive path')
+        require(ident(archive) == {k: info[k] for k in ('bytes', 'sha256')}, 'Archive identity mismatch')
+        decoder = subprocess.Popen(['zstd', '-q', '-d', '-c', str(archive)], stdout=subprocess.PIPE)
+        found, total = set(), 0
+        try:
+            with tarfile.open(fileobj=decoder.stdout, mode='r|') as tar:
+                for entry in tar:
+                    require(entry.isfile() and entry.name in info['members'] and entry.name not in found, 'Unexpected/duplicate member')
+                    expected = info['members'][entry.name]
+                    require(entry.size == expected['bytes'], 'Member size mismatch')
+                    h, count = hashlib.sha256(), 0
+                    with tar.extractfile(entry) as stream:
+                        for block in iter(lambda: stream.read(8 << 20), b''):
+                            h.update(block)
+                            count += len(block)
+                    require(count == entry.size and h.hexdigest() == expected['sha256'], 'Member hash mismatch')
+                    found.add(entry.name)
+                    total += count
+            while decoder.stdout.read(1 << 20):
+                pass
+            require(decoder.wait(timeout=30) == 0 and found == set(info['members']), 'Archive truncated or member set differs')
+        finally:
+            decoder.stdout.close()
+            if decoder.poll() is None:
+                decoder.kill()
+                decoder.wait()
+        results[group] = dict(files=len(found), original_bytes=total, archive_bytes=info['bytes'], sha256=info['sha256'], verified=True)
+    return dict(pass_all=True, groups=results, catalog_sha256=sha(catalog_path), verification='Full streamed members, no extraction or model execution')
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('mode', choices=('pack', 'verify'))
+    args = parser.parse_args()
+    if args.mode == 'pack':
+        pack(Path.cwd())
+    else:
+        print(json.dumps(verify(Path.cwd()), indent=2))

tools/acceleration-publication/verify_delivery.py

@@ -0,0 +1,68 @@
+"""Actual fresh-store remote retrieval; no scientific execution or retries."""
+import argparse
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import subprocess
+import time
+
+import archive_results as archives
+
+REMOTE = 'ssh://git@192.168.10.31:2222/qishizhe/digital-drosophila.git'
+BRANCH = 'codex/v100-conditioning-acceleration'
+
+
+def cmd(args, output=False):
+    result = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    archives.require(result.returncode == 0, 'Git/LFS command failed; no automatic retry; diagnostic output not published')
+    return result.stdout.decode().strip() if output else result.returncode
+
+
+def run(expected, receipt):
+    root = Path.cwd()
+    archives.require(root == Path('/home/qishizhe/digital-drosophila-acceleration-verify-20261001')
+                     and (root / '.git').is_dir(), 'New independent verification clone required')
+    archives.require(cmd(['git', 'rev-parse', 'HEAD'], True) == expected, 'Unexpected checkout commit')
+    archives.require(cmd(['git', 'remote', 'get-url', 'origin'], True) == REMOTE, 'Unexpected remote')
+    remote_ref = cmd(['git', 'ls-remote', 'origin', 'refs/heads/' + BRANCH], True)
+    archives.require(remote_ref.split()[0] == expected, 'Remote branch does not identify data commit')
+    archives.require(not cmd(['git', 'status', '--porcelain'], True), 'Unclean initial checkout')
+    objects = root / '.git/lfs/objects'
+    before = list(p for p in objects.rglob('*') if p.is_file()) if objects.exists() else []
+    archives.require(not before, 'Fresh LFS object store must contain no prior object')
+    archives.require(not receipt.exists() and receipt.parent.is_dir()
+                     and receipt.parent == Path('/home/qishizhe/digital-drosophila-acceleration-publication-20261001/registry/acceleration-20261001'),
+                     'Exclusive publication receipt required')
+    start = time.perf_counter()
+    pull = cmd(['git', 'lfs', 'pull', '--include=artifacts/acceleration-20261001/**', '--exclude=', 'origin'])
+    fsck = cmd(['git', 'lfs', 'fsck', '--dry-run'])
+    report = archives.verify(root)
+    catalog = json.loads((root / archives.REGISTRY / 'publication-catalog.json').read_text())
+    source_count = 0
+    for group, info in catalog['groups'].items():
+        directory = archives.GROUPS[group][2]
+        for name, expected_sha in info['source_files'].items():
+            archives.require(archives.sha(root / 'models/male-cns-lif' / directory / name) == expected_sha,
+                             'Published source differs from sealed version')
+            source_count += 1
+    stored = [p for p in objects.rglob('*') if p.is_file()]
+    archives.require(len(stored) == 2 and not cmd(['git', 'status', '--porcelain'], True), 'Incomplete LFS store or changed checkout')
+    archives.require(cmd(['git', 'rev-parse', 'HEAD'], True) == expected, 'Checkout changed during verification')
+    report.update(schema='acceleration-fresh-remote-delivery-v1', verified_utc=datetime.now(timezone.utc).isoformat(),
+        remote=REMOTE, branch=BRANCH, data_commit=expected, fresh_download_proven=True,
+        initial_LFS_objects=0, downloaded_LFS_objects=len(stored), downloaded_bytes=sum(p.stat().st_size for p in stored),
+        pull_exit_code=pull, fsck_exit_code=fsck, sealed_source_files_checked=source_count,
+        wall_seconds=time.perf_counter()-start, scientific_experiments_run=0, training_resumed=False,
+        complete_training_restore=False, historical_scientific_gate_reexecuted=False,
+        transport='Previously audited LAN-pinned HTTPS adapter, verified TLS and SSH short-lived authorization',
+        scope='Remote Git commit, two actual LFS downloads, complete public archive contents and 22 sealed code files; not all external scientific dependencies')
+    archives.save(receipt, report)
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--expected-commit', required=True)
+    parser.add_argument('--receipt', type=Path, required=True)
+    args = parser.parse_args()
+    run(args.expected_commit, args.receipt)

tools/branch-consolidation/manage_refs.py

@@ -0,0 +1,122 @@
+"""Explicitly authorized, fail-closed archive/retire operations in the new clone."""
+import argparse
+from datetime import datetime, timezone
+import json
+import os
+from pathlib import Path
+import subprocess
+
+ROOT = Path('/home/qishizhe/digital-drosophila-main-integration-20261001')
+RECOVERY = Path('/home/qishizhe/digital-drosophila-branch-recovery-20261001.git')
+AUDIT = ROOT / 'registry/branch-consolidation-20261001'
+
+
+def require(value, message):
+    if not value:
+        raise RuntimeError(message)
+
+
+def git(*args, cwd=ROOT):
+    # Existing payloads were checked separately. This operation transfers refs
+    # and Git objects only; it neither replaces nor uploads any LFS object.
+    env = dict(os.environ, GIT_LFS_SKIP_SMUDGE='1', GIT_LFS_SKIP_PUSH='1')
+    return subprocess.check_output(['git', *args], cwd=cwd, env=env, text=True).strip()
+
+
+def snapshot():
+    refs = {}
+    default = None
+    for line in git('ls-remote', '--symref', 'origin').splitlines():
+        value, name = line.split('\t')
+        if value.startswith('ref: '):
+            if name == 'HEAD':
+                default = value[5:]
+        else:
+            refs[name] = value
+    return refs, default
+
+
+def write_receipt(name, **data):
+    with (AUDIT / name).open('x') as f:
+        json.dump(dict(schema='branch-consolidation-ref-audit-v1',
+                       created_utc=datetime.now(timezone.utc).isoformat(), **data),
+                  f, indent=2, sort_keys=True)
+        f.write('\n')
+    print(json.dumps(data, indent=2))
+
+
+def main(action):
+    require(Path.cwd().resolve() == ROOT, 'Independent integration clone required')
+    plan = json.loads((AUDIT / 'plan.json').read_text())
+    require(git('remote', 'get-url', 'origin') == plan['remote'], 'Unexpected remote')
+    branches = {'refs/heads/' + name: sha for name, sha in plan['branches'].items()}
+    tags = {plan['archive_tag_prefix'] + name.removeprefix('codex/'): sha
+            for name, sha in plan['branches'].items()}
+    before, default_before = snapshot()
+
+    if action == 'archive':
+        require(not (AUDIT / 'archive-recovery.json').exists(), 'Archive receipt already exists')
+        require(not RECOVERY.exists(), 'Recovery clone already exists; inspect, do not replace')
+        require({k: v for k, v in before.items() if k.startswith('refs/heads/')} == branches,
+                'Remote heads changed since authorized inventory')
+        for tag, sha in tags.items():
+            ref = 'refs/tags/' + tag
+            require(ref not in before, 'Archive tag already exists; inspect before proceeding')
+            require(not git('tag', '--list', tag), 'Local archive tag already exists')
+            git('tag', '-a', tag, sha, '-m',
+                'Archive before user-authorized main consolidation; preserve this exact historical tip. Do not rewrite.')
+        git('push', '--atomic', 'origin', *['refs/tags/' + tag + ':refs/tags/' + tag for tag in tags])
+        after, _ = snapshot()
+        for tag, sha in tags.items():
+            require(after.get('refs/tags/' + tag + '^{}') == sha, 'Remote archived commit differs')
+        git('init', '--bare', str(RECOVERY))
+        git('fetch', '--no-tags', plan['remote'],
+            *['refs/tags/' + tag + ':refs/tags/' + tag for tag in tags], cwd=RECOVERY)
+        recovered = {tag: git('rev-parse', 'refs/tags/' + tag + '^{commit}', cwd=RECOVERY)
+                     for tag in tags}
+        require(recovered == tags, 'Fresh remote recovery failed')
+        git('fsck', '--full', '--no-reflogs', cwd=RECOVERY)
+        write_receipt('archive-recovery.json', pass_all=True, remote=plan['remote'],
+                      remote_heads_before=branches, remote_default_before=default_before,
+                      tags=tags, fresh_remote_recovery_path=str(RECOVERY),
+                      recovered_commits=recovered, git_fsck_pass=True,
+                      lfs_payload_downloaded=False, old_remote_branches_deleted=False)
+
+    elif action == 'retire':
+        require(not (AUDIT / 'remote-cleanup.json').exists(), 'Cleanup receipt already exists')
+        require(json.loads((AUDIT / 'archive-recovery.json').read_text())['pass_all'], 'Recovery not verified')
+        require(json.loads((AUDIT / 'merge-audit-final.json').read_text())['pass_all'], 'Merge not verified')
+        require(default_before == 'refs/heads/main', 'Remote default must already be main')
+        require(git('branch', '--show-current') == 'main', 'Wrong local branch')
+        require(git('status', '--porcelain') == '', 'Integration clone is not clean')
+        main_sha = git('rev-parse', 'HEAD')
+        expected = dict(branches, **{'refs/heads/main': main_sha})
+        require({k: v for k, v in before.items() if k.startswith('refs/heads/')} == expected,
+                'Remote heads changed; stop cleanup')
+        for tag, sha in tags.items():
+            require(before.get('refs/tags/' + tag + '^{}') == sha, 'Remote archive missing/different')
+            require(git('rev-parse', 'refs/tags/' + tag + '^{commit}', cwd=RECOVERY) == sha,
+                    'Recovery archive differs')
+            git('merge-base', '--is-ancestor', sha, main_sha)
+        leases = ['--force-with-lease=' + ref + ':' + sha for ref, sha in branches.items()]
+        # Delete only these seven exact branch refs, atomically and with their
+        # recorded old OIDs. No local refs, tags, commits, worktrees or LFS deletion.
+        git('push', '--atomic', *leases, 'origin', *[':' + ref for ref in branches])
+        after, default_after = snapshot()
+        require({k: v for k, v in after.items() if k.startswith('refs/heads/')} ==
+                {'refs/heads/main': main_sha}, 'Unexpected final heads')
+        require(default_after == 'refs/heads/main', 'Default branch changed unexpectedly')
+        for tag, sha in tags.items():
+            require(after.get('refs/tags/' + tag + '^{}') == sha, 'Archive lost after deletion')
+        write_receipt('remote-cleanup.json', pass_all=True, remote=plan['remote'],
+                      main_commit=main_sha, remote_default=default_after,
+                      deleted_remote_branch_refs=branches, preserved_archive_tags=tags,
+                      remaining_remote_heads={'main': main_sha},
+                      all_old_tips_ancestors_of_main=True, local_branches_deleted=False,
+                      source_worktrees_write_operations=False, lfs_objects_deleted=False)
+
+
+if __name__ == '__main__':
+    p = argparse.ArgumentParser()
+    p.add_argument('action', choices=['archive', 'retire'])
+    main(p.parse_args().action)

tools/branch-consolidation/seal_receipt.py

@@ -0,0 +1,70 @@
+"""Save final consolidation evidence; no writes outside this integration clone."""
+from datetime import datetime, timezone
+import hashlib
+import json
+from pathlib import Path
+import subprocess
+
+ROOT = Path('/home/qishizhe/digital-drosophila-main-integration-20261001')
+AUDIT = ROOT / 'registry/branch-consolidation-20261001'
+
+
+def git(*args, cwd=ROOT):
+    return subprocess.check_output(['git', *args], cwd=cwd, text=True).strip()
+
+
+def main():
+    assert Path.cwd().resolve() == ROOT
+    assert not (AUDIT / 'completion.json').exists()
+    plan = json.loads((AUDIT / 'plan.json').read_text())
+    cleanup = json.loads((AUDIT / 'remote-cleanup.json').read_text())
+    integrity = json.loads((AUDIT / 'source-protection-final.json').read_text())
+    assert cleanup['pass_all'] and integrity['status'] == 'PASS'
+    refs = git('ls-remote', '--symref', 'origin').splitlines()
+    assert 'ref: refs/heads/main\tHEAD' in refs
+    heads = [line for line in refs if '\trefs/heads/' in line]
+    assert heads == [cleanup['main_commit'] + '\trefs/heads/main']
+    tag_refs = {line.split('\t')[1]: line.split('\t')[0] for line in refs
+                if '\trefs/tags/' in line}
+    assert len(tag_refs) == 14
+    for branch, sha in plan['branches'].items():
+        tag = plan['archive_tag_prefix'] + branch.removeprefix('codex/')
+        assert tag_refs['refs/tags/' + tag + '^{}'] == sha
+        git('merge-base', '--is-ancestor', sha, 'HEAD')
+    source_trees = {}
+    expected = {
+        '/data/digital-drosophila': ('codex/lif-author-semantics-lab', '09187e4d4d67badf1b418c5f211258ca5d8fb328'),
+        '/home/qishizhe/digital-drosophila-v100-acceleration': ('codex/v100-conditioning-acceleration', '018f038c7857c7e0236dd7408a680458520d92ce'),
+    }
+    for path, (branch, sha) in expected.items():
+        actual = dict(branch=git('branch', '--show-current', cwd=path),
+                      head=git('rev-parse', 'HEAD', cwd=path),
+                      status=git('status', '--porcelain', cwd=path))
+        assert actual == dict(branch=branch, head=sha, status='')
+        source_trees[path] = actual
+    guard = json.loads(subprocess.check_output(['python3', '-B', 'tools/repo_guard.py'], text=True))
+    assert guard['pass']
+    report = dict(schema='branch-consolidation-completion-v1', status='PASS',
+        created_utc=datetime.now(timezone.utc).isoformat(), integration_commit=cleanup['main_commit'],
+        remote_default='main', remote_branches=1, archived_tags=7,
+        removed_remote_branch_refs=7, local_branches_preserved=True,
+        all_old_tips_recoverable_and_ancestors_of_main=True, source_worktrees=source_trees,
+        source_protection=integrity, staged_publication_guard=guard,
+        model_or_science_changes=False, scientific_execution=False,
+        lfs_objects_deleted=False, lfs_payloads_reuploaded=False,
+        lfs_verification_scope='Original pointers preserved; authenticated availability checked. Prior fresh-download hash verification receipts remain unchanged.',
+        final_receipt_publication='This report is committed after the integration commit; containing Git commit is the receipt publication revision.')
+    with (AUDIT / 'completion.json').open('x') as f:
+        json.dump(report, f, indent=2, sort_keys=True)
+        f.write('\n')
+    files = sorted(p for p in AUDIT.iterdir() if p.is_file())
+    files += sorted((ROOT / 'tools/branch-consolidation').glob('*.py'))
+    files += [ROOT / 'docs/30-reproducibility/main-restore.md', ROOT / 'docs/40-operations/branches-20261001.md']
+    with (AUDIT / 'SHA256SUMS').open('x') as f:
+        for path in files:
+            f.write(hashlib.sha256(path.read_bytes()).hexdigest() + '  ' + str(path.relative_to(ROOT)) + '\n')
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == '__main__':
+    main()

tools/branch-consolidation/verify_merge.py

@@ -0,0 +1,134 @@
+"""Validate staged integration against both original trees without science runs."""
+import argparse
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+import re
+import subprocess
+from datetime import datetime, timezone
+
+
+def require(value, message):
+    if not value:
+        raise ValueError(message)
+
+
+def git(*args):
+    return subprocess.check_output(['git', *args])
+
+
+def tree(ref):
+    result = {}
+    for row in git('ls-tree', '-r', '-z', ref).split(b'\0'):
+        if row:
+            meta, path = row.split(b'\t', 1)
+            mode, kind, oid = meta.decode().split()
+            require(kind == 'blob', 'Unexpected tree object')
+            result[path.decode()] = (mode, oid)
+    return result
+
+
+def main(output, check_lfs):
+    root = Path.cwd()
+    require(root == Path('/home/qishizhe/digital-drosophila-main-integration-20261001'), 'Independent integration clone required')
+    plan = json.loads((root / 'registry/branch-consolidation-20261001/plan.json').read_text())
+    left, right = plan['merge_parents']
+    base = git('merge-base', left, right).decode().strip()
+    a, b, old = tree(left), tree(right), tree(base)
+    staged = {}
+    for row in git('ls-files', '--stage', '-z').split(b'\0'):
+        if row:
+            meta, path = row.split(b'\t', 1)
+            mode, oid, stage = meta.decode().split()
+            require(stage == '0', 'Unresolved merge conflict')
+            staged[path.decode()] = (mode, oid)
+    allowed = set(plan['allowed_existing_file_changes'])
+    checked = 0
+    for name in sorted(set(a) | set(b)):
+        require(name in staged, 'Original file removed: ' + name)
+        if name in allowed:
+            continue
+        av, bv, ov = a.get(name), b.get(name), old.get(name)
+        if av == bv:
+            expected = av
+        elif av == ov:
+            expected = bv
+        elif bv == ov:
+            expected = av
+        elif av is None:
+            expected = bv
+        elif bv is None:
+            expected = av
+        else:
+            raise ValueError('Unapproved conflicting original file: ' + name)
+        require(staged[name] == expected, 'Original blob or mode changed: ' + name)
+        checked += 1
+    new_paths = sorted(set(staged) - set(a) - set(b))
+    for name in new_paths:
+        require(any(name.startswith(p) if p.endswith('/') else name == p for p in plan['new_paths']), 'Unapproved new path')
+    artifacts = {p: v for p, v in staged.items() if p.startswith('artifacts/')}
+    require(len(artifacts) == plan['expected_artifact_paths'], 'Artifact path inventory differs')
+    pointers = {}
+    pattern = re.compile(rb'version https://git-lfs.github.com/spec/v1\noid sha256:([0-9a-f]{64})\nsize ([0-9]+)\n?')
+    for name, (mode, oid) in artifacts.items():
+        data = git('cat-file', 'blob', oid)
+        match = pattern.fullmatch(data)
+        if match:
+            pointers[name] = dict(oid=match[1].decode(), bytes=int(match[2]), git_blob=oid)
+    require(len(pointers) == plan['expected_lfs_pointer_paths'], 'LFS pointer path inventory differs')
+    attributes = git('check-attr', '--cached', 'filter', '--', *pointers).decode().splitlines()
+    require(len(attributes) == len(pointers) and all(x.endswith(': filter: lfs') for x in attributes), 'Merged LFS rules do not cover every original object')
+    lfs_report = None
+    if check_lfs:
+        source = root / 'tools/lfs-publication/lan_lfs_transfer.py'
+        require(hashlib.sha256(source.read_bytes()).digest() == hashlib.sha256(git('show', left + ':tools/lfs-publication/lan_lfs_transfer.py')).digest(), 'Transfer adapter changed')
+        spec = importlib.util.spec_from_file_location('merge_lan', source)
+        lan = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(lan)
+        agent = lan.Agent(dict(event='init', operation='download', remote='origin', concurrent=True, concurrenttransfers=2), lambda _: None)
+        href, headers = agent.authenticate()
+        unique = {v['oid']: v['bytes'] for v in pointers.values()}
+        requested = [{'oid': oid, 'size': size} for oid, size in sorted(unique.items())]
+        batches = 0
+        for begin in range(0, len(requested), 100):
+            items = requested[begin:begin + 100]
+            response = lan.decode_json(agent.curl('POST', href + '/objects/batch', headers,
+                body=dict(operation='download', transfers=['basic'], objects=items)))
+            require(response.get('transfer', 'basic') == 'basic', 'Unexpected LFS transfer mode')
+            received = response.get('objects', [])
+            require(len(received) == len(items), 'LFS metadata inventory incomplete')
+            seen = set()
+            for item in received:
+                oid = item.get('oid')
+                require(oid in unique and oid not in seen and item.get('size') == unique[oid] and 'error' not in item, 'LFS object unavailable')
+                action = item.get('actions', {}).get('download')
+                require(isinstance(action, dict), 'LFS object has no download action')
+                lan.safe_url(action['href'])
+                lan.safe_headers(action.get('header', {}))
+                seen.add(oid)
+            require(seen == {item['oid'] for item in items}, 'LFS response object set differs')
+            batches += 1
+        lfs_report = dict(unique_objects=len(unique), unique_bytes=sum(unique.values()), batches=batches,
+            all_download_actions_available=True, payloads_redownloaded=False,
+            scope='Authenticated read-only LFS availability; full byte validation remains the unchanged prior fresh-download receipts')
+    report = dict(schema='main-integration-audit-v1', verified_utc=datetime.now(timezone.utc).isoformat(),
+        pass_all=True, parents=[left, right], merge_base=base, staged_original_blobs_checked=checked,
+        allowed_existing_changes=sorted(allowed), new_paths=new_paths, artifact_paths=len(artifacts),
+        lfs_pointer_paths=len(pointers), pointers=pointers, lfs_availability=lfs_report,
+        model_tool_registry_artifact_bytes_unchanged=True, scientific_execution=False,
+        source_worktree_write_operations_by_this_tool=False,
+        source_worktree_integrity_requires_separate_audit=True,
+        staged_tree=git('write-tree').decode().strip())
+    with output.open('x') as stream:
+        json.dump(report, stream, indent=2, sort_keys=True)
+        stream.write('\n')
+    print(json.dumps({k: v for k, v in report.items() if k not in ('pointers', 'new_paths')}, indent=2))
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--output', type=Path, required=True)
+    parser.add_argument('--check-lfs', action='store_true')
+    args = parser.parse_args()
+    main(args.output, args.check_lfs)