Publish October 1 runtime progress snapshot and refresh project entry points

CURRENT.md

@@ -1,6 +1,29 @@
 # Digital Drosophila — 当前状态
 
-更新：2026-09-30。独立分支：`codex/lif-author-semantics-lab`。
+更新：2026-10-01。独立分支：`codex/lif-author-semantics-lab`。
+
+## 最新状态（取代下方历史摘要的“当前／下一步”表述）
+
+Phase 4AQ 已封存为 **PASS-EXACT-UPDATED-BOUNDARY-ENGINEERING-NOT-LEARNING**。Phase 4AR 的普通嗅觉 acquisition 已登记并启动，仍在执行；学习成功尚未判定，没有新 learned candidate。
+
+2026-10-01 00:09:04（Asia/Shanghai）的只读账本观察：
+
+- 已提交 **411/30,000** 轮训练（包含每轮更新和独立 CPU 校验）。
+- 已提交 **62/3,920** 次独立 probe。
+- 实际进程检查确认监督器、协调器和一个子进程存在；该未提交子进程不计入上述完成量。
+- 无 stopped、最终退出或 execution-complete 记录。登记 SHA 和 16 个登记源码 SHA 全部匹配；没有执行全量输入或历史产物完整性审计。
+
+登记 SHA-256：`b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740`。登记科学源码提交：`80aeb2093db655329774eff7b32fb6e417b8b40b`。这与当前仓库文档提交是不同概念；后续文档提交不会替换已登记源码版本。
+
+CPU 常驻原型的小范围工程验证已完成，原型未接入当前实验，也不据此更改当前运行速度或完成时间估计。
+
+下一步保持原登记执行，不自动重试、不调参或读取中途学习指标。真实完整退出后，再独立进行科学 gate 和最终完整性审计。普通 acquisition 本身不自动授权后续 assay、游戏、RL、decoder 或 Web/3D。
+
+[AR 登记范围](docs/progress/phase4ar-normal-acquisition.md) · [AQ 封存结果](docs/progress/phase4aq-execution-boundary.md) · [最新运行快照](registry/phase4ar-runtime-observation-20261001T000904/snapshot.json) · [本次同步说明](docs/progress/repository-sync-20261001.md) · [CPU 原型边界](docs/progress/conditioning-cpu-residency-probe-20260930.md)
+
+Git 仍仅同步代码、文档和小证据。本次没有上传大型原始数据或完整运行轨迹，也没有启用 Git LFS；不代表完成全量异机备份。下方截至 Phase 4AP 的原文作为历史摘要保留，其中“尚未启动条件化”等状态已经由本节取代。
+
+## 以下为截至 Phase 4AP 的历史摘要
 
 ## 最近已封存结果
 

README.md

@@ -3,7 +3,9 @@
 面向 MaleCNS v1.0 的可审计连接组、LIF 模型、感觉接口与局部可塑性机制研究。
 **这是研究工程仓库，不是已经实现自主学习或游戏控制的果蝇。**
 
-截至 2026-09-29，最新封存阶段是 **Phase 4Z：COMPLETE-EVENT-RESOLVED-PN-AUDIT**。
+截至 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`，远端默认分支仍为初始化分支。本页状态不表示已完成分支合并。
 项目顶层验收口径为 **5/10（50%）**；这不是生物学逼真度、工作量完成率或剩余工期。
 最新正式候选运行时为 `MaleCNS-LIF-runtime-v2-deterministic-candidate`。
 `MaleCNS-TemporalEligibility-v2-candidate` 与 `MaleCNS-OlfactoryEncoder-v1-candidate` 保留。
@@ -13,7 +15,8 @@
 
 | 主题 | 文档 |
 |---|---|
-| 当前状态、验收比例、下一步 | [项目状态](docs/00-overview/status.md) |
+| 最新运行状态、证据与下一步 | [当前状态](CURRENT.md)、[本次同步说明](docs/progress/repository-sync-20261001.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) |
@@ -35,7 +38,7 @@
 
 服务器项目根目录：`/data/digital-drosophila/`。
 远程：`ssh://git@192.168.10.31:2222/qishizhe/digital-drosophila.git`。
-初始化分支：`codex/project-bootstrap`。
+初始化／当前远端默认分支：`codex/project-bootstrap`；最新研发分支：`codex/lif-author-semantics-lab`。
 
 Git 保存源代码、配置、文档、书目、阶段证据副本和逐文件哈希清单。
 **Git 不保存原始 SWC/Feather、CSR、完整事件/状态、模型 checkpoint、虚拟环境或大型压缩包。**
@@ -45,7 +48,7 @@ Git 保存源代码、配置、文档、书目、阶段证据副本和逐文件
 ## 安全的首次检查
 
 ```bash
-git clone --branch codex/project-bootstrap ssh://git@192.168.10.31:2222/qishizhe/digital-drosophila.git
+git clone --branch codex/lif-author-semantics-lab ssh://git@192.168.10.31:2222/qishizhe/digital-drosophila.git
 cd digital-drosophila
 python3 -B tools/repo_guard.py
 ```

docs/progress/conditioning-cpu-residency-probe-20260930.md

@@ -0,0 +1,77 @@
+# CPU 常驻原型性能验证（2026-09-30）
+
+## 结论与边界
+
+结果：`PASS-CPU-RESIDENCY-PROTOTYPE-ONLY`。这是独立工程原型，不是新的
+学习候选、GPU runtime 验收或 Phase 4AR 替换授权。原型没有执行脑模拟，
+没有修改或安装权重，没有读取 AR 中途学习指标，也没有减少任何文件校验。
+
+当前正式 AR 继续原样执行；不能将此原型热替换到已登记的执行账本中。
+常驻任务 ACK 与真实进程退出属于不同证据，不能把前者伪装成每轮 OS exit。
+
+## 方法
+
+- 使用已封存 AQ 的 `mechanical--fresh-parent` 和
+  `performance--natural-light-fresh` 两个预先指定工程 checkpoint。
+- 固定 7 组：M、N、M、N_D0、N_frozen、M_D0、M。
+- M 的 before 为零 overlay；N 使用实际 AP 历史 learned overlay。
+- D0/frozen 是在独立 authority 中声明的工程命令变体，保留原 sealed events，
+  不修改原文件，不重新运行 conditioning。
+- 更新器调用原 `E.postprocess_epoch`，只复用同身份的已验证模块。
+- 原 AQ fresh-process validator 对每组原型输出独立重算并实际退出 0。
+- 新 resident validator 使用独立 PID；数学和校验主体与原实现 AST 一致，
+  仅调整模块复用与来源声明。所有动态输入、校验和 U 重算仍逐次执行。
+- CPU 单线程、低优先级、CUDA 不可见且未初始化。两常驻 worker 串行接收任务，
+  更新器和验证器不混载同一个解释器。
+
+## 真实计时
+
+首次请求单列为冷启动；下表为后 6 组配对热态均值。fresh 与 resident 的
+父级请求计时均包括请求/响应保存、输入摘要与输出核验；fresh 另外包含
+其每次进程启动/ready/退出。resident 生命周期启动与退出另有实际记录。
+
+| CPU 环节 | fresh 原实现 | resident 原型 |
+|---|---:|---:|
+| Epoch 更新 | 4.672 秒 | 2.763 秒 |
+| 独立校验 | 3.995 秒 | 2.063 秒 |
+| 合计 | 8.667 秒 | 4.826 秒 |
+
+- 两阶段均常驻：该 CPU 段加速 **1.796×**，耗时下降约 **44.3%**。
+- 只常驻更新器、仍保留 fresh 原验证器：该 CPU 段加速 **1.283×**。
+- 整个有界原型实测约 100.46 秒；服务器 benchmark 父进程实际退出 0。
+- 这些数值不包括全脑 GPU 模拟、AP 外层包装和 AR ledger 开销，不能据此
+  声称全实验加速 1.8 倍，或将原 9 天预测直接除以 1.8。
+- 正式 AR 同时运行，且仅测试两个源轨迹、一个 compartment，结果是小样本
+  工程测量，不是所有条件的性能保证。
+
+## 一致性与完整性
+
+- 本地和服务器安全/AST 单元测试：12/12 通过。
+- 7/7 真实全尺寸 CPU 回放：四个更新文件 SHA 完全相同；delta 的 dtype、
+  shape、raw bytes 完全相同；完整 update receipt、trace 摘要相同。
+- 原始 M/N 同时与已封存 AQ 更新输出比较，完全相同。
+- D0/frozen 的 before/after delta 逐位不变，包含非零历史 delta 条件。
+- 两验证器的科学校验字段完全相同；仅白名单列出的 schema/source/cache
+  provenance 字段不同，明确不冒称新验证器为原 frozen verifier。
+- 14 次 fresh 进程及 2 个 resident 进程均由父级观察实际退出 0。
+- 170 个新产物的清单、大小、SHA 已独立复核；消费的冻结输入及原型源代码
+  在前后保持原 SHA。这里不声称重新扫描了全部历史 Phase 1–4AQ。
+- 23:26 北京时间，AR 的 16 个已登记源码仍匹配原 SHA；原 supervisor /
+  controller 441824/441825 活跃，累计 310 个已验证 epoch、50 个 probe，
+  没有 stopped 记录。本段是时间限定快照，不是实时状态或学习结论。
+
+## 保存位置
+
+- 代码：`tools/conditioning-perf-lab-v1/`
+- 执行源码提交：`7f341d7ffbacc4b46bca74e5f570f7f2e8108ac0`
+- 原始执行目录：`/tmp/malecns-cpu-residency-woqIQa/`（保留，未删除）。
+- 持久化证据副本：`registry/conditioning-perf-prototype-20260930/`。
+- 主要结果：该目录的 `report.json`、`benchmark-plan.json`、`manifest.json`。
+- 副本不重写原回执中的实际执行路径。Git 同步代码及小型 JSON 证据；NPZ
+  按现有仓库策略保留在服务器，不把 Git 同步描述成所有数据异机备份。
+
+## 下一步
+
+优先验证静态图/APL 的常驻加载和独立 GPU worker 状态重置，但这需要不与
+当前正式任务争抢 4090 的测试窗口，以及逐事件、状态和更新的一致性回归。
+没有进行这一测试前，不升级为正式 runtime，也不终止或改写当前 AR。

docs/progress/phase4ar-normal-acquisition.md

@@ -0,0 +1,87 @@
+# Phase 4AR：独立分支普通嗅觉条件化
+
+## 当前状态
+
+2026-09-30：新分支代码已提交并同步远程仓库；服务器整套 CPU 测试
+73/73 通过，0 失败、0 跳过。旧封存完整性检查通过，实验预注册已锁定。
+4,080 份固定 CS 输入已生成并由真实进程退出记录及账本确认。
+独立后台执行器已启动；尚未据此宣称训练完成或学习成功。
+
+启动后观察到 4 个训练 epoch 已完成原更新及独立 CPU 校验、6 次独立
+probe 已提交；后续仍在运行。这是有时间边界的启动快照，不是当前实时
+累计数，也不是科学 gate 结果。首轮实际 CPU 校验确认使用封存 spike events
+重算原 U 更新，父进程记录退出码为 0。
+
+- 模型：`/data/digital-drosophila/models/male-cns-lif/normal-conditioning-v1/`
+- 实验：`/data/digital-drosophila/experiments/phase4ar-normal-conditioning/`
+- 管理日志：`/data/digital-drosophila/logs/phase4ar-normal-conditioning/`
+- 源码提交：`80aeb2093db655329774eff7b32fb6e417b8b40b`
+- 预注册 SHA-256：`b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740`
+- 仓库分支：`codex/lif-author-semantics-lab`
+
+## 固定实验与边界
+
+这是用户授权的独立动力学假设分支，不是替换 reference/runtime，
+也不是重新解释旧阶段失败。Phase 1–4AQ 封存产物、base graph、原始权重、
+transmitter sign、14,232-edge mask、eligibility-v2 与 APL 参数保持只读。
+
+按既有固定计划执行 physiological / matched-energy、PAM15 / PPL103、
+A+/B− 与 B+/A−、5 个训练重复，共 40 个 block。A 为 4-ethylphenol，
+B 为 3-hexanone。PAM15/PPL103 功能预测是明确的 compartment-specific
+模型假设，不能推广成“所有 PAM 为正、所有 PPL 为负”。
+
+7 组实际执行的实验臂为 paired、D=0、frozen、random reward、unpaired、
+CS-only、DAN-only，共 30,000 训练/对照 epoch、3,920 次独立 A/B probe。
+每 epoch 120 ms，CS 为前 100 ms，人工 US 为 90 ms；每轮重置神经状态，
+仅携带经独立 CPU 验证的 plastic delta。Probe 无 US、无学习更新、无反馈。
+
+终点固定，不允许根据中间结果改参数、改种子或挑最好条件。普通 acquisition
+通过也不等于已经获得可用学习模型；不会自动启动 reversal、retention、
+delayed reward 或任何游戏、动作解码器、RL、视觉、Web/3D。
+
+## 可审计执行
+
+当前登记包含 16 份源码、63 项输入身份、33 份准备产物。登记之后不得
+修改这些文件来修复运行中的实验；失败必须保留证据，不能原地改后续试跑。
+
+每个子进程先写独占开始记录，再保存真实退出状态、输入/输出 SHA-256、
+不可变顺序账本。部分失败保留，不自动重试。训练依次运行原 brain、
+原 E/U 更新和独立 CPU 重算；不能用父进程中自报成功代替真实退出。
+
+仅使用已登记的 RTX 4090，逐次检查 ComfyUI 队列，不停止其他服务。
+新输出上限 256 GiB、磁盘保留至少 100 GiB、单子进程上限 1,800 秒，
+登记期限 21 天。约 9 天仅为少量 AQ 计时的线性规划估算，并非全条件实测。
+
+完整性核验与 CPU 测试是工程证据，不是新数值回归，更不是学习证据。
+最终必须另行进行全产物审计、固定学习 gate 分析及旧阶段完整性复核。
+仓库同步源码/文档/小型证据，不等于大体量实验数据已经异机备份。
+
+## 后续只读检查
+
+已安排本线程每小时检查，仅在实质进展、异常、完成或需人工操作时提醒。
+不自动重试、修补已注册源码、进入后续 assay 或声明学习成功。
+
+独立只读工具位于 `tools/normal-conditioning-audit/progress_normal.py`，
+8 项临时数据测试在服务器通过。它读取实际提交账本与最新退出记录，
+不读取大体量脑输出；其进度结果不是完整性报告或科学结论。
+正在执行的 child 在没有真实退出记录时明确保持 UNKNOWN，不能由 PID
+或一个提前写出的 results 文件推定成功。完整 run 完成后仍需最终独立审计。
+
+## 终审工具准备进展（不改变正在运行的实验）
+
+独立终审工具已完成服务器联合测试：42/42 通过，0 失败、0 跳过。
+其中学习结果判定测试通过冻结的原指标代码生成六神经元合成报告，
+包含正常通过、终点未达 3/5、单一 H 对照来源失败、严格等号不通过等情形。
+这些不是本次真实学习结果，也没有读取中途学习指标。
+
+`tools/normal-conditioning-audit/normal_finalize.py check` 已在服务器实测：
+发现注册进程仍在运行后按设计拒绝终审，未创建终审输出目录。
+真正的完整审计和固定 gate 分析只能在全部任务结束、实际退出为 0 后进行。
+终审产物将位于独立的 `phase4ar-normal-conditioning-final-audit/`，
+不会向已完成的原实验目录追加或替换文件。
+
+终审保留原账本的全部字段，不改 PASS/FAIL 标志；完成记录在账本检查后
+才生成这一文件边界由单独的真实文件清单核对。任何额外文件、变更、
+未完成进程或来源矛盾均不得被当成完整的学习阳性/阴性结论。
+即便普通 acquisition 通过，delayed/reversal/retention 仍未运行，不能
+生成候选模型、宣称学习已经可用或自动启动后续实验。

docs/progress/repository-sync-20261001.md

@@ -0,0 +1,37 @@
+# 仓库同步与运行观察 — 2026-10-01
+
+采样时间：2026-10-01 00:09:04（Asia/Shanghai，UTC+08:00）。本报告是运行状态快照，不是新的科学结论，也不是完整数据备份。
+
+## 本轮新增内容
+
+- 发布独立的 [Phase 4AR 运行观察](../../registry/phase4ar-runtime-observation-20261001T000904/snapshot.json)。
+- 更新仓库 README 和 CURRENT 的入口状态，保留旧阶段报告与历史事实。
+- 未修改科学源码、配置、输入、权重或 Phase 1–4AQ 封存产物；未重启、重试或停止 Phase 4AR。
+- 未将 CPU 常驻性能原型接入当前登记实验。
+
+## 已提交执行账本
+
+| 项目 | 完成量 | 登记总量 |
+|---|---:|---:|
+| 训练轮次（神经运行、更新及独立 CPU 校验均已提交） | 411 | 30,000 |
+| 独立 probe | 62 | 3,920 |
+
+采样时操作系统确认监督器、协调器和一个子进程存在。子进程仍未提交，不能加入完成数；PID 或结果文件存在不构成完成证据。无 stopped 记录、无最终退出记录、无 execution-complete 记录。因此仍是运行中，学习成功尚未判断。
+
+登记 SHA-256：`b63e6281b6505ca3b60acb467dd0b3fae274cf513dcbfd653649ba52e9ba9740`。
+登记科学源码提交：`80aeb2093db655329774eff7b32fb6e417b8b40b`。
+本次直接核对登记的 16 个源码文件 SHA-256，全部匹配；63 个输入 pin 和 33 个准备文件 pin 仅记录登记数量，没有再次全量读取、哈希或重跑。实验所在文件系统可用约 602.45 GiB，这不是整台服务器总容量。
+
+## 观察边界
+
+这是一次非原子的在线元数据观察；读取期间未观察到账本条目增加，但不因此声称取得文件系统原子快照。只读取登记、账本、绑定的少量回执和任务身份，不读取 spike/state/delta 数组，不评估中途学习指标，不挑选条件，不调整策略。
+
+正式科学 gate 与最终历史完整性审计须在真实完整退出后独立执行。执行完成不等于学习成功；不自动开始反转、延迟奖励、保持或游戏等后续任务。
+
+## 同步范围和分支
+
+当前研发分支：`codex/lif-author-semantics-lab`。远端：`ssh://git@192.168.10.31:2222/qishizhe/digital-drosophila.git`。
+
+采样前本地与该远端分支均为 `b0728419fb4caaef37e41e3989b138c3fc6f754e`，已有代码、报告与小证据并无漏推。远端默认分支仍为 `codex/project-bootstrap`；本轮不合并、不改默认分支。
+
+本轮只发布本报告、入口文档及元数据快照。raw、SWC、CSR、权重和完整实验轨迹仍未通过 Git 上传，未配置或迁移 Git LFS。完整异机数据备份未因此完成。后续如启用 LFS，需要单独检查服务配置、可用空间与归档方案，不改动冻结数据原件。

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

@@ -0,0 +1,91 @@
+# Normal olfactory acquisition: independent D18 branch
+
+This phase does not modify MaleCNS reference/runtime, Phase 1–4AQ data, the
+base graph, the 14,232 candidate edges, eligibility-v2, APL gain, cell thresholds,
+transmitter signs or any previously sealed failure. An engineering interface
+PASS is not evidence of learning.
+
+## Fixed science
+
+The original AO file (SHA-256
+`a7bda850ee87df4d9f647994e1a1a4074dfea5793184edb1822ab3d8c02e8216`)
+supplies master 20260930, all semantic seeds, ordered cues and control schedules.
+The old frozen evaluation policy supplies completed-epoch snapshot boundaries.
+There are 40 normal blocks: physiological/matched-energy × PAM15/PPL103 ×
+reciprocal reinforced odor × five training replicates. A is 4-ethylphenol, B is
+3-hexanone. Evaluation uses 80 independently registered input streams.
+
+All seven arms are real: paired, D=0, frozen, random reward, unpaired, CS-only
+and DAN-only. 30,000 complete fresh training/control epochs and 3,920 real
+fresh A/B probes are required. Even identical baselines are executed, not
+relabelled copies. Snapshots 0/1/2/5/10/20/50 never authorize outcome selection.
+Only the 50-pairing terminal outcome determines acquisition. Every arm finishes
+its entire original schedule, including trailing neutral or blank epochs.
+
+Epochs are 120 ms, CS is [0,100) ms, scheduled artificial US is at 90 ms.
+PAM15 and PPL103 use only their existing confirmed compartment-specific DAN
+identities. The positive/negative behavioral predictions are explicit model
+hypotheses, not a claim that every PAM/PPL neuron has that function. Scheduled
+D is an artificial dimensionless interface, not measured dopamine concentration
+or the number of accepted DAN spikes. US attempts/rejections and actual events
+remain in the original runtime artifacts. No resampling compensates for a
+rejected pulse.
+
+Fresh neural state is reset each epoch; only the separately authenticated
+plastic delta carries forward. Original E/U compute the end-of-epoch update,
+then a separate CPU process recomputes it from sealed actual KC events. Probes
+have no US, no E/update and no feedback. Brain math is untouched.
+
+## Readout and gates
+
+The frozen AQ `learning_gates.py` and original `metrics.py` are pinned before
+sampling. All six controls, raw signed MBON balance, functional count/latency
+change, MBON separation and both downstream readouts remain mandatory. The
+same replicate must satisfy the conjunction; at least three of five pass in
+each of the eight cells. PAM/PPL or input modes are never pooled to rescue a
+failure. Original H mean-control rules are reported separately for each DAN
+control source, both required. Delta change alone cannot imply learning.
+
+Readout populations are anatomical, never inferred from active/plastic subsets.
+The original H actual MBON downstream edge table defines legacyDownstream;
+nonMBONDownstream is its exact set difference with the full MBON population.
+Missing identity or an altered frozen source stops preparation.
+
+## Execution, resources and integrity
+
+Use only the registered 4090 UUID and serial execution. ComfyUI admission must
+be empty; never stop or evict a service. Source code is committed before
+registration. Static tables invoke the original L PN-rate transform, preserving
+all original PN columns for both modes. Shared CS aliases reuse saved input
+bytes only. The full 63-bit CUDA sampler, full matrix draw and CS window are
+unchanged; there is no CPU-RNG replacement.
+
+The engineering ceiling is 256 GiB of new outputs, at least 100 GiB disk reserve,
+1,800 seconds per child and an absolute 21-day registration deadline. The AQ
+linear estimate is only planning arithmetic from limited warm measurements,
+not a measured forecast across all conditions. Exceeding a limit means an
+incomplete preserved experiment, not shortened trials or changed parameters.
+
+Each child has an exclusive start record, actual parent-observed exit,
+dependency hashes and immutable output inventory. A stopped or uncommitted
+child is never silently retried. A persistent incremental ledger avoids
+rehashing every historical trial on every iteration; each invocation still
+rehashes its actual consumed dependencies. Full audits read every unique file
+and reject missing, extra, changed, linked or incomplete output. They are not
+claimed to be atomic filesystem snapshots. Mutable compiler cache is accounted
+separately. CPU/source tests are not described as GPU numerical regression.
+
+A detached supervisor keeps the serial controller alive across SSH disconnects.
+Administrative logs live in `/data/digital-drosophila/logs/phase4ar-normal-conditioning/`,
+outside the immutable per-trial ledger. The final outer auditor must retain
+these logs and its actual exit receipt. A launch PID alone proves no completion.
+
+All original event/state/queue/update artifacts are retained; no dense wholebrain
+time-by-neuron output is added. Complete historical sealed integrity is checked
+at the boundaries. The five historical reference trials are preserved evidence,
+not claimed as newly rerun here.
+
+Normal acquisition is the only authorized scientific scope of this registration.
+No delayed/reversal/retention assay starts automatically, and no candidate is
+issued from normal acquisition alone. There is no game, action decoder, RL,
+visual input, training of base weights, web service or 3D interface.

models/male-cns-lif/normal-conditioning-v1/append_ledger.py

@@ -0,0 +1,442 @@
+"""Serial, immutable artifact accounting; not a process runner or science gate.
+
+The long-lived parent hashes this cycle's declared inputs/outputs and the known
+ledger tail. It does NOT rehash all old artifacts per cycle. Reopening, inspect
+and final_verify perform full historical verification. Never infer a process's
+terminal state from a PID, missing file, elapsed time, or a live handle.
+"""
+from __future__ import annotations
+
+from contextlib import contextmanager
+import hashlib
+import json
+import os
+from pathlib import Path, PurePosixPath
+import re
+import shutil
+import uuid
+
+SCHEMA = 'normal-append-ledger-v1'
+CONTROL = '.append-ledger'
+REGISTRATION = 'protocol/preregistered.json'
+SHA = re.compile('[0-9a-f]{64}')
+ID = re.compile('[A-Za-z0-9][A-Za-z0-9_-]{0,127}')
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def raw_json(value):
+    return (json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=False, allow_nan=False)+'\n').encode('utf-8')
+
+
+def read_json(path):
+    def unique(items):
+        result = {}
+        for key, value in items:
+            require(key not in result, 'Duplicate JSON key'); result[key] = value
+        return result
+    return json.loads(Path(path).read_bytes().decode('utf-8'), object_pairs_hook=unique,
+        parse_constant=lambda _: (_ for _ in ()).throw(ValueError('Nonfinite JSON')))
+
+
+def digest(path):
+    h = hashlib.sha256()
+    with Path(path).open('rb') as stream:
+        for block in iter(lambda: stream.read(8 << 20), b''): h.update(block)
+    return h.hexdigest()
+
+
+def relative_name(value):
+    require(type(value) is str and bool(value) and '\\' not in value and '\x00' not in value and
+            '\n' not in value and '\r' not in value, 'Invalid relative path')
+    path = PurePosixPath(value)
+    require(not path.is_absolute() and str(path) == value and
+            all(p not in ('.', '..', '') and ':' not in p for p in path.parts), 'Escaping/noncanonical path')
+    return value
+
+
+def unlinked(path):
+    p = Path(path)
+    require(p.is_absolute() and '..' not in p.parts, 'Absolute nonescaping path required')
+    require(not any(q.is_symlink() or (hasattr(q, 'is_junction') and q.is_junction()) for q in (p, *p.parents)),
+            'Linked path forbidden')
+    return p
+
+
+def identity(path):
+    p = unlinked(path)
+    require(p.is_file(), 'Missing regular file: '+str(p))
+    size = p.stat().st_size; sha = digest(p)
+    require(p.stat().st_size == size, 'File changed while hashing')
+    return dict(bytes=size, sha256=sha)
+
+
+def validate_identity(value):
+    require(type(value) is dict and set(value) == {'bytes', 'sha256'} and type(value['bytes']) is int and
+            value['bytes'] >= 0 and type(value['sha256']) is str and SHA.fullmatch(value['sha256']), 'Invalid SHA/byte identity')
+
+
+def _sync_directory(directory):
+    # Windows has no portable directory fsync. File bytes are fsynced there.
+    if os.name != 'nt':
+        descriptor = os.open(directory, os.O_RDONLY)
+        try: os.fsync(descriptor)
+        finally: os.close(descriptor)
+
+
+def publish_exclusive(path, value):
+    """Atomic no-replace publication on filesystems supporting hard links.
+
+    No unsafe rename/replace fallback. An interrupted temporary is preserved;
+    inspect/final audit rejects it. A failed destination collision also never
+    deletes or replaces the pre-existing destination.
+    """
+    path = unlinked(path); require(path.parent.is_dir(), 'Missing publication parent')
+    require(not path.exists(), 'Immutable destination already exists; no retry')
+    raw = raw_json(value); temporary = path.parent / ('.publishing-'+uuid.uuid4().hex)
+    descriptor = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    with os.fdopen(descriptor, 'wb') as stream:
+        stream.write(raw); stream.flush(); os.fsync(stream.fileno())
+    os.link(temporary, path)  # Exclusive destination, same bytes/inode; never overwrite.
+    _sync_directory(path.parent)
+    require(path.read_bytes() == raw, 'Published bytes changed')
+    temporary.unlink()  # Only this function's exact, newly created temporary.
+    _sync_directory(path.parent)
+    return dict(bytes=len(raw), sha256=hashlib.sha256(raw).hexdigest())
+
+
+class Ledger:
+    """One long-lived instance per serial parent, never parallel scheduling.
+
+    Inventories map absolute or root-relative paths to {bytes, sha256}; initial
+    inventory is root-relative and must contain the exact registration file.
+    Call begin BEFORE spawn, then append only after the parent has observed
+    actual exit 0 and saved its independent process receipt. Existing starts
+    are never reissued. An interrupted append may be independently inspected,
+    but automatic resume/rerun is not provided.
+    """
+    def __init__(self, root, registration_sha, initial_inventory, max_output_bytes, reserve_bytes,
+                 shared_build_relative='extension-build'):
+        self.root = unlinked(Path(root)).resolve(strict=True)
+        require(self.root.is_dir(), 'Existing experiment root required')
+        require(type(registration_sha) is str and SHA.fullmatch(registration_sha), 'External registration SHA required')
+        require(type(max_output_bytes) is int and max_output_bytes > 0 and type(reserve_bytes) is int and reserve_bytes >= 0,
+                'Explicit nonnegative reserve and positive output cap required')
+        self.registration_sha = registration_sha; self.max_output_bytes = max_output_bytes; self.reserve_bytes = reserve_bytes
+        self.build_name = relative_name(shared_build_relative)
+        require(self.build_name != CONTROL and not self.build_name.startswith(CONTROL+'/'), 'Build overlaps ledger controls')
+        self.control = self.root / CONTROL; self.header_path = self.control / 'header.json'
+        self.starts = self.control / 'started'; self.entries = self.control / 'entries'
+        require(type(initial_inventory) is dict and initial_inventory, 'Explicit initial inventory required')
+        initial = {}
+        for name, expected in initial_inventory.items():
+            relative_name(name); self._payload_path(name); validate_identity(expected)
+            require(identity(self.root/name) == expected, 'Initial file identity differs: '+name)
+            initial[name] = dict(expected)
+        require(initial.get(REGISTRATION, {}).get('sha256') == registration_sha, 'Initial registration binding missing')
+        header = dict(schema=SCHEMA, root=str(self.root), registration_sha256=registration_sha,
+            initial_inventory=initial, max_output_bytes=max_output_bytes, reserve_bytes=reserve_bytes,
+            shared_mutable_build=self.build_name, initial_inventory_scope='caller supplied; entire tree checked only by final_verify',
+            scientific_gate_claimed=False)
+        if self.header_path.exists():
+            require(read_json(self.header_path) == header, 'Existing ledger authority/options differ')
+        else:
+            require(not self.control.exists(), 'Partial ledger initialization; no automatic retry')
+            self.control.mkdir(); self.starts.mkdir(); self.entries.mkdir()
+            publish_exclusive(self.header_path, header)
+        self.header_identity = identity(self.header_path); self.initial = initial
+        self._tracked = dict(initial); self._controls = {CONTROL+'/header.json': self.header_identity}
+        self._completed = []; self._completed_set = set(); self._pending = {}; self._tail = None
+        self._immutable_bytes = sum(v['bytes'] for v in initial.values())
+        self._control_bytes = self.header_identity['bytes']
+        self._write_failed = False
+        self._replay()
+        self._budget()
+
+    def _payload_path(self, value):
+        path = Path(value)
+        if not path.is_absolute(): path = self.root / relative_name(str(value))
+        path = unlinked(path)
+        require(path.is_relative_to(self.root), 'Output escapes experiment')
+        rel = path.relative_to(self.root).as_posix(); relative_name(rel)
+        require(rel != CONTROL and not rel.startswith(CONTROL+'/') and rel != self.build_name and
+                not rel.startswith(self.build_name+'/'), 'Immutable payload overlaps controls/shared build')
+        return path, rel
+
+    def _rows(self, mapping, *, output, verified=None):
+        require(type(mapping) is dict, 'Explicit inventory dictionary required')
+        result = []; used = set()
+        for text, expected in mapping.items():
+            validate_identity(expected); p = Path(text)
+            if output: p, rel = self._payload_path(text)
+            else:
+                if not p.is_absolute(): p = self.root / relative_name(str(text))
+                p = unlinked(p); rel = p.relative_to(self.root).as_posix() if p.is_relative_to(self.root) else None
+            p = p.resolve(strict=True)
+            rel = p.relative_to(self.root).as_posix() if p.is_relative_to(self.root) else None
+            require(str(p) not in used, 'Duplicate path aliases'); used.add(str(p))
+            if not output and rel in self._tracked:
+                require(expected == self._tracked[rel], 'Consumed immutable input differs from committed identity')
+            observed = self._identity_once(p, verified)
+            require(observed == expected, 'Actual file SHA/bytes differ: '+str(p))
+            result.append(dict(path=str(p), relative_path=rel, **expected))
+        return sorted(result, key=lambda row: row['path'])
+
+    @staticmethod
+    def _identity_once(path, verified):
+        """One *invocation-local* actual SHA read per unique file, no stat cache."""
+        if verified is None: return identity(path)
+        key = str(path)
+        if key not in verified: verified[key] = identity(path)
+        return verified[key]
+
+    def _check_tail(self):
+        require(not self._write_failed, 'Previous publication failed; independent inspection required, no automatic retry')
+        require(identity(self.header_path) == self.header_identity, 'Ledger header changed')
+        if self._completed:
+            p = self.entries / f'{len(self._completed):016d}.json'
+            require(identity(p)['sha256'] == self._tail, 'Known ledger tail changed')
+        require(not (self.entries / f'{len(self._completed)+1:016d}.json').exists(), 'Unobserved appended entry; independently reopen/inspect')
+
+    @contextmanager
+    def _writer(self):
+        lock = self.control/'writer.lock'; token = uuid.uuid4().hex.encode()
+        unlinked(lock)
+        descriptor = os.open(lock, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+        try:
+            with os.fdopen(descriptor, 'wb') as stream: stream.write(token); stream.flush(); os.fsync(stream.fileno())
+            self._check_tail()
+            yield
+        finally:
+            # Do not remove another actor's/stale lock or broadly delete a tree.
+            if lock.is_file() and lock.read_bytes() == token: lock.unlink()
+
+    def _build_inventory(self):
+        root = unlinked(self.root/self.build_name); result = {}
+        if root.exists():
+            require(root.is_dir(), 'Shared build must be a directory')
+            for p in sorted(root.rglob('*')):
+                unlinked(p)
+                if p.is_file(): result[p.relative_to(self.root).as_posix()] = identity(p)
+                else: require(p.is_dir(), 'Nonregular shared build file')
+        return result
+
+    def _budget(self, *, outputs=(), extra_control=0):
+        # O(new outputs), not O(all previous payload rows), for the serial path.
+        added = {row['relative_path']:row['bytes'] for row in outputs}
+        provisional = {}
+        for attempt in self._pending.values():
+            job = attempt['job']; rel = job['relative_path']
+            if rel is not None and rel not in self._tracked and rel not in added: provisional[rel] = job['bytes']
+        build = self._build_inventory()
+        immutable = self._immutable_bytes+sum(added.values())
+        control = self._control_bytes+extra_control
+        build_bytes = sum(row['bytes'] for row in build.values())
+        total = immutable+control+build_bytes+sum(provisional.values())
+        require(total <= self.max_output_bytes, 'Tracked outputs/control/shared build exceed cap')
+        require(shutil.disk_usage(self.root).free >= self.reserve_bytes+extra_control, 'Free-space reserve would be crossed')
+        return dict(immutable_payload_bytes=immutable, ledger_control_bytes=control, shared_mutable_build_bytes=build_bytes,
+            provisional_job_bytes=sum(provisional.values()), total_accounted_bytes=total,
+            shared_mutable_build_inventory=build, unlisted_files_included=False,
+            scope='tracked immutable payload + ledger controls + pending job files + current shared mutable build; unlisted files checked at final audit')
+
+    def begin(self, entry_id, job_file, metadata=None):
+        """Persist BEFORE spawning; success does not authorize automatic retry."""
+        require(type(entry_id) is str and ID.fullmatch(entry_id), 'Unsafe entry ID')
+        require(metadata is None or type(metadata) is dict, 'Begin metadata must be a JSON dictionary')
+        with self._writer():
+            require(not self._pending, 'Serial ledger has an uncommitted start; do not rerun it')
+            require(entry_id not in self._completed_set and not (self.starts/(entry_id+'.json')).exists(), 'Entry already started/committed; no retry')
+            path = Path(job_file)
+            if not path.is_absolute(): path = self.root / relative_name(str(job_file))
+            rows = self._rows({str(path):identity(path)}, output=False)
+            value = dict(schema=SCHEMA+'-start', entry_id=entry_id, registration_sha256=self.registration_sha,
+                next_sequence=len(self._completed)+1, prev_entry_sha256=self._tail, job=rows[0], metadata=metadata or {},
+                terminal_state='unknown', retry_authorized=False)
+            raw_json(value); self._pending[entry_id] = value
+            try:
+                self._budget(extra_control=len(raw_json(value)))
+                info = publish_exclusive(self.starts/(entry_id+'.json'),value)
+            except BaseException:
+                self._write_failed = True
+                self._pending.pop(entry_id, None); raise
+            self._controls[f'{CONTROL}/started/{entry_id}.json'] = info
+            self._control_bytes += info['bytes']
+            return dict(entry_id=entry_id,start_sha256=info['sha256'],sequence=value['next_sequence'],terminal_state='unknown',retry_authorized=False)
+
+    def append(self, entry_id, inputs, outputs, metadata):
+        """Commit exactly one observed-successful serial parent job.
+
+        metadata requires job_file/process_receipt_file/scope/observed_returncode.
+        The independent parent process JSON must declare entry_id, registration
+        SHA, job SHA, complete=true, exit_code integer 0, timed_out=false,
+        exit_observed_by_parent=true. These are authenticated recorded facts,
+        not a new OS observation by this ledger.
+        """
+        require(type(metadata) is dict and all(k in metadata for k in
+            ('job_file','process_receipt_file','scope','observed_returncode')), 'Complete parent metadata required')
+        require(type(metadata['scope']) is str and bool(metadata['scope'].strip()) and
+                type(metadata['observed_returncode']) is int and metadata['observed_returncode'] == 0,
+                'Live/failed process cannot be committed as successful')
+        raw_json(metadata)
+        with self._writer():
+            require(entry_id in self._pending and entry_id not in self._completed_set, 'No unique uncommitted start; no retry')
+            start = self._pending[entry_id]; startfile = self.starts/(entry_id+'.json')
+            require(identity(startfile) == self._controls[f'{CONTROL}/started/{entry_id}.json'] and read_json(startfile) == start,
+                    'Start authority changed')
+            incoming = self._rows(inputs, output=False); outgoing = self._rows(outputs, output=True)
+            require(outgoing, 'Empty completed output inventory')
+            require(all(row['relative_path'] not in self._tracked for row in outgoing), 'Output overwrites previously tracked file')
+            self._receipt(entry_id,start,incoming,outgoing,metadata)
+            cumulative = self._immutable_bytes+sum(row['bytes'] for row in outgoing)
+            budget = self._budget(outputs=outgoing)
+            value = dict(schema=SCHEMA+'-entry', sequence=len(self._completed)+1, entry_id=entry_id,
+                registration_sha256=self.registration_sha, prev_entry_sha256=self._tail,
+                start_sha256=identity(startfile)['sha256'], consumed_inputs=incoming, new_outputs=outgoing,
+                metadata=metadata, cumulative_immutable_bytes=cumulative, shared_mutable_build=budget['shared_mutable_build_inventory'],
+                hash_scope='actual declared files and current head; historical payload is rehashed at inspect/reopen/final_verify',
+                scientific_gate_claimed=False, OS_exit_independently_observed_here=False)
+            budget = self._budget(outputs=outgoing,extra_control=len(raw_json(value)))
+            require(budget['shared_mutable_build_inventory'] == value['shared_mutable_build'], 'Shared build changed during append accounting')
+            try: info = publish_exclusive(self.entries/f'{value["sequence"]:016d}.json',value)
+            except BaseException:
+                self._write_failed = True; raise
+            self._controls[f'{CONTROL}/entries/{value["sequence"]:016d}.json'] = info
+            self._control_bytes += info['bytes']; self._immutable_bytes = cumulative
+            self._tracked.update({r['relative_path']:{k:r[k] for k in ('bytes','sha256')} for r in outgoing})
+            self._completed.append(entry_id); self._completed_set.add(entry_id); self._pending.pop(entry_id); self._tail = info['sha256']
+            return dict(sequence=value['sequence'],entry_id=entry_id,entry_sha256=self._tail,
+                cumulative_immutable_bytes=cumulative,budget=budget,scientific_gate_claimed=False)
+
+    def _receipt(self,entry_id,start,inputs,outputs,metadata):
+        def path(value):
+            p=Path(value)
+            return str(unlinked(p if p.is_absolute() else self.root/relative_name(str(value))))
+        jobpath=path(metadata['job_file']);receiptpath=path(metadata['process_receipt_file'])
+        supplied={r['path']:r for r in inputs+outputs}
+        require(jobpath == start['job']['path'] and jobpath in supplied and
+                all(supplied[jobpath][k] == start['job'][k] for k in ('bytes','sha256')), 'Job not bound to original start')
+        require(type(metadata.get('observed_returncode')) is int and metadata['observed_returncode'] == 0 and
+                type(metadata.get('scope')) is str and bool(metadata['scope'].strip()), 'Invalid parent observation/scope')
+        require(receiptpath in {r['path'] for r in outputs}, 'Parent process receipt must be a new output')
+        receipt=read_json(receiptpath)
+        require(receipt.get('entry_id') == entry_id and receipt.get('registration_sha256') == self.registration_sha and
+                receipt.get('job_sha256') == start['job']['sha256'] and receipt.get('complete') is True and
+                type(receipt.get('exit_code')) is int and receipt['exit_code'] == 0 and receipt.get('timed_out') is False and
+                receipt.get('exit_observed_by_parent') is True, 'Missing bound observed-successful parent process receipt')
+
+    def _replay(self, verified=None):
+        verified = {} if verified is None else verified
+        header_observed = identity(self.header_path)
+        require(header_observed == self.header_identity, 'Ledger header changed')
+        verified[str(self.header_path)] = header_observed
+        if self._completed:
+            require(identity(self.entries/f'{len(self._completed):016d}.json')['sha256'] == self._tail,
+                    'Previously observed ledger head changed')
+        require(not (self.control/'writer.lock').exists(), 'Writer/stale lock present; state unknown, never clear automatically')
+        tracked=dict(self.initial);controls={CONTROL+'/header.json':self.header_identity};completed=[];completed_set=set();tail=None
+        cumulative=sum(v['bytes'] for v in tracked.values())
+        starts={}
+        require(self.starts.is_dir() and self.entries.is_dir(), 'Missing ledger directories')
+        for p in sorted(self.starts.iterdir()):
+            unlinked(p);require(p.is_file() and p.suffix=='.json' and ID.fullmatch(p.stem), 'Unknown/partial start artifact')
+            row=read_json(p);require(row.get('schema')==SCHEMA+'-start' and row.get('entry_id')==p.stem and
+                row.get('registration_sha256')==self.registration_sha and row.get('retry_authorized') is False,
+                'Invalid start schema/authority')
+            require(row['job']==self._rows({row['job']['path']:{k:row['job'][k] for k in ('bytes','sha256')}},output=False,verified=verified)[0], 'Start job bytes changed')
+            starts[p.stem]=row;controls[p.relative_to(self.root).as_posix()]=self._identity_once(p,verified)
+        for index,p in enumerate(sorted(self.entries.iterdir()),1):
+            unlinked(p);require(p.is_file() and p.name==f'{index:016d}.json','Missing/out-of-order/temporary ledger entry')
+            row=read_json(p);entry_id=row.get('entry_id');require(entry_id in starts and entry_id not in completed_set,'Missing/duplicate start binding')
+            start=starts[entry_id]
+            require(row.get('schema')==SCHEMA+'-entry' and type(row.get('sequence')) is int and row['sequence']==index and
+                row.get('registration_sha256')==self.registration_sha and row.get('prev_entry_sha256')==tail and
+                start['next_sequence']==index and start['prev_entry_sha256']==tail and
+                row['start_sha256']==controls[f'{CONTROL}/started/{entry_id}.json']['sha256'] and
+                row.get('scientific_gate_claimed') is False,'Entry chain/start identity differs')
+            for field,output in (('consumed_inputs',False),('new_outputs',True)):
+                items=row[field];require(type(items) is list and len({r['path'] for r in items})==len(items),'Invalid stored file rows')
+                observed=self._rows({r['path']:{k:r[k] for k in ('bytes','sha256')} for r in items},output=output,verified=verified)
+                require(items==observed,'Stored absolute/relative/hash identity differs')
+            require(row['new_outputs'] and all(r['relative_path'] not in tracked for r in row['new_outputs']), 'Immutable output repeated')
+            self._receipt(entry_id,start,row['consumed_inputs'],row['new_outputs'],row['metadata'])
+            tracked.update({r['relative_path']:{k:r[k] for k in ('bytes','sha256')} for r in row['new_outputs']})
+            cumulative+=sum(r['bytes'] for r in row['new_outputs'])
+            require(type(row['cumulative_immutable_bytes']) is int and row['cumulative_immutable_bytes']==cumulative,'Cumulative byte accounting differs')
+            completed.append(entry_id);completed_set.add(entry_id);info=self._identity_once(p,verified);controls[p.relative_to(self.root).as_posix()]=info;tail=info['sha256']
+        pending={k:v for k,v in starts.items() if k not in completed_set}
+        require(len(pending)<=1 and all(v['next_sequence']==len(completed)+1 and v['prev_entry_sha256']==tail for v in pending.values()),
+                'Uncommitted start does not follow actual head')
+        for name,info in tracked.items():require(self._identity_once(self.root/name,verified)==info,'Historical payload changed: '+name)
+        allowed=set(controls)
+        for p in self.control.rglob('*'):
+            unlinked(p)
+            require(p.is_dir() or (p.is_file() and p.relative_to(self.root).as_posix() in allowed),'Unlisted/partial ledger control artifact')
+        # Fresh head reads bracket this audit. This is not an atomic FS snapshot.
+        require(identity(self.header_path)==self.header_identity,'Ledger header changed during audit')
+        require(not (self.control/'writer.lock').exists() and not (self.entries/f'{len(completed)+1:016d}.json').exists(),
+                'Concurrent writer/append detected; audit not terminal')
+        if completed:require(identity(self.entries/f'{len(completed):016d}.json')['sha256']==tail,'Ledger head changed during audit')
+        self._tracked=tracked;self._controls=controls;self._completed=completed;self._completed_set=completed_set;self._pending=pending;self._tail=tail
+        self._immutable_bytes=cumulative
+        self._control_bytes=sum(v['bytes'] for v in controls.values())
+
+    def inspect(self):
+        """Full historical read verification; no restart or retry authorization."""
+        self._replay()
+        return dict(schema=SCHEMA+'-inspection',registration_sha256=self.registration_sha,entries=len(self._completed),
+            entry_ids=list(self._completed),head_sha256=self._tail,uncommitted_entry_ids=sorted(self._pending),
+            uncommitted_state='STARTED-UNCOMMITTED-STATE-UNKNOWN' if self._pending else None,
+            retry_authorized=False,all_tracked_history_rehashed=True,entire_experiment_tree_checked=False,
+            SHA_scope='each unique payload path read during this invocation; no cross-invocation cache; not an atomic snapshot',
+            budget=self._budget(),scientific_gate_claimed=False)
+
+    def final_verify(self,expected_entry_ids):
+        """Full tree at this instant, before caller writes any future final report.
+
+        expected IDs must be derived by caller from the externally pinned
+        registration. Shared build is mutable and separately hashed/accounted,
+        never silently accepted as an immutable payload.
+        """
+        require(type(expected_entry_ids) is list and all(type(x) is str and ID.fullmatch(x) for x in expected_entry_ids) and
+                len(set(expected_entry_ids))==len(expected_entry_ids),'Exact registered expected entry order required')
+        errors=[];verified={}
+        try:self._replay(verified)
+        except (ValueError,OSError,KeyError,TypeError) as exc:errors.append(type(exc).__name__+': '+str(exc))
+        expected={**self._tracked,**self._controls};actual={};links=[]
+        for p in sorted(self.root.rglob('*')):
+            rel=p.relative_to(self.root).as_posix()
+            try:
+                unlinked(p)
+                if p.is_file():actual[rel]=self._identity_once(p,verified)
+                else:require(p.is_dir(),'Nonregular artifact')
+            except (ValueError,OSError) as exc:links.append(rel);errors.append(str(exc))
+        build={k:v for k,v in actual.items() if k.startswith(self.build_name+'/')}
+        immutable={k:v for k,v in actual.items() if k not in build}
+        extra=sorted(set(immutable)-set(expected));missing=sorted(set(expected)-set(immutable))
+        changed=sorted(k for k in set(expected)&set(immutable) if expected[k]!=immutable[k])
+        exact_order=self._completed==expected_entry_ids
+        actual_bytes=sum(v['bytes'] for v in actual.values());within_cap=actual_bytes<=self.max_output_bytes
+        free_reserve=shutil.disk_usage(self.root).free>=self.reserve_bytes
+        # Bracket the *entire* tree walk as well as replay. These fresh small
+        # authority reads deliberately bypass the per-invocation payload cache.
+        # They detect changed/appended heads, not an atomic filesystem snapshot.
+        try:
+            self._check_tail()
+            require(not (self.control/'writer.lock').exists(), 'Concurrent writer detected at final audit end')
+        except (ValueError,OSError) as exc:errors.append(type(exc).__name__+': '+str(exc))
+        passed=not(errors or extra or missing or changed or self._pending) and exact_order and within_cap and free_reserve
+        return dict(schema=SCHEMA+'-final-audit',pass_all=passed,registration_sha256=self.registration_sha,
+            entry_ids=list(self._completed),expected_entry_ids=expected_entry_ids,expected_order_exact=exact_order,
+            head_sha256=self._tail,extra_files=extra,missing_files=missing,changed_files=changed,unsafe_files=links,errors=errors,
+            uncommitted_entry_ids=sorted(self._pending),uncommitted_state_unknown=bool(self._pending),retry_authorized=False,
+            actual_total_bytes=actual_bytes,immutable_and_ledger_bytes=actual_bytes-sum(v['bytes'] for v in build.values()),
+            shared_mutable_build_bytes=sum(v['bytes'] for v in build.values()),shared_mutable_build_inventory=build,
+            output_cap_respected=within_cap,free_reserve_respected=free_reserve,
+            all_current_files_rehashed=True,checked_before_future_final_report=True,
+            SHA_scope='each unique path read during this invocation; fresh header/head checks bracket full audit; no cross-invocation cache; not an atomic snapshot',
+            expected_inventory_authority='caller derives IDs from pinned registration; ledger does not interpret scientific plan',
+            scientific_gate_claimed=False)

models/male-cns-lif/normal-conditioning-v1/normal_inputs.py

@@ -0,0 +1,131 @@
+"""Exact frozen L rate transform and full-shape CUDA sampler, no brain/update.
+
+Static table derivation is CPU/read-only. Sampling is a separate explicit job.
+Common-random aliases share only saved immutable CS bytes, never brain outputs.
+"""
+from __future__ import annotations
+import argparse
+import os
+from pathlib import Path
+import sys
+import time
+import numpy as np
+from normal_io import *
+
+PINS = {
+    'conditioning_inputs.py': '19382e066e450140bb653a3661f980ffe7cc62f412020ef57df0b6e6b3cbb8ba',
+    'conditioning_preflight_inputs.py': '846d2141b472f18b1bb728eed4aa33876896d4b33dece364787c81204f62995f',
+    'trial_plan.py': '6fed3f494d075339a7e5b001d43b2598640b189e038952fbd4d41200bacac587',
+    'seed_registry.py': '0da033b132095ec3087b5d9f64e53c2e391fa50ab0b7653b31296eeb84799b7e',
+}
+
+def dependencies():
+    verify({str(LAB/n): s for n,s in PINS.items()})
+    require(not any(n in sys.modules for n in ('runtime_light','conditioning_epoch')), 'No neural modules in sampler')
+    sys.path.insert(0, str(LAB))
+    import conditioning_preflight_inputs as source
+    import conditioning_inputs as inputs
+    require(Path(source.__file__) == LAB/'conditioning_preflight_inputs.py' and
+            Path(inputs.__file__) == LAB/'conditioning_inputs.py', 'Wrong input module identity')
+    return source, inputs
+
+def derive_rates(root=ROOT):
+    """Calls the original pinned pn_drive for both registered modes."""
+    import pandas as pd
+    import yaml
+    source, inputs = dependencies()
+    loaded = source.load_rate_tables(root)
+    static = Path(root)/source.STATIC
+    selection = read(static/'odor-encoder/selection.json')
+    panel = pd.read_parquet(static/'odor-encoder/frozen-odor-panel.parquet')
+    mapping = pd.read_parquet(static/'receptor-mapping/olfactory-mapping.parquet')
+    config = yaml.safe_load((Path(root)/source.CONFIG_REL).read_text())
+    drive, ast_sha = source._extract_drive((Path(root)/source.SOURCE_REL).read_bytes(), str(Path(root)/source.SOURCE_REL))
+    vectors = npz(static/'odor-encoder/mapped-glomerular-vectors.npz')
+    result = {}
+    for mode in ('physiological','matched_energy'):
+        for cue in ('A','B'):
+            original = loaded['tables'][cue]
+            targets, rates, frame = drive(original['odor_id'], vectors[original['odor_id']], mapping,
+                selection['glomeruli_order'], mode, loaded['audit']['median_mapped_response_sum'], config)
+            inputs.probabilities_f32(targets, rates)
+            require(np.array_equal(frame.neuron_idx.to_numpy(np.int32), targets) and
+                frame.rate_hz.to_numpy(np.float32).tobytes() == rates.tobytes(), 'Original PN order differs')
+            if mode == 'physiological':
+                require(all(original[n].tobytes() == a.tobytes() for n,a in (('targets',targets),('rates_hz',rates))),
+                    'Physiological reconstruction differs')
+                prior = npz(Path(root)/f'experiments/phase4ao-conditioning-interface/inputs/static/{cue}-rates.npz')
+                require(all(prior[n].dtype == a.dtype and prior[n].shape == a.shape and prior[n].tobytes() == a.tobytes()
+                    for n,a in (('targets',targets),('rates_hz',rates))), 'Prior AO rate bytes differ')
+            result[mode+'--'+cue] = dict(targets=targets, rates_hz=rates)
+    verify({str(Path(root)/p):s for p,s in source.SOURCE_PINS.items()})
+    return result, dict(original_source_sha256=source.SOURCE_PINS, original_AST_sha256=ast_sha,
+        physiological_matches_original_AO=True, original_PN_column_order_preserved=True,
+        modes=['physiological','matched_energy'], clipping=False, gain_tuning=False,
+        historical_dynamic_results_read=False, random_draws=0)
+
+def descriptor(task):
+    r = task['recipe']
+    require(task['steps'] == 1200 and task['mode'] in ('physiological','matched_energy'), 'Wrong normal clock/mode')
+    if task['kind'] == 'train':
+        cs = r['cs']
+        if cs is None: return None
+        cue, seed, start, stop = cs['cue'],cs['seed'],cs['start_tick'],cs['stop_tick_exclusive']
+        stream = cs['source_stream_id']
+    else:
+        require(task['kind'] == 'probe' and r['US_requested'] is False and r['weight_updates_enabled'] is False,
+            'Probe contains US/update')
+        cue, seed = r['cue'], r['input']['seed']
+        start, stop, stream = r['cs_start_tick'], r['cs_stop_tick_exclusive'], r['input']['stream_id']
+    require(cue in ('A','B') and type(seed) is int and 0 <= seed < 2**63 and (start,stop) == (0,1000),
+        'CS timing/full seed differs')
+    return dict(mode=task['mode'],cue=cue,seed=seed,steps=1200,cs_start_tick=start,cs_stop_tick_exclusive=stop,
+        source_stream_id=stream,table_id=task['mode']+'--'+cue)
+
+def inventory_from_plan(plan):
+    descriptors, task_inputs = {}, {}
+    for task in plan['tasks']:
+        d = descriptor(task)
+        key = None if d is None else content_sha(d)
+        if d is not None:
+            require(key not in descriptors or descriptors[key] == d, 'Conflicting shared CS descriptor')
+            descriptors[key] = d
+        require(task['task_id'] not in task_inputs, 'Duplicate planned task')
+        task_inputs[task['task_id']] = key
+    require(len(descriptors) == 4080, 'Expected 4,000 training + 80 evaluation streams')
+    return dict(schema='normal-CS-input-inventory-v1',descriptors=descriptors,task_inputs=task_inputs,
+        brain_output_deduplication=False,CS_only_saved=True,US_composed_from_each_original_epoch=True)
+
+def sample(reg_sha):
+    require(sys.dont_write_bytecode, 'Use -B')
+    file = EXP/'protocol/preregistered.json'; require(digest(file) == reg_sha, 'Registration differs')
+    reg = read(file); verify(reg['source_sha256']); verify(reg['static_input_sha256'])
+    require(reg['scientific_scope'] == 'normal-acquisition-only', 'Wrong scientific scope')
+    out = unlinked(EXP/'inputs/generated'); require(not out.exists(), 'Sampler cannot retry existing output')
+    h = load_source('_normal_sampler_admission', AP/'isolated_workers.py', AP_SHA)
+    os.environ['CUDA_VISIBLE_DEVICES'] = GPU
+    admission = h._admit_brain()
+    source, inputs = dependencies()
+    inv = read(EXP/'protocol/input-inventory.json')
+    require(digest(EXP/'protocol/input-inventory.json') == reg['prepared_sha256'][str(EXP/'protocol/input-inventory.json')],
+        'Input inventory differs')
+    out.mkdir(); start = time.perf_counter(); completed = {}
+    for index,(key,d) in enumerate(inv['descriptors'].items()):
+        if index % 100 == 0: h._admit_brain()
+        table = npz(EXP/f"inputs/static/{d['table_id']}.npz")
+        require(digest(EXP/f"inputs/static/{d['table_id']}.npz") ==
+            reg['prepared_sha256'][str(EXP/f"inputs/static/{d['table_id']}.npz")], 'Rate file changed')
+        result = inputs.generate_cs_requests(table['targets'],table['rates_hz'],seed=d['seed'],steps=1200,
+            cs_start_tick=0,cs_stop_tick=1000,device='cuda:0',max_uniform_draws=reg['budget']['max_uniform_draws'])
+        save_npz(out/(key+'.npz'),result['requests'])
+        save(out/(key+'.json'),dict(descriptor=d,audit=result['audit'],requests_sha256=digest(out/(key+'.npz'))))
+        completed[key] = dict(requests=pin(out/(key+'.npz')),audit=pin(out/(key+'.json')))
+    verify(reg['source_sha256']); verify(reg['static_input_sha256'])
+    save(EXP/'receipts/input-generation.json',dict(complete=True,registration_sha256=reg_sha,
+        input_inventory_sha256=digest(EXP/'protocol/input-inventory.json'),inputs=completed,
+        descriptors=len(completed),wall_seconds=time.perf_counter()-start,admission=admission,
+        brain_executed=False,weight_updates_executed=False))
+
+if __name__ == '__main__':
+    p=argparse.ArgumentParser();p.add_argument('--registration-sha256',required=True)
+    sample(p.parse_args().registration_sha256)

models/male-cns-lif/normal-conditioning-v1/normal_io.py

@@ -0,0 +1,88 @@
+"""Small exclusive file helpers. No neural imports, mutation or retry policy."""
+from __future__ import annotations
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+import sys
+
+ROOT = Path('/data/digital-drosophila')
+MODEL = Path(__file__).resolve().parent
+LAB = MODEL.parent/'olfactory-conditioning-lab-v1'
+AQ = MODEL.parent/'conditioning-execution-v1'
+AP = MODEL.parent/'conditioning-interface-v2'
+EXP = ROOT/'experiments/phase4ar-normal-conditioning'
+GPU = 'GPU-79f3a85d-adce-7833-7003-6488140ca596'
+AP_SHA = 'e47651a8ea99d7c44115107ff6b5dc71312183609ae11c891db65bb21ed61e30'
+
+def require(ok, message):
+    if not ok: raise ValueError(message)
+
+def digest(path):
+    h = hashlib.sha256()
+    with Path(path).open('rb') as f:
+        for data in iter(lambda: f.read(8 << 20), b''): h.update(data)
+    return h.hexdigest()
+
+def canonical(value):
+    return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=False, allow_nan=False)
+
+def content_sha(value):
+    return hashlib.sha256(canonical(value).encode()).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(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 f:
+        json.dump(value, f, sort_keys=True, indent=2, ensure_ascii=False, allow_nan=False); f.write('\n')
+
+def unlinked(path):
+    p = Path(path)
+    require(p.is_absolute() and '..' not in p.parts and not any(x.is_symlink() or
+        (hasattr(x, 'is_junction') and x.is_junction()) for x in (p, *p.parents)), 'Unsafe linked path')
+    return p
+
+def identity(path):
+    p = unlinked(path); require(p.is_file(), 'Missing regular file: '+str(p))
+    return dict(sha256=digest(p), bytes=p.stat().st_size)
+
+def pin(path):
+    return dict(path=str(unlinked(path)), sha256=digest(path))
+
+def verify(pins):
+    for p, sha in pins.items(): require(identity(p)['sha256'] == sha, 'Pinned input changed: '+str(p))
+
+def inventory(root):
+    result = {}
+    for p in sorted(unlinked(root).rglob('*')):
+        unlinked(p)
+        if p.is_file(): result[str(p)] = identity(p)
+        else: require(p.is_dir(), 'Nonregular artifact')
+    return result
+
+def load_source(name, path, sha):
+    path = unlinked(path); raw = 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 npz(path):
+    import numpy as np
+    with np.load(path, allow_pickle=False) as f: return {k: f[k].copy() for k in f.files}
+
+def save_npz(path, values):
+    import numpy as np
+    with unlinked(path).open('xb') as f: np.savez_compressed(f, **values)
+
+def task_key(task):
+    # IDs remain verbatim in receipts; filesystem IDs never incorporate slashes.
+    return 'task-'+hashlib.sha256(task['task_id'].encode()).hexdigest()

models/male-cns-lif/normal-conditioning-v1/normal_metrics.py

@@ -0,0 +1,528 @@
+"""Read-only normal analysis, conditional on independent final integrity.
+
+analyze(exp, registration_sha256, *, verified_inventory, final_ledger) consumes
+an externally authenticated absolute-path -> {bytes, sha256} inventory and the
+final append-ledger audit. Neither caller Boolean nor digest alone is treated
+as an OS observation: actual ledger/start/job/parent/worker receipts and every
+consumed file are rebound to bytes. SHA caching is invocation-local, never
+mtime-based. The outer verifier still owns complete tree/historical integrity,
+anatomical/source authority, concurrency exclusion and the final science claim.
+No writes, sampling, subprocesses, follow-up assays, candidates or new gates.
+"""
+from __future__ import annotations
+
+from collections import defaultdict
+import hashlib
+import io
+import json
+from pathlib import Path
+import types
+
+import numpy as np
+
+GATES_SHA256 = '8ae9bcb77fe14dbdda164f86ffdbfc1e2976be752766ef526777577223b4dd99'
+PLAN_SHA256 = 'd1a6b840a547cb10b00df40f4d8b287867d09f355c9777e5f7a8b9489f5555ea'
+ARM_NAMES = dict(paired='paired', d_zero='D=0', frozen='frozen', random_reward='random reward',
+                 unpaired='unpaired', cs_only='CS-only', dan_only='DAN-only')
+ODORS = {'A': '4-ethylphenol', 'B': '3-hexanone'}
+POINTS = (0, 1, 2, 5, 10, 20, 50)
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def canonical(value):
+    return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=False, allow_nan=False)
+
+
+def sha(value):
+    return hashlib.sha256(canonical(value).encode()).hexdigest()
+
+
+def _module(name, path, expected):
+    raw = path.read_bytes()
+    require(hashlib.sha256(raw).hexdigest() == expected, 'Analysis dependency pin differs: ' + str(path))
+    module = types.ModuleType(name)
+    module.__file__ = str(path)
+    exec(compile(raw, str(path), 'exec'), module.__dict__)
+    return module
+
+
+_HERE = Path(__file__).resolve().parent
+G = _module('_normal_frozen_gates', _HERE.parent / 'conditioning-execution-v1/learning_gates.py', GATES_SHA256)
+P = _module('_normal_frozen_plan', _HERE / 'normal_plan.py', PLAN_SHA256)
+M = G.M
+
+
+class Reader:
+    """Actual SHA once per unique path per invocation; not an atomic snapshot."""
+    def __init__(self, inventory):
+        require(type(inventory) is dict and inventory, 'Externally verified checksum inventory required')
+        self.inventory = inventory
+        self.seen = {}
+
+    def path(self, path):
+        path = Path(path)
+        require(path.is_absolute() and '..' not in path.parts and not any(p.is_symlink() or
+            (hasattr(p, 'is_junction') and p.is_junction()) for p in (path, *path.parents)), 'Unsafe artifact path')
+        key = str(path)
+        require(key in self.inventory, 'Artifact absent from external checksum authority: ' + key)
+        expected = self.inventory[key]
+        require(type(expected) is dict and set(expected) == {'bytes', 'sha256'} and
+            type(expected['bytes']) is int and expected['bytes'] >= 0 and M._sha(expected['sha256']), 'Invalid checksum authority')
+        return path, expected
+
+    def check(self, path):
+        path, expected = self.path(path)
+        key = str(path)
+        if key not in self.seen:
+            require(path.is_file(), 'Missing artifact: ' + key)
+            digest = hashlib.sha256()
+            size = 0
+            with path.open('rb') as stream:
+                for part in iter(lambda: stream.read(8 << 20), b''):
+                    digest.update(part); size += len(part)
+            require(dict(bytes=size, sha256=digest.hexdigest()) == expected, 'Actual file checksum differs: ' + key)
+            self.seen[key] = dict(expected)
+        require(self.seen[key] == expected, 'Checksum authority changed during analysis')
+        return expected
+
+    def raw(self, path):
+        self.check(path)
+        # Parsed data are read from the now-bound file, not retained for every
+        # trajectory. Concurrent mutation remains an outer quiescence obligation.
+        return Path(path).read_bytes()
+
+    def json(self, path):
+        def unique(items):
+            result = {}
+            for key, value in items:
+                require(key not in result, 'Duplicate JSON field'); result[key] = value
+            return result
+        return json.loads(self.raw(path).decode('utf-8'), object_pairs_hook=unique,
+            parse_constant=lambda _: (_ for _ in ()).throw(ValueError('Nonfinite JSON')))
+
+    def arrays(self, path):
+        with np.load(io.BytesIO(self.raw(path)), allow_pickle=False) as archive:
+            return {key: archive[key].copy() for key in archive.files}
+
+
+def task_key(task):
+    return 'task-' + hashlib.sha256(task['task_id'].encode()).hexdigest()
+
+
+def expected_entries(plan):
+    result = ['input-generation']
+    for task in plan['tasks']:
+        result.extend(task_key(task) + suffix for suffix in
+            (('--brain', '--update', '--verify') if task['kind'] == 'train' else ('--brain',)))
+    return result
+
+
+def audit_case(reader, exp, task, job, *, template, inputs, sampler, populations, population_file, output_cap):
+    """Independent raw CS/US composition and reset/spec checks; no brain call.
+
+    A scheduled US request is not an accepted spike or a successful behavior.
+    The artificial D scalar remains the original recipe, never an event count.
+    """
+    exp = Path(exp); case = exp / 'cases' / task_key(task)
+    require(job['case_dir'] == str(case), 'Case path differs from original task')
+    spec = reader.json(case / 'spec.json')
+    removed = ('validation_cohort', 'odor_index', 'expected_external_events', 'training', 'cs_input_seed', 'cs_input_seed_bits',
+        'seed_scope', 'odor_id', 'odor_name', 'source_panel_row', 'source_panel_split', 'rate_sum_hz', 'target_count',
+        'expected_CS_requests', 'CS_window', 'outer_epoch_id', 'outer_arm', 'outer_protocol')
+    fixed = {k: v for k, v in template.items() if k not in removed}
+    fixed.update(name=task_key(task), steps=1200, duration_ms=120., max_steps=1200, budget_root=str(exp),
+        output_budget_bytes=output_cap, mode=task['mode'], within_trial_weight_updates=False,
+        outer_protocol='normal-acquisition-v1', outer_task_id=task['task_id'], outer_arm=task['arm'])
+    require(canonical(spec) == canonical(fixed) and spec['seed'] == template['seed'] and spec['dt_ms'] == .1 and
+        spec['apl_delay_steps'] == 18 and spec['precision'] == 'float64' and spec['apl_precision'] == 'float32' and
+        spec['record_history'] is False and spec['kind'] == 'fullgraph', 'Scientific model/reset/clock spec changed')
+    recipe = task['recipe']
+    cs_recipe = recipe['cs'] if task['kind'] == 'train' else recipe
+    expected = None
+    if cs_recipe is not None:
+        cue = cs_recipe['cue']
+        seed = cs_recipe['seed'] if task['kind'] == 'train' else cs_recipe['input']['seed']
+        stream = cs_recipe['source_stream_id'] if task['kind'] == 'train' else cs_recipe['input']['stream_id']
+        require(type(seed) is int and 0 <= seed < 2**63, 'Original full63 seed required')
+        expected = dict(mode=task['mode'], cue=cue, seed=seed, steps=1200, cs_start_tick=0,
+            cs_stop_tick_exclusive=1000, source_stream_id=stream, table_id=task['mode'] + '--' + cue)
+    csid = None if expected is None else sha(expected)
+    require(inputs['task_inputs'][task['task_id']] == csid, 'Original task/CS descriptor mapping differs')
+    binding = reader.json(case / 'input-binding.json')
+    require(binding['task_id'] == task['task_id'] and binding['CS_descriptor_id'] == csid and
+        binding['DAN_type'] == task['dan_type'] and binding['population_file'] ==
+        dict(path=population_file, sha256=reader.check(population_file)['sha256']), 'Case input/population binding differs')
+    empty = dict(tick=np.empty(0, np.int32), neuron_idx=np.empty(0, np.int32))
+    source = empty
+    if csid is None:
+        require(binding['CS_source'] is None, 'No-CS epoch acquired an odor source')
+    else:
+        npzpath = exp / f'inputs/generated/{csid}.npz'; jsonpath = exp / f'inputs/generated/{csid}.json'
+        generated = reader.json(jsonpath); audit = generated['audit']
+        require(inputs['descriptors'][csid] == generated['descriptor'] == expected and
+            generated['requests_sha256'] == reader.check(npzpath)['sha256'] and
+            binding['CS_source'] == dict(path=str(npzpath), sha256=reader.check(npzpath)['sha256']) and
+            sampler['inputs'][csid] == dict(requests=binding['CS_source'], audit=dict(path=str(jsonpath), sha256=reader.check(jsonpath)['sha256'])),
+            'Saved sampler receipt/descriptor differs')
+        require(audit['seed'] == audit['generator_initial_seed'] == seed and audit['seed_bits'] == 63 and
+            audit['seed_conversion'] == 'exact integer; no truncation/modulo/offset' and audit['private_generator'] is True and
+            audit['matrix_draw_calls'] == 1 and audit['uniform_matrix_shape'][0] == 1200 and audit['CS_window'] == [0, 1000],
+            'Original sampler seed/full-shape/window evidence differs')
+        source = reader.arrays(npzpath)
+
+    def keys(request):
+        require(set(request) == {'tick', 'neuron_idx'} and all(v.dtype == np.int32 and v.ndim == 1 for v in request.values()) and
+            request['tick'].shape == request['neuron_idx'].shape and np.all((request['tick'] >= 0) & (request['tick'] < 1200)) and
+            np.all((request['neuron_idx'] >= 0) & (request['neuron_idx'] < 166700)), 'Invalid raw request arrays')
+        result = request['tick'].astype(np.int64) * 166700 + request['neuron_idx']
+        require(np.all(result[1:] > result[:-1]), 'Requests are not sorted unique')
+        return result
+
+    source_keys = keys(source)
+    require(np.all(source['tick'] < 1000), 'CS escaped original window')
+    cs, us, combined = (reader.arrays(case / name) for name in ('cs_requests.npz', 'us_requests.npz', 'requests.npz'))
+    cs_keys, us_keys, combined_keys = keys(cs), keys(us), keys(combined)
+    require(np.array_equal(source_keys, cs_keys), 'Actual case CS differs from original saved input')
+    requested = task['kind'] == 'train' and recipe['us']['requested']
+    dan = populations[task['dan_type']]
+    require(dan.dtype == np.int32 and dan.ndim == 1 and np.all(dan[1:] > dan[:-1]), 'Actual DAN mapping differs')
+    require(binding['DAN_membership_sha256'] == hashlib.sha256(dan.tobytes()).hexdigest(), 'DAN membership binding differs')
+    expected_us = 900 * 166700 + dan.astype(np.int64) if requested else np.empty(0, np.int64)
+    require(np.array_equal(us_keys, expected_us) and not np.intersect1d(cs_keys, us_keys).size and
+        np.array_equal(combined_keys, np.union1d(cs_keys, us_keys)), 'Actual scheduled US/CS composition differs')
+    masks = reader.arrays(case / 'source-mask.npz')
+    expected_mask = np.where(np.isin(combined_keys, cs_keys), 1, 2).astype(np.uint8)
+    require(set(masks) == {'source_mask'} and masks['source_mask'].dtype == np.uint8 and
+        np.array_equal(masks['source_mask'], expected_mask) and binding['composition']['policy'] == 'error' and
+        binding['composition']['cross_source_conflict_count'] == 0, 'Raw composition/source-mask differs')
+
+
+class Evidence:
+    def __init__(self, reader, exp, registration_sha, expected, final):
+        require(final.get('schema') == 'normal-append-ledger-v1-final-audit' and
+            final.get('registration_sha256') == registration_sha and final.get('pass_all') is True and
+            final.get('entry_ids') == final.get('expected_entry_ids') == expected and
+            final.get('expected_order_exact') is True, 'Final ledger authority/complete order differs')
+        require(all(final.get(k) == [] for k in ('extra_files', 'missing_files', 'changed_files',
+            'unsafe_files', 'errors', 'uncommitted_entry_ids')) and final.get('uncommitted_state_unknown') is False,
+            'Incomplete/failed final ledger audit')
+        self.r, self.exp, self.regsha, self.expected = reader, Path(exp), registration_sha, expected
+        self.index, self.tail, self.final = 0, None, final
+
+    def process(self, entry_id, kind):
+        self.index += 1
+        require(self.expected[self.index - 1] == entry_id, 'Analysis process order differs')
+        entry_path = self.exp / f'.append-ledger/entries/{self.index:016d}.json'
+        entry = self.r.json(entry_path)
+        start_path = self.exp / f'.append-ledger/started/{entry_id}.json'
+        start = self.r.json(start_path)
+        job_path = self.exp / f'jobs/{entry_id}.json'
+        process_path = self.exp / 'receipts' / entry_id / 'process.json'
+        require(entry['entry_id'] == start['entry_id'] == entry_id and entry['sequence'] == start['next_sequence'] == self.index and
+            entry['registration_sha256'] == start['registration_sha256'] == self.regsha and
+            entry['prev_entry_sha256'] == start['prev_entry_sha256'] == self.tail and
+            entry['start_sha256'] == self.r.check(start_path)['sha256'] and start['retry_authorized'] is False,
+            'Ledger/start chain differs')
+        incoming = {row['path']: row for row in entry['consumed_inputs']}
+        outgoing = {row['path']: row for row in entry['new_outputs']}
+        require(len(incoming) == len(entry['consumed_inputs']) and len(outgoing) == len(entry['new_outputs']), 'Duplicate ledger files')
+        for path, row in {**incoming, **outgoing}.items():
+            _, bound = self.r.path(path)
+            require(all(row[k] == bound[k] for k in ('bytes', 'sha256')), 'Ledger/checksum authority differs')
+        metadata = entry['metadata']
+        require(metadata['job_file'] == str(job_path) and metadata['process_receipt_file'] == str(process_path) and
+            type(metadata['observed_returncode']) is int and metadata['observed_returncode'] == 0 and
+            str(process_path) in outgoing and str(job_path) in incoming and
+            start['job']['path'] == str(job_path) and start['job']['sha256'] == self.r.check(job_path)['sha256'],
+            'Process/job not owned by committed ledger entry')
+        process, job = self.r.json(process_path), self.r.json(job_path)
+        require(process['entry_id'] == entry_id and process['registration_sha256'] == job['registration_sha256'] == self.regsha and
+            process['job_sha256'] == self.r.check(job_path)['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 job['kind'] == kind, 'Actual parent exit/job receipt differs')
+        for path, digest in job['input_sha256'].items():
+            require(path in incoming and self.r.check(path)['sha256'] == digest, 'Actual consumed job input differs')
+        for label in ('stdout', 'stderr'):
+            path = self.exp / f'logs/{entry_id}.{label}.log'
+            require(str(path) in outgoing and self.r.check(path)['sha256'] == process[label + '_sha256'], 'Parent log differs')
+        if kind in ('brain', 'update'):
+            require(job['receipt_file'] in outgoing and job['receipt_file'] + '.attempt.json' in outgoing,
+                    'Worker/attempt receipt not ledger owned')
+            worker = self.r.json(job['receipt_file'])
+            closure = dict(job['input_sha256'])
+            closure[str(job_path)] = self.r.check(job_path)['sha256']
+            # The AP worker includes its own exact script source in its closure.
+            script = process['argv'][2]
+            closure[script] = self.r.check(script)['sha256']
+            for value in job['sources'].values():
+                require(self.r.check(value['path'])['sha256'] == value['sha256'], 'Worker source differs')
+                closure[value['path']] = value['sha256']
+            require(worker['schema'] == 'phase4ap-isolated-worker-receipt-v1' and worker['complete'] is True and
+                worker['job_id'] == entry_id and worker['kind'] == kind and worker['registration_sha256'] == self.regsha and
+                worker['job_sha256'] == self.r.check(job_path)['sha256'] and worker['verified_input_sha256'] == closure and
+                worker['attempt_sha256'] == self.r.check(job['receipt_file'] + '.attempt.json')['sha256'], 'Worker/attempt binding differs')
+            declared = {str(Path(p).relative_to(job['output_dir'])): row['sha256'] for p, row in outgoing.items()
+                        if Path(p).is_relative_to(job['output_dir'])}
+            require(worker['output_files_sha256'] == declared, 'Worker output coverage differs')
+        self.tail = self.r.check(entry_path)['sha256']
+        return dict(job=job, outgoing=outgoing, process_sha256=self.r.check(process_path)['sha256'], process_path=str(process_path))
+
+    def finish(self):
+        require(self.index == len(self.expected) and self.tail == self.final['head_sha256'], 'Missing process or terminal ledger head differs')
+
+
+def audit_records(reader, exp, reg, regsha, plan, evidence, *, template, inputs, populations):
+    """Bind all 33,920 tasks and actual update chains; retain only small indexes."""
+    sample = evidence.process('input-generation', 'sample')
+    sampler = reader.json(Path(exp) / 'receipts/input-generation.json')
+    require(sampler['complete'] is True and sampler['registration_sha256'] == regsha and
+        str(Path(exp) / 'receipts/input-generation.json') in sample['outgoing'], 'Sampler receipt not ledger owned')
+    require(sampler['descriptors'] == len(inputs['descriptors']) == 4080 and set(sampler['inputs']) == set(inputs['descriptors']) and
+        sampler['input_inventory_sha256'] == reader.check(Path(exp) / 'protocol/input-inventory.json')['sha256'], 'Actual sampler inventory incomplete')
+    previous, probes, arms, record_hashes = {}, {}, defaultdict(list), []
+    for task in plan['tasks']:
+        key = task_key(task); result_path = Path(exp) / f'results/{key}.json'
+        record = reader.json(result_path)
+        require(record['schema'] == 'normal-task-result-v1' and record['complete'] is True and
+            record['registration_sha256'] == regsha and canonical(record['task']) == canonical(task), 'Actual result/task differs')
+        branch = task['block_id'], task['arm']
+        overlay = previous.get(branch, reg['initial_overlay'])
+        require(record['overlay_before'] == overlay, 'Delta ancestry changed or probe fed back')
+        brain = evidence.process(key + '--brain', 'brain')
+        audit_case(reader, exp, task, brain['job'], template=template, inputs=inputs, sampler=sampler,
+            populations=populations, population_file=reg['population_file'], output_cap=reg['budget']['output_cap_bytes'])
+        job = brain['job']; output = Path(exp) / 'runs' / key
+        require(record['brain_process_receipt_path'] == brain['process_path'] and
+            record['checkpoint_dir'] == job['output_dir'] == str(output) and
+            all(job[k] == overlay[k] for k in ('overlay_file', 'overlay_manifest')) and
+            job['diagnostic_mode'] == 'light', 'Brain result/overlay path differs')
+        manifest = reader.json(output / 'checkpoint-manifest.json')
+        require(record['checkpoint_manifest_sha256'] == record['brain_audit']['checkpoint_manifest_sha256'] ==
+            reader.check(output / 'checkpoint-manifest.json')['sha256'] and
+            record['brain_audit']['task_id'] == task['task_id'], 'Checkpoint binding differs')
+        for name, digest in manifest['files_sha256'].items():
+            require(reader.check(output / name)['sha256'] == digest, 'Checkpoint payload differs')
+        record_hashes.append([task['task_id'], reader.check(result_path)['sha256']])
+        if task['kind'] == 'probe':
+            require(str(result_path) in brain['outgoing'], 'Probe result not ledger owned')
+            probes[(task['block_id'], task['arm'], task['checkpoint'], task['recipe']['cue'])] = record
+            continue
+        update = evidence.process(key + '--update', 'update')
+        cpu = evidence.process(key + '--verify', 'cpu_verify')
+        require(record['update_process_receipt_path'] == update['process_path'] and record['cpu_process_receipt_path'] == cpu['process_path'] and
+            str(result_path) in cpu['outgoing'], 'Training result/parent process ownership differs')
+        authority = reader.json(record['epoch_authority']['path'])
+        require(reader.check(record['epoch_authority']['path'])['sha256'] == record['epoch_authority']['sha256'] ==
+            update['job']['authority_sha256'] == cpu['job']['authority_sha256'] and authority['epoch_id'] == task['task_id'] and
+            authority['checkpoint_dir'] == str(output) and authority['checkpoint_manifest_sha256'] == record['checkpoint_manifest_sha256'],
+            'Original E authority differs')
+        command = dict(steps=1200, 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')
+        require(authority['command'] == command, 'Original E command changed')
+        valid = reader.json(record['cpu_validation']['path'])
+        after = dict(overlay_file=str(Path(exp) / 'updates' / key / 'delta-after.npz'),
+                     overlay_manifest=str(Path(exp) / 'updates' / key / 'overlay-manifest.json'))
+        require(record['update_dir'] == update['job']['output_dir'] == cpu['job']['update_dir'] == str(Path(exp) / 'updates' / key) and
+            record['cpu_validation']['path'] == cpu['job']['receipt_file'] and record['cpu_validation']['path'] in cpu['outgoing'] and
+            record['epoch_authority']['path'] == update['job']['authority_file'] == cpu['job']['authority_file'] and
+            authority['files']['state'] == dict(path=str(output / 'state.npz'), sha256=reader.check(output / 'state.npz')['sha256']) and
+            authority['files']['overlay_before'] == dict(path=overlay['overlay_file'], sha256=reader.check(overlay['overlay_file'])['sha256']) and
+            authority['files']['overlay_manifest_before'] == dict(path=overlay['overlay_manifest'], sha256=reader.check(overlay['overlay_manifest'])['sha256']) and
+            record['after_overlay'] == after and reader.check(record['cpu_validation']['path'])['sha256'] == record['cpu_validation']['sha256'] and
+            valid['complete'] is True and valid['frozen_U_verify_receipt_recomputed'] is True and valid['actual_sealed_events_used'] is True and
+            valid['epoch_authority_sha256'] == record['epoch_authority']['sha256'] and
+            valid['after_overlay_sha256'] == reader.check(after['overlay_file'])['sha256'], 'Independent CPU update validation differs')
+        if task['arm'] in ('d_zero', 'frozen', 'cs_only'):
+            require(not reader.arrays(after['overlay_file'])['plastic_delta_mv'].view(np.uint32).any(), 'Zero control contains nonzero delta')
+        previous[branch] = after
+        arms[branch].append(dict(result=record_hashes[-1], brain=brain['process_sha256'],
+            update=update['process_sha256'], cpu=cpu['process_sha256'], requested=task['recipe']['us']['requested']))
+    evidence.finish()
+    require(len(probes) == 3920 and len(arms) == 280 and len(record_hashes) == 33920, 'Incomplete actual task inventory')
+    return probes, arms, sha(record_hashes)
+
+
+def build_registry(trial, plan, *, nodes, populations, population_binding_sha, regsha, input_hashes):
+    membership = M.validate_populations(nodes, populations)
+    blocks = {}
+    inputs = {(r['block_id'], r['cue']): r for r in plan['evaluation_inputs']}
+    for block in trial['plan']['blocks']:
+        identity = block['block_id']
+        source_rows = [r for r in trial['seed_manifest']['independent_streams']
+                       if r['key'][0] == identity and r['key'][1] == 'normal' and r['split'] in ('training', 'design')]
+        sources = [dict(stream_id=P._FROZEN['trial_plan']._stream_id(P.MASTER, r['split'], r['key']),
+                        seed=r['seed'], split=r['split']) for r in source_rows]
+        blocks[identity] = dict(mode=block['mode'], dan_type=block['dan_type'], compartment_verbatim=block['compartment_verbatim'],
+            conditioned_cue=ODORS[block['initial_reinforced_cue']], replicate=block['replicate'], training_sources=sources,
+            evaluation_sources={ODORS[c]: {k: inputs[(identity, c)][k] for k in ('stream_id', 'seed', 'split')} for c in ODORS},
+            evaluation_input_sha256={ODORS[c]: input_hashes[(identity, c)] for c in ODORS})
+    registry = dict(schema=G.REGISTRY_SCHEMA, protocol_sha256=regsha, population_binding_sha256=population_binding_sha,
+        nodes_raw_sha256=M._hash(nodes), population_membership_sha256=membership['membership_sha256'], blocks=blocks)
+    G.validate_registry(registry, expected_sha256=G.descriptor_sha256(registry))
+    return registry
+
+
+def compact_metric(metric):
+    return dict(rawS=metric['rawS'], rawB=metric['rawB'], separation=metric['separation'],
+        cues={cue: dict(state_pre=summary['pre_state_raw_sha256'], state_post=summary['post_state_raw_sha256'],
+            populations={name: {k: v for k, v in group.items() if not isinstance(v, list)}
+                         for name, group in summary['populations'].items()}) for cue, summary in metric['cues'].items()})
+
+
+def scientific_reports(probes, arms, *, registry, authority, nodes, populations, load_state):
+    """One cell's terminal vectors at a time; curve outputs contain no raw vectors."""
+    curves, compact_reports = [], []
+
+    def cells():
+        for mode in M.MODES:
+            for dan in M.DAN_TYPES:
+                for conditioned in M.CUES:
+                    rows = []
+                    selected = [(key, b) for key, b in registry['blocks'].items()
+                                if (b['mode'], b['dan_type'], b['conditioned_cue']) == (mode, dan, conditioned)]
+                    for identity, block in selected:
+                        arm_values = {}
+                        for name, legacy_name in ARM_NAMES.items():
+                            pre = {ODORS[c]: load_state(probes[(identity, name, 0, c)]) for c in ODORS}
+                            terminal = None
+                            for point in POINTS:
+                                post = pre if point == 0 else {ODORS[c]: load_state(probes[(identity, name, point, c)]) for c in ODORS}
+                                metric = M.arm_metrics(pre, post, conditioned_cue=conditioned, nodes=nodes, populations=populations)
+                                curves.append(dict(block_id=identity, arm=name, checkpoint=point, metrics=compact_metric(metric)))
+                                if point == 50:
+                                    terminal = metric
+                            history = arms[(identity, name)]
+                            require(len(history) == (150 if name == 'unpaired' else 100), 'Missing actual training/control epochs')
+                            execution = dict(complete=True, recording_verified=True, receipt_sha256=sha(history), assay='normal',
+                                epoch_duration_ms=120., cs_duration_ms=100., us_tick=900, completed_epochs=len(history),
+                                reinforcement_opportunities=sum(r['requested'] for r in history), terminal_pairings=50)
+                            arm_values[legacy_name] = dict(metrics=terminal, execution=execution)
+                        rows.append(dict(replicate_id=identity, replicate_unit='independent_training',
+                            training_stream_ids=[x['stream_id'] for x in block['training_sources']],
+                            evaluation_stream_ids=[block['evaluation_sources'][c]['stream_id'] for c in M.CUES],
+                            assay='normal', mode=mode, dan_type=dan, conditioned_cue=conditioned, arms=arm_values))
+                    report = G.evaluate_acquisition(rows, assay='normal', mode=mode, dan_type=dan,
+                        conditioned_cue=conditioned, registry=registry, authority=authority)
+                    compact_reports.append({k: v for k, v in report.items()
+                                            if k not in ('acquisition_metric_inputs', 'frozen_acquisition_result')})
+                    yield report
+
+    cohort = G.summarize_cohort(cells(), registry=registry, authority=authority, required_assays=('normal',))
+    require(cohort['complete_inventory'], 'Missing normal cells')
+    return dict(cells=compact_reports, cohort=cohort, curves=curves)
+
+
+def legacy_audit(reports, declared_mapping):
+    """G.H_MAPPING source layout; call the unchanged M scalar twice per group."""
+    require(declared_mapping == G.H_MAPPING, 'Explicit original registered H mapping required')
+    lookup = {(r['mode'], r['dan_type'], r['conditioned_cue']): r for r in reports}
+    require(len(reports) == len(lookup) == 8, 'Exact eight-cell legacy input required')
+    groups = []
+    for mode in M.MODES:
+        for cue in M.CUES:
+            selected = {d: lookup[(mode, d, cue)] for d in M.DAN_TYPES}
+            outcomes = {}
+            for source in M.DAN_TYPES:
+                gains = {label: [r['population_separation_gains']['MBON'] for r in selected[dan]['replicates']]
+                         for dan, label in (('PAM15', 'appetitive-conditioning'), ('PPL103', 'aversive-conditioning'))}
+                for name, label in (('D=0', 'd-zero-control'), ('random reward', 'random-reward-control'), ('frozen', 'frozen-brain-control')):
+                    controls = selected[source]['legacy_control_MBON_gains'][name]
+                    require(set(controls) == {r['replicate_id'] for r in selected[source]['replicates']}, 'Legacy replicate control source differs')
+                    gains[label] = [controls[r['replicate_id']] for r in selected[source]['replicates']]
+                outcomes[source] = M.legacy_h_mean_control_audit(gains)
+            groups.append(dict(mode=mode, conditioned_cue=cue, control_sources=outcomes,
+                               both_pass=all(v['predicate_pass'] for v in outcomes.values())))
+    return dict(schema=G.SCHEMA, status='CONDITIONAL-AUDIT', declared_mapping=declared_mapping, groups=groups,
+        both_pass=all(g['both_pass'] for g in groups), original_H_data_layout_reproduced=False,
+        new_stricter_control_source_mapping=True, **G._scope())
+
+
+def analyze(exp, registration_sha256, *, verified_inventory, final_ledger):
+    exp, reader = Path(exp), Reader(verified_inventory)
+    regpath = exp / 'protocol/preregistered.json'
+    require(reader.check(regpath)['sha256'] == registration_sha256, 'Registration authority differs')
+    reg = reader.json(regpath)
+    require(reg['schema'] == 'normal-conditioning-registration-v1' and reg['scientific_scope'] == 'normal-acquisition-only' and
+        reg['subsequent_assays_authorized'] is False, 'Wrong scientific authority')
+    for collection in ('source_sha256', 'input_sha256', 'prepared_sha256'):
+        for path, digest in reg[collection].items():
+            require(reader.check(path)['sha256'] == digest, 'Registered dependency differs')
+    plan = reader.json(exp / 'protocol/normal-plan.json')
+    full = reader.json(reg['original_full_trial_plan']['path'])
+    require(reader.check(reg['original_full_trial_plan']['path'])['sha256'] == reg['original_full_trial_plan']['sha256'] == P.AO_TRIAL_FILE_SHA256,
+            'Original AO full plan differs')
+    evaluation = P.expand_pinned_evaluation(full)
+    P.validate_normal_plan(plan, full, evaluation)
+    gates = reader.json(exp / 'protocol/gates.json')
+    require(gates['H_mapping'] == G.H_MAPPING and gates['all_eight_cells_required'] is True and
+        gates['same_replicate_conjunction_at_least'] == 3 and gates['training_replicates'] == 5 and gates['terminal_checkpoint'] == 50 and
+        gates['intermediate_checkpoints_cannot_rescue_terminal'] is True, 'Registered scientific policy differs')
+    template = reader.json(exp / 'protocol/case-template.json')
+    nodes_path = Path(template['graph_dir']) / 'nodes.npy'
+    nodes = np.load(io.BytesIO(reader.raw(nodes_path)), allow_pickle=False)
+    require(nodes.dtype == np.int32 and len(nodes) == 166700, 'Full original graph nodes required')
+    require('readout_population_file' in reg, 'Registered full legacy/non-MBON readout populations missing')
+    populations = reader.arrays(reg['readout_population_file'])
+    original = reader.arrays(reg['population_file'])
+    for name in ('MBON', 'MBON01', 'MBON12'):
+        require(np.array_equal(original[name], populations[name]), 'Original anatomical population changed')
+    M.validate_populations(nodes, populations)
+    require('readout_population_binding_file' in reg, 'Registered anatomical binding file missing')
+    population_binding_sha = reader.check(reg['readout_population_binding_file'])['sha256']
+    evidence = Evidence(reader, exp, registration_sha256, expected_entries(plan), final_ledger)
+    inputs = reader.json(exp / 'protocol/input-inventory.json')
+    probes, arms, inventory_sha = audit_records(reader, exp, reg, registration_sha256, plan, evidence,
+        template=template, inputs=inputs, populations=original)
+    input_hashes, seen_receipts = {}, set()
+
+    def load_state(record):
+        task = record['task']; key = task_key(task)
+        receipt = record['brain_process_receipt_path']
+        require(receipt not in seen_receipts, 'Probe execution reused across snapshots')
+        seen_receipts.add(receipt)
+        csid = inputs['task_inputs'][task['task_id']]
+        recipe = task['recipe']
+        expected_descriptor = dict(mode=task['mode'], cue=recipe['cue'], seed=recipe['input']['seed'], steps=1200,
+            cs_start_tick=0, cs_stop_tick_exclusive=1000, source_stream_id=recipe['input']['stream_id'],
+            table_id=task['mode'] + '--' + recipe['cue'])
+        require(csid == sha(expected_descriptor) and inputs['descriptors'][csid] == expected_descriptor,
+                'Evaluation seed/stream/clock mapping differs from original plan')
+        source = exp / f'inputs/generated/{csid}.npz'
+        generated = reader.json(exp / f'inputs/generated/{csid}.json')
+        require(generated['descriptor'] == inputs['descriptors'][csid] and generated['requests_sha256'] == reader.check(source)['sha256'],
+                'Actual evaluation input descriptor differs')
+        case = exp / 'cases' / key
+        binding = reader.json(case / 'input-binding.json')
+        require(binding['CS_source'] == dict(path=str(source), sha256=reader.check(source)['sha256']) and
+            binding['CS_descriptor_id'] == csid and binding['task_id'] == task['task_id'], 'Probe shared input binding differs')
+        requests, cs, us = (reader.arrays(path) for path in (case / 'requests.npz', source, case / 'us_requests.npz'))
+        require(set(requests) == set(cs) == set(us) == {'tick', 'neuron_idx'} and
+            all(not len(v) for v in us.values()) and all(np.array_equal(requests[k], cs[k]) for k in requests), 'Probe includes US or changed CS')
+        state = reader.arrays(Path(record['checkpoint_dir']) / 'state.npz')
+        actual = M.validate_state(state, nodes=nodes, steps=1200)
+        require(actual['hashes'] == record['brain_audit']['state_raw_sha256'], 'Actual probe raw arrays differ')
+        return state
+
+    for item in plan['evaluation_inputs']:
+        record = probes[(item['block_id'], 'paired', 0, item['cue'])]
+        csid = inputs['task_inputs'][record['task']['task_id']]
+        input_hashes[(item['block_id'], item['cue'])] = reader.check(exp / f'inputs/generated/{csid}.npz')['sha256']
+    registry = build_registry(full, plan, nodes=nodes, populations=populations, population_binding_sha=population_binding_sha,
+        regsha=registration_sha256, input_hashes=input_hashes)
+    authority = dict(schema=G.AUTHORITY_SCHEMA, registry_sha256=G.descriptor_sha256(registry),
+        verification_receipt_sha256=sha(final_ledger), execution_inventory_sha256=inventory_sha,
+        population_binding_sha256=population_binding_sha)
+    result = scientific_reports(probes, arms, registry=registry, authority=authority, nodes=nodes, populations=populations, load_state=load_state)
+    require(len(seen_receipts) == 3920, 'Not every independently executed probe was analyzed')
+    result['legacy_H'] = legacy_audit(result['cells'], gates['H_mapping'])
+    return dict(schema='normal-scientific-analysis-v1', status='CONDITIONAL-PENDING-OUTER-INTEGRITY',
+        registration_sha256=registration_sha256, normal_plan_sha256=plan['payload_sha256'], registry=registry, authority=authority,
+        analysis=result, analyzed_probe_calls=3920, curve_points=1960, consumed_file_count=len(reader.seen),
+        subsequent_assays_status='NOT-RUN', subsequent_assays_authorized=False, candidate_generated=False,
+        learning_pass_claimed=False, scientific_learning_pass_claimed=False, data_backed_claimed=False,
+        external_full_tree_anatomy_historical_integrity_verified_here=False,
+        retained_raw_evidence='original state and receipt files; terminal raw metric vectors recomputable, not duplicated in report')

models/male-cns-lif/normal-conditioning-v1/normal_plan.py

@@ -0,0 +1,199 @@
+"""Pure normal-only adapter of the AO-pinned, master-20260930 inventory.
+
+No sampling, brain execution, file writes, biological identity certification,
+or execution authorization. Import reads and SHA-checks six frozen sources.
+The trial argument must reproduce the ORIGINAL AO saved-file bytes under its
+documented JSON encoding. The evaluation argument is a new exact expansion of
+the old pinned policy, NOT an independently archived AO evaluation artifact.
+Physical inputs, actual DAN mapping, checkpoints, model and process receipts
+remain the registering executor's responsibility. No scientific gate changes.
+"""
+from __future__ import annotations
+
+import builtins
+from collections import Counter
+import hashlib
+import json
+from pathlib import Path
+import types
+
+
+SCHEMA = "normal-conditioning-plan-v1"
+MASTER = 20260930
+AO_TRIAL_FILE_SHA256 = "a7bda850ee87df4d9f647994e1a1a4074dfea5793184edb1822ab3d8c02e8216"
+AO_REGISTRATION_SHA256 = "9e2ed05879ce279da7dc0b4cac09a44d67665c230b56db94e2ca39c645bdc250"
+AP_REGISTRATION_SHA256 = "02a03b536a9f14196ad4b92fa9565b592732c6c863e72eeaee89b3b0ea8ed37d"
+AO_TRIAL_PATH = "/data/digital-drosophila/experiments/phase4ao-conditioning-interface/protocol/full-trial-plan.json"
+FROZEN_DIRECTORY = Path(__file__).resolve().parent.parent / "olfactory-conditioning-lab-v1"
+SOURCE_PINS = {
+    "seed_registry.py": "0da033b132095ec3087b5d9f64e53c2e391fa50ab0b7653b31296eeb84799b7e",
+    "trial_plan.py": "6fed3f494d075339a7e5b001d43b2598640b189e038952fbd4d41200bacac587",
+    "evaluation_plan.py": "991c813ff3322b230947f302b12b04ec382c3b632817f94b698101e4b17efa7d",
+    "evaluation_policy.py": "21331a9ff3567dc6f6399e16bb91ef486d74231f5db51799beb6dd1bf71d022b",
+    "PROTOCOL_DRAFT.md": "8ebecb1f3d012ddc29a1cb727269dd277629c53565e09978bf9dbf7140cb8508",
+    "EVALUATION_POLICY_DRAFT.md": "a84170a61564715a1532f20df4c6a330f0f9725c383db48b8f3e1a4b5fba0bc8",
+}
+
+
+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 _sha(value):
+    return hashlib.sha256(_canonical(value).encode("utf-8")).hexdigest()
+
+
+def _load_frozen():
+    """Private module graph; never change sys.path or ordinary module caches."""
+    sources = {}
+    for filename, expected in SOURCE_PINS.items():
+        raw = (FROZEN_DIRECTORY / filename).read_bytes()
+        _require(hashlib.sha256(raw).hexdigest() == expected,
+                 "Frozen source pin mismatch: " + filename)
+        sources[filename] = raw
+    modules = {}
+    ordinary_import = builtins.__import__
+
+    def private_import(name, globals=None, locals=None, fromlist=(), level=0):
+        if level == 0 and name in modules:
+            return modules[name]
+        return ordinary_import(name, globals, locals, fromlist, level)
+
+    for name in ("seed_registry", "trial_plan", "evaluation_plan", "evaluation_policy"):
+        module = types.ModuleType("_normal_frozen_" + name)
+        module.__file__ = str(FROZEN_DIRECTORY / (name + ".py"))
+        module.__dict__["__builtins__"] = dict(vars(builtins), __import__=private_import)
+        exec(compile(sources[name + ".py"], module.__file__, "exec"), module.__dict__)
+        modules[name] = module
+    return modules
+
+
+_FROZEN = _load_frozen()
+
+
+def _validate_original_trial(trial):
+    _require(type(trial) is dict and set(trial) ==
+             {"plan", "seed_manifest", "budget", "payload_sha256"}, "Full original trial payload required")
+    _require(type(trial["plan"]["master"]) is int and trial["plan"]["master"] == MASTER,
+             "Original AO master is fixed; no seed selection")
+    # This is the exact LF serialization used by AO engineering_prepare.save.
+    # Its registered file pin is stronger than reconstructing with a new seed.
+    encoded = json.dumps(trial, sort_keys=True, indent=2, ensure_ascii=False,
+                         allow_nan=False) + "\n"
+    _require(hashlib.sha256(encoded.encode("utf-8")).hexdigest() == AO_TRIAL_FILE_SHA256,
+             "Trial does not reproduce the AO registered full-trial-plan file")
+    _require(_sha({k: v for k, v in trial.items() if k != "payload_sha256"}) ==
+             trial["payload_sha256"], "Original trial self-hash mismatch")
+
+
+def _expand_validated_trial(trial):
+    # Private frozen assembly is safe AFTER the exact archived-file pin above;
+    # avoid the old public APIs' redundant 68,000-epoch trial reconstruction.
+    policy = _FROZEN["evaluation_policy"]._assemble(trial)
+    return _FROZEN["evaluation_plan"]._assemble(trial, policy["config"])
+
+
+def expand_pinned_evaluation(full_trial_payload):
+    """Expand the fixed historical policy; no new choices or sampled inputs."""
+    _validate_original_trial(full_trial_payload)
+    return _expand_validated_trial(full_trial_payload)
+
+
+def build_normal_plan(full_trial_payload, full_evaluation_payload):
+    """Return 33,920 ordered tasks; caller supplies both complete authorities."""
+    trial, evaluation = full_trial_payload, full_evaluation_payload
+    _validate_original_trial(trial)
+    expected_evaluation = _expand_validated_trial(trial)
+    _require(_canonical(evaluation) == _canonical(expected_evaluation),
+             "Evaluation must exactly expand the AO-pinned evaluation policy")
+    snapshots = {(s["block_id"], s["arm"], s["completed_epochs"]): s
+                 for s in evaluation["snapshots"] if s["assay"] == "normal"}
+    probes = {(p["snapshot_id"], p["cue"]): p
+              for p in evaluation["probes"] if p["assay"] == "normal"}
+    tasks, inputs, blocks = [], [], []
+    for block in trial["plan"]["blocks"]:
+        common = dict(block_id=block["block_id"], mode=block["mode"], dan_type=block["dan_type"],
+            compartment_verbatim=block["compartment_verbatim"],
+            reinforced_cue=block["initial_reinforced_cue"], replicate=block["replicate"],
+            assay="normal", steps=1200, artifact_validation_required=True)
+        blocks.append(dict(common, DAN_target_binding=block["DAN_target_binding"]))
+        for cue in ("A", "B"):
+            sid = block["block_id"] + "/normal/paired/checkpoint-00"
+            inputs.append(dict(block_id=block["block_id"], cue=cue, **probes[(sid, cue)]["input"]))
+        suite = next(s for s in block["suites"] if s["assay"] == "normal")
+        for arm in suite["arms"]:
+            name = arm["arm"]
+            delta = dict(arm["delta_start"])
+
+            def append_probes(completed):
+                snapshot = snapshots.get((block["block_id"], name, completed))
+                if snapshot is None:
+                    return
+                _require(snapshot["delta_source"] == delta, "Snapshot delta dependency differs")
+                for cue in ("A", "B"):
+                    recipe = probes[(snapshot["snapshot_id"], cue)]
+                    tasks.append(dict(common, kind="probe", arm=name, task_id=recipe["probe_id"],
+                        probe_id=recipe["probe_id"], snapshot_id=snapshot["snapshot_id"],
+                        checkpoint=snapshot["checkpoint"], completed_epochs=completed,
+                        evaluation_input_id=recipe["input"]["input_id"], delta_dependency=dict(delta),
+                        delta_output_id=None, neural_state_policy="common_frozen_reset_independent_probe",
+                        carry_between_epochs=[], original_E_required=False, cpu_validation_required=False,
+                        feedback_to_training_or_idle=False, recipe=recipe, snapshot_binding=snapshot,
+                        source_binding=dict(payload_sha256=evaluation["payload_sha256"],
+                            record_id=recipe["probe_id"], record_sha256=_sha(recipe))))
+
+            append_probes(0)
+            for completed, epoch in enumerate(arm["epochs"], 1):
+                tasks.append(dict(common, kind="train", arm=name, task_id=epoch["epoch_id"],
+                    epoch_id=epoch["epoch_id"], epoch_index=epoch["epoch_index"],
+                    delta_dependency=dict(delta), delta_output_id=epoch["epoch_id"] + "/delta-after",
+                    neural_state_policy=epoch["initial_neural_state"],
+                    carry_between_epochs=list(arm["carry_between_epochs"]),
+                    original_E_required=True, cpu_validation_required=True,
+                    feedback_to_training_or_idle=True, recipe=epoch,
+                    source_binding=dict(payload_sha256=trial["payload_sha256"],
+                        record_id=epoch["epoch_id"], record_sha256=_sha(epoch))))
+                delta = dict(kind="epoch_delta_after", source=epoch["epoch_id"] + "/delta-after")
+                append_probes(completed)
+    counts = Counter(row["kind"] for row in tasks)
+    _require(counts == {"train": 30000, "probe": 3920} and len(inputs) == 80 and len(blocks) == 40,
+             "Normal inventory changed")
+    _require(len({t["task_id"] for t in tasks}) == len(tasks), "Task IDs must be unique")
+    result = dict(schema=SCHEMA, master=MASTER, assay="normal", blocks=blocks,
+        tasks=tasks, evaluation_inputs=inputs,
+        inventory=dict(blocks=40, training_replicates_per_cell=5, arms_per_block=7,
+            nominal_reinforcements=50, checkpoints=[0, 1, 2, 5, 10, 20, 50],
+            train_calls=30000, probe_calls=3920, brain_calls=33920,
+            original_E_calls=30000, training_cpu_validation_calls=30000,
+            brain_steps=40704000, biological_seconds=4070.4, evaluation_inputs=80,
+            baseline_execution="execute_each_snapshot", baseline_output_deduplication=False),
+        provenance=dict(trial_payload_sha256=trial["payload_sha256"],
+            seed_manifest_sha256=trial["seed_manifest"]["payload_sha256"],
+            evaluation_payload_sha256=evaluation["payload_sha256"],
+            evaluation_config_sha256=evaluation["config_sha256"],
+            ao_trial_file_sha256=AO_TRIAL_FILE_SHA256, ao_trial_path=AO_TRIAL_PATH,
+            ao_registration_sha256=AO_REGISTRATION_SHA256, ap_registration_sha256=AP_REGISTRATION_SHA256,
+            frozen_source_sha256=SOURCE_PINS,
+            evaluation_authority="exact expansion of AO-pinned policy; not a historical saved evaluation artifact",
+            external_inputs_mapping_processes_and_physical_source_files_verified=False),
+        execution_authorized=False, inputs_generated=False, new_seed_streams=0,
+        learning_pass_claimed=False, subsequent_assays_included=False)
+    result["payload_sha256"] = _sha(result)
+    # No returned nested structure aliases either caller argument or module pins.
+    return json.loads(_canonical(result))
+
+
+def validate_normal_plan(payload, full_trial_payload, full_evaluation_payload):
+    """Fail closed even if a modified plan has been given a fresh self-hash."""
+    _require(type(payload) is dict and "payload_sha256" in payload, "Normal payload required")
+    _require(_sha({k: v for k, v in payload.items() if k != "payload_sha256"}) ==
+             payload["payload_sha256"], "Normal plan self-hash mismatch")
+    expected = build_normal_plan(full_trial_payload, full_evaluation_payload)
+    _require(_canonical(payload) == _canonical(expected), "Normal plan exact reconstruction mismatch")
+    return True

models/male-cns-lif/normal-conditioning-v1/normal_prepare.py

@@ -0,0 +1,205 @@
+"""Register only normal acquisition; never sample inputs or execute a brain.
+
+Prior sealed files stay read-only. Complete historical integrity is checked at
+the phase boundary; each trial rehashes its actual runtime dependency closure,
+not every historical engineering result. No source or budget changes after
+registration. Outcome files have no invented pre-outcome hashes.
+"""
+from __future__ import annotations
+import argparse
+import copy
+from datetime import datetime, timezone, timedelta
+import shutil
+import subprocess
+import sys
+from normal_io import *
+import normal_plan as PLAN
+
+AQ_EXP = ROOT/'experiments/phase4aq-conditioning-execution'
+AP_EXP = ROOT/'experiments/phase4ap-conditioning-interface-v2'
+AO_EXP = ROOT/'experiments/phase4ao-conditioning-interface'
+AQ_ANCHORS = {
+    'protocol/preregistered.json':'dad0ba33ded8c6725662c419525ef4185a6ff169042a402c18d0bd760dad7358',
+    'manifest.json':'2dc0feca75f718f2ee0d7c9240da503221823573fd25f1344d2fd97d97eb2db7',
+    'audit/final-status.json':'dcbb58f296bd0d51e3c8757f0c45dd5585b3a76f8c2a0b5881f4c14076721882',
+}
+H_ANCHORS = {
+    'audit/phase4h.py':'28bb2ab7c4c95af3d95b0bf0bc45a5a9bea791996c59ce296ec66b71e01b1695',
+    'mappings/mbon-to-downstream-actual-edges.parquet':'76bac27c50cec41c48fd6414bcef5a6e270753ac4062b92537f38226018e9278',
+    'manifests/checksums.sha256':'1ea0394fd0477bb40d656ed0854108964f3809d633b5561bed9de43cda630ba1',
+    'manifests/manifest.json':'d1f187f164f7775a1a02fff259c8f5e31ae035929d808c3876cfc0013d19c73c',
+}
+
+# Exact arrays consumed by the pinned isolated worker, not every reference file
+# colocated in its graph/APL directories. Tests compare these to that worker.
+GRAPH_FILES = ('nodes.npy', 'edge_id.npy', 'src.npy', 'dst.npy', 'signed_raw.npy', 'ptr.npy', 'weights.npy')
+APL_FILES = ('input_matrix.npy', 'output_matrix.npy', 'kc_globals.npy', 'apl_globals.npy')
+
+def runtime_array_paths(template):
+    return {str(Path(template['graph_dir'])/name) for name in GRAPH_FILES} | {
+        str(Path(template['apl_bundle_dir'])/name) for name in APL_FILES} | {template['coefficients_path']}
+
+def readout_populations(population_file):
+    import numpy as np
+    import pyarrow.parquet as pq
+    h=ROOT/'experiments/phase4h-dopamine-plasticity'
+    verify({str(h/p):s for p,s in H_ANCHORS.items()})
+    rows=pq.read_table(h/'mappings/mbon-to-downstream-actual-edges.parquet',columns=['target_neuron_idx'])['target_neuron_idx'].to_numpy()
+    require(rows.dtype==np.int32 and len(rows)==39279 and np.all((rows>=0)&(rows<166700)), 'Original H endpoint schema differs')
+    old=npz(population_file)
+    result={k:old[k] for k in ('MBON','MBON01','MBON12')}
+    result['legacyDownstream']=np.unique(rows).astype(np.int32)
+    result['nonMBONDownstream']=np.setdiff1d(result['legacyDownstream'],result['MBON'])
+    require(not len(np.setdiff1d(result['MBON'],result['legacyDownstream'])),'H downstream no longer includes all MBON')
+    hashes={k:hashlib.sha256(v.tobytes()).hexdigest() for k,v in result.items()}
+    require(hashes['legacyDownstream']=='ce9edbb56854be8f6891bfb83559dd7529c70acac6867864947f32f933175dbc' and
+        hashes['nonMBONDownstream']=='01e3fbdde8bf2558665f142cdf546d8b89b4898427b90e2f4368f21f4e241a7f',
+        'Actual H readout membership changed')
+    return result,dict(source_sha256={str(h/p):s for p,s in H_ANCHORS.items()},
+        original_populations=pin(population_file),definition='unique actual H MBON-edge target_neuron_idx, int32; no plastic/active subset',
+        nonMBON_definition='exact set difference legacyDownstream minus full anatomical MBON',
+        counts={k:len(v) for k,v in result.items()},raw_membership_sha256=hashes,
+        historical_current_model_source_used=False,original_sealed_audit_source_used=True)
+
+def historical_integrity():
+    verify({str(AQ_EXP/p):s for p,s in AQ_ANCHORS.items()})
+    ar = read(AQ_EXP/'protocol/preregistered.json')
+    verify(ar['source_sha256'])
+    # This function is executed in a separate preparation/integrity CPU process.
+    for p in (AQ, AP, LAB): sys.path.insert(0,str(p))
+    old = load_source('_normal_previous_integrity',AQ/'prepare_execution.py',ar['source_sha256'][str(AQ/'prepare_execution.py')])
+    prior = old.integrity()
+    helper = load_source('_normal_AQ_seal_reader', MODEL.parent/'pn-recruitment-audit-v1/publication.py',
+        '7a79c499098b74163e7bb16adabcbc54e7069dafa204d0b99c7f4c03d79f8016')
+    sealed = helper.verify_seal(AQ_EXP)
+    require(read(AQ_EXP/'audit/final-status.json')['status'] ==
+        'PASS-EXACT-UPDATED-BOUNDARY-ENGINEERING-NOT-LEARNING','AQ gate differs')
+    return dict(complete=True,prior=prior,AQ=sealed,old_experiments_reexecuted=False,
+        frozen_five_reexecuted=False,scope='actual historical seal bytes reverified, preserved numerical evidence; not a new numerical trial')
+
+def resource_policy():
+    """Engineering ceiling, not a measured all-condition forecast or stop-for-success."""
+    return dict(root=str(EXP),output_cap_bytes=256*1024**3,minimum_free_reserve_bytes=100*1024**3,
+        child_timeout_seconds=1800,workflow_timeout_seconds=21*86400,max_uniform_draws=10_000_000,
+        next_child_headroom_bytes=4*1024**3,
+        execution='serial_single_4090',no_automatic_retry=True,
+        forecast_scope='rough planning arithmetic from one AQ warm training cycle and one probe; not condition-complete measurement',
+        AQ_measured_training_cycle_seconds=24.771224757998425,AQ_measured_probe_seconds=10.394962482001574,
+        AQ_linear_wall_scenario_seconds=30000*24.771224757998425+3920*10.394962482001574,
+        uncertainties=['startup and materialization','event-dependent output size','all control/DAN/odor activity',
+            'ledger growth','shared service contention','final full integrity audit'],
+        cap_or_timeout_policy='preserve all outputs, stop incomplete; no shortening epochs or selecting favorable outcomes')
+
+def prepare():
+    require(sys.dont_write_bytecode and unlinked(EXP).is_dir() and not any(EXP.iterdir()), 'Exact new empty EXP and -B required')
+    files=sorted(MODEL.iterdir())
+    require(files and all(p.is_file() and not p.is_symlink() and p.suffix in ('.py','.md') for p in files), 'Source-only model directory')
+    sources={str(p):digest(p) for p in files}
+    commit=subprocess.check_output(['git','-C',str(ROOT),'rev-parse','HEAD']).decode().strip()
+    for path,sha in sources.items():
+        blob=subprocess.check_output(['git','-C',str(ROOT),'show',commit+':'+Path(path).relative_to(ROOT).as_posix()])
+        require(hashlib.sha256(blob).hexdigest()==sha, 'Uncommitted source '+path)
+    budget=resource_policy()
+    budget['registered_utc']=datetime.now(timezone.utc).isoformat()
+    budget['not_after_utc']=(datetime.now(timezone.utc)+timedelta(seconds=budget['workflow_timeout_seconds'])).isoformat()
+    require(shutil.disk_usage(EXP).free >= budget['output_cap_bytes']+budget['minimum_free_reserve_bytes'], 'Insufficient reserved capacity')
+    for name in ('protocol/source-snapshot','inputs/static','jobs','cases','runs','updates','validation','results','receipts','logs','audit','regression'):
+        unlinked(EXP/name).mkdir(parents=True)
+    tests=subprocess.run([sys.executable,'-B',str(MODEL/'run_cpu_tests.py'),'--output',str(EXP/'audit/cpu-tests.json')],
+        capture_output=True,text=True,timeout=1800,env={**dict(__import__('os').environ),'CUDA_VISIBLE_DEVICES':''})
+    save(EXP/'audit/cpu-tests.process.json',dict(exit_code=tests.returncode,stdout=tests.stdout,stderr=tests.stderr,
+        actual_parent_observation=True))
+    require(tests.returncode==0 and read(EXP/'audit/cpu-tests.json')['pass_all'] is True,
+        'CPU/source tests failed; no sampler or brain started')
+    # Old integrity readers may own a private R/C module graph. Keep them in an
+    # exec-isolated CPU process, never the table/registration interpreter.
+    integrity_command=[sys.executable,'-B',str(MODEL/'normal_prepare.py'),'integrity',
+        '--output',str(EXP/'regression/integrity-before.json')]
+    checked=subprocess.run(integrity_command,capture_output=True,text=True,timeout=1800,
+        env={**dict(__import__('os').environ),'CUDA_VISIBLE_DEVICES':''})
+    save(EXP/'regression/integrity-before.process.json',dict(argv=integrity_command,exit_code=checked.returncode,
+        stdout=checked.stdout,stderr=checked.stderr,actual_parent_observation=True))
+    require(checked.returncode==0,'Historical integrity child failed; preserve artifacts')
+    before=read(EXP/'regression/integrity-before.json');require(before['complete'] is True,'Integrity child incomplete')
+    aq=read(AQ_EXP/'protocol/preregistered.json')
+    full=read(PLAN.AO_TRIAL_PATH)
+    require(digest(PLAN.AO_TRIAL_PATH)==PLAN.AO_TRIAL_FILE_SHA256,'Original full plan pin differs')
+    evaluation=PLAN.expand_pinned_evaluation(full)
+    plan=PLAN.build_normal_plan(full,evaluation)
+    from normal_inputs import derive_rates, inventory_from_plan, PINS, dependencies
+    rate_tables,rate_audit=derive_rates()
+    inputs=inventory_from_plan(plan)
+    template_path=AP_EXP/'cases/D1--reference--epoch-001/spec.json'
+    authority_path=AP_EXP/'jobs/D1--reference--epoch-001.authority.json'
+    template=read(template_path); epoch=read(authority_path)
+    pinned={**aq['input_sha256'],**aq['source_sha256'],**aq['prepared_file_sha256']}
+    for path in (template_path,authority_path,AO_EXP/'inputs/static/populations.npz'):
+        require(str(path) in pinned and digest(path)==pinned[str(path)],'Original template/population not pinned')
+    for path in sources:
+        with Path(path).open('rb') as i,(EXP/'protocol/source-snapshot'/Path(path).name).open('xb') as o:shutil.copyfileobj(i,o)
+    save(EXP/'protocol/normal-plan.json',plan)
+    save(EXP/'protocol/evaluation-policy.json',evaluation['config'])
+    save(EXP/'protocol/input-inventory.json',inputs)
+    save(EXP/'protocol/case-template.json',template)
+    # Freeze scientific predicates before any new CS sample or outcome.
+    gate_sources={str(AQ/'learning_gates.py'):'8ae9bcb77fe14dbdda164f86ffdbfc1e2976be752766ef526777577223b4dd99',
+        str(LAB/'metrics.py'):'47319e21db3c8b030b1bafbf0703cd86fb588d23bb29436accbacdba73d08c3c'}
+    verify(gate_sources)
+    save(EXP/'protocol/gates.json',dict(source_sha256=gate_sources,all_eight_cells_required=True,
+        same_replicate_conjunction_at_least=3,training_replicates=5,terminal_checkpoint=50,
+        normal_failure_prevents_followups=True,intermediate_checkpoints_cannot_rescue_terminal=True,
+        downstream_policy='nonMBONDownstream-pre-outcome-operationalization-v1',
+        H_mapping='each-DAN-control-source-separately-both-pass-v1',
+        physiological_and_matched_energy_not_pooled=True,unknown_compartments_not_guessed=True))
+    save(EXP/'inputs/static/rate-audit.json',rate_audit)
+    for key,table in rate_tables.items():save_npz(EXP/f'inputs/static/{key}.npz',table)
+    populations,pop_audit=readout_populations(AO_EXP/'inputs/static/populations.npz')
+    save_npz(EXP/'inputs/static/readout-populations.npz',populations)
+    save(EXP/'inputs/static/readout-population-binding.json',pop_audit)
+    # Actual consumed neural dependency closure, all inherited byte pins.
+    required=runtime_array_paths(template)
+    require(required <= pinned.keys(), 'Consumed runtime arrays missing inherited pins: '+str(sorted(required-pinned.keys())))
+    original_sources={p:s for p,s in epoch['frozen_inputs'].items() if p.startswith(str(ROOT/'models/male-cns-lif/') )
+        and ('author-' in p or 'apl-timing-lab-v1/' in p)}
+    runtime={p:pinned[p] for p in required}
+    runtime.update(original_sources)
+    roles={k:v for k,v in epoch['files'].items() if k not in ('spec','requests','state','overlay_before','overlay_manifest_before')}
+    runtime.update({v['path']:v['sha256'] for v in roles.values()})
+    save(EXP/'protocol/epoch-template.json',dict(schema=epoch['schema'],files=roles,frozen_inputs=runtime))
+    static={str(LAB/n):s for n,s in {**PLAN.SOURCE_PINS,**PINS}.items()}
+    static.update({str(ROOT/p):s for p,s in rate_audit['original_source_sha256'].items()})
+    external={**runtime,**static,**gate_sources,**pop_audit['source_sha256'],**{str(AQ_EXP/p):s for p,s in AQ_ANCHORS.items()},
+        str(PLAN.AO_TRIAL_PATH):PLAN.AO_TRIAL_FILE_SHA256,str(AP/'isolated_workers.py'):AP_SHA,
+        str(authority_path):pinned[str(authority_path)],str(template_path):pinned[str(template_path)],
+        str(AO_EXP/'inputs/static/populations.npz'):pinned[str(AO_EXP/'inputs/static/populations.npz')],
+        str(AQ/'validate_update_cpu.py'):aq['source_sha256'][str(AQ/'validate_update_cpu.py')]}
+    for name in ('conditioning_epoch.py','conditioning_preflight_compare.py','engineering_compare.py'):
+        path=str(LAB/name);require(path in pinned,'Missing original verifier source pin');external[path]=pinned[path]
+    zero=aq['initial_overlay']
+    external.update({p:digest(p) for p in zero.values()})
+    verify(external)
+    prepared={p:row['sha256'] for p,row in inventory(EXP).items()}
+    reg=dict(schema='normal-conditioning-registration-v1',scientific_scope='normal-acquisition-only',
+        subsequent_assays_authorized=False,source_code_commit=commit,source_sha256=sources,input_sha256=external,
+        static_input_sha256=static,runtime_input_sha256=runtime,prepared_sha256=prepared,budget=budget,
+        initial_overlay=zero,population_file=str(AO_EXP/'inputs/static/populations.npz'),
+        readout_population_file=str(EXP/'inputs/static/readout-populations.npz'),
+        readout_population_binding_file=str(EXP/'inputs/static/readout-population-binding.json'),
+        original_full_trial_plan=pin(PLAN.AO_TRIAL_PATH),normal_inventory=plan['inventory'],
+        evidence_scope='AQ validates exact interface, not learning; this new registration admits actual normal outcomes',
+        brain_parameters_changed=False,learning_success_claimed=False,
+        execution_order='original fixed block/arm order; actual A/B baseline each arm; no outcome selection',
+        biological_hypotheses='D18 branch; PAM15/PPL103 compartment hypotheses only, not all-PAM/PPL functional assignment',
+        historical_integrity_scope=before['scope'],failure_policy='stop preserve partials, never auto retry',
+        administrative_supervisor_directory=str(ROOT/'logs/phase4ar-normal-conditioning'),
+        supervisor_logging_scope='outside immutable EXP ledger; real top-level exit and logs must be included by final outer auditor',
+        full_plan_in_old_frozen_location=True,future_artifact_hashes_fabricated=False)
+    save(EXP/'protocol/preregistered.json',reg)
+    return digest(EXP/'protocol/preregistered.json')
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser();p.add_argument('mode',choices=('prepare','integrity'));p.add_argument('--output')
+    a=p.parse_args()
+    if a.mode=='prepare':print('REGISTRATION_SHA256',prepare(),flush=True)
+    else:
+        require(a.output,'Exclusive report path required');save(a.output,historical_integrity())

models/male-cns-lif/normal-conditioning-v1/normal_runner.py

@@ -0,0 +1,341 @@
+"""Serial normal conditioning. Original R/E/U executables stay unchanged.
+
+Every fresh brain trial is followed by original E and independent original-U
+recomputation in separate exec processes. Probes never run E or feed back.
+Only fully committed steps may be skipped on explicit resume. An uncommitted
+start, failed child or partial task always stops; no inferred OS exit or retry.
+"""
+from __future__ import annotations
+import argparse
+import copy
+from datetime import datetime, timezone
+import os
+import shutil
+import subprocess
+import sys
+import time
+import traceback
+import numpy as np
+from normal_io import *
+from append_ledger import Ledger
+
+def registration(expected):
+    require(digest(EXP/'protocol/preregistered.json')==expected,'Registration hash differs')
+    reg=read(EXP/'protocol/preregistered.json')
+    require(reg['schema']=='normal-conditioning-registration-v1' and reg['scientific_scope']=='normal-acquisition-only'
+        and reg['subsequent_assays_authorized'] is False,'Wrong authority')
+    verify(reg['source_sha256']);verify(reg['input_sha256']);verify(reg['prepared_sha256'])
+    return reg
+
+def derive_spec(original,task,*,budget_root,output_cap):
+    require(original['kind']=='fullgraph' and original['dt_ms']==.1 and original['apl_delay_steps']==18 and
+        original['precision']=='float64' and original['apl_precision']=='float32' and original['record_history'] is False,
+        'Original fixed D18 spec required')
+    require(task['steps']==1200 and task['kind'] in ('train','probe'),'Wrong task')
+    allowed=('validation_cohort','odor_index','expected_external_events','training','cs_input_seed','cs_input_seed_bits',
+        'seed_scope','odor_id','odor_name','source_panel_row','source_panel_split','rate_sum_hz','target_count',
+        'expected_CS_requests','CS_window','outer_epoch_id','outer_arm','outer_protocol')
+    result={k:copy.deepcopy(v) for k,v in original.items() if k not in allowed}
+    result.update(name=task_key(task),steps=1200,duration_ms=120.,max_steps=1200,budget_root=str(budget_root),
+        output_budget_bytes=output_cap,mode=task['mode'],within_trial_weight_updates=False,
+        outer_protocol='normal-acquisition-v1',outer_task_id=task['task_id'],outer_arm=task['arm'])
+    # The frozen independent reset-control seed is retained, not derived from CS.
+    require(result['seed']==original['seed'],'Reset seed changed')
+    return result
+
+def compose_requests(cs,dan,task,inputs):
+    require(task['steps']==1200,'Only normal120ms tasks')
+    if task['kind']=='probe':
+        recipe=task['recipe'];require(recipe['US_requested'] is False and recipe['D_command']==0 and
+            recipe['weight_updates_enabled'] is False and task['feedback_to_training_or_idle'] is False,'Probe command differs')
+        nodes=np.empty(0,np.int32)
+    else:
+        recipe=task['recipe'];us=recipe['us']
+        require(us['nominal_slot_tick']==900 and us['rng_seed'] is None and us['rng_draws']==0 and
+            ((us['requested'] is True and us['tick']==900) or (us['requested'] is False and us['tick'] is None)),
+            'Scheduled artificial US differs')
+        require(recipe['D_command']==(1. if us['requested'] and task['arm']!='d_zero' else 0.) and
+            recipe['update_enabled'] is (task['arm']!='frozen'),'D/update command differs')
+        require(dan.dtype==np.int32 and dan.ndim==1 and len(dan) in (2,4) and np.all(dan[1:]>dan[:-1]),'Bound DAN IDs required')
+        nodes=dan.copy() if us['requested'] else np.empty(0,np.int32)
+    us=dict(tick=np.full(len(nodes),900,np.int32),neuron_idx=nodes)
+    composed=inputs.merge_requests(cs,us,steps=1200,conflict_policy='error')
+    return composed,us
+
+class Workflow:
+    def __init__(self,sha):
+        self.sha=sha;self.reg=registration(sha);self.start=time.perf_counter()
+        require(not (EXP/'audit/stopped.json').exists() and not (EXP/'manifest.json').exists(), 'Stopped or sealed phase cannot run')
+        self.plan=read(EXP/'protocol/normal-plan.json');self.input_plan=read(EXP/'protocol/input-inventory.json')
+        self.tasks={x['task_id']:x for x in self.plan['tasks']}
+        self.h=load_source('_normal_AP_helpers',AP/'isolated_workers.py',AP_SHA)
+        self.inputs=load_source('_normal_request_composer',LAB/'conditioning_inputs.py',self.reg['static_input_sha256'][str(LAB/'conditioning_inputs.py')])
+        self.metric=load_source('_normal_CPU_state_validation',LAB/'metrics.py',self.reg['input_sha256'][str(LAB/'metrics.py')])
+        self.nodes=np.load(Path(read(EXP/'protocol/case-template.json')['graph_dir'])/'nodes.npy',allow_pickle=False)
+        self.populations=npz(self.reg['population_file'])
+        initial={Path(p).relative_to(EXP).as_posix():identity(p) for p in self.reg['prepared_sha256']}
+        initial['protocol/preregistered.json']=identity(EXP/'protocol/preregistered.json')
+        self.ledger=Ledger(EXP,sha,initial,self.reg['budget']['output_cap_bytes'],self.reg['budget']['minimum_free_reserve_bytes'])
+        status=self.ledger.inspect();require(not status['uncommitted_entry_ids'],'Uncommitted OS state unknown; no automatic retry')
+        self.completed=set(status['entry_ids']);self.expected=[]
+
+    def basepins(self):
+        return {**self.reg['runtime_input_sha256'],str(EXP/'protocol/preregistered.json'):self.sha}
+
+    def immutable_pin(self,path):
+        path=unlinked(path);rel=path.relative_to(EXP).as_posix()
+        require(rel in self.ledger._tracked and identity(path)==self.ledger._tracked[rel],
+            'Consumed immutable file differs from committed bytes: '+rel)
+        return dict(path=str(path),sha256=self.ledger._tracked[rel]['sha256'])
+
+    def budget(self):
+        require(time.perf_counter()-self.start < self.reg['budget']['workflow_timeout_seconds'],'Invocation wall cap exceeded')
+        require(datetime.now(timezone.utc)<datetime.fromisoformat(self.reg['budget']['not_after_utc']),
+            'Registered absolute deadline exceeded; resume cannot reset wall allowance')
+        require(shutil.disk_usage(EXP).free>=self.reg['budget']['minimum_free_reserve_bytes'],'Free space reserve exceeded')
+        # Running totals account only committed payload, ledger and shared build.
+        # Each child also gets a fresh per-child output allowance; full tree at final.
+        accounting=self.ledger._budget()
+        require(accounting['total_accounted_bytes']+self.reg['budget']['next_child_headroom_bytes'] <=
+            self.reg['budget']['output_cap_bytes'],'No registered headroom for another complete child')
+
+    def launch(self,name,job,argv,outputs,*,pre_outputs=(),post=None,ap=False):
+        self.expected.append(name)
+        require(name not in self.completed,'Internal attempt to rerun committed job')
+        self.budget()
+        unlinked(EXP/'receipts'/name).mkdir()
+        jobfile=EXP/f'jobs/{name}.json';save(jobfile,job);jobsha=digest(jobfile)
+        argv=[*argv]
+        if ap:argv+=['--job',str(jobfile),'--job-sha256',jobsha]
+        start=self.ledger.begin(name,jobfile,dict(kind=job['kind']))
+        stdout=EXP/f'logs/{name}.stdout.log';stderr=EXP/f'logs/{name}.stderr.log'
+        process=EXP/f'receipts/{name}/process.json'
+        started=time.perf_counter();rc=None;timed=False;launch_error=None
+        env=dict(os.environ);env['PYTHONDONTWRITEBYTECODE']='1'
+        if job['kind'] not in ('brain','sample'):env['CUDA_VISIBLE_DEVICES']=''
+        with unlinked(stdout).open('xb') as out,unlinked(stderr).open('xb') as err:
+            try:rc=subprocess.run(argv,cwd=MODEL,env=env,stdout=out,stderr=err,
+                timeout=self.reg['budget']['child_timeout_seconds']).returncode
+            except subprocess.TimeoutExpired:timed=True
+            except OSError as error:launch_error=type(error).__name__+': '+str(error)
+        base=dict(entry_id=name,registration_sha256=self.sha,job_sha256=jobsha,argv=argv,
+            exit_code=rc,timed_out=timed,exit_observed_by_parent=rc is not None or timed,launch_error=launch_error,
+            child_wall_seconds=time.perf_counter()-started,observed_utc=datetime.now(timezone.utc).isoformat(),
+            stdout_sha256=digest(stdout),stderr_sha256=digest(stderr))
+        try:
+            require(type(rc)is int and rc==0 and not timed,'Child failed; retain outputs and stop')
+            verify(job['input_sha256'])
+            if ap:
+                receipt=read(job['receipt_file'])
+                require(receipt['schema']=='phase4ap-isolated-worker-receipt-v1' and receipt['complete'] is True and
+                    receipt['job_sha256']==jobsha and receipt['registration_sha256']==self.sha and
+                    receipt['kind']==job['kind'] and receipt['job_id']==name,'Actual child receipt differs')
+                expected={**job['input_sha256'],str(jobfile):jobsha,str(AP/'isolated_workers.py'):AP_SHA,
+                    **{v['path']:v['sha256'] for v in job['sources'].values()}}
+                require(receipt['verified_input_sha256']==expected,'Worker input closure differs')
+                actual={str(Path(p).relative_to(job['output_dir'])):v['sha256'] for p,v in inventory(Path(job['output_dir'])).items()}
+                require(actual==receipt['output_files_sha256'],'Worker output inventory differs')
+                require(digest(job['receipt_file']+'.attempt.json')==receipt['attempt_sha256'],'Attempt changed')
+            if post is not None:post()
+            base.update(complete=True,end_to_end_seconds=time.perf_counter()-started)
+            save(process,base)
+            files=[*pre_outputs,jobfile,stdout,stderr,process]
+            for p in outputs:
+                p=Path(p);files.extend(Path(x) for x in inventory(p)) if p.is_dir() else files.append(p)
+            outgoing={str(p):identity(p) for p in files}
+            incoming={p:identity(p) for p in job['input_sha256']}
+            incoming[str(jobfile)]=identity(jobfile)
+            self.ledger.append(name,incoming,outgoing,dict(job_file=str(jobfile),process_receipt_file=str(process),
+                observed_returncode=rc,scope='actual serial child exit and immutable artifact verification'))
+            self.completed.add(name)
+            print(json.dumps(dict(complete=True,entry_id=name,wall_seconds=base['end_to_end_seconds']),sort_keys=True),flush=True)
+        except BaseException as error:
+            if not process.exists():save(process,dict(base,complete=False,error=str(error)))
+            raise
+
+    def input_generation(self):
+        name='input-generation'
+        if name in self.completed:self.expected.append(name);return
+        pins={**self.reg['source_sha256'],**self.reg['static_input_sha256'],
+            **{p:s for p,s in self.reg['prepared_sha256'].items() if '/inputs/static/' in p or p.endswith('/input-inventory.json')},
+            str(EXP/'protocol/preregistered.json'):self.sha}
+        job=dict(kind='sample',registration_sha256=self.sha,input_sha256=pins)
+        def validate_sample():
+            report=read(EXP/'receipts/input-generation.json')
+            require(report['complete'] is True and report['registration_sha256']==self.sha and
+                set(report['inputs'])==set(self.input_plan['descriptors']) and report['descriptors']==4080,
+                'Incomplete original sampling inventory')
+            for key,d in self.input_plan['descriptors'].items():
+                f=EXP/f'inputs/generated/{key}.npz';a=EXP/f'inputs/generated/{key}.json'
+                audit=read(a)
+                require(audit['descriptor']==d and audit['requests_sha256']==digest(f) and
+                    report['inputs'][key]==dict(requests=pin(f),audit=pin(a)), 'Saved sampler binding differs')
+                self.inputs.validate_requests(npz(f),1200)
+        self.launch(name,job,[sys.executable,'-B',str(MODEL/'normal_inputs.py'),'--registration-sha256',self.sha],
+            [EXP/'inputs/generated',EXP/'receipts/input-generation.json'],post=validate_sample)
+
+    def overlay(self,task):
+        self.overlay_dependency_pins={}
+        dependency=task['delta_dependency']
+        if dependency==dict(kind='zero',source=None):return copy.deepcopy(self.reg['initial_overlay'])
+        require(dependency['kind']=='epoch_delta_after' and dependency['source'].endswith('/delta-after'),'Unknown delta dependency')
+        previous=self.tasks[dependency['source'][:-len('/delta-after')]]
+        key=task_key(previous);require(key+'--verify' in self.completed,'Previous real E+CPU validation missing')
+        result_path=EXP/f'results/{key}.json'
+        def committed(path):
+            checked=self.immutable_pin(path)
+            self.overlay_dependency_pins[checked['path']]=checked['sha256']
+        committed(result_path);record=read(result_path)
+        require(record['complete'] is True and record['task']==previous and previous['kind']=='train' and
+            all(previous[k]==task[k] for k in ('block_id','arm')),'Delta cannot cross unrelated branch')
+        validation=Path(record['cpu_validation']['path']);committed(validation)
+        require(digest(validation)==record['cpu_validation']['sha256'],'CPU receipt changed')
+        valid=read(validation)
+        committed(Path(record['cpu_process_receipt_path']))
+        process=read(record['cpu_process_receipt_path'])
+        require(process['complete'] is True and type(process['exit_code']) is int and process['exit_code']==0 and
+            process['entry_id']==key+'--verify' and process['registration_sha256']==self.sha,
+            'Previous CPU exit missing')
+        for role,filename,field in (('overlay_file','delta-after.npz','after_overlay_sha256'),
+            ('overlay_manifest','overlay-manifest.json','after_manifest_sha256')):
+            path=Path(record['after_overlay'][role]);committed(path)
+            require(path==Path(record['update_dir'])/filename and digest(path)==valid[field],
+                'Next installed delta is not the actual independently verified output')
+        return copy.deepcopy(record['after_overlay'])
+
+    def prepare_case(self,task):
+        key=task_key(task);case=unlinked(EXP/'cases'/key);case.mkdir()
+        template_file=EXP/'protocol/case-template.json'
+        checked=self.immutable_pin(template_file)
+        self.case_dependency_pins={checked['path']:checked['sha256'],
+            self.reg['population_file']:self.reg['input_sha256'][self.reg['population_file']]}
+        template=read(template_file)
+        spec=derive_spec(template,task,budget_root=EXP,output_cap=self.reg['budget']['output_cap_bytes'])
+        csid=self.input_plan['task_inputs'][task['task_id']]
+        if csid is None:cs=dict(tick=np.empty(0,np.int32),neuron_idx=np.empty(0,np.int32));cs_source=None
+        else:
+            cs_source=EXP/f'inputs/generated/{csid}.npz'
+            audit_file=EXP/'inputs/generated'/(csid+'.json')
+            for path in (cs_source,audit_file):
+                checked=self.immutable_pin(path);self.case_dependency_pins[checked['path']]=checked['sha256']
+            generated=read(audit_file)
+            require(generated['descriptor']==self.input_plan['descriptors'][csid] and
+                generated['requests_sha256']==digest(cs_source),'Saved shared CS changed')
+            cs=npz(cs_source)
+        combined,us=compose_requests(cs,self.populations[task['dan_type']],task,self.inputs)
+        save(case/'spec.json',spec);save_npz(case/'requests.npz',combined['requests'])
+        save_npz(case/'cs_requests.npz',cs);save_npz(case/'us_requests.npz',us)
+        save_npz(case/'source-mask.npz',dict(source_mask=combined['source_mask']))
+        save(case/'input-binding.json',dict(task_id=task['task_id'],CS_source=None if cs_source is None else pin(cs_source),
+            CS_descriptor_id=csid,composition=combined['audit'],DAN_type=task['dan_type'],
+            DAN_membership_sha256=hashlib.sha256(self.populations[task['dan_type']].tobytes()).hexdigest(),
+            population_file=pin(self.reg['population_file']),artificial_US_not_dopamine_concentration=True))
+        return case
+
+    def ap_job(self,name,kind,output,*,case=None,overlay=None,authority=None):
+        pins=self.basepins()
+        job=dict(schema='phase4ap-isolated-worker-job-v1',job_id=name,kind=kind,registration_sha256=self.sha,
+            worker_sha256=AP_SHA,output_dir=str(output),receipt_file=str(EXP/f'receipts/{name}/worker.json'))
+        if kind=='brain':
+            pins.update(self.overlay_dependency_pins)
+            pins.update(self.case_dependency_pins)
+            for p in (case/'spec.json',case/'requests.npz',overlay['overlay_file'],overlay['overlay_manifest']):pins[str(p)]=digest(p)
+            job.update(case_dir=str(case),build_root=str(EXP/'extension-build'),**overlay,diagnostic_mode='light',
+                admission=dict(gpu_uuid=GPU,comfy_queue_urls=list(self.h.COMFY_URLS)),
+                sources={n:dict(path=str(LAB/(n+'.py')),sha256=self.h.SOURCE_PINS[n]) for n in ('runtime_light','runtime_continuation')})
+        else:
+            auth=read(authority);pins[str(authority)]=digest(authority)
+            pins.update({v['path']:v['sha256'] for v in auth['files'].values()})
+            pins.update(auth['frozen_inputs']);pins[str(Path(auth['checkpoint_dir'])/'checkpoint-manifest.json')]=auth['checkpoint_manifest_sha256']
+            job.update(authority_file=str(authority),authority_sha256=digest(authority),
+                sources={'conditioning_epoch':dict(path=str(LAB/'conditioning_epoch.py'),sha256=self.h.SOURCE_PINS['conditioning_epoch'])})
+        job['input_sha256']=pins;return job
+
+    def brain_verify(self,task,case,output):
+        summary=read(output/'summary.json');state=npz(output/'state.npz')
+        checked=self.metric.validate_state(state,nodes=self.nodes,steps=1200)
+        require(summary['all_finite'] is True and summary['steps']==1200 and summary['diagnostic_mode']=='light','Nonfinite/incomplete brain')
+        require(int(state['counts'].sum())==summary['total_spikes'],'Spike event/count mismatch')
+        manifest=read(output/'checkpoint-manifest.json')
+        for rel,sha in manifest['files_sha256'].items():require(digest(output/rel)==sha,'Checkpoint payload changed')
+        return dict(complete=True,state_raw_sha256=checked['hashes'],finite=True,
+            checkpoint_manifest_sha256=digest(output/'checkpoint-manifest.json'),task_id=task['task_id'])
+
+    def task(self,task):
+        key=task_key(task);brain=key+'--brain';up=key+'--update';cpu=key+'--verify'
+        planned=[brain,up,cpu] if task['kind']=='train' else [brain]
+        if all(x in self.completed for x in planned):self.expected.extend(planned);return
+        require(not any(x in self.completed for x in planned),'Partially completed task: preserve and inspect; no implicit replay')
+        overlay=self.overlay(task);case=self.prepare_case(task);output=EXP/'runs'/key
+        record=dict(schema='normal-task-result-v1',complete=True,registration_sha256=self.sha,task=task,
+            checkpoint_dir=str(output),overlay_before=overlay,brain_process_receipt_path=str(EXP/f'receipts/{brain}/process.json'))
+        def after_brain():
+            record['brain_audit']=self.brain_verify(task,case,output)
+            record['checkpoint_manifest_sha256']=digest(output/'checkpoint-manifest.json')
+            # Parent process receipt is produced later and is bound by the ledger,
+            # avoiding a self-reference in a result written before process exit audit.
+            if task['kind']=='probe':save(EXP/f'results/{key}.json',record)
+        job=self.ap_job(brain,'brain',output,case=case,overlay=overlay)
+        outs=[output,Path(job['receipt_file']),Path(job['receipt_file']+'.attempt.json')]
+        if task['kind']=='probe':outs.append(EXP/f'results/{key}.json')
+        self.launch(brain,job,[sys.executable,'-B',str(AP/'isolated_workers.py'),'brain'],outs,
+            pre_outputs=[Path(p) for p in inventory(case)],post=after_brain,ap=True)
+        if task['kind']=='probe':return
+        template_pin=self.immutable_pin(EXP/'protocol/epoch-template.json')
+        template=read(template_pin['path']);auth=copy.deepcopy(template)
+        r=task['recipe'];auth.update(epoch_id=task['task_id'],diagnostic_mode='light',checkpoint_dir=str(output),
+            checkpoint_manifest_sha256=digest(output/'checkpoint-manifest.json'),
+            command=dict(steps=1200,compartment=task['compartment_verbatim'],us_tick=r['us']['tick'],d_command=r['D_command'],
+                frozen=not r['update_enabled'],trace_backend='torch'))
+        for role,path in dict(spec=case/'spec.json',requests=case/'requests.npz',state=output/'state.npz',
+            overlay_before=overlay['overlay_file'],overlay_manifest_before=overlay['overlay_manifest']).items():auth['files'][role]=pin(path)
+        authority=EXP/f'jobs/{key}.authority.json';save(authority,auth);update=EXP/'updates'/key
+        job=self.ap_job(up,'update',update,authority=authority)
+        job['input_sha256'][template_pin['path']]=template_pin['sha256']
+        for path in (EXP/f'receipts/{brain}/process.json',EXP/f'receipts/{brain}/worker.json'):
+            checked=self.immutable_pin(path);job['input_sha256'][checked['path']]=checked['sha256']
+        self.launch(up,job,[sys.executable,'-B',str(AP/'isolated_workers.py'),'update'],
+            [update,Path(job['receipt_file']),Path(job['receipt_file']+'.attempt.json')],pre_outputs=[authority],ap=True)
+        out=unlinked(EXP/'validation'/key);out.mkdir();validation=out/'validation.json'
+        script=AQ/'validate_update_cpu.py';verify({str(script):self.reg['input_sha256'][str(script)]})
+        pins={**job['input_sha256'],str(script):self.reg['input_sha256'][str(script)]}
+        for name in ('conditioning_epoch.py','conditioning_preflight_compare.py','engineering_compare.py'):
+            path=str(LAB/name);pins[path]=self.reg['input_sha256'][path]
+        pins.update({p:v['sha256'] for p,v in inventory(update).items()})
+        job=dict(kind='cpu_verify',registration_sha256=self.sha,input_sha256=pins,authority_file=str(authority),
+            authority_sha256=digest(authority),update_dir=str(update),chain_sha256=digest(update/'chain-receipt.json'),
+            receipt_file=str(validation),validator_sha256=self.reg['input_sha256'][str(script)])
+        def after_cpu():
+            valid=read(validation)
+            require(valid['complete'] is True and valid['frozen_U_verify_receipt_recomputed'] is True and
+                valid['actual_sealed_events_used'] is True and valid['after_overlay_sha256']==digest(update/'delta-after.npz') and
+                valid['epoch_authority_sha256']==digest(authority),'Independent update verification differs')
+            if task['arm'] in ('d_zero','frozen','cs_only'):
+                require(not npz(update/'delta-after.npz')['plastic_delta_mv'].view(np.uint32).any(),'Zero-update control became nonzero')
+            record.update(epoch_authority=pin(authority),update_dir=str(update),cpu_validation=pin(validation),
+                after_overlay=dict(overlay_file=str(update/'delta-after.npz'),overlay_manifest=str(update/'overlay-manifest.json')),
+                update_process_receipt_path=str(EXP/f'receipts/{up}/process.json'),
+                cpu_process_receipt_path=str(EXP/f'receipts/{cpu}/process.json'))
+            save(EXP/f'results/{key}.json',record)
+        self.launch(cpu,job,[sys.executable,'-B',str(script),'--authority',str(authority),'--authority-sha256',digest(authority),
+            '--update-dir',str(update),'--chain-sha256',digest(update/'chain-receipt.json'),'--receipt',str(validation)],
+            [out,EXP/f'results/{key}.json'],post=after_cpu)
+
+    def run(self):
+        try:
+            self.input_generation()
+            for task in self.plan['tasks']:self.task(task)
+            report=self.ledger.final_verify(self.expected)
+            require(report['pass_all'],'Final ledger coverage/integrity failed')
+            save(EXP/'audit/execution-complete.json',dict(complete=True,registration_sha256=self.sha,
+                inventory=self.plan['inventory'],ledger=report,learning_success_claimed=False,
+                next='independent scientific analysis and frozen integrity, no subsequent assay'))
+        except BaseException as error:
+            if not (EXP/'audit/stopped.json').exists():save(EXP/'audit/stopped.json',dict(complete=False,
+                registration_sha256=self.sha,error_type=type(error).__name__,error=str(error),
+                traceback=traceback.format_exc(),partial_files_preserved=True,automatic_retry=False))
+            raise
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser();p.add_argument('--registration-sha256',required=True)
+    Workflow(p.parse_args().registration_sha256).run()

models/male-cns-lif/normal-conditioning-v1/run_cpu_tests.py

@@ -0,0 +1,30 @@
+"""Exclusive CPU/source test receipt. No scientific execution or CUDA allowed."""
+import argparse
+import io
+import os
+from pathlib import Path
+import sys
+import time
+import unittest
+from normal_io import digest, save, require, MODEL
+
+def run(output):
+    require(sys.dont_write_bytecode,'Use -B')
+    os.environ['CUDA_VISIBLE_DEVICES']=''
+    before={p.name:digest(p) for p in MODEL.iterdir() if p.is_file()}
+    suite=unittest.defaultTestLoader.discover(str(MODEL),pattern='test_*.py')
+    text=io.StringIO();start=time.perf_counter()
+    result=unittest.TextTestRunner(stream=text,verbosity=2).run(suite)
+    after={p.name:digest(p) for p in MODEL.iterdir() if p.is_file()}
+    no_neural_modules=not any(n in sys.modules for n in ('torch','runtime_light','conditioning_epoch'))
+    success=result.wasSuccessful() and not result.skipped and before==after and no_neural_modules
+    save(output,dict(schema='normal-CPU-tests-v1',pass_all=success,tests=result.testsRun,
+        failures=len(result.failures),errors=len(result.errors),skips=len(result.skipped),
+        source_sha256=before,sources_unchanged=before==after,wall_seconds=time.perf_counter()-start,
+        stdout=text.getvalue(),fresh_process=True,CUDA_hidden=True,no_neural_modules=no_neural_modules,
+        scope='CPU source and mock-process tests; not real GPU numerical or scientific evidence'))
+    return success
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser();p.add_argument('--output',required=True)
+    sys.exit(0 if run(p.parse_args().output) else 1)

models/male-cns-lif/normal-conditioning-v1/run_normal.py

@@ -0,0 +1,55 @@
+"""Detached parent supervisor, with real final exit receipts outside EXP.
+
+Administrative stdout is separate from the immutable per-trial ledger. Launch
+is exclusive, never a retry policy. A launch PID is NOT a completion receipt.
+"""
+import argparse
+from datetime import datetime, timezone
+import os
+import subprocess
+import sys
+import time
+from normal_io import *
+
+CONTROL=ROOT/'logs/phase4ar-normal-conditioning'
+
+def authority(sha):
+    require(sys.dont_write_bytecode,'Use -B')
+    require(digest(EXP/'protocol/preregistered.json')==sha,'Registration differs')
+    reg=read(EXP/'protocol/preregistered.json');verify(reg['source_sha256'])
+    require(reg['scientific_scope']=='normal-acquisition-only' and unlinked(CONTROL).is_dir(),'Wrong scope/control directory')
+    require(not (EXP/'audit/stopped.json').exists() and not (EXP/'audit/execution-complete.json').exists(),
+        'Stopped/completed phase cannot launch')
+    return reg
+
+def launch(sha):
+    authority(sha)
+    require(not any(CONTROL.iterdir()),'Control directory nonempty: inspect, do not retry')
+    save(CONTROL/'launch-attempt.json',dict(registration_sha256=sha,started_utc=datetime.now(timezone.utc).isoformat(),
+        complete=False,terminal_state='UNKNOWN',automatic_retry=False))
+    command=[sys.executable,'-B',str(MODEL/'run_normal.py'),'supervise','--registration-sha256',sha]
+    with unlinked(CONTROL/'stdout.log').open('xb') as out,unlinked(CONTROL/'stderr.log').open('xb') as err:
+        process=subprocess.Popen(command,cwd=MODEL,stdin=subprocess.DEVNULL,stdout=out,stderr=err,start_new_session=True,
+            env={**os.environ,'PYTHONDONTWRITEBYTECODE':'1'})
+    record=dict(supervisor_pid=process.pid,argv=command,registration_sha256=sha,launch_observed=True,
+        final_exit_observed=False,not_evidence_of_completion=True)
+    save(CONTROL/'launch.json',record);return record
+
+def supervise(sha):
+    authority(sha)
+    save(CONTROL/'supervisor-start.json',dict(pid=os.getpid(),registration_sha256=sha,
+        started_utc=datetime.now(timezone.utc).isoformat(),complete=False))
+    command=[sys.executable,'-B',str(MODEL/'normal_runner.py'),'--registration-sha256',sha]
+    started=time.perf_counter();code=None;error=None
+    try:code=subprocess.run(command,cwd=MODEL,stdin=subprocess.DEVNULL).returncode
+    except BaseException as exc:error=type(exc).__name__+': '+str(exc)
+    save(CONTROL/'exit.json',dict(registration_sha256=sha,argv=command,exit_code=code,
+        final_exit_observed=type(code)is int,wall_seconds=time.perf_counter()-started,error=error,
+        complete=code==0,learning_success_claimed=False,scientific_analysis_required=True))
+    return 0 if code==0 else 1
+
+if __name__=='__main__':
+    parser=argparse.ArgumentParser();parser.add_argument('mode',choices=('launch','supervise'))
+    parser.add_argument('--registration-sha256',required=True);args=parser.parse_args()
+    if args.mode=='launch':print(canonical(launch(args.registration_sha256)),flush=True)
+    else:sys.exit(supervise(args.registration_sha256))

models/male-cns-lif/normal-conditioning-v1/test_append_ledger.py

@@ -0,0 +1,241 @@
+"""Temporary filesystem tests only; no process/brain/GPU execution."""
+import copy
+import json
+import os
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+import append_ledger as L
+
+
+def put(path, value):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(value if type(value) is bytes else L.raw_json(value))
+    return L.identity(path)
+
+
+class LedgerTests(unittest.TestCase):
+    def setUp(self):
+        self.temp=tempfile.TemporaryDirectory();self.addCleanup(self.temp.cleanup)
+        self.root=Path(self.temp.name).resolve()/'normal';self.root.mkdir()
+        self.reg=self.root/L.REGISTRATION; info=put(self.reg,{'only':'synthetic-registration'})
+        self.initial={L.REGISTRATION:info};self.sha=info['sha256']
+        self.ledger=L.Ledger(self.root,self.sha,self.initial,1<<20,0)
+
+    def job(self,name):
+        job=self.root/'jobs'/(name+'.json');put(job,{'entry_id':name})
+        self.ledger.begin(name,job,{'synthetic':True})
+        return job
+
+    def completion(self,name,job,*,payload=b'output',changes=None):
+        out=self.root/'runs'/name/'payload.dat';put(out,payload)
+        process=self.root/'receipts'/(name+'.json')
+        value=dict(entry_id=name,registration_sha256=self.sha,job_sha256=L.digest(job),complete=True,
+            exit_code=0,timed_out=False,exit_observed_by_parent=True)
+        value.update(changes or {});put(process,value)
+        inputs={str(self.reg):L.identity(self.reg),str(job):L.identity(job)}
+        outputs={str(p):L.identity(p) for p in (job,out,process)}
+        metadata=dict(job_file=str(job),process_receipt_file=str(process),scope='synthetic completed parent job only',observed_returncode=0)
+        return inputs,outputs,metadata
+
+    def commit(self,name):
+        job=self.job(name);args=self.completion(name,job)
+        return self.ledger.append(name,*args)
+
+    def test_two_entries_chain_full_tree_and_cumulative_bytes(self):
+        one=self.commit('one');two=self.commit('two')
+        second=L.read_json(self.root/L.CONTROL/'entries/0000000000000002.json')
+        self.assertEqual(second['prev_entry_sha256'],one['entry_sha256'])
+        self.assertEqual(two['entry_sha256'],L.digest(self.root/L.CONTROL/'entries/0000000000000002.json'))
+        inspected=self.ledger.inspect();self.assertEqual(inspected['entry_ids'],['one','two'])
+        self.assertFalse(inspected['retry_authorized']);self.assertTrue(inspected['all_tracked_history_rehashed'])
+        final=self.ledger.final_verify(['one','two']);self.assertTrue(final['pass_all'])
+        self.assertEqual(final['actual_total_bytes'],sum(p.stat().st_size for p in self.root.rglob('*') if p.is_file()))
+        self.assertFalse(final['scientific_gate_claimed'])
+
+    def test_reopen_independent_read_verifies_no_reexecution_or_duplicate_append(self):
+        self.commit('one')
+        reopened=L.Ledger(self.root,self.sha,self.initial,1<<20,0)
+        self.assertEqual(reopened.inspect()['entry_ids'],['one'])
+        with self.assertRaisesRegex(ValueError,'already started/committed'):
+            reopened.begin('one',self.root/'jobs/one.json')
+        with self.assertRaisesRegex(ValueError,'No unique uncommitted'):
+            reopened.append('one',{}, {},dict(job_file='x',process_receipt_file='y',scope='s',observed_returncode=0))
+
+    def test_pending_or_live_handle_is_unknown_and_never_retry_authority(self):
+        job=self.job('live');state=self.ledger.inspect()
+        self.assertEqual(state['uncommitted_state'],'STARTED-UNCOMMITTED-STATE-UNKNOWN')
+        self.assertFalse(state['retry_authorized'])
+        with self.assertRaisesRegex(ValueError,'uncommitted start'):self.ledger.begin('another',job)
+        args=list(self.completion('live',job));args[2]['observed_returncode']=None
+        with self.assertRaisesRegex(ValueError,'Live/failed'):self.ledger.append('live',*args)
+        final=self.ledger.final_verify(['live']);self.assertFalse(final['pass_all']);self.assertTrue(final['uncommitted_state_unknown'])
+        reopened=L.Ledger(self.root,self.sha,self.initial,1<<20,0)
+        self.assertEqual(reopened.inspect()['uncommitted_entry_ids'],['live'])
+
+    def test_actual_parent_receipt_required_not_worker_success_or_bool_exit(self):
+        job=self.job('one')
+        for mutation in ({'exit_code':False},{'complete':False},{'exit_observed_by_parent':False},
+                         {'timed_out':True},{'registration_sha256':'0'*64},{'job_sha256':'0'*64},{'entry_id':'other'}):
+            args=self.completion('one',job,changes=mutation)
+            with self.subTest(mutation=mutation),self.assertRaisesRegex(ValueError,'parent process receipt'):
+                self.ledger.append('one',*args)
+
+    def test_same_size_same_mtime_mutation_fails_actual_SHA(self):
+        job=self.job('one');args=self.completion('one',job,payload=b'aaaa')
+        out=self.root/'runs/one/payload.dat';stat=out.stat();out.write_bytes(b'bbbb')
+        os.utime(out,ns=(stat.st_atime_ns,stat.st_mtime_ns))
+        with self.assertRaisesRegex(ValueError,'Actual file SHA/bytes'):self.ledger.append('one',*args)
+
+    def test_missing_extra_changed_files_reported_at_full_audit(self):
+        self.commit('one');out=self.root/'runs/one/payload.dat'
+        extra=self.root/'unexpected.log';put(extra,b'extra')
+        final=self.ledger.final_verify(['one']);self.assertFalse(final['pass_all']);self.assertIn('unexpected.log',final['extra_files'])
+        out.unlink();final=self.ledger.final_verify(['one'])
+        self.assertIn('runs/one/payload.dat',final['missing_files'])
+        put(out,b'different');final=self.ledger.final_verify(['one'])
+        self.assertIn('runs/one/payload.dat',final['changed_files'])
+
+    def test_tail_and_middle_tamper_not_trusted_by_inspect(self):
+        self.commit('one');self.commit('two')
+        first=self.root/L.CONTROL/'entries/0000000000000001.json'
+        value=L.read_json(first);value['metadata']['scope']='tampered'
+        put(first,value)
+        with self.assertRaisesRegex(ValueError,'chain/start identity'):self.ledger.inspect()
+        self.assertFalse(self.ledger.final_verify(['one','two'])['pass_all'])
+
+    def test_previously_observed_head_rewrite_rejected_even_new_valid_JSON(self):
+        self.commit('one');path=self.root/L.CONTROL/'entries/0000000000000001.json'
+        value=L.read_json(path);value['metadata']['scope']='changed';put(path,value)
+        with self.assertRaisesRegex(ValueError,'head changed'):self.ledger.inspect()
+
+    def test_registered_final_entry_order_and_coverage_are_exact(self):
+        self.commit('one');self.commit('two')
+        for expected in (['two','one'],['one'],['one','two','three']):
+            report=self.ledger.final_verify(expected)
+            self.assertFalse(report['pass_all']);self.assertFalse(report['expected_order_exact'])
+        with self.assertRaisesRegex(ValueError,'expected entry order'):self.ledger.final_verify(['one','one'])
+
+    def test_path_escape_aliases_and_overwrite_rejected(self):
+        self.commit('one');job=self.job('two');inputs,outputs,meta=self.completion('two',job)
+        outside=self.root.parent/'outside.dat';put(outside,b'external')
+        outputs[str(outside)]=L.identity(outside)
+        with self.assertRaisesRegex(ValueError,'escapes experiment'):self.ledger.append('two',inputs,outputs,meta)
+        del outputs[str(outside)];old=self.root/'runs/one/payload.dat';outputs[str(old)]=L.identity(old)
+        with self.assertRaisesRegex(ValueError,'previously tracked'):self.ledger.append('two',inputs,outputs,meta)
+        del outputs[str(old)];outputs['runs/two/payload.dat']=outputs[str(self.root/'runs/two/payload.dat')]
+        with self.assertRaisesRegex(ValueError,'Duplicate path aliases'):self.ledger.append('two',inputs,outputs,meta)
+        with self.assertRaisesRegex(ValueError,'Escaping/noncanonical'):L.relative_name('../escape')
+
+    def test_consumed_tracked_input_cannot_be_silently_reauthorized_with_new_SHA(self):
+        self.commit('one');job=self.job('two');inputs,outputs,meta=self.completion('two',job)
+        prior=self.root/'runs/one/payload.dat';put(prior,b'overwritten')
+        inputs[str(prior)]=L.identity(prior)
+        with self.assertRaisesRegex(ValueError,'committed identity'):self.ledger.append('two',inputs,outputs,meta)
+
+    def test_external_inputs_allowed_but_declared_bytes_reverified(self):
+        job=self.job('one');inputs,outputs,meta=self.completion('one',job)
+        external=self.root.parent/'frozen-reference.json';put(external,{'read_only':'data'})
+        inputs[str(external)]=L.identity(external);self.ledger.append('one',inputs,outputs,meta)
+        row=L.read_json(self.root/L.CONTROL/'entries/0000000000000001.json')
+        self.assertIsNone(next(r for r in row['consumed_inputs'] if r['path']==str(external))['relative_path'])
+        put(external,{'read_only':'changed'})
+        with self.assertRaisesRegex(ValueError,'Actual file SHA/bytes'):self.ledger.inspect()
+
+    def test_full_audit_hashes_shared_external_input_once_per_invocation(self):
+        external=self.root.parent/'large-shared-reference';put(external,b'fixed external bytes')
+        expected=L.identity(external)
+        for name in ('one','two','three'):
+            job=self.job(name);inputs,outputs,meta=self.completion(name,job)
+            inputs[str(external)]=expected;self.ledger.append(name,inputs,outputs,meta)
+        original=L.digest;counts={}
+        def counted(path):
+            key=str(Path(path));counts[key]=counts.get(key,0)+1
+            return original(path)
+        with patch.object(L,'digest',side_effect=counted):
+            self.assertTrue(self.ledger.final_verify(['one','two','three'])['pass_all'])
+            self.assertEqual(counts[str(external)],1)
+            counts.clear();self.ledger.inspect();self.assertEqual(counts[str(external)],1)
+            counts.clear();self.ledger.inspect();self.assertEqual(counts[str(external)],1)
+        oldstat=external.stat();external.write_bytes(b'other external bytes')
+        os.utime(external,ns=(oldstat.st_atime_ns,oldstat.st_mtime_ns))
+        with self.assertRaisesRegex(ValueError,'Actual file SHA/bytes'):self.ledger.inspect()
+
+    def test_append_does_not_iterate_or_sum_historical_maps_or_search_ordered_ids(self):
+        self.commit('one')
+        class LookupOnlyDict(dict):
+            def __iter__(self):raise AssertionError('Historical map iteration in fast append')
+            def keys(self):raise AssertionError('Historical map copy in fast append')
+            def values(self):raise AssertionError('Historical map sum in fast append')
+            def items(self):raise AssertionError('Historical map iteration in fast append')
+        class NoLinearMembership(list):
+            def __contains__(self,value):raise AssertionError('Linear completed-ID membership')
+        self.ledger._tracked=LookupOnlyDict(self.ledger._tracked)
+        self.ledger._controls=LookupOnlyDict(self.ledger._controls)
+        self.ledger._completed=NoLinearMembership(self.ledger._completed)
+        self.commit('two')
+        self.assertEqual(self.ledger._completed,['one','two'])
+        self.assertTrue(self.ledger.final_verify(['one','two'])['pass_all'])
+
+    def test_head_is_freshly_checked_after_cached_full_tree_walk(self):
+        self.commit('one');tail=self.root/L.CONTROL/'entries/0000000000000001.json'
+        original_replay=self.ledger._replay;original_identity=self.ledger._identity_once
+        state={'walking':False,'mutated':False}
+        def replay(verified):
+            original_replay(verified);state['walking']=True
+        def during_walk(path,verified):
+            if state['walking'] and not state['mutated']:
+                value=L.read_json(tail);value['metadata']['scope']='mutation during final walk'
+                put(tail,value);state['mutated']=True
+            return original_identity(path,verified)
+        with patch.object(self.ledger,'_replay',side_effect=replay),\
+             patch.object(self.ledger,'_identity_once',side_effect=during_walk):
+            report=self.ledger.final_verify(['one'])
+        self.assertTrue(state['mutated']);self.assertFalse(report['pass_all'])
+        self.assertTrue(any('Known ledger tail changed' in message for message in report['errors']))
+
+    def test_shared_mutable_build_separate_current_inventory_and_cap(self):
+        build=self.root/'extension-build/cache.bin';put(build,b'first');self.commit('one')
+        put(build,b'changed build is allowed');self.commit('two')
+        report=self.ledger.final_verify(['one','two']);self.assertTrue(report['pass_all'])
+        self.assertEqual(report['shared_mutable_build_bytes'],len(b'changed build is allowed'))
+        self.assertNotIn('extension-build/cache.bin',report['extra_files'])
+        put(build,b'x'*(1<<20));report=self.ledger.final_verify(['one','two'])
+        self.assertFalse(report['pass_all']);self.assertFalse(report['output_cap_respected'])
+
+    def test_stale_writer_lock_and_partial_publication_never_auto_cleared(self):
+        lock=self.root/L.CONTROL/'writer.lock';put(lock,b'unknown owner')
+        with self.assertRaises(FileExistsError):self.ledger.begin('one',self.reg)
+        with self.assertRaisesRegex(ValueError,'state unknown'):self.ledger.inspect()
+        self.assertEqual(lock.read_bytes(),b'unknown owner')
+
+    def test_exclusive_atomic_publication_and_preserved_failed_temporary(self):
+        target=self.root/'standalone.json';info=L.publish_exclusive(target,{'a':1})
+        self.assertEqual(info,L.identity(target))
+        with self.assertRaisesRegex(ValueError,'already exists'):L.publish_exclusive(target,{'a':2})
+        self.assertEqual(L.read_json(target),{'a':1})
+        target2=self.root/'failed.json'
+        with patch.object(L.os,'link',side_effect=OSError('synthetic unsupported filesystem')):
+            with self.assertRaises(OSError):L.publish_exclusive(target2,{'a':2})
+        self.assertFalse(target2.exists());self.assertEqual(len(list(self.root.glob('.publishing-*'))),1)
+
+    def test_linked_output_rejected_if_platform_supports_links(self):
+        source=self.root.parent/'other';source.mkdir();link=self.root/'linked'
+        try:link.symlink_to(source,target_is_directory=True)
+        except OSError:self.skipTest('Platform disallows synthetic symlink')
+        job=self.job('one');inputs,outputs,meta=self.completion('one',job)
+        put(source/'payload',b'x');outputs[str(link/'payload')]=L.identity(source/'payload')
+        with self.assertRaisesRegex(ValueError,'Linked'):self.ledger.append('one',inputs,outputs,meta)
+
+    def test_initial_and_header_authority_are_not_optional(self):
+        for change in ('registration','options'):
+            with self.subTest(change=change),self.assertRaises(ValueError):
+                L.Ledger(self.root,'0'*64 if change=='registration' else self.sha,self.initial,
+                    2<<20 if change=='options' else 1<<20,0)
+        header=self.root/L.CONTROL/'header.json';value=L.read_json(header);value['max_output_bytes']+=1;put(header,value)
+        with self.assertRaisesRegex(ValueError,'header changed'):self.ledger.inspect()
+
+
+if __name__=='__main__':unittest.main()

models/male-cns-lif/normal-conditioning-v1/test_normal_inputs.py

@@ -0,0 +1,73 @@
+"""CPU request descriptors and pinned static transform, never a CUDA test."""
+import copy
+import unittest
+import numpy as np
+import normal_inputs as I
+from normal_io import load_source, LAB
+from normal_runner import compose_requests, derive_spec
+
+class InputsTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.inputs=load_source('_normal_test_CI', LAB/'conditioning_inputs.py',I.PINS['conditioning_inputs.py'])
+
+    def task(self,arm='paired',cs=True):
+        return dict(task_id='block/normal/'+arm+'/000',kind='train',arm=arm,steps=1200,mode='physiological',
+            recipe=dict(cs=None if not cs else dict(cue='A',seed=2**62+37,start_tick=0,stop_tick_exclusive=1000,source_stream_id='s'),
+                us=dict(nominal_slot_tick=900,rng_seed=None,rng_draws=0,requested=True,tick=900),
+                D_command=0. if arm=='d_zero' else 1.,update_enabled=arm!='frozen'))
+
+    def test_full63_seed_and_aliases(self):
+        a=self.task();b=self.task('d_zero')
+        self.assertEqual(I.descriptor(a),I.descriptor(b))
+        self.assertEqual(I.descriptor(a)['seed'],2**62+37)
+
+    def test_empty_CS_is_not_resampled(self):
+        self.assertIsNone(I.descriptor(self.task('dan_only',False)))
+
+    def test_all_DAN_ids_and_counterfactual_US(self):
+        dan=np.array([10,20],np.int32);empty=dict(tick=np.empty(0,np.int32),neuron_idx=np.empty(0,np.int32))
+        for arm in ('paired','d_zero','frozen'):
+            composed,us=compose_requests(empty,dan,self.task(arm),self.inputs)
+            np.testing.assert_array_equal(composed['requests']['neuron_idx'],dan)
+            self.assertEqual(us['tick'].tolist(),[900,900])
+
+    def test_no_US_and_zero_command(self):
+        task=self.task('cs_only');task['recipe']['us'].update(requested=False,tick=None);task['recipe']['D_command']=0.
+        cs=dict(tick=np.array([1],np.int32),neuron_idx=np.array([5],np.int32))
+        combined,us=compose_requests(cs,np.array([10,20],np.int32),task,self.inputs)
+        self.assertEqual(len(us['tick']),0);self.assertEqual(combined['requests']['neuron_idx'].tolist(),[5])
+
+    def test_conflict_and_command_fail_closed(self):
+        cs=dict(tick=np.array([900],np.int32),neuron_idx=np.array([10],np.int32))
+        with self.assertRaises(ValueError):compose_requests(cs,np.array([10,20],np.int32),self.task(),self.inputs)
+        task=self.task('d_zero');task['recipe']['D_command']=1.
+        with self.assertRaises(ValueError):compose_requests(cs,np.array([10,20],np.int32),task,self.inputs)
+
+    def test_probe_no_US_no_update(self):
+        p=dict(kind='probe',mode='matched_energy',steps=1200,feedback_to_training_or_idle=False,
+            recipe=dict(cue='B',input=dict(seed=2**61,stream_id='eval'),cs_start_tick=0,cs_stop_tick_exclusive=1000,
+                US_requested=False,D_command=0.,weight_updates_enabled=False))
+        d=I.descriptor(p);self.assertEqual(d['table_id'],'matched_energy--B')
+        empty=dict(tick=np.empty(0,np.int32),neuron_idx=np.empty(0,np.int32))
+        combined,us=compose_requests(empty,np.array([10,20],np.int32),p,self.inputs)
+        self.assertEqual(len(combined['requests']['tick']),0)
+        p['feedback_to_training_or_idle']=True
+        with self.assertRaises(ValueError):compose_requests(empty,np.array([10,20],np.int32),p,self.inputs)
+
+    def test_clock_rejected(self):
+        task=self.task();task['steps']=1800
+        with self.assertRaises(ValueError):I.descriptor(task)
+
+    def test_case_math_config_retained(self):
+        original=dict(kind='fullgraph',dt_ms=.1,apl_delay_steps=18,precision='float64',apl_precision='float32',
+            record_history=False,seed=1073741825,model=dict(tau=20),apl=dict(gain=.01),graph_dir='/frozen/graph',
+            rate_sum_hz=1,mode='physiological')
+        task=self.task();task['mode']='matched_energy';before=copy.deepcopy(original)
+        spec=derive_spec(original,task,budget_root='/new/exp',output_cap=1234)
+        self.assertEqual(original,before)
+        for key in ('dt_ms','apl_delay_steps','precision','apl_precision','seed','model','apl','graph_dir'):
+            self.assertEqual(spec[key],original[key])
+        self.assertEqual(spec['steps'],1200);self.assertFalse(spec['within_trial_weight_updates'])
+
+if __name__=='__main__':unittest.main()

models/male-cns-lif/normal-conditioning-v1/test_normal_metrics.py

@@ -0,0 +1,274 @@
+"""CPU arrays and mocked artifact I/O; these are not scientific observations."""
+import copy
+import hashlib
+import importlib.util
+import io
+from pathlib import Path
+import unittest
+from unittest.mock import patch
+
+import numpy as np
+
+spec = importlib.util.spec_from_file_location('_test_normal_metrics', Path(__file__).with_name('normal_metrics.py'))
+N = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(N)
+
+
+def fixture():
+    nodes = np.arange(6, dtype=np.int32)
+    pops = {k: np.asarray(v, np.int32) for k, v in dict(MBON=[0, 1], MBON01=[0], MBON12=[1],
+            legacyDownstream=[0, 1, 2, 3], nonMBONDownstream=[2, 3]).items()}
+    blocks, probes, arms = {}, {}, {}
+    seed = 1
+    for mode in N.M.MODES:
+        for dan in N.M.DAN_TYPES:
+            for cue in ('A', 'B'):
+                for rep in range(1, 6):
+                    identity = f'{mode}__{dan}__reinforce_{cue}__rep{rep:02d}'
+                    sources = []
+                    for split in ('training', 'design'):
+                        sources.append(dict(stream_id=identity + '/' + split, seed=seed, split=split)); seed += 1
+                    evaluation = {}
+                    for c in ('A', 'B'):
+                        evaluation[N.ODORS[c]] = dict(stream_id=identity + '/evaluation/' + c, seed=seed, split='evaluation'); seed += 1
+                    blocks[identity] = dict(mode=mode, dan_type=dan, compartment_verbatim=N.G.DAN_COMPARTMENTS[dan],
+                        conditioned_cue=N.ODORS[cue], replicate=rep, training_sources=sources, evaluation_sources=evaluation,
+                        evaluation_input_sha256={N.ODORS[c]: N.sha([identity, c]) for c in ('A', 'B')})
+                    for arm in N.ARM_NAMES:
+                        arms[(identity, arm)] = [dict(result=[identity, arm, e], requested=e < 50 and arm != 'cs_only')
+                                                for e in range(150 if arm == 'unpaired' else 100)]
+                        for point in N.POINTS:
+                            for c in ('A', 'B'):
+                                probes[(identity, arm, point, c)] = dict(block=identity, arm=arm, point=point, cue=c,
+                                    active=arm == 'paired' and point > 0 and c == cue and rep <= 3, dan=dan)
+    membership = N.M.validate_populations(nodes, pops)
+    registry = dict(schema=N.G.REGISTRY_SCHEMA, protocol_sha256='1' * 64, population_binding_sha256='2' * 64,
+        nodes_raw_sha256=N.M._hash(nodes), population_membership_sha256=membership['membership_sha256'], blocks=blocks)
+    authority = dict(schema=N.G.AUTHORITY_SCHEMA, registry_sha256=N.G.descriptor_sha256(registry),
+        verification_receipt_sha256='3' * 64, execution_inventory_sha256='4' * 64, population_binding_sha256='2' * 64)
+    return nodes, pops, registry, authority, probes, arms
+
+
+def state_for(record):
+    ids = np.asarray(sorted([1 if record['dan'] == 'PAM15' else 0, 2]) if record['active'] else [], np.int32)
+    state = dict(step=np.full(len(ids), 10, np.int32), neuron_idx=ids,
+        counts=np.bincount(ids, minlength=6).astype(np.int32), v=np.zeros(6, np.float64),
+        g=np.zeros(6, np.float64), ref=np.zeros(6, np.int32))
+    if record['active']:
+        state['g'][ids[0]] = .1
+    return state
+
+
+class MockReader:
+    def __init__(self, values):
+        self.values = values
+        self.inventory = {str(p): dict(bytes=len(N.canonical(v)), sha256=N.sha(v)) for p, v in values.items()}
+    def json(self, path): return copy.deepcopy(self.values[str(path)])
+    def check(self, path): return self.inventory[str(path)]
+    def path(self, path): return Path(path), self.inventory[str(path)]
+
+
+def process_fixture():
+    exp = Path.cwd() / 'mock-normal-evidence'
+    entry_id = 'input-generation'; regsha = '1' * 64
+    job_path = exp / 'jobs/input-generation.json'
+    proc_path = exp / 'receipts/input-generation/process.json'
+    start_path = exp / '.append-ledger/started/input-generation.json'
+    entry_path = exp / '.append-ledger/entries/0000000000000001.json'
+    values = {str(job_path): dict(kind='sample', registration_sha256=regsha, input_sha256={})}
+    for label in ('stdout', 'stderr'):
+        values[str(exp / f'logs/input-generation.{label}.log')] = {'log': label}
+    values[str(proc_path)] = dict(entry_id=entry_id, registration_sha256=regsha, job_sha256=N.sha(values[str(job_path)]),
+        complete=True, exit_code=0, timed_out=False, exit_observed_by_parent=True,
+        stdout_sha256=N.sha({'log': 'stdout'}), stderr_sha256=N.sha({'log': 'stderr'}))
+    r = MockReader(values)
+    row = lambda p: dict(path=str(p), relative_path=Path(p).relative_to(exp).as_posix(), **r.inventory[str(p)])
+    values[str(start_path)] = dict(entry_id=entry_id, registration_sha256=regsha, next_sequence=1,
+        prev_entry_sha256=None, retry_authorized=False, job=row(job_path))
+    values[str(entry_path)] = dict(entry_id=entry_id, registration_sha256=regsha, sequence=1,
+        prev_entry_sha256=None, start_sha256=N.sha(values[str(start_path)]), consumed_inputs=[row(job_path)],
+        new_outputs=[row(p) for p in list(values) if p != str(start_path)],
+        metadata=dict(job_file=str(job_path), process_receipt_file=str(proc_path), observed_returncode=0))
+    final = dict(schema='normal-append-ledger-v1-final-audit', registration_sha256=regsha, pass_all=True,
+        entry_ids=[entry_id], expected_entry_ids=[entry_id], expected_order_exact=True,
+        extra_files=[], missing_files=[], changed_files=[], unsafe_files=[], errors=[], uncommitted_entry_ids=[],
+        uncommitted_state_unknown=False, head_sha256=N.sha(values[str(entry_path)]))
+    return exp, values, final, proc_path, entry_path
+
+
+def case_fixture(no_cs=False):
+    exp = Path.cwd() / 'mock-normal-case'; population_file = str(exp / 'population.npz')
+    seed = (1 << 62) + 17
+    task = dict(task_id='real-recipe/epoch-000', kind='train', mode='physiological', arm='dan_only' if no_cs else 'paired',
+        dan_type='PAM15', recipe=dict(cs=None if no_cs else dict(cue='A', seed=seed, source_stream_id='independent-original'),
+                                   us=dict(requested=True), D_command=1.0))
+    case = exp / 'cases' / N.task_key(task)
+    template = dict(kind='fullgraph', steps=1200, dt_ms=.1, apl_delay_steps=18, precision='float64',
+        apl_precision='float32', record_history=False, seed=98765, synaptic_tau=5.0, cs_input_seed=999)
+    spec = {k: v for k, v in template.items() if k != 'cs_input_seed'}
+    spec.update(name=N.task_key(task), steps=1200, duration_ms=120., max_steps=1200, budget_root=str(exp),
+        output_budget_bytes=123, mode=task['mode'], within_trial_weight_updates=False,
+        outer_protocol='normal-acquisition-v1', outer_task_id=task['task_id'], outer_arm=task['arm'])
+    descriptor = dict(mode=task['mode'], cue='A', seed=seed, steps=1200, cs_start_tick=0,
+        cs_stop_tick_exclusive=1000, source_stream_id='independent-original', table_id='physiological--A')
+    csid = None if no_cs else N.sha(descriptor)
+    arrays = {}
+    source = dict(tick=np.asarray([] if no_cs else [10], np.int32), neuron_idx=np.asarray([] if no_cs else [3], np.int32))
+    dan = np.asarray([4, 5, 6, 7], np.int32)
+    us = dict(tick=np.full(4, 900, np.int32), neuron_idx=dan)
+    combined = {k: np.concatenate((source[k], us[k])) for k in source}
+    for name, value in (('cs_requests.npz', source), ('us_requests.npz', us), ('requests.npz', combined),
+                         ('source-mask.npz', dict(source_mask=np.asarray(([1] if not no_cs else []) + [2]*4, np.uint8)))):
+        arrays[str(case / name)] = value
+    values = {str(case / 'spec.json'): spec, population_file: {'artifact': 'actual-static-populations'}}
+    source_pin = None; sampler = dict(inputs={})
+    if not no_cs:
+        source_path = exp / f'inputs/generated/{csid}.npz'; audit_path = exp / f'inputs/generated/{csid}.json'
+        values[str(source_path)] = {'array-artifact': 'mock-sparse-CS'}
+        arrays[str(source_path)] = source
+        source_pin = dict(path=str(source_path), sha256=N.sha(values[str(source_path)]))
+        values[str(audit_path)] = dict(descriptor=descriptor, requests_sha256=source_pin['sha256'], audit=dict(seed=seed,
+            generator_initial_seed=seed, seed_bits=63, seed_conversion='exact integer; no truncation/modulo/offset',
+            private_generator=True, matrix_draw_calls=1, uniform_matrix_shape=[1200, 1], CS_window=[0, 1000]))
+        sampler['inputs'][csid] = dict(requests=source_pin, audit=dict(path=str(audit_path), sha256=N.sha(values[str(audit_path)])))
+    values[str(case / 'input-binding.json')] = dict(task_id=task['task_id'], CS_descriptor_id=csid, CS_source=source_pin,
+        DAN_type='PAM15', population_file=dict(path=population_file, sha256=N.sha(values[population_file])),
+        DAN_membership_sha256=hashlib.sha256(dan.tobytes()).hexdigest(), composition=dict(policy='error', cross_source_conflict_count=0))
+    reader = MockReader(values)
+    reader.arrays = lambda p: {k: v.copy() for k, v in arrays[str(p)].items()}
+    args = dict(template=template, inputs=dict(task_inputs={task['task_id']: csid}, descriptors={} if no_cs else {csid: descriptor}),
+        sampler=sampler, populations=dict(PAM15=dan), population_file=population_file, output_cap=123)
+    return reader, exp, task, dict(case_dir=str(case)), args, values, arrays, case
+
+
+class NormalMetricTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.nodes, cls.pops, cls.registry, cls.authority, cls.probes, cls.arms = fixture()
+        cls.full_reports = {}
+        original = N.G.evaluate_acquisition
+        def capture(*args, **kwargs):
+            result = original(*args, **kwargs)
+            cls.full_reports[(result['mode'], result['dan_type'], result['conditioned_cue'])] = result
+            return result
+        with patch.object(N.G, 'evaluate_acquisition', side_effect=capture):
+            cls.report = N.scientific_reports(cls.probes, cls.arms, registry=cls.registry, authority=cls.authority,
+                nodes=cls.nodes, populations=cls.pops, load_state=state_for)
+
+    def test_full_fixed_curves_and_eight_same_replicate_gates(self):
+        self.assertEqual(len(self.report['cells']), 8)
+        self.assertEqual(len(self.report['curves']), 1960)
+        self.assertTrue(self.report['cohort']['all_functional_predicates_pass'])
+        self.assertTrue(all(r['successful_same_replicate_conjunctions'] == 3 for r in self.report['cells']))
+        self.assertTrue(all('acquisition_metric_inputs' not in r for r in self.report['cells']))
+        self.assertTrue(all(not r['scientific_learning_pass_claimed'] for r in self.report['cells']))
+        self.assertEqual({r['checkpoint'] for r in self.report['curves']}, set(N.POINTS))
+        self.assertTrue(all(r['metrics']['rawS'] == 0 for r in self.report['curves'] if r['checkpoint'] == 0))
+        self.assertTrue(all(not isinstance(v, list) for r in self.report['curves']
+            for cue in r['metrics']['cues'].values() for group in cue['populations'].values() for v in group.values()))
+
+    def test_legacy_mapping_exactly_matches_frozen_wrapper(self):
+        expected = N.G.legacy_h_cohort_audit(list(self.full_reports.values()), registry=self.registry,
+            authority=self.authority, declared_mapping=N.G.H_MAPPING)
+        actual = N.legacy_audit(self.report['cells'], N.G.H_MAPPING)
+        self.assertEqual(actual, expected)
+        self.assertEqual(len(actual['groups']), 4)
+        self.assertTrue(all(set(g['control_sources']) == {'PAM15', 'PPL103'} for g in actual['groups']))
+        with self.assertRaises(ValueError): N.legacy_audit(self.report['cells'], None)
+
+    def test_training_evaluation_seed_collision_and_missing_control_fail_closed(self):
+        registry = copy.deepcopy(self.registry)
+        block = next(iter(registry['blocks'].values()))
+        block['evaluation_sources'][N.M.CUES[0]]['seed'] = block['training_sources'][0]['seed']
+        with self.assertRaisesRegex(ValueError, 'collision'):
+            N.G.validate_registry(registry, expected_sha256=N.G.descriptor_sha256(registry))
+        report = next(iter(self.full_reports.values()))
+        rows = copy.deepcopy(report['acquisition_metric_inputs'])
+        del rows[0]['arms']['DAN-only']
+        with self.assertRaisesRegex(ValueError, 'six actual controls'):
+            N.G.evaluate_acquisition(rows, assay='normal', mode=report['mode'], dan_type=report['dan_type'],
+                conditioned_cue=report['conditioned_cue'], registry=self.registry, authority=self.authority)
+
+    def test_state_mutation_and_absent_probe_never_become_zero_metrics(self):
+        probes = dict(self.probes); del probes[next(iter(probes))]
+        with self.assertRaises((KeyError, ValueError)):
+            N.scientific_reports(probes, self.arms, registry=self.registry, authority=self.authority,
+                nodes=self.nodes, populations=self.pops, load_state=state_for)
+        def corrupt(record):
+            state = state_for(record); state['g'][0] = np.nan; return state
+        with self.assertRaisesRegex(ValueError, 'Nonfinite'):
+            N.scientific_reports(self.probes, self.arms, registry=self.registry, authority=self.authority,
+                nodes=self.nodes, populations=self.pops, load_state=corrupt)
+
+    def test_actual_parent_receipt_nested_layout_and_exit_failure(self):
+        exp, values, final, proc, _ = process_fixture()
+        evidence = N.Evidence(MockReader(values), exp, '1' * 64, ['input-generation'], final)
+        observed = evidence.process('input-generation', 'sample'); evidence.finish()
+        self.assertEqual(observed['process_path'], str(exp / 'receipts/input-generation/process.json'))
+        values[str(proc)]['exit_code'] = 1
+        # Even a caller report saying pass_all cannot rescue a real exit failure.
+        r = MockReader(values)
+        entry = next(v for v in values.values() if 'new_outputs' in v)
+        for row in entry['new_outputs']:
+            if row['path'] == str(proc): row.update(r.inventory[str(proc)])
+        with self.assertRaisesRegex(ValueError, 'Actual parent exit'):
+            N.Evidence(MockReader(values), exp, '1' * 64, ['input-generation'], final).process('input-generation', 'sample')
+
+    def test_result_process_must_be_ledger_owned_not_only_metadata(self):
+        exp, values, final, proc, entry_path = process_fixture()
+        entry = values[str(entry_path)]
+        entry['new_outputs'] = [r for r in entry['new_outputs'] if r['path'] != str(proc)]
+        with self.assertRaisesRegex(ValueError, 'not owned'):
+            N.Evidence(MockReader(values), exp, '1' * 64, ['input-generation'], final).process('input-generation', 'sample')
+        bad = dict(final, uncommitted_entry_ids=['unknown-child'])
+        with self.assertRaisesRegex(ValueError, 'Incomplete'):
+            N.Evidence(MockReader(values), exp, '1' * 64, ['input-generation'], bad)
+
+    def test_reader_per_invocation_actual_sha_cache_and_no_boolean_substitution(self):
+        path = Path.cwd() / 'mock-artifact.json'; raw = b'{"actual":true}'
+        identity = dict(bytes=len(raw), sha256=hashlib.sha256(raw).hexdigest())
+        with patch.object(Path, 'is_symlink', return_value=False), patch.object(Path, 'is_junction', return_value=False, create=True), \
+             patch.object(Path, 'is_file', return_value=True), patch.object(Path, 'open', side_effect=lambda *a, **k: io.BytesIO(raw)) as opened:
+            reader = N.Reader({str(path): identity})
+            reader.check(path); reader.check(path)
+            self.assertEqual(opened.call_count, 1)
+            N.Reader({str(path): identity}).check(path)
+            self.assertEqual(opened.call_count, 2)
+            with self.assertRaisesRegex(ValueError, 'Actual file checksum'):
+                N.Reader({str(path): dict(bytes=len(raw), sha256='0' * 64)}).check(path)
+
+    def test_real_inventory_process_count_and_no_followup(self):
+        tasks = [dict(task_id='train-' + str(i), kind='train') for i in range(30000)]
+        tasks += [dict(task_id='probe-' + str(i), kind='probe') for i in range(3920)]
+        entries = N.expected_entries(dict(tasks=tasks))
+        self.assertEqual(len(entries), 93921)
+        self.assertEqual(len(set(entries)), 93921)
+        self.assertEqual(entries[0], 'input-generation')
+        self.assertTrue(entries[-1].endswith('--brain'))
+
+    def test_original_train_cs_us_seed_and_model_checked_independently(self):
+        reader, exp, task, job, args, values, arrays, case = case_fixture()
+        N.audit_case(reader, exp, task, job, **args)
+        arrays[str(case / 'us_requests.npz')]['tick'][0] = 901
+        with self.assertRaisesRegex(ValueError, 'sorted unique|scheduled US'):
+            N.audit_case(reader, exp, task, job, **args)
+        arrays[str(case / 'us_requests.npz')]['tick'][0] = 900
+        values[str(case / 'spec.json')]['seed'] += 1
+        with self.assertRaisesRegex(ValueError, 'model/reset/clock'):
+            N.audit_case(reader, exp, task, job, **args)
+        values[str(case / 'spec.json')]['seed'] -= 1
+        generated = next(v for v in values.values() if 'audit' in v)
+        generated['audit']['generator_initial_seed'] %= 2**32
+        with self.assertRaisesRegex(ValueError, 'sampler seed'):
+            N.audit_case(reader, exp, task, job, **args)
+
+    def test_no_cs_is_empty_and_dan_only_still_uses_original_fixed_us(self):
+        reader, exp, task, job, args, values, arrays, case = case_fixture(no_cs=True)
+        N.audit_case(reader, exp, task, job, **args)
+        arrays[str(case / 'cs_requests.npz')] = dict(tick=np.asarray([10], np.int32), neuron_idx=np.asarray([3], np.int32))
+        with self.assertRaisesRegex(ValueError, 'case CS'):
+            N.audit_case(reader, exp, task, job, **args)
+
+
+if __name__ == '__main__':
+    unittest.main()

models/male-cns-lif/normal-conditioning-v1/test_normal_plan.py

@@ -0,0 +1,160 @@
+"""CPU-only fixed inventory, authority, and dependency regression tests."""
+from collections import Counter, defaultdict
+import importlib.util
+from pathlib import Path
+import random
+import sys
+import unittest
+from unittest.mock import patch
+
+
+_SPEC = importlib.util.spec_from_file_location("normal_plan_test_subject", Path(__file__).with_name("normal_plan.py"))
+P = importlib.util.module_from_spec(_SPEC)
+_SPEC.loader.exec_module(P)
+
+
+class NormalPlanTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        # Deterministic recipe construction, NOT neural random sampling.
+        cls.trial = P._FROZEN["trial_plan"].build_trial_plan(P.MASTER)
+        cls.evaluation = P.expand_pinned_evaluation(cls.trial)
+        with patch.object(random, "random", side_effect=AssertionError("RNG draw")), \
+             patch.object(random, "Random", side_effect=AssertionError("RNG instance")):
+            cls.plan = P.build_normal_plan(cls.trial, cls.evaluation)
+
+    def test_complete_inventory_and_order(self):
+        plan = self.plan
+        self.assertEqual(Counter(t["kind"] for t in plan["tasks"]), {"train": 30000, "probe": 3920})
+        self.assertEqual(sum(t["steps"] for t in plan["tasks"]), 40704000)
+        self.assertEqual(len(plan["blocks"]), 40)
+        self.assertEqual(Counter((b["mode"], b["dan_type"], b["reinforced_cue"]) for b in plan["blocks"]),
+                         {(m, d, c): 5 for m in ("physiological", "matched_energy")
+                          for d in ("PAM15", "PPL103") for c in ("A", "B")})
+        groups = defaultdict(list)
+        for row in plan["tasks"]:
+            groups[(row["block_id"], row["arm"])].append(row)
+        self.assertEqual(list(groups), [(b["block_id"], a) for b in self.trial["plan"]["blocks"]
+                                      for a in P._FROZEN["trial_plan"].ARMS])
+        for (_, arm), rows in groups.items():
+            self.assertEqual([r["kind"] for r in rows[:3]], ["probe", "probe", "train"])
+            self.assertEqual([r["recipe"]["cue"] for r in rows[:2]], ["A", "B"])
+            self.assertEqual(len(rows), 164 if arm == "unpaired" else 114)
+            self.assertEqual([r["checkpoint"] for r in rows if r["kind"] == "probe"],
+                             [n for n in (0, 1, 2, 5, 10, 20, 50) for _ in range(2)])
+        self.assertEqual(len(groups), 280)
+
+    def test_every_dependency_is_earlier_same_arm_delta_and_probes_do_not_feed_back(self):
+        previous, completed = {}, Counter()
+        for row in self.plan["tasks"]:
+            key = row["block_id"], row["arm"]
+            expected = previous.get(key, {"kind": "zero", "source": None})
+            self.assertEqual(row["delta_dependency"], expected)
+            self.assertTrue(row["artifact_validation_required"])
+            if row["kind"] == "train":
+                self.assertEqual(row["epoch_index"], completed[key])
+                completed[key] += 1
+                self.assertEqual(row["carry_between_epochs"], ["plastic_delta_only"])
+                self.assertEqual(row["neural_state_policy"], "frozen_reset_including_KC_trace_and_both_delay_queues")
+                self.assertTrue(row["original_E_required"] and row["cpu_validation_required"])
+                previous[key] = {"kind": "epoch_delta_after", "source": row["delta_output_id"]}
+            else:
+                self.assertEqual(row["completed_epochs"], completed[key])
+                self.assertEqual(row["snapshot_binding"]["completed_epochs"], completed[key])
+                self.assertFalse(row["feedback_to_training_or_idle"])
+                self.assertFalse(row["original_E_required"] or row["cpu_validation_required"])
+                self.assertFalse(row["recipe"]["US_requested"] or row["recipe"]["weight_updates_enabled"])
+                self.assertEqual(row["recipe"]["D_command"], 0.0)
+                self.assertIsNone(row["delta_output_id"])
+
+    def test_frozen_control_recipes_not_nominal_boundaries(self):
+        actual = {r["task_id"]: r for r in self.plan["tasks"]}
+        for block in self.trial["plan"]["blocks"]:
+            normal = next(s for s in block["suites"] if s["assay"] == "normal")
+            for arm in normal["arms"]:
+                for recipe in arm["epochs"]:
+                    row = actual[recipe["epoch_id"]]
+                    self.assertEqual(row["recipe"], recipe)
+                    self.assertEqual(row["source_binding"]["record_sha256"], P._sha(recipe))
+                    self.assertEqual(row["source_binding"]["payload_sha256"], self.trial["payload_sha256"])
+                self.assertEqual(sum(e["us"]["requested"] for e in arm["epochs"]),
+                                 0 if arm["arm"] == "cs_only" else 50)
+                if arm["arm"] == "unpaired":
+                    self.assertTrue(all(not (e["cs"] and e["us"]["requested"]) for e in arm["epochs"]))
+        for original in self.evaluation["probes"]:
+            if original["assay"] == "normal":
+                self.assertEqual(actual[original["probe_id"]]["recipe"], original)
+        self.assertTrue(any(r["kind"] == "probe" and r["arm"] == "unpaired" and
+                            r["checkpoint"] == 50 and r["completed_epochs"] == 150
+                            for r in actual.values()))
+
+    def test_evaluation_inputs_reused_not_redrawn_or_counted_as_replicates(self):
+        inputs = self.plan["evaluation_inputs"]
+        self.assertEqual(len(inputs), 80)
+        self.assertEqual(len({r["stream_id"] for r in inputs}), 80)
+        seeds = {r["seed"] for r in inputs}
+        training = {r["recipe"]["cs"]["seed"] for r in self.plan["tasks"]
+                    if r["kind"] == "train" and r["recipe"]["cs"] is not None}
+        self.assertFalse(seeds & training)
+        self.assertTrue(all(type(s) is int and 0 <= s < 2**63 for s in seeds | training))
+        reuse = Counter(r["evaluation_input_id"] for r in self.plan["tasks"] if r["kind"] == "probe")
+        self.assertEqual(set(reuse.values()), {49})
+        self.assertEqual(set(reuse), {r["input_id"] for r in inputs})
+        self.assertTrue(all(not r["recipe"]["adds_training_replicate"] for r in self.plan["tasks"] if r["kind"] == "probe"))
+        self.assertEqual(self.plan["new_seed_streams"], 0)
+        self.assertFalse(self.plan["learning_pass_claimed"] or self.plan["execution_authorized"])
+
+    def test_no_mutable_alias_to_authorities(self):
+        row = next(r for r in self.plan["tasks"] if r["kind"] == "train")
+        before = row["recipe"]["D_command"]
+        try:
+            row["recipe"]["D_command"] = 999
+            original = self.trial["plan"]["blocks"][0]["suites"][0]["arms"][0]["epochs"][0]
+            self.assertEqual(original["D_command"], before)
+        finally:
+            row["recipe"]["D_command"] = before
+        self.assertIsNot(self.plan["provenance"]["frozen_source_sha256"], P.SOURCE_PINS)
+
+    def test_private_loader_ignores_ordinary_module_cache_and_fails_closed_on_source_pin(self):
+        sentinels = {name: object() for name in ("seed_registry", "trial_plan", "evaluation_plan", "evaluation_policy", "R", "E")}
+        with patch.dict(sys.modules, sentinels):
+            loaded = P._load_frozen()
+            self.assertIs(loaded["trial_plan"].seed_registry, loaded["seed_registry"])
+            self.assertIs(loaded["evaluation_policy"].evaluation_plan, loaded["evaluation_plan"])
+            self.assertTrue(all(sys.modules[name] is value for name, value in sentinels.items()))
+        with patch.object(Path, "read_bytes", return_value=b"unregistered mutation"):
+            with self.assertRaisesRegex(ValueError, "Frozen source pin mismatch"):
+                P._load_frozen()
+
+    def test_original_trial_and_policy_mutation_rejected(self):
+        master = self.trial["plan"]["master"]
+        try:
+            self.trial["plan"]["master"] = master + 1
+            with self.assertRaisesRegex(ValueError, "master"):
+                P.build_normal_plan(self.trial, self.evaluation)
+        finally:
+            self.trial["plan"]["master"] = master
+        binding = self.evaluation["config"]["snapshot_bindings"][1]
+        count = binding["completed_epochs"]
+        try:
+            binding["completed_epochs"] += 1
+            with self.assertRaisesRegex(ValueError, "exactly expand"):
+                P.build_normal_plan(self.trial, self.evaluation)
+        finally:
+            binding["completed_epochs"] = count
+
+    def test_validates_exact_reconstruction_and_rejects_rehashed_task_mutation(self):
+        self.assertTrue(P.validate_normal_plan(self.plan, self.trial, self.evaluation))
+        row, original_hash = self.plan["tasks"][0], self.plan["payload_sha256"]
+        try:
+            row["feedback_to_training_or_idle"] = True
+            self.plan["payload_sha256"] = P._sha({k: v for k, v in self.plan.items() if k != "payload_sha256"})
+            with self.assertRaisesRegex(ValueError, "exact reconstruction"):
+                P.validate_normal_plan(self.plan, self.trial, self.evaluation)
+        finally:
+            row["feedback_to_training_or_idle"] = False
+            self.plan["payload_sha256"] = original_hash
+
+
+if __name__ == "__main__":
+    unittest.main()

models/male-cns-lif/normal-conditioning-v1/test_normal_runner.py

@@ -0,0 +1,387 @@
+"""Pure temporary-file and mock-process tests; no sampler, Torch, brain or GPU."""
+import copy
+import importlib.util
+from pathlib import Path
+import subprocess
+import tempfile
+import time
+from types import SimpleNamespace
+import unittest
+from unittest.mock import patch
+
+import numpy as np
+import normal_runner as R
+import normal_prepare as P
+
+
+def load_readonly(name, path):
+    spec=importlib.util.spec_from_file_location(name,path)
+    module=importlib.util.module_from_spec(spec)
+    exec(compile(path.read_bytes(),str(path),'exec'),module.__dict__)
+    return module
+
+
+LAB=Path(__file__).resolve().parent.parent/'olfactory-conditioning-lab-v1'
+COMPOSER=load_readonly('_runner_test_original_composer',LAB/'conditioning_inputs.py')
+WORKER=load_readonly('_runner_test_original_worker',LAB.parent/'conditioning-interface-v2/isolated_workers.py')
+
+
+def task(arm='paired', *, requested=True, kind='train', dan='PAM15', number=1):
+    value=dict(task_id=f'block/normal/{arm}/epoch-{number:03d}',kind=kind,steps=1200,
+        block_id='block',arm=arm,mode='physiological',dan_type=dan,
+        compartment_verbatim="y5B'2a" if dan=='PAM15' else "y2a'1",
+        delta_dependency=dict(kind='zero',source=None),feedback_to_training_or_idle=kind=='train')
+    if kind=='probe':
+        value['recipe']=dict(US_requested=False,D_command=0,weight_updates_enabled=False)
+    else:
+        value['recipe']=dict(us=dict(nominal_slot_tick=900,rng_seed=None,rng_draws=0,
+            requested=requested,tick=900 if requested else None),
+            D_command=1. if requested and arm!='d_zero' else 0.,update_enabled=arm!='frozen')
+    return value
+
+
+class RunnerTests(unittest.TestCase):
+    def test_runtime_array_closure_matches_original_worker_not_directory_glob(self):
+        self.assertEqual(P.GRAPH_FILES,WORKER.GRAPH_FILES)
+        self.assertEqual(P.APL_FILES,WORKER.APL_FILES)
+        with tempfile.TemporaryDirectory() as folder:
+            root=Path(folder);graph=root/'graph';apl=root/'apl'
+            graph.mkdir();apl.mkdir()
+            # Additional reference arrays are neither consumed nor required.
+            for name in ('apl_out_ids.npy','input_raw.npy','output_raw.npy','pn_globals.npy'):
+                (apl/name).touch()
+            template=dict(graph_dir=str(graph),apl_bundle_dir=str(apl),coefficients_path=str(root/'coeff.json'))
+            paths=P.runtime_array_paths(template)
+            expected={str(graph/name) for name in WORKER.GRAPH_FILES} | {
+                str(apl/name) for name in WORKER.APL_FILES} | {template['coefficients_path']}
+            self.assertEqual(paths,expected);self.assertEqual(len(paths),12)
+
+    def setUp(self):
+        temporary=tempfile.TemporaryDirectory();self.addCleanup(temporary.cleanup)
+        self.root=Path(temporary.name).resolve()
+        for rel in ('protocol','jobs','cases','runs','updates','validation','results','receipts','logs','audit'):
+            (self.root/rel).mkdir()
+        self.addCleanup(patch.stopall)
+        patch.object(R,'EXP',self.root).start()
+        self.regfile=self.root/'protocol/preregistered.json';R.save(self.regfile,{'synthetic':True})
+        self.sha=R.digest(self.regfile)
+        self.w=R.Workflow.__new__(R.Workflow);self.w.sha=self.sha
+        self.w.start=time.perf_counter();self.w.completed=set();self.w.expected=[];self.w.tasks={}
+        self.w.overlay_dependency_pins={};self.w.case_dependency_pins={}
+        self.w.reg=dict(budget=dict(output_cap_bytes=8<<20,minimum_free_reserve_bytes=0,
+            workflow_timeout_seconds=60,child_timeout_seconds=10,not_after_utc='2099-01-01T00:00:00+00:00',
+            next_child_headroom_bytes=65536),runtime_input_sha256={},
+            input_sha256={},initial_overlay=dict(overlay_file=str(self.root/'protocol/zero.npz'),
+                overlay_manifest=str(self.root/'protocol/zero.json')))
+        R.save_npz(self.root/'protocol/zero.npz',dict(plastic_delta_mv=np.zeros(2,np.float32)))
+        R.save(self.root/'protocol/zero.json',dict(synthetic=True))
+        initial={p.relative_to(self.root).as_posix():R.identity(p) for p in (self.root/'protocol').iterdir()}
+        self.w.ledger=R.Ledger(self.root,self.sha,initial,8<<20,0)
+
+    def test_original_composer_no_US_D0_frozen_and_PPL_requests(self):
+        cs=dict(tick=np.array([10,20],np.int32),neuron_idx=np.array([3,4],np.int32))
+        for arm,requested,dan in (('paired',False,'PAM15'),('d_zero',True,'PAM15'),
+                                  ('frozen',True,'PAM15'),('paired',True,'PPL103')):
+            item=task(arm,requested=requested,dan=dan)
+            ids=np.array([10,11,12,13] if dan=='PAM15' else [14,15],np.int32)
+            composed,us=R.compose_requests(cs,ids,item,COMPOSER)
+            self.assertEqual(len(us['tick']),len(ids) if requested else 0)
+            self.assertEqual(composed['audit']['US_attempts'],len(us['tick']))
+            self.assertEqual(item['recipe']['D_command'],0. if not requested or arm=='d_zero' else 1.)
+            self.assertEqual(item['recipe']['update_enabled'],arm!='frozen')
+            if requested:self.assertTrue(np.array_equal(us['neuron_idx'],ids))
+        bad=task('d_zero');bad['recipe']['D_command']=1.
+        with self.assertRaisesRegex(ValueError,'D/update'):R.compose_requests(cs,ids,bad,COMPOSER)
+
+    def test_probe_refuses_US_update_or_feedback(self):
+        cs=dict(tick=np.array([7],np.int32),neuron_idx=np.array([3],np.int32))
+        value=task(kind='probe');combined,us=R.compose_requests(cs,np.array([9,10],np.int32),value,COMPOSER)
+        self.assertEqual(len(us['tick']),0);self.assertEqual(combined['audit']['US_attempts'],0)
+        for role in ('US_requested','weight_updates_enabled','feedback_to_training_or_idle'):
+            bad=copy.deepcopy(value)
+            (bad if role=='feedback_to_training_or_idle' else bad['recipe'])[role]=True
+            with self.assertRaisesRegex(ValueError,'Probe command'):R.compose_requests(cs,np.array([9,10],np.int32),bad,COMPOSER)
+
+    def test_frozen_clock_and_reset_seed_retained(self):
+        original=dict(kind='fullgraph',dt_ms=.1,apl_delay_steps=18,precision='float64',
+            apl_precision='float32',record_history=False,seed=1234,training=False,cs_input_seed=999)
+        actual=R.derive_spec(original,task(),budget_root=self.root,output_cap=123456)
+        self.assertEqual(actual['seed'],1234);self.assertEqual(actual['steps'],1200)
+        self.assertEqual(actual['duration_ms'],120.);self.assertNotIn('cs_input_seed',actual)
+        self.assertFalse(actual['within_trial_weight_updates']);self.assertFalse(original['training'])
+        with self.assertRaisesRegex(ValueError,'fixed D18'):R.derive_spec(dict(original,apl_delay_steps=0),task(),budget_root=self.root,output_cap=1)
+
+    def test_actual_successful_parent_receipt_commits_ledger(self):
+        output=self.root/'runs/synthetic.txt'
+        job=dict(kind='cpu_verify',input_sha256={str(self.regfile):self.sha})
+        def fake_run(argv,**kwargs):
+            self.assertEqual(kwargs['env']['CUDA_VISIBLE_DEVICES'],'')
+            self.assertEqual(kwargs['env']['PYTHONDONTWRITEBYTECODE'],'1')
+            kwargs['stdout'].write(b'synthetic child only\n');output.write_bytes(b'new immutable output')
+            return SimpleNamespace(returncode=0)
+        with patch.object(R.subprocess,'run',side_effect=fake_run) as run:
+            self.w.launch('unit',job,['not-a-real-executable'],[output])
+        self.assertEqual(run.call_count,1);self.assertIn('unit',self.w.completed)
+        self.assertTrue(self.w.ledger.final_verify(['unit'])['pass_all'])
+        process=R.read(self.root/'receipts/unit/process.json')
+        self.assertEqual(process['exit_code'],0);self.assertTrue(process['complete'])
+        with self.assertRaisesRegex(ValueError,'rerun committed'):
+            self.w.launch('unit',job,['not-real'],[output])
+
+    def test_failed_child_is_uncommitted_unknown_and_cannot_rerun(self):
+        job=dict(kind='cpu_verify',input_sha256={str(self.regfile):self.sha})
+        with patch.object(R.subprocess,'run',return_value=SimpleNamespace(returncode=9)):
+            with self.assertRaisesRegex(ValueError,'Child failed'):self.w.launch('failed',job,['not-real'],[])
+        receipt=R.read(self.root/'receipts/failed/process.json')
+        self.assertFalse(receipt['complete']);self.assertEqual(receipt['exit_code'],9)
+        self.assertEqual(self.w.ledger.inspect()['uncommitted_entry_ids'],['failed'])
+        with self.assertRaises(FileExistsError):self.w.launch('failed',job,['not-real'],[])
+
+    def test_timed_out_child_never_gets_success_commit(self):
+        job=dict(kind='cpu_verify',input_sha256={str(self.regfile):self.sha})
+        with patch.object(R.subprocess,'run',side_effect=subprocess.TimeoutExpired('not-real',10)):
+            with self.assertRaisesRegex(ValueError,'Child failed'):self.w.launch('timeout',job,['not-real'],[])
+        receipt=R.read(self.root/'receipts/timeout/process.json')
+        self.assertTrue(receipt['timed_out']);self.assertIsNone(receipt['exit_code'])
+        self.assertNotIn('timeout',self.w.completed)
+
+    def test_spawn_OSerror_retains_failed_receipt_without_fake_exit(self):
+        job=dict(kind='cpu_verify',input_sha256={str(self.regfile):self.sha})
+        with patch.object(R.subprocess,'run',side_effect=OSError('synthetic spawn failure')):
+            with self.assertRaisesRegex(ValueError,'Child failed'):self.w.launch('spawn-error',job,['not-real'],[])
+        receipt=R.read(self.root/'receipts/spawn-error/process.json')
+        self.assertFalse(receipt['complete']);self.assertIsNone(receipt['exit_code'])
+        self.assertFalse(receipt['exit_observed_by_parent']);self.assertIn('synthetic spawn failure',receipt['launch_error'])
+        self.assertEqual(self.w.ledger.inspect()['uncommitted_entry_ids'],['spawn-error'])
+
+    def test_after_process_input_mutation_stops_before_commit(self):
+        dependency=self.root/'protocol/input.json';R.save(dependency,dict(value=1))
+        job=dict(kind='cpu_verify',input_sha256={str(dependency):R.digest(dependency)})
+        def fake_run(*a,**k):
+            dependency.write_bytes(b'{"value":2}');return SimpleNamespace(returncode=0)
+        with patch.object(R.subprocess,'run',side_effect=fake_run):
+            with self.assertRaisesRegex(ValueError,'Pinned input changed'):self.w.launch('mutation',job,['not-real'],[])
+        self.assertNotIn('mutation',self.w.completed)
+
+    def _delta_fixture(self):
+        old=task();new=task(number=2);new['delta_dependency']=dict(kind='epoch_delta_after',source=old['task_id']+'/delta-after')
+        self.w.tasks={old['task_id']:old};key=R.task_key(old)
+        self.w.completed.add(key+'--verify')
+        output=self.root/'updates'/key;output.mkdir()
+        R.save_npz(output/'delta-after.npz',dict(plastic_delta_mv=np.array([-.25,0.],np.float32)))
+        R.save(output/'overlay-manifest.json',dict(synthetic=True))
+        validation=self.root/'validation/previous.json';R.save(validation,dict(complete=True,
+            after_overlay_sha256=R.digest(output/'delta-after.npz'),after_manifest_sha256=R.digest(output/'overlay-manifest.json')))
+        process=self.root/f'receipts/{key}--verify/process.json';process.parent.mkdir()
+        R.save(process,dict(complete=True,exit_code=0,
+            entry_id=key+'--verify',registration_sha256=self.sha))
+        overlay=dict(overlay_file=str(output/'delta-after.npz'),overlay_manifest=str(output/'overlay-manifest.json'))
+        result=self.root/f'results/{key}.json'
+        R.save(result,dict(complete=True,task=old,cpu_validation=R.pin(validation),after_overlay=overlay,
+            cpu_process_receipt_path=str(process),update_dir=str(output)))
+        for path in (result,validation,process,output/'delta-after.npz',output/'overlay-manifest.json'):
+            self.w.ledger._tracked[path.relative_to(self.root).as_posix()]=R.identity(path)
+        return old,new,overlay,result,validation
+
+    def test_delta_dependency_requires_same_branch_completed_verify_and_receipt(self):
+        old,new,overlay,result,validation=self._delta_fixture()
+        self.w.completed.clear()
+        with self.assertRaisesRegex(ValueError,'CPU validation missing'):self.w.overlay(new)
+        self.w.completed.add(R.task_key(old)+'--verify')
+        self.assertEqual(self.w.overlay(new),overlay)
+        self.assertIn(str(result),self.w.overlay_dependency_pins)
+        self.assertIn(str(validation),self.w.overlay_dependency_pins)
+        for field in ('arm','block_id'):
+            altered=copy.deepcopy(new);altered[field]='unrelated'
+            with self.assertRaisesRegex(ValueError,'unrelated branch'):self.w.overlay(altered)
+        validation.write_bytes(b'{}')
+        with self.assertRaisesRegex(ValueError,'committed bytes'):self.w.overlay(new)
+
+    def test_alternate_valid_overlay_cannot_replace_previous_verified_delta(self):
+        _,new,_,result,_=self._delta_fixture()
+        alternative=self.root/'updates/other-valid';alternative.mkdir()
+        R.save_npz(alternative/'delta-after.npz',dict(plastic_delta_mv=np.array([-.5,0.],np.float32)))
+        R.save(alternative/'overlay-manifest.json',dict(synthetic=True,other=True))
+        for path in alternative.iterdir():self.w.ledger._tracked[path.relative_to(self.root).as_posix()]=R.identity(path)
+        record=R.read(result);record['update_dir']=str(alternative)
+        record['after_overlay']={k:str(alternative/name) for k,name in
+            (('overlay_file','delta-after.npz'),('overlay_manifest','overlay-manifest.json'))}
+        result.write_text(R.canonical(record),encoding='utf-8')
+        with self.assertRaisesRegex(ValueError,'committed bytes'):self.w.overlay(new)
+        # Even a synthetic "committed" bad result must fail its independent CPU output binding.
+        self.w.ledger._tracked[result.relative_to(self.root).as_posix()]=R.identity(result)
+        with self.assertRaisesRegex(ValueError,'independently verified output'):self.w.overlay(new)
+
+    def test_zero_dependency_does_not_carry_previous_lineage_pins(self):
+        self.w.overlay_dependency_pins={'stale':'0'*64}
+        self.assertEqual(self.w.overlay(task()),self.w.reg['initial_overlay'])
+        self.assertEqual(self.w.overlay_dependency_pins,{})
+
+    def _case_fixture(self):
+        item=task();template=self.root/'protocol/case-template.json'
+        R.save(template,dict(kind='fullgraph',dt_ms=.1,apl_delay_steps=18,precision='float64',
+            apl_precision='float32',record_history=False,seed=1234))
+        population=self.root/'protocol/populations.npz'
+        self.w.populations=dict(PAM15=np.array([10,11,12,13],np.int32),PPL103=np.array([14,15],np.int32))
+        R.save_npz(population,self.w.populations);self.w.reg['population_file']=str(population)
+        self.w.reg['input_sha256'][str(population)]=R.digest(population)
+        directory=self.root/'inputs/generated';directory.mkdir(parents=True)
+        source=directory/'source.npz';audit=directory/'source.json'
+        R.save_npz(source,dict(tick=np.array([5],np.int32),neuron_idx=np.array([3],np.int32)))
+        descriptor=dict(synthetic=True)
+        R.save(audit,dict(descriptor=descriptor,requests_sha256=R.digest(source)))
+        self.w.input_plan=dict(task_inputs={item['task_id']:'source'},descriptors={'source':descriptor})
+        self.w.inputs=COMPOSER
+        for path in (template,population,source,audit):
+            self.w.ledger._tracked[path.relative_to(self.root).as_posix()]=R.identity(path)
+        return item,template,source,audit
+
+    def test_prepare_case_reads_only_committed_template_and_shared_CS(self):
+        item,template,source,audit=self._case_fixture()
+        directory=self.w.prepare_case(item)
+        self.assertEqual(R.read(directory/'spec.json')['seed'],1234)
+        self.assertTrue({str(template),str(source),str(audit)} <= set(self.w.case_dependency_pins))
+        self.assertEqual(R.npz(directory/'us_requests.npz')['tick'].tolist(),[900]*4)
+
+    def test_changed_case_template_is_rejected_before_new_spec_write(self):
+        item,template,_,_=self._case_fixture();value=R.read(template);value['seed']=9876
+        template.write_text(R.canonical(value),encoding='utf-8')
+        with self.assertRaisesRegex(ValueError,'committed bytes'):self.w.prepare_case(item)
+        self.assertFalse((self.root/'cases'/R.task_key(item)/'spec.json').exists())
+
+    def test_changed_CS_and_self_rehashed_audit_are_both_rejected(self):
+        item,_,source,audit=self._case_fixture()
+        with source.open('wb') as stream:np.savez_compressed(stream,tick=np.array([9],np.int32),neuron_idx=np.array([4],np.int32))
+        value=R.read(audit);value['requests_sha256']=R.digest(source)
+        audit.write_text(R.canonical(value),encoding='utf-8')
+        with self.assertRaisesRegex(ValueError,'committed bytes'):self.w.prepare_case(item)
+        self.assertFalse((self.root/'cases'/R.task_key(item)/'requests.npz').exists())
+
+    def test_exclusive_helpers_reject_linked_parent_before_writes(self):
+        destination=self.root/'external';destination.mkdir();link=self.root/'alias'
+        try:link.symlink_to(destination,target_is_directory=True)
+        except OSError:self.skipTest('Platform disallows temporary symlinks')
+        for filename,write in (('x.json',lambda p:R.save(p,{'a':1})),
+                               ('x.npz',lambda p:R.save_npz(p,{'a':np.array([1],np.int32)}))):
+            with self.assertRaisesRegex(ValueError,'linked path'):write(link/filename)
+            self.assertFalse((destination/filename).exists())
+
+    def _mock_task(self,item):
+        """Exercise real orchestration/control closures, with no scientific child."""
+        validator=self.root/'validator.py';validator.write_bytes(b'# not executed\n')
+        self.w.reg['input_sha256'][str(validator)]=R.digest(validator)
+        patch.object(R,'AQ',self.root).start()
+        target=self.root/'validate_update_cpu.py';target.write_bytes(validator.read_bytes())
+        self.w.reg['input_sha256'][str(target)]=R.digest(target)
+        for name in ('conditioning_epoch.py','conditioning_preflight_compare.py','engineering_compare.py'):
+            self.w.reg['input_sha256'][str(LAB/name)]=R.digest(LAB/name)
+        R.save(self.root/'protocol/epoch-template.json',dict(schema='synthetic',files={},frozen_inputs={}))
+        self.w.ledger._tracked['protocol/epoch-template.json']=R.identity(self.root/'protocol/epoch-template.json')
+        calls=[];authorities=[]
+        def case(task_value):
+            result=self.root/'cases'/R.task_key(task_value);result.mkdir()
+            R.save(result/'spec.json',dict(steps=1200));R.save_npz(result/'requests.npz',dict(tick=np.empty(0,np.int32),neuron_idx=np.empty(0,np.int32)))
+            return result
+        def ap_job(name,kind,output,**kwargs):
+            return dict(kind=kind,output_dir=str(output),receipt_file=str(self.root/f'receipts/{name}/worker.json'),
+                input_sha256={},authority_file=str(kwargs.get('authority','')))
+        def launch(name,job,argv,outputs,*,pre_outputs=(),post=None,ap=False):
+            calls.append(job['kind'])
+            if job['kind']=='brain':
+                out=Path(job['output_dir']);out.mkdir();R.save(out/'checkpoint-manifest.json',dict(synthetic=True))
+                R.save_npz(out/'state.npz',dict(step=np.empty(0,np.int32)))
+                for filename in ('process.json','worker.json'):
+                    receipt=self.root/f'receipts/{name}/{filename}';receipt.parent.mkdir(exist_ok=True)
+                    R.save(receipt,dict(synthetic=True))
+                    self.w.ledger._tracked[receipt.relative_to(self.root).as_posix()]=R.identity(receipt)
+            elif job['kind']=='update':
+                authorities.append(R.read(job['authority_file']))
+                out=Path(job['output_dir']);out.mkdir()
+                R.save_npz(out/'delta-after.npz',dict(plastic_delta_mv=np.zeros(2,np.float32)))
+                R.save(out/'overlay-manifest.json',{});R.save(out/'chain-receipt.json',{})
+            else:
+                out=Path(job['update_dir'])
+                R.save(job['receipt_file'],dict(complete=True,frozen_U_verify_receipt_recomputed=True,
+                    actual_sealed_events_used=True,after_overlay_sha256=R.digest(out/'delta-after.npz'),
+                    epoch_authority_sha256=job['authority_sha256']))
+            if post is not None:post()
+            self.w.completed.add(name)
+        with patch.object(self.w,'prepare_case',side_effect=case),patch.object(self.w,'ap_job',side_effect=ap_job),\
+             patch.object(self.w,'launch',side_effect=launch),patch.object(self.w,'brain_verify',return_value={'synthetic':True}):
+            self.w.task(item)
+        return calls,authorities,R.read(self.root/f'results/{R.task_key(item)}.json')
+
+    def test_probe_orchestration_never_calls_E_or_CPU_update(self):
+        calls,authorities,record=self._mock_task(task(kind='probe'))
+        self.assertEqual(calls,['brain']);self.assertEqual(authorities,[])
+        self.assertNotIn('after_overlay',record);self.assertNotIn('cpu_validation',record)
+
+    def test_training_no_US_preserves_None_and_zero_D(self):
+        calls,authorities,record=self._mock_task(task(requested=False))
+        self.assertEqual(calls,['brain','update','cpu_verify'])
+        self.assertIsNone(authorities[0]['command']['us_tick'])
+        self.assertEqual(authorities[0]['command']['d_command'],0.)
+        self.assertFalse(authorities[0]['command']['frozen']);self.assertIn('after_overlay',record)
+
+    def test_D0_keeps_US_but_passes_zero_D_to_original_E(self):
+        calls,authorities,_=self._mock_task(task('d_zero'))
+        self.assertEqual(calls,['brain','update','cpu_verify'])
+        self.assertEqual(authorities[0]['command']['us_tick'],900)
+        self.assertEqual(authorities[0]['command']['d_command'],0.)
+        self.assertFalse(authorities[0]['command']['frozen'])
+
+    def test_frozen_keeps_D_request_but_explicitly_disables_update(self):
+        _,authorities,_=self._mock_task(task('frozen'))
+        self.assertEqual(authorities[0]['command']['d_command'],1.)
+        self.assertTrue(authorities[0]['command']['frozen'])
+
+    def test_PPL_compartment_not_replaced_by_PAM_or_sign_flip(self):
+        _,authorities,_=self._mock_task(task(dan='PPL103'))
+        self.assertEqual(authorities[0]['command']['compartment'],"y2a'1")
+        self.assertEqual(authorities[0]['command']['d_command'],1.)
+        self.assertEqual(authorities[0]['command']['trace_backend'],'torch')
+
+    def test_partial_task_cannot_silently_resume_remaining_children(self):
+        item=task();self.w.completed.add(R.task_key(item)+'--brain')
+        with patch.object(self.w,'launch') as launch:
+            with self.assertRaisesRegex(ValueError,'Partially completed task'):self.w.task(item)
+        launch.assert_not_called()
+
+    def test_real_AP_validation_accepts_brain_job_and_rejects_protected_outputs(self):
+        # Actual frozen parser only, using small synthetic files, no runtime load.
+        frozen=self.root/'frozen';frozen.mkdir();graph=frozen/'graph';graph.mkdir();apl=frozen/'apl';apl.mkdir()
+        for name in WORKER.GRAPH_FILES:(graph/name).write_bytes(b'synthetic graph bytes')
+        for name in WORKER.APL_FILES:(apl/name).write_bytes(b'synthetic APL bytes')
+        for name in ('mask.npy','base.npy','coeff.json'):(frozen/name).write_bytes(b'synthetic authority')
+        case=self.root/'cases/first';case.mkdir()
+        R.save(case/'spec.json',dict(graph_dir=str(graph),apl_bundle_dir=str(apl),coefficients_path=str(frozen/'coeff.json')))
+        R.save_npz(case/'requests.npz',dict(tick=np.empty(0,np.int32),neuron_idx=np.empty(0,np.int32)))
+        overlay=self.w.reg['initial_overlay'];manifest=Path(overlay['overlay_manifest'])
+        am=LAB.parent/'wholebrain-plastic-interface-v1/overlay.py'
+        manifest.write_text(R.canonical(dict(mask_path=str(frozen/'mask.npy'),mask_sha256=R.digest(frozen/'mask.npy'),
+            base_candidate_path=str(frozen/'base.npy'),base_candidate_sha256=R.digest(frozen/'base.npy'),
+            am_overlay_path=str(am),am_overlay_sha256=R.digest(am))),encoding='utf-8')
+        self.w.reg['runtime_input_sha256']={p:v['sha256'] for p,v in R.inventory(frozen).items()}
+        self.w.reg['runtime_input_sha256'][str(am)]=R.digest(am);self.w.h=WORKER
+        name='parser-brain';job=self.w.ap_job(name,'brain',self.root/'runs/first',case=case,overlay=overlay)
+        Path(job['receipt_file']).parent.mkdir()
+        file=self.root/'jobs/parser.json';R.save(file,job)
+        parsed,paths,_,_=WORKER.validate_job(file,R.digest(file),'brain')
+        self.assertEqual(parsed['diagnostic_mode'],'light');self.assertFalse(paths['output'].exists())
+        for field in ('output_dir','receipt_file','build_root'):
+            altered=copy.deepcopy(job);altered[field]=str(case/('forbidden-'+field))
+            alternative=self.root/'jobs'/(field+'.json');R.save(alternative,altered)
+            with self.assertRaisesRegex(ValueError,'protected input/source'):
+                WORKER.validate_job(alternative,R.digest(alternative),'brain')
+        self.assertFalse((case/'forbidden-output_dir').exists())
+
+    def test_separate_receipt_directories_allow_original_worker_lineage_protection(self):
+        # Real AP path validator should not interpret a previous receipt as
+        # authorizing writes into its parent. New receipts must be siblings.
+        prior=self.root/'receipts/previous';prior.mkdir()
+        previous=prior/'process.json';R.save(previous,dict(synthetic=True))
+        self.w.overlay_dependency_pins={str(previous):R.digest(previous)}
+        self.test_real_AP_validation_accepts_brain_job_and_rejects_protected_outputs()
+
+
+if __name__=='__main__':unittest.main()

models/male-cns-lif/normal-conditioning-v1/test_run_normal.py

@@ -0,0 +1,37 @@
+"""Pure temporary-file supervisor bookkeeping tests, no actual child launch."""
+from pathlib import Path
+import tempfile
+from types import SimpleNamespace
+import unittest
+from unittest.mock import patch
+import run_normal as R
+
+class SupervisorTests(unittest.TestCase):
+    def test_launch_is_exclusive_not_completion(self):
+        with tempfile.TemporaryDirectory() as temp,patch.object(R,'CONTROL',Path(temp)),patch.object(R,'authority',return_value={}):
+            with patch.object(R.subprocess,'Popen',return_value=SimpleNamespace(pid=123)) as spawn:
+                record=R.launch('a'*64)
+                self.assertEqual(spawn.call_count,1)
+                self.assertTrue(spawn.call_args.kwargs['start_new_session'])
+                self.assertFalse(record['final_exit_observed'])
+                self.assertFalse((Path(temp)/'exit.json').exists())
+                with self.assertRaises(ValueError):R.launch('a'*64)
+                self.assertEqual(spawn.call_count,1)
+
+    def test_final_exit_is_parent_observed_not_learning(self):
+        with tempfile.TemporaryDirectory() as temp,patch.object(R,'CONTROL',Path(temp)),patch.object(R,'authority',return_value={}):
+            with patch.object(R.subprocess,'run',return_value=SimpleNamespace(returncode=0)):
+                self.assertEqual(R.supervise('b'*64),0)
+            record=R.read(Path(temp)/'exit.json')
+            self.assertTrue(record['complete'] and record['final_exit_observed'])
+            self.assertFalse(record['learning_success_claimed'])
+
+    def test_failed_spawn_has_no_fabricated_exit(self):
+        with tempfile.TemporaryDirectory() as temp,patch.object(R,'CONTROL',Path(temp)),patch.object(R,'authority',return_value={}):
+            with patch.object(R.subprocess,'run',side_effect=OSError('fixture')):
+                self.assertEqual(R.supervise('b'*64),1)
+            record=R.read(Path(temp)/'exit.json')
+            self.assertIsNone(record['exit_code'])
+            self.assertFalse(record['complete'] or record['final_exit_observed'])
+
+if __name__=='__main__':unittest.main()

registry/conditioning-perf-prototype-20260930/00-M-comparison.json

@@ -0,0 +1,24 @@
+{
+  "fresh_E_seconds": 4.8041809019996435,
+  "fresh_V_seconds": 4.153049107000697,
+  "label": "M",
+  "original_fresh_validator_actual_exit": 0,
+  "position": 0,
+  "resident_E_seconds": 4.331270731003315,
+  "resident_V_seconds": 3.5904566640019766,
+  "update_comparison": {
+    "all_four_files_SHA_identical": true,
+    "arrays_bitwise_identical": true,
+    "full_update_receipt_and_trace_digests_identical": true
+  },
+  "validator_comparison": {
+    "all_scientific_fields_identical": true,
+    "explicit_differing_fields": [
+      "schema",
+      "validator_source",
+      "original_validator_source",
+      "resident_prototype",
+      "resident_cache_scope"
+    ]
+  }
+}

registry/conditioning-perf-prototype-20260930/01-N-comparison.json

@@ -0,0 +1,24 @@
+{
+  "fresh_E_seconds": 4.551296638994245,
+  "fresh_V_seconds": 3.902626559000055,
+  "label": "N",
+  "original_fresh_validator_actual_exit": 0,
+  "position": 1,
+  "resident_E_seconds": 2.678891448005743,
+  "resident_V_seconds": 2.062450468001771,
+  "update_comparison": {
+    "all_four_files_SHA_identical": true,
+    "arrays_bitwise_identical": true,
+    "full_update_receipt_and_trace_digests_identical": true
+  },
+  "validator_comparison": {
+    "all_scientific_fields_identical": true,
+    "explicit_differing_fields": [
+      "schema",
+      "validator_source",
+      "original_validator_source",
+      "resident_prototype",
+      "resident_cache_scope"
+    ]
+  }
+}

registry/conditioning-perf-prototype-20260930/02-M-comparison.json

@@ -0,0 +1,24 @@
+{
+  "fresh_E_seconds": 4.735514142004831,
+  "fresh_V_seconds": 4.103694833996997,
+  "label": "M",
+  "original_fresh_validator_actual_exit": 0,
+  "position": 2,
+  "resident_E_seconds": 2.857203049999953,
+  "resident_V_seconds": 2.14666489699448,
+  "update_comparison": {
+    "all_four_files_SHA_identical": true,
+    "arrays_bitwise_identical": true,
+    "full_update_receipt_and_trace_digests_identical": true
+  },
+  "validator_comparison": {
+    "all_scientific_fields_identical": true,
+    "explicit_differing_fields": [
+      "schema",
+      "validator_source",
+      "original_validator_source",
+      "resident_prototype",
+      "resident_cache_scope"
+    ]
+  }
+}

registry/conditioning-perf-prototype-20260930/03-N_D0-comparison.json

@@ -0,0 +1,24 @@
+{
+  "fresh_E_seconds": 4.5949991710003815,
+  "fresh_V_seconds": 3.924993649998214,
+  "label": "N_D0",
+  "original_fresh_validator_actual_exit": 0,
+  "position": 3,
+  "resident_E_seconds": 2.6922046239997144,
+  "resident_V_seconds": 1.9751014260036754,
+  "update_comparison": {
+    "all_four_files_SHA_identical": true,
+    "arrays_bitwise_identical": true,
+    "full_update_receipt_and_trace_digests_identical": true
+  },
+  "validator_comparison": {
+    "all_scientific_fields_identical": true,
+    "explicit_differing_fields": [
+      "schema",
+      "validator_source",
+      "original_validator_source",
+      "resident_prototype",
+      "resident_cache_scope"
+    ]
+  }
+}

registry/conditioning-perf-prototype-20260930/04-N_frozen-comparison.json

@@ -0,0 +1,24 @@
+{
+  "fresh_E_seconds": 4.620397169004718,
+  "fresh_V_seconds": 3.9045120619994123,
+  "label": "N_frozen",
+  "original_fresh_validator_actual_exit": 0,
+  "position": 4,
+  "resident_E_seconds": 2.7464958280033898,
+  "resident_V_seconds": 2.027457176001917,
+  "update_comparison": {
+    "all_four_files_SHA_identical": true,
+    "arrays_bitwise_identical": true,
+    "full_update_receipt_and_trace_digests_identical": true
+  },
+  "validator_comparison": {
+    "all_scientific_fields_identical": true,
+    "explicit_differing_fields": [
+      "schema",
+      "validator_source",
+      "original_validator_source",
+      "resident_prototype",
+      "resident_cache_scope"
+    ]
+  }
+}

registry/conditioning-perf-prototype-20260930/05-M_D0-comparison.json

@@ -0,0 +1,24 @@
+{
+  "fresh_E_seconds": 4.764637047999713,
+  "fresh_V_seconds": 4.06785895700159,
+  "label": "M_D0",
+  "original_fresh_validator_actual_exit": 0,
+  "position": 5,
+  "resident_E_seconds": 2.7973176640007296,
+  "resident_V_seconds": 2.0859955760024604,
+  "update_comparison": {
+    "all_four_files_SHA_identical": true,
+    "arrays_bitwise_identical": true,
+    "full_update_receipt_and_trace_digests_identical": true
+  },
+  "validator_comparison": {
+    "all_scientific_fields_identical": true,
+    "explicit_differing_fields": [
+      "schema",
+      "validator_source",
+      "original_validator_source",
+      "resident_prototype",
+      "resident_cache_scope"
+    ]
+  }
+}

registry/conditioning-perf-prototype-20260930/06-M-comparison.json

@@ -0,0 +1,24 @@
+{
+  "fresh_E_seconds": 4.7666301089993794,
+  "fresh_V_seconds": 4.0638777050044155,
+  "label": "M",
+  "original_fresh_validator_actual_exit": 0,
+  "position": 6,
+  "resident_E_seconds": 2.8035546359969885,
+  "resident_V_seconds": 2.0804165529989405,
+  "update_comparison": {
+    "all_four_files_SHA_identical": true,
+    "arrays_bitwise_identical": true,
+    "full_update_receipt_and_trace_digests_identical": true
+  },
+  "validator_comparison": {
+    "all_scientific_fields_identical": true,
+    "explicit_differing_fields": [
+      "schema",
+      "validator_source",
+      "original_validator_source",
+      "resident_prototype",
+      "resident_cache_scope"
+    ]
+  }
+}

registry/conditioning-perf-prototype-20260930/benchmark-plan.json

@@ -0,0 +1,308 @@
+{
+  "CPU_only": true,
+  "acceptance": "Exact four update files, bitwise delta, full trace/receipt identity, fresh original verifier exit0, separate resident verifier identity",
+  "authorities": {
+    "M": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/mechanical--fresh-parent.epoch.json",
+    "M_D0": "/tmp/malecns-cpu-residency-woqIQa/inputs/M_D0.authority.json",
+    "N": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/performance--natural-light-fresh.epoch.json",
+    "N_D0": "/tmp/malecns-cpu-residency-woqIQa/inputs/N_D0.authority.json",
+    "N_frozen": "/tmp/malecns-cpu-residency-woqIQa/inputs/N_frozen.authority.json"
+  },
+  "benchmark_scope": "CPU epoch postprocessing and verification only; excludes AP wrapper/ledger and all GPU/brain work",
+  "current_AR_untouched": true,
+  "derived_controls": "Only D=0/frozen command variants over fixed sealed events; not new brain runs",
+  "fixture_selection": "Two predeclared complete frozen AQ engineering fixtures; never AR interim results",
+  "input_sha256": {
+    "/data/digital-drosophila/datasets/male-cns-v1.0/processed/neuron-only/neuron-index/unified-metadata.parquet": "922af16846a065c3dbfca7c11146b83ca217fcbd7392edc745f444a04eae8c63",
+    "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json": "bde79d95ef0097b827d5faf4d5658eafc009d8e9fcef1fddd645c953823e3f64",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/apl_globals.npy": "8388c8795d49cfe5b14fda54f76ef3a35030c62ba87bd8ca6334a2dcdf186f19",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/input_matrix.npy": "c4d3df703ea5f1d7402b8255cfa19d9744139ad1048827c23b151d8ba766fec6",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/kc_globals.npy": "97a570aafa089f93e642b2bb07e3a3322dabb14c3c7dd431f0c8d2b3b7951fdd",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/output_matrix.npy": "e2d0a1ccd740e6777245ebf2efcd88bf5e1da9e47308c63ec8e83d451e134a73",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/dst.npy": "ce20f7433f78442c717ad2a7b5394cf4a3b109d990b4be0788040b7b0f4ed150",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/edge_id.npy": "49260615ff2b6432ce3dea9ce2c7ab8f83d06c2fb7491e58e08355fcedf86a30",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/nodes.npy": "5b511a98e8fbf8d65bbc70b93e75ecae19366f650b7842a45611bfad62ed83dc",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/ptr.npy": "fe43420f11e6242a11f8199ae7f097cab4b8a6db181d36f2a46b9e46670acbb4",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/signed_raw.npy": "f9884ccb8930b32420b27c69271df78034a8350fe5a5c9b76a63c259268efc09",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/src.npy": "bfd625ce690fc21eb0a8b9dede831688ab73b789045ba83ddf4baeefeddf1fc3",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/weights.npy": "462839ffc3feb8f6c278044488082b1c8e410e7f23229d6b5e29d1b7042416a1",
+    "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation/cases/seed_validation/seed_validation-physiological-00-s1073741825/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation/cases/seed_validation/seed_validation-physiological-00-s1073741825/spec.json": "ebffa677b41e06cb776a987a496a0577bdda135cf3c067ca8017b038ff3fc5c4",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/final-status.json": "18b12c832e156bd6e5ba950f48a49fb908c62104b91bb3e78213f523c8fdc8f9",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/scientific-summary.json": "03f229fc0768d38bb7c2a3c558dbd68c2c3a622cbf96b1b16aef2819b6b67b77",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/static25-complete.json": "1a9cfd096bfc7ab826e043d450a32403a1a7176ab1f7056a3afaceb5c33ac098",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/zero-complete.json": "59397f4b7874894049cc5e77d0555ddcc8274c9573bc53a4bc5f41429683166e",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/checksums.sha256": "fde235a6d781d4c860107c3aa94671811b3f39b167965034ed57f3278e012c3a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/adapter-provenance.json": "d1b64bdd7b8bc2023dba8321f74bf8ba0a9cac8ded772711f68efeeeb2297156",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-applied.float32.npy": "6228c9e8ec19cb7532e65728ec8f2bd6b080dca8379b17bd393979beaba4c6eb",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-component.json": "f94b360033b4cb643c9774e7fa31c95a65c5571ca62b73072ee29b3af80121f9",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-drive.float32.npy": "19b32ccdefea22ddc3e2efcc98b919b8fcf69887f029c17dc75bafa5b34259c5",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-inhibition.float32.npy": "d5194ea98900ca1800416712619143b731d9b3a5d1391180e6881205c7a4d663",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-pending-tail.float32.npy": "2dd2e0c79d4ee5299b8c1e8863e6c61b81f3dba08e599011887b1e1621f7c945",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-state.float32.npy": "5fe5ac53e012232b42a7e717357e9782b247f74da93640a0cfb8a078bc9d4855",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-timing-audit.json": "6ceacfab219fc40146c3e753bdaa96a9e678762f1aeeec04fa303cbf9ebc09be",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/comparison.json": "becda112d4f7576318e2a825daf8f049eb3916c964252511963779899228974c",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/output-hashes.json": "74748bb4cde4769caa31ecc7c888e9e6192fffc022deee94e4378573d0dbc9cc",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/overlay-audit.json": "949d7f986ae2212d44777bd351b88e54c38db857fc062d4d232c2670d31e3085",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/overlay-input.npz": "7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/overlay-manifest.json": "96d8406b69e98ba9829a52788c6c96888493e8bf34581d6d653226b1eb2e494b",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/queue.jsonl": "3e93bbae67a18944383b2b11a63708ee31e18b8ae7084f24dcb24045c85aa9a7",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/requests.csv": "b11fb0b6d1ac9211f02f05a9809175c64b72e8bcd4c4e4da31be1efbe6a82a83",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/sealed-gpu-source.diff": "0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/source-audit.json": "d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/state.npz": "7de2f62ecbde41a11db5aa220aed2fa6128e9fb6e65d04357f5373eb21538f81",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/summary.json": "6f6fb3ffc5f9df761a7972aa97444c7c095edb359580d19103044fa54bce674f",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/tick-state-hashes.jsonl": "3428c112a32024b539218aa6f4778cfa8c19c208bbdbfb2567324294370f23ea",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/adapter-provenance.json": "46d8ad74b409145c42f9066f992166f114cef2272bb0c6ea40c58438bdd39c13",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-applied.float32.npy": "b3a535bc095db2464a75560ed11f336a9db8e843c08fd7681a1b9759b624ad8e",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-component.json": "f94b360033b4cb643c9774e7fa31c95a65c5571ca62b73072ee29b3af80121f9",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-drive.float32.npy": "8b6432e8947f4c67466b5cae28cb0d0877b61862e80e6d9b10c5734d9afa8411",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-inhibition.float32.npy": "8f9e59026dc7c7663abf8f7abc60ebf93b11a68483bc0960d375a83731acc859",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-pending-tail.float32.npy": "fc1e2d8ffa426d4118a7544129323c5f7523e9df3e298a60922ca0ecabe7c18f",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-state.float32.npy": "36ecfec747be0c700959ba1ac171b81a1f3471aa9baba41b7bb6a67be01213c2",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-timing-audit.json": "850600c0560f98c1f2de35bae506c5619205375e6616137a7e8ff978000b0c3a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/comparison.json": "3e55e8edaf7e3cf4453e37cf90d7a420808977665174ccf525dfef7553418d46",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/output-hashes.json": "aabd9f46a9697440f0cc0204455e831d16b7aadfdebe3e5a8c986bfe85d05300",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/overlay-audit.json": "22d13f7d6ad27cbe117e01117d46c0457781adf3a0bf2aa6748fe7f4b484aa56",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/overlay-input.npz": "0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/overlay-manifest.json": "902933628aabc9e084b547dfdaff0f8361d353949ba3ee92439a2f35d8625d8a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/queue.jsonl": "22fbf106279d5ad314beba357137701df111bb28b57accdb09a0e299dfdf39cf",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/requests.csv": "4bcc9ef7fdc596ddac3be3b0d29f0aea2e086deeb803f3a90baba21b5490ef53",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/sealed-gpu-source.diff": "0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/source-audit.json": "d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/state.npz": "933afdc1bd0ea81174aeb334f017cfbe1bbc0a72f8eca767698275c5dca886f3",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/summary.json": "244be6a69b8276a212b1601ab7235e58c0bd9d523c88368025b29f4b4664ddcf",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/tick-state-hashes.jsonl": "0266afe78eadd1ea5bfb25026103d01d2af82d9b6ce2bcbb9d60e576ac898e91",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/manifest.json": "9e24b682935a9b18e05db7a933080c5f63ddbeb8a0c85cc0df1cfe1d06d88ab4",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/static25.json": "96d8406b69e98ba9829a52788c6c96888493e8bf34581d6d653226b1eb2e494b",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/static25.npz": "7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/zero.json": "902933628aabc9e084b547dfdaff0f8361d353949ba3ee92439a2f35d8625d8a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/zero.npz": "0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/base-candidate.float32-mV.npy": "1218d1b328f29a7afefb0ca0b7b6421247f14ad598aa1957a6a7aacbc8cebcae",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/prepared-hashes.json": "4af0bccbb9153be0d8cb65c5e4150946be3396ca351eab52b273c86459200580",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/preregistered.json": "465886b78ada08092c2c83de278844707499718977fb6dc6a7608391da0e5304",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/regression/frozen-five.json": "905c64c8b3f7de942d55f6ecb76c27c42821691a9fd3e0c17ffb466e1de0fea0",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/regression/old-integrity-after.json": "7d3de4ba6248cc52960087bcfa2658f9b8ee34d9ac08c56380f7018c34097929",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/regression/old-integrity-before.json": "7d3de4ba6248cc52960087bcfa2658f9b8ee34d9ac08c56380f7018c34097929",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s00/template-spec.json": "065e4b01b74ac6619f6533c54fdb58a345fffe7be30ae2295e50ab7015da888a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s01/template-spec.json": "38001935f07393a08f8c83595541a6ff060b0f9ca7b9fdaf357e2f77f9348994",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s02/template-spec.json": "c89d7994d40fc79591c78d11c549766b45d283145fdcebb1e3b6c964b8750b2a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s03/template-spec.json": "390f3d472a2baf3b7d14f1bb22185e027fb1c5ede8f42bfbd8e7c2051e78d0fe",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s04/template-spec.json": "90a262080e33a6014679e7f3d932f61e1edb04cffcd9a2cf35440c078a9085f4",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s00/template-spec.json": "3b63e236d755714dc59b083b2ee48761ce48e9a8456770e3502798f5bd5e2ff6",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s01/template-spec.json": "595a1a67fd82b48e0db25480771a93bd289e8f65c511c43780b42dabf9c8b478",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s02/template-spec.json": "bda9afb21aebd4cf37d52a0cb83c21f179ca4fe9aca8a43e5a1cc92f2af81897",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s03/template-spec.json": "246cbb287972c7539c4f53bc2546bd9cdd0dd960e8714bce060db1bee1ba0fc9",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s04/template-spec.json": "de59abaa0670a9be8d90a9dd9b41522edd277d9f75dbdb77ddeeeca1c508265f",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r0/template-spec.json": "802b717691f9a6b460a1a58044286e727ffa8393605127ee7a11ad267fbf6338",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r1/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r1/template-spec.json": "f4cdfd5de0fb80dd39203425c4ff7d063b0b66f2ac887e4276043251e3ad956c",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--reference-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--reference-r0/template-spec.json": "2ee541997a8a82f9ac356e9fedf8fc70ce31f622d42d846ab6de8c5f6cdea39f",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0018/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0018/template-spec.json": "282eccfb1ee2008f0b9ae8cca4daf45bfefd664806e7d04b8712fadf90b83bb5",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0019/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0019/template-spec.json": "8cd7512a1b2cdef47aecfd26bfb7ee8b22b566dc6c6812e887b4cc3f5416e7e3",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0500/requests.npz": "aa2773a740b0e85940f3d96738a141903d5d178e40586522b603ae1c9de53e98",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0500/template-spec.json": "654043502385a40dc4396c25ab2bf6f74701a7026fc85e6789672a810e5f700e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s00/template-spec.json": "e8f6fe8e0f67cbe851c045a067485d753979f5af32d30f596f545387b306f123",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s01/template-spec.json": "b727d54f9d28e9b8482860c3ed2bb6c30d4778fe90644b2df9ebb8d0c032e148",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s02/template-spec.json": "8af5bc5ed35084f15c7d77ded8224d49f49561d48510c862410eccd4d7dc5560",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s03/template-spec.json": "7e140b41ae610cd67a8cfe2e30d633190ac2c7689a4682bba676e423b54e689d",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s04/template-spec.json": "5cc7905cdca67bdf09eb0730a274644f5605178b1c97928572c5ecf2a3b5acff",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s00/template-spec.json": "452da911a5f3d6d8cbd33e96451d6f65af5e46eee57fda00125c59f6378dfba6",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s01/template-spec.json": "b943e29941af75b7c4ff333bdc0a9697d0e15131bdea46c4460ef91f894565b2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s02/template-spec.json": "412390b67001e08930f243f54954d78e7edf94b330aee2087c35748963a883db",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s03/template-spec.json": "6d5f2819be44646890cdad1969043bee5209e801b79687a8c1c2205601bc9656",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s04/template-spec.json": "d8bd2b1b151582ec7495e59a15cae15279f71d444429c5c273397b63008b3440",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r0/template-spec.json": "df1a6663ea748b0dc0333540877000e5c91d493b151e134e346dee54e834e3de",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r1/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r1/template-spec.json": "32dce4105aaadac4f7079264cf0a30a3f8171862edf59cceaba6624f01a5252d",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--reference-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--reference-r0/template-spec.json": "a0bf214d782ddef0adb5b6f9b89c2d52566a5928b5d96316bddfe12520aa5460",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0018/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0018/template-spec.json": "8400934e175d3c20f19d863082e7df02c5279864b5191736565e9014df6e0e83",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0019/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0019/template-spec.json": "9c361dfb9af4dd7071a7f1c3c2315adddb21b42e9ed5e9a199b1cdf52fab40e7",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0500/requests.npz": "aa2773a740b0e85940f3d96738a141903d5d178e40586522b603ae1c9de53e98",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0500/template-spec.json": "bda640a599d6cdf80ad435f344fcd576d91ca0afe9de732f36fa7bd54d470c1e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/overlays/static25.json": "b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/overlays/zero.json": "11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/AM-gate-authority.json": "66257eb665808e33005dd7ba14a16063064618cc48e47cb65b70f3900cec2484",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/AM-seal-verification.json": "175b5d0e2de12a9ce01c6167591dab882d9c9c6869de2d194bcd9e6732c6ed6d",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/ENGINEERING_GATE_DRAFT.md": "1ac0d65b906e1061781c967cc6a99e8a0a73df6a1ee564ed6603f88e3f5d7056",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_analysis.py": "3970d13bd43d4bc12baf4b6ad1cda3eb085e10bf4648752cfcecb6d12314c5ea",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_compare.py": "5a2403f11bc08d65a9d242ac2cf9686b850e0c3680d65659f785e9b6b50c0238",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_inputs.py": "cc8c0e83016af4836c81cd0773fc521c69fd30e6f4d021bf54d0e7897105c6d5",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_plan.py": "3c127aee723a054fda272fee458067608b521a7c443455822d97f509caded6c7",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_prepare.py": "62dedce2439407398e70beb4c718bf14e02d3e624b3db3ef6f74299115d84bc1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_queue_audit.py": "6ddaec52f2a0b5d0c528d51230d372fe2344160aef5eccea6a95b6c5e61a574e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_scopes.py": "1043ba217e5395c9e81e58b95a5aa396f572588872b954e549774f2b99cac5df",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_workflow.py": "76313332b8d18f121a61f7b6e2fc32ea9e893848e8ed5d049557fc08b385e674",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/runtime_continuation.py": "0b8e8e0a6a23a079dc62a88355ce355d53b3ae22f6665519a8f6aef2dcfc5aba",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/runtime_light.py": "522b8c31ea938890fe15364fccd25ccc5bded54101754909f255532e7ad01aae",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_analysis.py": "35e4ee37a1e82cf5e645d24165343049d400104c94a6d184b8aa834ba5ef2d20",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_compare.py": "87a85843d918cce6529ab94f7cb82499aa413281e803c00c030a3c340a581469",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_inputs.py": "4dcc7b775eb3c7e59ed9cc3d7591eacc0ef7bda1209edbd847e2ae79b115ef1b",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_plan.py": "c26c2c75bb27d3b8514b7d44f40369130d60147c6c8edc569b4efba4a4ad9815",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_prepare.py": "a12aa1d2cb4880a3f7a7889b89d71a859bc8c68b4badfb8f082d712cdd342627",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_queue_audit.py": "0e2bcfe25c3b5a5cd0ed5cd05a89392207191ec4db950cdb06a0137666c8adb7",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_scopes.py": "748c0777e4a8164e80c03c727df1c2decbac7747737ad1c9fb730ea5c9e208d3",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_workflow.py": "bb781b23f92b5c0eb92f8dbc54468a8e843177f6da004c444b48947b037bd705",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_runtime_continuation.py": "325c0b688d0ca1648ffdf29a8d3d4bb91d6f6115bea6f5ac30982acd6dfe8e06",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_runtime_light.py": "887345e497e6fa9c10ffa49c490196711d8cee028c62ec7a73f42db36569be2b",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/regression/old-integrity-before.json": "68475cc0e72039e044c8fb3aaea9c8487c6737c1b8a457641e818581d81c387c",
+    "/data/digital-drosophila/experiments/phase4ao-conditioning-interface/inputs/static/candidate-map.npz": "29dcb57fcaefb5817fa4616b9a75285327b41d8a67cfc0f2ad2bacc14e41f2f0",
+    "/data/digital-drosophila/experiments/phase4ap-conditioning-interface-v2/updates/D1--reference--epoch-000/delta-after.npz": "b89e407a5d93b5f1901f901b00428dc19bd20cee2d81e57b117a2fa68d200a48",
+    "/data/digital-drosophila/experiments/phase4ap-conditioning-interface-v2/updates/D1--reference--epoch-000/overlay-manifest.json": "38dabc55ea0569843ee70f13cf570832ecaa8f1ee7f26a7420e7ebc3ea86f6bd",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/mechanical--fresh-parent.epoch.json": "4616a42c255ab839346368aa0e5e4306bb3878e55fcc95b176f058b1993c9b0c",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/performance--natural-light-fresh.epoch.json": "785e3d26d06b47efe7f054883d38fe2e13711195359bf9f4b03aa88887fbfb37",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/cases/mechanical--fresh-parent/requests.npz": "edabb35c72f41a72cad5965ba0a6789b56c9a4ce38b25d6c6a2811ec3981066b",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/cases/mechanical--fresh-parent/spec.json": "82d95a9d4f2933986ec30a02cb0a3e1c1b50a0d4eab47068ac1cde169986e57d",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/cases/performance--natural-light-fresh/requests.npz": "571d09c32cabd45af79f71f0f27f7adcc38b9c65daf5ca124366ea439e088143",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/cases/performance--natural-light-fresh/spec.json": "ea4c40897aceb26edfa5db934647fbc6f6946746441f843bc336f15e5d4e0a23",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/manifest.json": "2dc0feca75f718f2ee0d7c9240da503221823573fd25f1344d2fd97d97eb2db7",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/apl-applied.float32.npy": "017d0cd13616ce97ee46aec1cd0a80153e15d1a56cdbad19020b57db64a1281b",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/apl-component.json": "7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/apl-drive.float32.npy": "09140f1cdb91af98894ff5592d5d346af82f2d82564150c46b10dfe5dd253cf5",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/apl-inhibition.float32.npy": "05b289e2d464765764cc8500bbb3c021fd87ce31124b4996c7290dd5ef6df90e",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/apl-pending-tail.float32.npy": "f988ec0eac0043a911c2489d5cd9f2ca08a5089dc3c8fdcea148b44b045a2f73",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/apl-state.float32.npy": "09140f1cdb91af98894ff5592d5d346af82f2d82564150c46b10dfe5dd253cf5",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/apl-timing-audit.json": "54507570ba3b668c0362c26858e2a426c258bbf763c06570c9ecdc531b53848c",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/checkpoint-manifest.json": "8814431d9e1afbf431affbe77c7e4402d43b5ece3063cd47696cb77249a295f5",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/finite-audit.json": "a230387da908449ff29f1acf53f3157ec4dee893208f32a424260d75924ad620",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/overlay-audit.json": "bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/overlay-input.npz": "0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/overlay-manifest.json": "11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/queue.jsonl": "b9042219ea87c5bc89f53fc5710fa86a848de456088257182a20da33460bb05d",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/requests.csv": "c5ffaae03d4390faf7d7bb15dee8b5ce573c20538137ecb3464c652411400342",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/runtime-provenance.json": "3726d29c81de9823dc75ee676f1c17fcc2a649ae2d033fe45cb8f4ca6e5eeac7",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/sealed-gpu-source.diff": "0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/source-audit.json": "d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/state.npz": "de5740758c280d250714be96d0598dadf78434ae4b915ff3b6646bbd5219b201",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/summary.json": "c53d4dfc2befa3ed4dba5b6b93f2bea6de3a9fea3ae51371bd5a17576d315cc8",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/terminal-queues.npz": "c4cf2ea1e4c04ca06a85e830976fc5348e4723aea84751442bee12e3bef95ab2",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/tick-state-hashes.jsonl": "eea659b000781f96e89c2687a5ec4957d106b589cc20dfa8e6228f35697e6691",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/apl-component.json": "7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/apl-pending-tail.float32.npy": "d26056012aaebe26ee9acdb2ee0ac226fa5496d87fe33c4378cc9359a0c5d5c8",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/apl-timing-audit.json": "92812c9cb2a35d53034799317a94c4d1f369968d378fe7806ba4b6d9c667e5ca",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/checkpoint-manifest.json": "5cec0f224be49493af884e969cb97d47ac3e000da88c6d0ac8d1b23e3025db8a",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/finite-audit.json": "5f0182167c4c628ec8fd6354a2fecde3dc99282894397aba155e7cb7e1fbce40",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/overlay-audit.json": "cfa98093495747b091d9863c5de8b30571ae4d9579771ed4a42b9fda72d2f912",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/overlay-input.npz": "b89e407a5d93b5f1901f901b00428dc19bd20cee2d81e57b117a2fa68d200a48",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/overlay-manifest.json": "38dabc55ea0569843ee70f13cf570832ecaa8f1ee7f26a7420e7ebc3ea86f6bd",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/requests.csv": "f448e63324feba55899e634b1ef79b89c80cb8842b1d2e38b74a198cb9af36f8",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/runtime-provenance.json": "164e4825ba0fb1aa02de73ad5bf7b0d7e28ece6180d77e0cae72c64826c483ea",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/sealed-gpu-source.diff": "0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/source-audit.json": "d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/state.npz": "137d5a73a869f27df8a3f97002ca6a683c80d3d715057759fb2aad64a05d37ff",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/summary.json": "6eaec94ddc0032e93a2e7d5bac4083ba05aa39e892b76b82c46cddd4d7f87759",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/terminal-queues.npz": "42dbeaa6f50c6d5e7492774393a2fcc8af775b682dd517a53535f6d7cd162c2c",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/updates/mechanical--fresh-parent/chain-receipt.json": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/updates/mechanical--fresh-parent/delta-after.npz": "35b55ff715e797221163e812e4128a700eb05a4546d7f3f13dc5edc547aeb8e6",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/updates/mechanical--fresh-parent/overlay-manifest.json": "60f77f30609859a718db1004e6da1c23730736285c5a1d845ec0da97385b01be",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/updates/mechanical--fresh-parent/update-receipt.json": "d26c0fec7b1fcd8bbb5f7fb86b094c0870f1f0a4b29be1b3def77b66b6a3cbb5",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/updates/performance--natural-light-fresh/chain-receipt.json": "c4a45ddcfea6b1800ccb6f737733b7e13b726e54e8f10e145ac6787527fffd9e",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/updates/performance--natural-light-fresh/delta-after.npz": "af15c05aa9ce0fdcd2b47dcc8bef426a242f84efe7b45e79c345ff4d361d23b4",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/updates/performance--natural-light-fresh/overlay-manifest.json": "a98095968f62fe7375e5acab89dbfbf55de6a28760f93dc1f5b48f238a4c54c5",
+    "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/updates/performance--natural-light-fresh/update-receipt.json": "18c47fc5fceb4f1b52d601ed5114eec8239156677c44bfe364706a7e7d2fc972",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/mappings/dan-to-compartment.parquet": "a16f72c3121ed0ec638c1a2b249ace446e6ccee020b49679818eb42589d00662",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/mappings/dan-to-mbon-confirmed.parquet": "730d000f25667b59181d2ee6703c64591229a8beab0856197ed71e68d799d191",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/mappings/mbon-to-compartment.parquet": "54f371f7e35b9def44becd1ba9bd2872861f4876b255b2c8ec46feee6473b70c",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/plastic-mask/plastic-edge-candidates.parquet": "e5075ee3e5a0edf3a4d197453847163cc295b254f21c67203159bba204b12a76",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/plastic-mask/plastic-edge-ids.int64.npy": "8b0fb6eb2e6c31da4d17dc20d890aa3f367e514f05642de5bad6b42a1611c05b",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/odor-encoder/frozen-odor-panel.parquet": "907f16a56e024a8e2112b5751e53b0e6037b329fa110098af3d31b119c10a1a0",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/odor-encoder/mapped-glomerular-vectors.npz": "f057563152e0fa22060080af13019f319e7f36563a775eff829bbc1929c451b0",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/odor-encoder/selection.json": "1b832becf9d08935716fe9ba5e3cd3e619e7d208dfb43c4fa197c969d095f113",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/receptor-mapping/olfactory-mapping.parquet": "a01d27000533e9844458a4c559cac084f1c34ca20a1104e97e6a0f72b0cc93b1",
+    "/data/digital-drosophila/models/male-cns-lif/apl-timing-lab-v1/gpu_timing.py": "af1975ba5e5e700208c0a598d3cbe648a3cf10885c6231239b6e4b28f76d173b",
+    "/data/digital-drosophila/models/male-cns-lif/apl-timing-lab-v1/timing_queue.py": "54df6d4818e2a0c26e96fb0aaf5d9b71cd964981706da937562d48af79aca14e",
+    "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/gpu_apl.py": "69f5d893f47dafff4ef7c3186c3df0b9014666b32c8f4e943b57016bec92b18a",
+    "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py": "21ceec65fe42581dc55872010e0025d660e80358905f1cf4df1dadf341a3b291",
+    "/data/digital-drosophila/models/male-cns-lif/author-fullgraph-lab-v1/oracle_full.py": "d72003d98f0f1624b12126eff50bd361c43d888f4a64d90ba9247a58976f1961",
+    "/data/digital-drosophila/models/male-cns-lif/author-runtime-lab-v1/author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15",
+    "/data/digital-drosophila/models/male-cns-lif/author-runtime-lab-v1/author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e",
+    "/data/digital-drosophila/models/male-cns-lif/author-runtime-lab-v1/gpu_backend.py": "03758d07572f4b44d272059d9308fac534268ad201b57bdd77d69fee95e67278",
+    "/data/digital-drosophila/models/male-cns-lif/conditioning-execution-v1/validate_update_cpu.py": "44e95eca9e39e9cd25a1d5d2d46b2cea76e839143865a196f865a61fac700b9f",
+    "/data/digital-drosophila/models/male-cns-lif/mb-physiology-v1/phase4j.py": "abb4574da85f00bd9ef61024c65993ef81d42651ff8d8d63c15dd69c6222471e",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/EVALUATION_POLICY_DRAFT.md": "a84170a61564715a1532f20df4c6a330f0f9725c383db48b8f3e1a4b5fba0bc8",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/EVIDENCE_DRAFT.md": "8455c12e3a6bb1b22a6e38f9017293fe5deea37ba3ec61e13598d00dafc12296",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/PROTOCOL_DRAFT.md": "8ebecb1f3d012ddc29a1cb727269dd277629c53565e09978bf9dbf7140cb8508",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/README_DRAFT.md": "50be97f64097b681355993a8afd7f467ea187e99e88b19ca30561e08d517999f",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/biological_contract.py": "e09f0f2b5e6ec746176e3a1aa2fdee1a15385e14e96bd343d14379a759f3ae43",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/conditioning_epoch.py": "757935a4815d9f625640df685184ed3fe44a8845323562796da7aa43cbb194e1",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/conditioning_inputs.py": "19382e066e450140bb653a3661f980ffe7cc62f412020ef57df0b6e6b3cbb8ba",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/conditioning_update.py": "96efff678cff910654eb08e86f1a17789e4e5589e340345f419c7027a7d547e2",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/draft-source-inventory.json": "2c72d47d09b4ad1949dc6cfdc170f64847ff75f95ded5d20b421fb5a75e0eb84",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/evaluation_plan.py": "991c813ff3322b230947f302b12b04ec382c3b632817f94b698101e4b17efa7d",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/evaluation_policy.py": "21331a9ff3567dc6f6399e16bb91ef486d74231f5db51799beb6dd1bf71d022b",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/metrics.py": "47319e21db3c8b030b1bafbf0703cd86fb588d23bb29436accbacdba73d08c3c",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/runtime_continuation.py": "0b8e8e0a6a23a079dc62a88355ce355d53b3ae22f6665519a8f6aef2dcfc5aba",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/runtime_light.py": "522b8c31ea938890fe15364fccd25ccc5bded54101754909f255532e7ad01aae",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/seed_registry.py": "0da033b132095ec3087b5d9f64e53c2e391fa50ab0b7653b31296eeb84799b7e",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_biological_contract.py": "0ce796e6ad1a4cbcb9bcb760eff628a9562b4a809cc9c177a9a0d88df68f02b3",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_conditioning_inputs.py": "95e37c770e78ce722a3007c5b371c51aec2989634cddfe5b414ac3fa817e5c22",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_conditioning_update.py": "1c25d93753932ace06abc876fe0867546b3bb330de3e602da6aec7bb4588e4bd",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_evaluation_plan.py": "21d2402025122d8665fb1f32e184fd8e30fc17242810fc70901b7f7fc8c53bfa",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_evaluation_policy.py": "421a31b76eaa547e890c291d2c38a415352d9ccad6fccc800461f522ff4c83f1",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_metrics.py": "1928894d248dd37fad0fc67bc9dcfeac27c4d8be4aec22f54b9ef20a10ea8645",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_seed_registry.py": "7aca38f3c975e3ad4f6337d83b826c09afef336381d124c22ff0eb2eb60a0834",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_trial_plan.py": "927678956ae9959a047b1cd258ee8dee22eb6842a96ff4b2ba2db077310163c9",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/trial_plan.py": "6fed3f494d075339a7e5b001d43b2598640b189e038952fbd4d41200bacac587",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-grounding-v1/phase4l.yaml": "9b8bcb7e031bf9063033a1854a439a7cd0bf6730301c2d2d02ca99a76f098d6e",
+    "/data/digital-drosophila/models/male-cns-lif/phase4l.py": "e97d58d8c1f44920d0e953f8f5831ddc86fa0198784e86460e315de4116ac553",
+    "/data/digital-drosophila/models/male-cns-lif/pn-recruitment-audit-v1/publication.py": "7a79c499098b74163e7bb16adabcbc54e7069dafa204d0b99c7f4c03d79f8016",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/checksums.sha256": "493f541756064d9d65603e550628656a6f2dbf44f8b862ef905e8c3fd2427a43",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/config.json": "c19f00c81f12c4c3503d3d557bd73d0722d4d3fed7279449408c67a89a6ffcf9",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/context.py": "0fa2e0892c973fe70ecbc0613e3cb508c256b7745042f8936edf23dedc31d166",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/eligibility_bridge.py": "174fb8d14619189e74b095e77a6db18b14c93046dc431c0b55710a5aa2dd2e61",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/manifest.json": "7edeb251ecbeac5a64805fefe171a0a0bf8bba2675919ef922cc1a329c203ea8",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/overlay.py": "7f891d0ba79b393c96e75fd2dee2eddc51e57d8213eaac2779703bc2c18712b4",
+    "/tmp/malecns-cpu-residency-woqIQa/inputs/M_D0.authority.json": "56d89454417c4c7d8e4dd1dc3437ad0df55ded706b9e603681bbf491338cbf04",
+    "/tmp/malecns-cpu-residency-woqIQa/inputs/N_D0.authority.json": "4a7ee78ca0671efa0cb5203f7ba405ae3a53b3e23ebfcb8bf52887ce20c0f40b",
+    "/tmp/malecns-cpu-residency-woqIQa/inputs/N_frozen.authority.json": "3063f74a5dbbfb6afa92ee7692bbb0626017b0451072b838be2f9e0bc58748e3"
+  },
+  "max_wall_seconds": 900,
+  "no_automatic_retry": true,
+  "no_brain_execution": true,
+  "no_weight_installation": true,
+  "output_root": "/tmp/malecns-cpu-residency-woqIQa",
+  "prototype_sources": {
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py": "a51e9140e5ddb50211dbeb313d0d546fa583daadecb767c289760f3f4896c2ac",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/resident_validator.py": "dfcea2f1406badc3122c2529e6b905a74e7cdf4e450f86fd82d22a7cb70e5ff7",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/test_perf_probe.py": "d0e24a2dddafd2e96ae57dd4bb71d66809c31099846b9337d9e8e4f30c259f0d"
+  },
+  "schema": "conditioning-cpu-residency-probe-v1",
+  "sequence": [
+    "M",
+    "N",
+    "M",
+    "N_D0",
+    "N_frozen",
+    "M_D0",
+    "M"
+  ],
+  "threads": 1
+}

registry/conditioning-perf-prototype-20260930/inputs/M_D0.authority.json

@@ -0,0 +1,292 @@
+{
+  "checkpoint_dir": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent",
+  "checkpoint_manifest_sha256": "8814431d9e1afbf431affbe77c7e4402d43b5ece3063cd47696cb77249a295f5",
+  "command": {
+    "compartment": "y5B'2a",
+    "d_command": 0.0,
+    "frozen": false,
+    "steps": 1200,
+    "trace_backend": "torch",
+    "us_tick": 1199
+  },
+  "diagnostic_mode": "reference",
+  "epoch_id": "engineering-residency-control-M_D0",
+  "files": {
+    "am_overlay_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/overlay.py",
+      "sha256": "7f891d0ba79b393c96e75fd2dee2eddc51e57d8213eaac2779703bc2c18712b4"
+    },
+    "base_candidate": {
+      "path": "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/base-candidate.float32-mV.npy",
+      "sha256": "1218d1b328f29a7afefb0ca0b7b6421247f14ad598aa1957a6a7aacbc8cebcae"
+    },
+    "candidate_map": {
+      "path": "/data/digital-drosophila/experiments/phase4ao-conditioning-interface/inputs/static/candidate-map.npz",
+      "sha256": "29dcb57fcaefb5817fa4616b9a75285327b41d8a67cfc0f2ad2bacc14e41f2f0"
+    },
+    "canonical_kc": {
+      "path": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/kc_globals.npy",
+      "sha256": "97a570aafa089f93e642b2bb07e3a3322dabb14c3c7dd431f0c8d2b3b7951fdd"
+    },
+    "conditioning_update_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/conditioning_update.py",
+      "sha256": "96efff678cff910654eb08e86f1a17789e4e5589e340345f419c7027a7d547e2"
+    },
+    "eligibility_bridge_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/eligibility_bridge.py",
+      "sha256": "174fb8d14619189e74b095e77a6db18b14c93046dc431c0b55710a5aa2dd2e61"
+    },
+    "kc": {
+      "path": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/kc_globals.npy",
+      "sha256": "97a570aafa089f93e642b2bb07e3a3322dabb14c3c7dd431f0c8d2b3b7951fdd"
+    },
+    "mask": {
+      "path": "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/plastic-mask/plastic-edge-ids.int64.npy",
+      "sha256": "8b0fb6eb2e6c31da4d17dc20d890aa3f367e514f05642de5bad6b42a1611c05b"
+    },
+    "overlay_before": {
+      "path": "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/zero.npz",
+      "sha256": "0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5"
+    },
+    "overlay_manifest_before": {
+      "path": "/data/digital-drosophila/experiments/phase4an-engineering-validation/overlays/zero.json",
+      "sha256": "11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2"
+    },
+    "phase4j_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/mb-physiology-v1/phase4j.py",
+      "sha256": "abb4574da85f00bd9ef61024c65993ef81d42651ff8d8d63c15dd69c6222471e"
+    },
+    "requests": {
+      "path": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/cases/mechanical--fresh-parent/requests.npz",
+      "sha256": "edabb35c72f41a72cad5965ba0a6789b56c9a4ce38b25d6c6a2811ec3981066b"
+    },
+    "runtime_continuation_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/runtime_continuation.py",
+      "sha256": "0b8e8e0a6a23a079dc62a88355ce355d53b3ae22f6665519a8f6aef2dcfc5aba"
+    },
+    "runtime_light_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/runtime_light.py",
+      "sha256": "522b8c31ea938890fe15364fccd25ccc5bded54101754909f255532e7ad01aae"
+    },
+    "spec": {
+      "path": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/cases/mechanical--fresh-parent/spec.json",
+      "sha256": "82d95a9d4f2933986ec30a02cb0a3e1c1b50a0d4eab47068ac1cde169986e57d"
+    },
+    "state": {
+      "path": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/mechanical--fresh-parent/state.npz",
+      "sha256": "de5740758c280d250714be96d0598dadf78434ae4b915ff3b6646bbd5219b201"
+    }
+  },
+  "frozen_inputs": {
+    "/data/digital-drosophila/datasets/male-cns-v1.0/processed/neuron-only/neuron-index/unified-metadata.parquet": "922af16846a065c3dbfca7c11146b83ca217fcbd7392edc745f444a04eae8c63",
+    "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json": "bde79d95ef0097b827d5faf4d5658eafc009d8e9fcef1fddd645c953823e3f64",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/apl_globals.npy": "8388c8795d49cfe5b14fda54f76ef3a35030c62ba87bd8ca6334a2dcdf186f19",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/input_matrix.npy": "c4d3df703ea5f1d7402b8255cfa19d9744139ad1048827c23b151d8ba766fec6",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/kc_globals.npy": "97a570aafa089f93e642b2bb07e3a3322dabb14c3c7dd431f0c8d2b3b7951fdd",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/output_matrix.npy": "e2d0a1ccd740e6777245ebf2efcd88bf5e1da9e47308c63ec8e83d451e134a73",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/dst.npy": "ce20f7433f78442c717ad2a7b5394cf4a3b109d990b4be0788040b7b0f4ed150",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/edge_id.npy": "49260615ff2b6432ce3dea9ce2c7ab8f83d06c2fb7491e58e08355fcedf86a30",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/nodes.npy": "5b511a98e8fbf8d65bbc70b93e75ecae19366f650b7842a45611bfad62ed83dc",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/ptr.npy": "fe43420f11e6242a11f8199ae7f097cab4b8a6db181d36f2a46b9e46670acbb4",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/signed_raw.npy": "f9884ccb8930b32420b27c69271df78034a8350fe5a5c9b76a63c259268efc09",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/src.npy": "bfd625ce690fc21eb0a8b9dede831688ab73b789045ba83ddf4baeefeddf1fc3",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/weights.npy": "462839ffc3feb8f6c278044488082b1c8e410e7f23229d6b5e29d1b7042416a1",
+    "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation/cases/seed_validation/seed_validation-physiological-00-s1073741825/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation/cases/seed_validation/seed_validation-physiological-00-s1073741825/spec.json": "ebffa677b41e06cb776a987a496a0577bdda135cf3c067ca8017b038ff3fc5c4",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/final-status.json": "18b12c832e156bd6e5ba950f48a49fb908c62104b91bb3e78213f523c8fdc8f9",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/scientific-summary.json": "03f229fc0768d38bb7c2a3c558dbd68c2c3a622cbf96b1b16aef2819b6b67b77",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/static25-complete.json": "1a9cfd096bfc7ab826e043d450a32403a1a7176ab1f7056a3afaceb5c33ac098",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/zero-complete.json": "59397f4b7874894049cc5e77d0555ddcc8274c9573bc53a4bc5f41429683166e",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/checksums.sha256": "fde235a6d781d4c860107c3aa94671811b3f39b167965034ed57f3278e012c3a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/adapter-provenance.json": "d1b64bdd7b8bc2023dba8321f74bf8ba0a9cac8ded772711f68efeeeb2297156",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-applied.float32.npy": "6228c9e8ec19cb7532e65728ec8f2bd6b080dca8379b17bd393979beaba4c6eb",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-component.json": "f94b360033b4cb643c9774e7fa31c95a65c5571ca62b73072ee29b3af80121f9",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-drive.float32.npy": "19b32ccdefea22ddc3e2efcc98b919b8fcf69887f029c17dc75bafa5b34259c5",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-inhibition.float32.npy": "d5194ea98900ca1800416712619143b731d9b3a5d1391180e6881205c7a4d663",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-pending-tail.float32.npy": "2dd2e0c79d4ee5299b8c1e8863e6c61b81f3dba08e599011887b1e1621f7c945",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-state.float32.npy": "5fe5ac53e012232b42a7e717357e9782b247f74da93640a0cfb8a078bc9d4855",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-timing-audit.json": "6ceacfab219fc40146c3e753bdaa96a9e678762f1aeeec04fa303cbf9ebc09be",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/comparison.json": "becda112d4f7576318e2a825daf8f049eb3916c964252511963779899228974c",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/output-hashes.json": "74748bb4cde4769caa31ecc7c888e9e6192fffc022deee94e4378573d0dbc9cc",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/overlay-audit.json": "949d7f986ae2212d44777bd351b88e54c38db857fc062d4d232c2670d31e3085",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/overlay-input.npz": "7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/overlay-manifest.json": "96d8406b69e98ba9829a52788c6c96888493e8bf34581d6d653226b1eb2e494b",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/queue.jsonl": "3e93bbae67a18944383b2b11a63708ee31e18b8ae7084f24dcb24045c85aa9a7",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/requests.csv": "b11fb0b6d1ac9211f02f05a9809175c64b72e8bcd4c4e4da31be1efbe6a82a83",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/sealed-gpu-source.diff": "0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/source-audit.json": "d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/state.npz": "7de2f62ecbde41a11db5aa220aed2fa6128e9fb6e65d04357f5373eb21538f81",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/summary.json": "6f6fb3ffc5f9df761a7972aa97444c7c095edb359580d19103044fa54bce674f",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/tick-state-hashes.jsonl": "3428c112a32024b539218aa6f4778cfa8c19c208bbdbfb2567324294370f23ea",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/adapter-provenance.json": "46d8ad74b409145c42f9066f992166f114cef2272bb0c6ea40c58438bdd39c13",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-applied.float32.npy": "b3a535bc095db2464a75560ed11f336a9db8e843c08fd7681a1b9759b624ad8e",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-component.json": "f94b360033b4cb643c9774e7fa31c95a65c5571ca62b73072ee29b3af80121f9",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-drive.float32.npy": "8b6432e8947f4c67466b5cae28cb0d0877b61862e80e6d9b10c5734d9afa8411",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-inhibition.float32.npy": "8f9e59026dc7c7663abf8f7abc60ebf93b11a68483bc0960d375a83731acc859",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-pending-tail.float32.npy": "fc1e2d8ffa426d4118a7544129323c5f7523e9df3e298a60922ca0ecabe7c18f",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-state.float32.npy": "36ecfec747be0c700959ba1ac171b81a1f3471aa9baba41b7bb6a67be01213c2",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-timing-audit.json": "850600c0560f98c1f2de35bae506c5619205375e6616137a7e8ff978000b0c3a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/comparison.json": "3e55e8edaf7e3cf4453e37cf90d7a420808977665174ccf525dfef7553418d46",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/output-hashes.json": "aabd9f46a9697440f0cc0204455e831d16b7aadfdebe3e5a8c986bfe85d05300",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/overlay-audit.json": "22d13f7d6ad27cbe117e01117d46c0457781adf3a0bf2aa6748fe7f4b484aa56",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/overlay-input.npz": "0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/overlay-manifest.json": "902933628aabc9e084b547dfdaff0f8361d353949ba3ee92439a2f35d8625d8a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/queue.jsonl": "22fbf106279d5ad314beba357137701df111bb28b57accdb09a0e299dfdf39cf",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/requests.csv": "4bcc9ef7fdc596ddac3be3b0d29f0aea2e086deeb803f3a90baba21b5490ef53",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/sealed-gpu-source.diff": "0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/source-audit.json": "d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/state.npz": "933afdc1bd0ea81174aeb334f017cfbe1bbc0a72f8eca767698275c5dca886f3",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/summary.json": "244be6a69b8276a212b1601ab7235e58c0bd9d523c88368025b29f4b4664ddcf",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/tick-state-hashes.jsonl": "0266afe78eadd1ea5bfb25026103d01d2af82d9b6ce2bcbb9d60e576ac898e91",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/manifest.json": "9e24b682935a9b18e05db7a933080c5f63ddbeb8a0c85cc0df1cfe1d06d88ab4",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/static25.json": "96d8406b69e98ba9829a52788c6c96888493e8bf34581d6d653226b1eb2e494b",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/static25.npz": "7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/zero.json": "902933628aabc9e084b547dfdaff0f8361d353949ba3ee92439a2f35d8625d8a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/zero.npz": "0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/base-candidate.float32-mV.npy": "1218d1b328f29a7afefb0ca0b7b6421247f14ad598aa1957a6a7aacbc8cebcae",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/prepared-hashes.json": "4af0bccbb9153be0d8cb65c5e4150946be3396ca351eab52b273c86459200580",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/preregistered.json": "465886b78ada08092c2c83de278844707499718977fb6dc6a7608391da0e5304",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/regression/frozen-five.json": "905c64c8b3f7de942d55f6ecb76c27c42821691a9fd3e0c17ffb466e1de0fea0",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/regression/old-integrity-after.json": "7d3de4ba6248cc52960087bcfa2658f9b8ee34d9ac08c56380f7018c34097929",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/regression/old-integrity-before.json": "7d3de4ba6248cc52960087bcfa2658f9b8ee34d9ac08c56380f7018c34097929",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s00/template-spec.json": "065e4b01b74ac6619f6533c54fdb58a345fffe7be30ae2295e50ab7015da888a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s01/template-spec.json": "38001935f07393a08f8c83595541a6ff060b0f9ca7b9fdaf357e2f77f9348994",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s02/template-spec.json": "c89d7994d40fc79591c78d11c549766b45d283145fdcebb1e3b6c964b8750b2a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s03/template-spec.json": "390f3d472a2baf3b7d14f1bb22185e027fb1c5ede8f42bfbd8e7c2051e78d0fe",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s04/template-spec.json": "90a262080e33a6014679e7f3d932f61e1edb04cffcd9a2cf35440c078a9085f4",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s00/template-spec.json": "3b63e236d755714dc59b083b2ee48761ce48e9a8456770e3502798f5bd5e2ff6",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s01/template-spec.json": "595a1a67fd82b48e0db25480771a93bd289e8f65c511c43780b42dabf9c8b478",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s02/template-spec.json": "bda9afb21aebd4cf37d52a0cb83c21f179ca4fe9aca8a43e5a1cc92f2af81897",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s03/template-spec.json": "246cbb287972c7539c4f53bc2546bd9cdd0dd960e8714bce060db1bee1ba0fc9",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s04/template-spec.json": "de59abaa0670a9be8d90a9dd9b41522edd277d9f75dbdb77ddeeeca1c508265f",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r0/template-spec.json": "802b717691f9a6b460a1a58044286e727ffa8393605127ee7a11ad267fbf6338",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r1/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r1/template-spec.json": "f4cdfd5de0fb80dd39203425c4ff7d063b0b66f2ac887e4276043251e3ad956c",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--reference-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--reference-r0/template-spec.json": "2ee541997a8a82f9ac356e9fedf8fc70ce31f622d42d846ab6de8c5f6cdea39f",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0018/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0018/template-spec.json": "282eccfb1ee2008f0b9ae8cca4daf45bfefd664806e7d04b8712fadf90b83bb5",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0019/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0019/template-spec.json": "8cd7512a1b2cdef47aecfd26bfb7ee8b22b566dc6c6812e887b4cc3f5416e7e3",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0500/requests.npz": "aa2773a740b0e85940f3d96738a141903d5d178e40586522b603ae1c9de53e98",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0500/template-spec.json": "654043502385a40dc4396c25ab2bf6f74701a7026fc85e6789672a810e5f700e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s00/template-spec.json": "e8f6fe8e0f67cbe851c045a067485d753979f5af32d30f596f545387b306f123",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s01/template-spec.json": "b727d54f9d28e9b8482860c3ed2bb6c30d4778fe90644b2df9ebb8d0c032e148",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s02/template-spec.json": "8af5bc5ed35084f15c7d77ded8224d49f49561d48510c862410eccd4d7dc5560",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s03/template-spec.json": "7e140b41ae610cd67a8cfe2e30d633190ac2c7689a4682bba676e423b54e689d",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s04/template-spec.json": "5cc7905cdca67bdf09eb0730a274644f5605178b1c97928572c5ecf2a3b5acff",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s00/template-spec.json": "452da911a5f3d6d8cbd33e96451d6f65af5e46eee57fda00125c59f6378dfba6",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s01/template-spec.json": "b943e29941af75b7c4ff333bdc0a9697d0e15131bdea46c4460ef91f894565b2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s02/template-spec.json": "412390b67001e08930f243f54954d78e7edf94b330aee2087c35748963a883db",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s03/template-spec.json": "6d5f2819be44646890cdad1969043bee5209e801b79687a8c1c2205601bc9656",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s04/template-spec.json": "d8bd2b1b151582ec7495e59a15cae15279f71d444429c5c273397b63008b3440",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r0/template-spec.json": "df1a6663ea748b0dc0333540877000e5c91d493b151e134e346dee54e834e3de",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r1/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r1/template-spec.json": "32dce4105aaadac4f7079264cf0a30a3f8171862edf59cceaba6624f01a5252d",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--reference-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--reference-r0/template-spec.json": "a0bf214d782ddef0adb5b6f9b89c2d52566a5928b5d96316bddfe12520aa5460",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0018/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0018/template-spec.json": "8400934e175d3c20f19d863082e7df02c5279864b5191736565e9014df6e0e83",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0019/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0019/template-spec.json": "9c361dfb9af4dd7071a7f1c3c2315adddb21b42e9ed5e9a199b1cdf52fab40e7",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0500/requests.npz": "aa2773a740b0e85940f3d96738a141903d5d178e40586522b603ae1c9de53e98",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0500/template-spec.json": "bda640a599d6cdf80ad435f344fcd576d91ca0afe9de732f36fa7bd54d470c1e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/overlays/static25.json": "b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/overlays/zero.json": "11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/AM-gate-authority.json": "66257eb665808e33005dd7ba14a16063064618cc48e47cb65b70f3900cec2484",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/AM-seal-verification.json": "175b5d0e2de12a9ce01c6167591dab882d9c9c6869de2d194bcd9e6732c6ed6d",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/ENGINEERING_GATE_DRAFT.md": "1ac0d65b906e1061781c967cc6a99e8a0a73df6a1ee564ed6603f88e3f5d7056",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_analysis.py": "3970d13bd43d4bc12baf4b6ad1cda3eb085e10bf4648752cfcecb6d12314c5ea",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_compare.py": "5a2403f11bc08d65a9d242ac2cf9686b850e0c3680d65659f785e9b6b50c0238",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_inputs.py": "cc8c0e83016af4836c81cd0773fc521c69fd30e6f4d021bf54d0e7897105c6d5",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_plan.py": "3c127aee723a054fda272fee458067608b521a7c443455822d97f509caded6c7",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_prepare.py": "62dedce2439407398e70beb4c718bf14e02d3e624b3db3ef6f74299115d84bc1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_queue_audit.py": "6ddaec52f2a0b5d0c528d51230d372fe2344160aef5eccea6a95b6c5e61a574e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_scopes.py": "1043ba217e5395c9e81e58b95a5aa396f572588872b954e549774f2b99cac5df",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_workflow.py": "76313332b8d18f121a61f7b6e2fc32ea9e893848e8ed5d049557fc08b385e674",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/runtime_continuation.py": "0b8e8e0a6a23a079dc62a88355ce355d53b3ae22f6665519a8f6aef2dcfc5aba",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/runtime_light.py": "522b8c31ea938890fe15364fccd25ccc5bded54101754909f255532e7ad01aae",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_analysis.py": "35e4ee37a1e82cf5e645d24165343049d400104c94a6d184b8aa834ba5ef2d20",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_compare.py": "87a85843d918cce6529ab94f7cb82499aa413281e803c00c030a3c340a581469",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_inputs.py": "4dcc7b775eb3c7e59ed9cc3d7591eacc0ef7bda1209edbd847e2ae79b115ef1b",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_plan.py": "c26c2c75bb27d3b8514b7d44f40369130d60147c6c8edc569b4efba4a4ad9815",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_prepare.py": "a12aa1d2cb4880a3f7a7889b89d71a859bc8c68b4badfb8f082d712cdd342627",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_queue_audit.py": "0e2bcfe25c3b5a5cd0ed5cd05a89392207191ec4db950cdb06a0137666c8adb7",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_scopes.py": "748c0777e4a8164e80c03c727df1c2decbac7747737ad1c9fb730ea5c9e208d3",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_workflow.py": "bb781b23f92b5c0eb92f8dbc54468a8e843177f6da004c444b48947b037bd705",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_runtime_continuation.py": "325c0b688d0ca1648ffdf29a8d3d4bb91d6f6115bea6f5ac30982acd6dfe8e06",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_runtime_light.py": "887345e497e6fa9c10ffa49c490196711d8cee028c62ec7a73f42db36569be2b",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/regression/old-integrity-before.json": "68475cc0e72039e044c8fb3aaea9c8487c6737c1b8a457641e818581d81c387c",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/mappings/dan-to-compartment.parquet": "a16f72c3121ed0ec638c1a2b249ace446e6ccee020b49679818eb42589d00662",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/mappings/dan-to-mbon-confirmed.parquet": "730d000f25667b59181d2ee6703c64591229a8beab0856197ed71e68d799d191",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/mappings/mbon-to-compartment.parquet": "54f371f7e35b9def44becd1ba9bd2872861f4876b255b2c8ec46feee6473b70c",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/plastic-mask/plastic-edge-candidates.parquet": "e5075ee3e5a0edf3a4d197453847163cc295b254f21c67203159bba204b12a76",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/plastic-mask/plastic-edge-ids.int64.npy": "8b0fb6eb2e6c31da4d17dc20d890aa3f367e514f05642de5bad6b42a1611c05b",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/odor-encoder/frozen-odor-panel.parquet": "907f16a56e024a8e2112b5751e53b0e6037b329fa110098af3d31b119c10a1a0",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/odor-encoder/mapped-glomerular-vectors.npz": "f057563152e0fa22060080af13019f319e7f36563a775eff829bbc1929c451b0",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/odor-encoder/selection.json": "1b832becf9d08935716fe9ba5e3cd3e619e7d208dfb43c4fa197c969d095f113",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/receptor-mapping/olfactory-mapping.parquet": "a01d27000533e9844458a4c559cac084f1c34ca20a1104e97e6a0f72b0cc93b1",
+    "/data/digital-drosophila/models/male-cns-lif/apl-timing-lab-v1/gpu_timing.py": "af1975ba5e5e700208c0a598d3cbe648a3cf10885c6231239b6e4b28f76d173b",
+    "/data/digital-drosophila/models/male-cns-lif/apl-timing-lab-v1/timing_queue.py": "54df6d4818e2a0c26e96fb0aaf5d9b71cd964981706da937562d48af79aca14e",
+    "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/gpu_apl.py": "69f5d893f47dafff4ef7c3186c3df0b9014666b32c8f4e943b57016bec92b18a",
+    "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py": "21ceec65fe42581dc55872010e0025d660e80358905f1cf4df1dadf341a3b291",
+    "/data/digital-drosophila/models/male-cns-lif/author-fullgraph-lab-v1/oracle_full.py": "d72003d98f0f1624b12126eff50bd361c43d888f4a64d90ba9247a58976f1961",
+    "/data/digital-drosophila/models/male-cns-lif/author-runtime-lab-v1/author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15",
+    "/data/digital-drosophila/models/male-cns-lif/author-runtime-lab-v1/author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e",
+    "/data/digital-drosophila/models/male-cns-lif/author-runtime-lab-v1/gpu_backend.py": "03758d07572f4b44d272059d9308fac534268ad201b57bdd77d69fee95e67278",
+    "/data/digital-drosophila/models/male-cns-lif/mb-physiology-v1/phase4j.py": "abb4574da85f00bd9ef61024c65993ef81d42651ff8d8d63c15dd69c6222471e",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/EVALUATION_POLICY_DRAFT.md": "a84170a61564715a1532f20df4c6a330f0f9725c383db48b8f3e1a4b5fba0bc8",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/EVIDENCE_DRAFT.md": "8455c12e3a6bb1b22a6e38f9017293fe5deea37ba3ec61e13598d00dafc12296",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/PROTOCOL_DRAFT.md": "8ebecb1f3d012ddc29a1cb727269dd277629c53565e09978bf9dbf7140cb8508",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/README_DRAFT.md": "50be97f64097b681355993a8afd7f467ea187e99e88b19ca30561e08d517999f",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/biological_contract.py": "e09f0f2b5e6ec746176e3a1aa2fdee1a15385e14e96bd343d14379a759f3ae43",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/conditioning_inputs.py": "19382e066e450140bb653a3661f980ffe7cc62f412020ef57df0b6e6b3cbb8ba",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/conditioning_update.py": "96efff678cff910654eb08e86f1a17789e4e5589e340345f419c7027a7d547e2",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/draft-source-inventory.json": "2c72d47d09b4ad1949dc6cfdc170f64847ff75f95ded5d20b421fb5a75e0eb84",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/evaluation_plan.py": "991c813ff3322b230947f302b12b04ec382c3b632817f94b698101e4b17efa7d",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/evaluation_policy.py": "21331a9ff3567dc6f6399e16bb91ef486d74231f5db51799beb6dd1bf71d022b",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/metrics.py": "47319e21db3c8b030b1bafbf0703cd86fb588d23bb29436accbacdba73d08c3c",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/seed_registry.py": "0da033b132095ec3087b5d9f64e53c2e391fa50ab0b7653b31296eeb84799b7e",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_biological_contract.py": "0ce796e6ad1a4cbcb9bcb760eff628a9562b4a809cc9c177a9a0d88df68f02b3",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_conditioning_inputs.py": "95e37c770e78ce722a3007c5b371c51aec2989634cddfe5b414ac3fa817e5c22",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_conditioning_update.py": "1c25d93753932ace06abc876fe0867546b3bb330de3e602da6aec7bb4588e4bd",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_evaluation_plan.py": "21d2402025122d8665fb1f32e184fd8e30fc17242810fc70901b7f7fc8c53bfa",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_evaluation_policy.py": "421a31b76eaa547e890c291d2c38a415352d9ccad6fccc800461f522ff4c83f1",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_metrics.py": "1928894d248dd37fad0fc67bc9dcfeac27c4d8be4aec22f54b9ef20a10ea8645",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_seed_registry.py": "7aca38f3c975e3ad4f6337d83b826c09afef336381d124c22ff0eb2eb60a0834",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_trial_plan.py": "927678956ae9959a047b1cd258ee8dee22eb6842a96ff4b2ba2db077310163c9",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/trial_plan.py": "6fed3f494d075339a7e5b001d43b2598640b189e038952fbd4d41200bacac587",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-grounding-v1/phase4l.yaml": "9b8bcb7e031bf9063033a1854a439a7cd0bf6730301c2d2d02ca99a76f098d6e",
+    "/data/digital-drosophila/models/male-cns-lif/phase4l.py": "e97d58d8c1f44920d0e953f8f5831ddc86fa0198784e86460e315de4116ac553",
+    "/data/digital-drosophila/models/male-cns-lif/pn-recruitment-audit-v1/publication.py": "7a79c499098b74163e7bb16adabcbc54e7069dafa204d0b99c7f4c03d79f8016",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/checksums.sha256": "493f541756064d9d65603e550628656a6f2dbf44f8b862ef905e8c3fd2427a43",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/config.json": "c19f00c81f12c4c3503d3d557bd73d0722d4d3fed7279449408c67a89a6ffcf9",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/context.py": "0fa2e0892c973fe70ecbc0613e3cb508c256b7745042f8936edf23dedc31d166",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/eligibility_bridge.py": "174fb8d14619189e74b095e77a6db18b14c93046dc431c0b55710a5aa2dd2e61",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/manifest.json": "7edeb251ecbeac5a64805fefe171a0a0bf8bba2675919ef922cc1a329c203ea8",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/overlay.py": "7f891d0ba79b393c96e75fd2dee2eddc51e57d8213eaac2779703bc2c18712b4"
+  },
+  "schema": "phase4an-epoch-postprocess-authority-v1"
+}

registry/conditioning-perf-prototype-20260930/inputs/N_D0.authority.json

@@ -0,0 +1,292 @@
+{
+  "checkpoint_dir": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh",
+  "checkpoint_manifest_sha256": "5cec0f224be49493af884e969cb97d47ac3e000da88c6d0ac8d1b23e3025db8a",
+  "command": {
+    "compartment": "y5B'2a",
+    "d_command": 0.0,
+    "frozen": false,
+    "steps": 1200,
+    "trace_backend": "torch",
+    "us_tick": 900
+  },
+  "diagnostic_mode": "light",
+  "epoch_id": "engineering-residency-control-N_D0",
+  "files": {
+    "am_overlay_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/overlay.py",
+      "sha256": "7f891d0ba79b393c96e75fd2dee2eddc51e57d8213eaac2779703bc2c18712b4"
+    },
+    "base_candidate": {
+      "path": "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/base-candidate.float32-mV.npy",
+      "sha256": "1218d1b328f29a7afefb0ca0b7b6421247f14ad598aa1957a6a7aacbc8cebcae"
+    },
+    "candidate_map": {
+      "path": "/data/digital-drosophila/experiments/phase4ao-conditioning-interface/inputs/static/candidate-map.npz",
+      "sha256": "29dcb57fcaefb5817fa4616b9a75285327b41d8a67cfc0f2ad2bacc14e41f2f0"
+    },
+    "canonical_kc": {
+      "path": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/kc_globals.npy",
+      "sha256": "97a570aafa089f93e642b2bb07e3a3322dabb14c3c7dd431f0c8d2b3b7951fdd"
+    },
+    "conditioning_update_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/conditioning_update.py",
+      "sha256": "96efff678cff910654eb08e86f1a17789e4e5589e340345f419c7027a7d547e2"
+    },
+    "eligibility_bridge_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/eligibility_bridge.py",
+      "sha256": "174fb8d14619189e74b095e77a6db18b14c93046dc431c0b55710a5aa2dd2e61"
+    },
+    "kc": {
+      "path": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/kc_globals.npy",
+      "sha256": "97a570aafa089f93e642b2bb07e3a3322dabb14c3c7dd431f0c8d2b3b7951fdd"
+    },
+    "mask": {
+      "path": "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/plastic-mask/plastic-edge-ids.int64.npy",
+      "sha256": "8b0fb6eb2e6c31da4d17dc20d890aa3f367e514f05642de5bad6b42a1611c05b"
+    },
+    "overlay_before": {
+      "path": "/data/digital-drosophila/experiments/phase4ap-conditioning-interface-v2/updates/D1--reference--epoch-000/delta-after.npz",
+      "sha256": "b89e407a5d93b5f1901f901b00428dc19bd20cee2d81e57b117a2fa68d200a48"
+    },
+    "overlay_manifest_before": {
+      "path": "/data/digital-drosophila/experiments/phase4ap-conditioning-interface-v2/updates/D1--reference--epoch-000/overlay-manifest.json",
+      "sha256": "38dabc55ea0569843ee70f13cf570832ecaa8f1ee7f26a7420e7ebc3ea86f6bd"
+    },
+    "phase4j_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/mb-physiology-v1/phase4j.py",
+      "sha256": "abb4574da85f00bd9ef61024c65993ef81d42651ff8d8d63c15dd69c6222471e"
+    },
+    "requests": {
+      "path": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/cases/performance--natural-light-fresh/requests.npz",
+      "sha256": "571d09c32cabd45af79f71f0f27f7adcc38b9c65daf5ca124366ea439e088143"
+    },
+    "runtime_continuation_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/runtime_continuation.py",
+      "sha256": "0b8e8e0a6a23a079dc62a88355ce355d53b3ae22f6665519a8f6aef2dcfc5aba"
+    },
+    "runtime_light_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/runtime_light.py",
+      "sha256": "522b8c31ea938890fe15364fccd25ccc5bded54101754909f255532e7ad01aae"
+    },
+    "spec": {
+      "path": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/cases/performance--natural-light-fresh/spec.json",
+      "sha256": "ea4c40897aceb26edfa5db934647fbc6f6946746441f843bc336f15e5d4e0a23"
+    },
+    "state": {
+      "path": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/state.npz",
+      "sha256": "137d5a73a869f27df8a3f97002ca6a683c80d3d715057759fb2aad64a05d37ff"
+    }
+  },
+  "frozen_inputs": {
+    "/data/digital-drosophila/datasets/male-cns-v1.0/processed/neuron-only/neuron-index/unified-metadata.parquet": "922af16846a065c3dbfca7c11146b83ca217fcbd7392edc745f444a04eae8c63",
+    "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json": "bde79d95ef0097b827d5faf4d5658eafc009d8e9fcef1fddd645c953823e3f64",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/apl_globals.npy": "8388c8795d49cfe5b14fda54f76ef3a35030c62ba87bd8ca6334a2dcdf186f19",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/input_matrix.npy": "c4d3df703ea5f1d7402b8255cfa19d9744139ad1048827c23b151d8ba766fec6",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/kc_globals.npy": "97a570aafa089f93e642b2bb07e3a3322dabb14c3c7dd431f0c8d2b3b7951fdd",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/output_matrix.npy": "e2d0a1ccd740e6777245ebf2efcd88bf5e1da9e47308c63ec8e83d451e134a73",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/dst.npy": "ce20f7433f78442c717ad2a7b5394cf4a3b109d990b4be0788040b7b0f4ed150",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/edge_id.npy": "49260615ff2b6432ce3dea9ce2c7ab8f83d06c2fb7491e58e08355fcedf86a30",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/nodes.npy": "5b511a98e8fbf8d65bbc70b93e75ecae19366f650b7842a45611bfad62ed83dc",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/ptr.npy": "fe43420f11e6242a11f8199ae7f097cab4b8a6db181d36f2a46b9e46670acbb4",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/signed_raw.npy": "f9884ccb8930b32420b27c69271df78034a8350fe5a5c9b76a63c259268efc09",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/src.npy": "bfd625ce690fc21eb0a8b9dede831688ab73b789045ba83ddf4baeefeddf1fc3",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/weights.npy": "462839ffc3feb8f6c278044488082b1c8e410e7f23229d6b5e29d1b7042416a1",
+    "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation/cases/seed_validation/seed_validation-physiological-00-s1073741825/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation/cases/seed_validation/seed_validation-physiological-00-s1073741825/spec.json": "ebffa677b41e06cb776a987a496a0577bdda135cf3c067ca8017b038ff3fc5c4",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/final-status.json": "18b12c832e156bd6e5ba950f48a49fb908c62104b91bb3e78213f523c8fdc8f9",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/scientific-summary.json": "03f229fc0768d38bb7c2a3c558dbd68c2c3a622cbf96b1b16aef2819b6b67b77",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/static25-complete.json": "1a9cfd096bfc7ab826e043d450a32403a1a7176ab1f7056a3afaceb5c33ac098",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/zero-complete.json": "59397f4b7874894049cc5e77d0555ddcc8274c9573bc53a4bc5f41429683166e",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/checksums.sha256": "fde235a6d781d4c860107c3aa94671811b3f39b167965034ed57f3278e012c3a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/adapter-provenance.json": "d1b64bdd7b8bc2023dba8321f74bf8ba0a9cac8ded772711f68efeeeb2297156",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-applied.float32.npy": "6228c9e8ec19cb7532e65728ec8f2bd6b080dca8379b17bd393979beaba4c6eb",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-component.json": "f94b360033b4cb643c9774e7fa31c95a65c5571ca62b73072ee29b3af80121f9",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-drive.float32.npy": "19b32ccdefea22ddc3e2efcc98b919b8fcf69887f029c17dc75bafa5b34259c5",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-inhibition.float32.npy": "d5194ea98900ca1800416712619143b731d9b3a5d1391180e6881205c7a4d663",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-pending-tail.float32.npy": "2dd2e0c79d4ee5299b8c1e8863e6c61b81f3dba08e599011887b1e1621f7c945",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-state.float32.npy": "5fe5ac53e012232b42a7e717357e9782b247f74da93640a0cfb8a078bc9d4855",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-timing-audit.json": "6ceacfab219fc40146c3e753bdaa96a9e678762f1aeeec04fa303cbf9ebc09be",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/comparison.json": "becda112d4f7576318e2a825daf8f049eb3916c964252511963779899228974c",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/output-hashes.json": "74748bb4cde4769caa31ecc7c888e9e6192fffc022deee94e4378573d0dbc9cc",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/overlay-audit.json": "949d7f986ae2212d44777bd351b88e54c38db857fc062d4d232c2670d31e3085",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/overlay-input.npz": "7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/overlay-manifest.json": "96d8406b69e98ba9829a52788c6c96888493e8bf34581d6d653226b1eb2e494b",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/queue.jsonl": "3e93bbae67a18944383b2b11a63708ee31e18b8ae7084f24dcb24045c85aa9a7",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/requests.csv": "b11fb0b6d1ac9211f02f05a9809175c64b72e8bcd4c4e4da31be1efbe6a82a83",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/sealed-gpu-source.diff": "0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/source-audit.json": "d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/state.npz": "7de2f62ecbde41a11db5aa220aed2fa6128e9fb6e65d04357f5373eb21538f81",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/summary.json": "6f6fb3ffc5f9df761a7972aa97444c7c095edb359580d19103044fa54bce674f",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/tick-state-hashes.jsonl": "3428c112a32024b539218aa6f4778cfa8c19c208bbdbfb2567324294370f23ea",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/adapter-provenance.json": "46d8ad74b409145c42f9066f992166f114cef2272bb0c6ea40c58438bdd39c13",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-applied.float32.npy": "b3a535bc095db2464a75560ed11f336a9db8e843c08fd7681a1b9759b624ad8e",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-component.json": "f94b360033b4cb643c9774e7fa31c95a65c5571ca62b73072ee29b3af80121f9",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-drive.float32.npy": "8b6432e8947f4c67466b5cae28cb0d0877b61862e80e6d9b10c5734d9afa8411",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-inhibition.float32.npy": "8f9e59026dc7c7663abf8f7abc60ebf93b11a68483bc0960d375a83731acc859",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-pending-tail.float32.npy": "fc1e2d8ffa426d4118a7544129323c5f7523e9df3e298a60922ca0ecabe7c18f",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-state.float32.npy": "36ecfec747be0c700959ba1ac171b81a1f3471aa9baba41b7bb6a67be01213c2",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-timing-audit.json": "850600c0560f98c1f2de35bae506c5619205375e6616137a7e8ff978000b0c3a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/comparison.json": "3e55e8edaf7e3cf4453e37cf90d7a420808977665174ccf525dfef7553418d46",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/output-hashes.json": "aabd9f46a9697440f0cc0204455e831d16b7aadfdebe3e5a8c986bfe85d05300",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/overlay-audit.json": "22d13f7d6ad27cbe117e01117d46c0457781adf3a0bf2aa6748fe7f4b484aa56",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/overlay-input.npz": "0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/overlay-manifest.json": "902933628aabc9e084b547dfdaff0f8361d353949ba3ee92439a2f35d8625d8a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/queue.jsonl": "22fbf106279d5ad314beba357137701df111bb28b57accdb09a0e299dfdf39cf",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/requests.csv": "4bcc9ef7fdc596ddac3be3b0d29f0aea2e086deeb803f3a90baba21b5490ef53",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/sealed-gpu-source.diff": "0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/source-audit.json": "d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/state.npz": "933afdc1bd0ea81174aeb334f017cfbe1bbc0a72f8eca767698275c5dca886f3",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/summary.json": "244be6a69b8276a212b1601ab7235e58c0bd9d523c88368025b29f4b4664ddcf",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/tick-state-hashes.jsonl": "0266afe78eadd1ea5bfb25026103d01d2af82d9b6ce2bcbb9d60e576ac898e91",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/manifest.json": "9e24b682935a9b18e05db7a933080c5f63ddbeb8a0c85cc0df1cfe1d06d88ab4",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/static25.json": "96d8406b69e98ba9829a52788c6c96888493e8bf34581d6d653226b1eb2e494b",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/static25.npz": "7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/zero.json": "902933628aabc9e084b547dfdaff0f8361d353949ba3ee92439a2f35d8625d8a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/zero.npz": "0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/base-candidate.float32-mV.npy": "1218d1b328f29a7afefb0ca0b7b6421247f14ad598aa1957a6a7aacbc8cebcae",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/prepared-hashes.json": "4af0bccbb9153be0d8cb65c5e4150946be3396ca351eab52b273c86459200580",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/preregistered.json": "465886b78ada08092c2c83de278844707499718977fb6dc6a7608391da0e5304",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/regression/frozen-five.json": "905c64c8b3f7de942d55f6ecb76c27c42821691a9fd3e0c17ffb466e1de0fea0",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/regression/old-integrity-after.json": "7d3de4ba6248cc52960087bcfa2658f9b8ee34d9ac08c56380f7018c34097929",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/regression/old-integrity-before.json": "7d3de4ba6248cc52960087bcfa2658f9b8ee34d9ac08c56380f7018c34097929",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s00/template-spec.json": "065e4b01b74ac6619f6533c54fdb58a345fffe7be30ae2295e50ab7015da888a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s01/template-spec.json": "38001935f07393a08f8c83595541a6ff060b0f9ca7b9fdaf357e2f77f9348994",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s02/template-spec.json": "c89d7994d40fc79591c78d11c549766b45d283145fdcebb1e3b6c964b8750b2a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s03/template-spec.json": "390f3d472a2baf3b7d14f1bb22185e027fb1c5ede8f42bfbd8e7c2051e78d0fe",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s04/template-spec.json": "90a262080e33a6014679e7f3d932f61e1edb04cffcd9a2cf35440c078a9085f4",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s00/template-spec.json": "3b63e236d755714dc59b083b2ee48761ce48e9a8456770e3502798f5bd5e2ff6",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s01/template-spec.json": "595a1a67fd82b48e0db25480771a93bd289e8f65c511c43780b42dabf9c8b478",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s02/template-spec.json": "bda9afb21aebd4cf37d52a0cb83c21f179ca4fe9aca8a43e5a1cc92f2af81897",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s03/template-spec.json": "246cbb287972c7539c4f53bc2546bd9cdd0dd960e8714bce060db1bee1ba0fc9",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s04/template-spec.json": "de59abaa0670a9be8d90a9dd9b41522edd277d9f75dbdb77ddeeeca1c508265f",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r0/template-spec.json": "802b717691f9a6b460a1a58044286e727ffa8393605127ee7a11ad267fbf6338",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r1/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r1/template-spec.json": "f4cdfd5de0fb80dd39203425c4ff7d063b0b66f2ac887e4276043251e3ad956c",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--reference-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--reference-r0/template-spec.json": "2ee541997a8a82f9ac356e9fedf8fc70ce31f622d42d846ab6de8c5f6cdea39f",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0018/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0018/template-spec.json": "282eccfb1ee2008f0b9ae8cca4daf45bfefd664806e7d04b8712fadf90b83bb5",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0019/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0019/template-spec.json": "8cd7512a1b2cdef47aecfd26bfb7ee8b22b566dc6c6812e887b4cc3f5416e7e3",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0500/requests.npz": "aa2773a740b0e85940f3d96738a141903d5d178e40586522b603ae1c9de53e98",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0500/template-spec.json": "654043502385a40dc4396c25ab2bf6f74701a7026fc85e6789672a810e5f700e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s00/template-spec.json": "e8f6fe8e0f67cbe851c045a067485d753979f5af32d30f596f545387b306f123",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s01/template-spec.json": "b727d54f9d28e9b8482860c3ed2bb6c30d4778fe90644b2df9ebb8d0c032e148",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s02/template-spec.json": "8af5bc5ed35084f15c7d77ded8224d49f49561d48510c862410eccd4d7dc5560",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s03/template-spec.json": "7e140b41ae610cd67a8cfe2e30d633190ac2c7689a4682bba676e423b54e689d",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s04/template-spec.json": "5cc7905cdca67bdf09eb0730a274644f5605178b1c97928572c5ecf2a3b5acff",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s00/template-spec.json": "452da911a5f3d6d8cbd33e96451d6f65af5e46eee57fda00125c59f6378dfba6",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s01/template-spec.json": "b943e29941af75b7c4ff333bdc0a9697d0e15131bdea46c4460ef91f894565b2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s02/template-spec.json": "412390b67001e08930f243f54954d78e7edf94b330aee2087c35748963a883db",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s03/template-spec.json": "6d5f2819be44646890cdad1969043bee5209e801b79687a8c1c2205601bc9656",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s04/template-spec.json": "d8bd2b1b151582ec7495e59a15cae15279f71d444429c5c273397b63008b3440",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r0/template-spec.json": "df1a6663ea748b0dc0333540877000e5c91d493b151e134e346dee54e834e3de",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r1/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r1/template-spec.json": "32dce4105aaadac4f7079264cf0a30a3f8171862edf59cceaba6624f01a5252d",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--reference-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--reference-r0/template-spec.json": "a0bf214d782ddef0adb5b6f9b89c2d52566a5928b5d96316bddfe12520aa5460",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0018/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0018/template-spec.json": "8400934e175d3c20f19d863082e7df02c5279864b5191736565e9014df6e0e83",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0019/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0019/template-spec.json": "9c361dfb9af4dd7071a7f1c3c2315adddb21b42e9ed5e9a199b1cdf52fab40e7",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0500/requests.npz": "aa2773a740b0e85940f3d96738a141903d5d178e40586522b603ae1c9de53e98",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0500/template-spec.json": "bda640a599d6cdf80ad435f344fcd576d91ca0afe9de732f36fa7bd54d470c1e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/overlays/static25.json": "b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/overlays/zero.json": "11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/AM-gate-authority.json": "66257eb665808e33005dd7ba14a16063064618cc48e47cb65b70f3900cec2484",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/AM-seal-verification.json": "175b5d0e2de12a9ce01c6167591dab882d9c9c6869de2d194bcd9e6732c6ed6d",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/ENGINEERING_GATE_DRAFT.md": "1ac0d65b906e1061781c967cc6a99e8a0a73df6a1ee564ed6603f88e3f5d7056",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_analysis.py": "3970d13bd43d4bc12baf4b6ad1cda3eb085e10bf4648752cfcecb6d12314c5ea",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_compare.py": "5a2403f11bc08d65a9d242ac2cf9686b850e0c3680d65659f785e9b6b50c0238",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_inputs.py": "cc8c0e83016af4836c81cd0773fc521c69fd30e6f4d021bf54d0e7897105c6d5",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_plan.py": "3c127aee723a054fda272fee458067608b521a7c443455822d97f509caded6c7",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_prepare.py": "62dedce2439407398e70beb4c718bf14e02d3e624b3db3ef6f74299115d84bc1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_queue_audit.py": "6ddaec52f2a0b5d0c528d51230d372fe2344160aef5eccea6a95b6c5e61a574e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_scopes.py": "1043ba217e5395c9e81e58b95a5aa396f572588872b954e549774f2b99cac5df",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_workflow.py": "76313332b8d18f121a61f7b6e2fc32ea9e893848e8ed5d049557fc08b385e674",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/runtime_continuation.py": "0b8e8e0a6a23a079dc62a88355ce355d53b3ae22f6665519a8f6aef2dcfc5aba",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/runtime_light.py": "522b8c31ea938890fe15364fccd25ccc5bded54101754909f255532e7ad01aae",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_analysis.py": "35e4ee37a1e82cf5e645d24165343049d400104c94a6d184b8aa834ba5ef2d20",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_compare.py": "87a85843d918cce6529ab94f7cb82499aa413281e803c00c030a3c340a581469",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_inputs.py": "4dcc7b775eb3c7e59ed9cc3d7591eacc0ef7bda1209edbd847e2ae79b115ef1b",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_plan.py": "c26c2c75bb27d3b8514b7d44f40369130d60147c6c8edc569b4efba4a4ad9815",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_prepare.py": "a12aa1d2cb4880a3f7a7889b89d71a859bc8c68b4badfb8f082d712cdd342627",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_queue_audit.py": "0e2bcfe25c3b5a5cd0ed5cd05a89392207191ec4db950cdb06a0137666c8adb7",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_scopes.py": "748c0777e4a8164e80c03c727df1c2decbac7747737ad1c9fb730ea5c9e208d3",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_workflow.py": "bb781b23f92b5c0eb92f8dbc54468a8e843177f6da004c444b48947b037bd705",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_runtime_continuation.py": "325c0b688d0ca1648ffdf29a8d3d4bb91d6f6115bea6f5ac30982acd6dfe8e06",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_runtime_light.py": "887345e497e6fa9c10ffa49c490196711d8cee028c62ec7a73f42db36569be2b",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/regression/old-integrity-before.json": "68475cc0e72039e044c8fb3aaea9c8487c6737c1b8a457641e818581d81c387c",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/mappings/dan-to-compartment.parquet": "a16f72c3121ed0ec638c1a2b249ace446e6ccee020b49679818eb42589d00662",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/mappings/dan-to-mbon-confirmed.parquet": "730d000f25667b59181d2ee6703c64591229a8beab0856197ed71e68d799d191",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/mappings/mbon-to-compartment.parquet": "54f371f7e35b9def44becd1ba9bd2872861f4876b255b2c8ec46feee6473b70c",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/plastic-mask/plastic-edge-candidates.parquet": "e5075ee3e5a0edf3a4d197453847163cc295b254f21c67203159bba204b12a76",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/plastic-mask/plastic-edge-ids.int64.npy": "8b0fb6eb2e6c31da4d17dc20d890aa3f367e514f05642de5bad6b42a1611c05b",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/odor-encoder/frozen-odor-panel.parquet": "907f16a56e024a8e2112b5751e53b0e6037b329fa110098af3d31b119c10a1a0",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/odor-encoder/mapped-glomerular-vectors.npz": "f057563152e0fa22060080af13019f319e7f36563a775eff829bbc1929c451b0",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/odor-encoder/selection.json": "1b832becf9d08935716fe9ba5e3cd3e619e7d208dfb43c4fa197c969d095f113",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/receptor-mapping/olfactory-mapping.parquet": "a01d27000533e9844458a4c559cac084f1c34ca20a1104e97e6a0f72b0cc93b1",
+    "/data/digital-drosophila/models/male-cns-lif/apl-timing-lab-v1/gpu_timing.py": "af1975ba5e5e700208c0a598d3cbe648a3cf10885c6231239b6e4b28f76d173b",
+    "/data/digital-drosophila/models/male-cns-lif/apl-timing-lab-v1/timing_queue.py": "54df6d4818e2a0c26e96fb0aaf5d9b71cd964981706da937562d48af79aca14e",
+    "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/gpu_apl.py": "69f5d893f47dafff4ef7c3186c3df0b9014666b32c8f4e943b57016bec92b18a",
+    "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py": "21ceec65fe42581dc55872010e0025d660e80358905f1cf4df1dadf341a3b291",
+    "/data/digital-drosophila/models/male-cns-lif/author-fullgraph-lab-v1/oracle_full.py": "d72003d98f0f1624b12126eff50bd361c43d888f4a64d90ba9247a58976f1961",
+    "/data/digital-drosophila/models/male-cns-lif/author-runtime-lab-v1/author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15",
+    "/data/digital-drosophila/models/male-cns-lif/author-runtime-lab-v1/author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e",
+    "/data/digital-drosophila/models/male-cns-lif/author-runtime-lab-v1/gpu_backend.py": "03758d07572f4b44d272059d9308fac534268ad201b57bdd77d69fee95e67278",
+    "/data/digital-drosophila/models/male-cns-lif/mb-physiology-v1/phase4j.py": "abb4574da85f00bd9ef61024c65993ef81d42651ff8d8d63c15dd69c6222471e",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/EVALUATION_POLICY_DRAFT.md": "a84170a61564715a1532f20df4c6a330f0f9725c383db48b8f3e1a4b5fba0bc8",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/EVIDENCE_DRAFT.md": "8455c12e3a6bb1b22a6e38f9017293fe5deea37ba3ec61e13598d00dafc12296",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/PROTOCOL_DRAFT.md": "8ebecb1f3d012ddc29a1cb727269dd277629c53565e09978bf9dbf7140cb8508",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/README_DRAFT.md": "50be97f64097b681355993a8afd7f467ea187e99e88b19ca30561e08d517999f",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/biological_contract.py": "e09f0f2b5e6ec746176e3a1aa2fdee1a15385e14e96bd343d14379a759f3ae43",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/conditioning_inputs.py": "19382e066e450140bb653a3661f980ffe7cc62f412020ef57df0b6e6b3cbb8ba",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/conditioning_update.py": "96efff678cff910654eb08e86f1a17789e4e5589e340345f419c7027a7d547e2",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/draft-source-inventory.json": "2c72d47d09b4ad1949dc6cfdc170f64847ff75f95ded5d20b421fb5a75e0eb84",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/evaluation_plan.py": "991c813ff3322b230947f302b12b04ec382c3b632817f94b698101e4b17efa7d",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/evaluation_policy.py": "21331a9ff3567dc6f6399e16bb91ef486d74231f5db51799beb6dd1bf71d022b",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/metrics.py": "47319e21db3c8b030b1bafbf0703cd86fb588d23bb29436accbacdba73d08c3c",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/seed_registry.py": "0da033b132095ec3087b5d9f64e53c2e391fa50ab0b7653b31296eeb84799b7e",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_biological_contract.py": "0ce796e6ad1a4cbcb9bcb760eff628a9562b4a809cc9c177a9a0d88df68f02b3",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_conditioning_inputs.py": "95e37c770e78ce722a3007c5b371c51aec2989634cddfe5b414ac3fa817e5c22",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_conditioning_update.py": "1c25d93753932ace06abc876fe0867546b3bb330de3e602da6aec7bb4588e4bd",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_evaluation_plan.py": "21d2402025122d8665fb1f32e184fd8e30fc17242810fc70901b7f7fc8c53bfa",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_evaluation_policy.py": "421a31b76eaa547e890c291d2c38a415352d9ccad6fccc800461f522ff4c83f1",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_metrics.py": "1928894d248dd37fad0fc67bc9dcfeac27c4d8be4aec22f54b9ef20a10ea8645",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_seed_registry.py": "7aca38f3c975e3ad4f6337d83b826c09afef336381d124c22ff0eb2eb60a0834",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_trial_plan.py": "927678956ae9959a047b1cd258ee8dee22eb6842a96ff4b2ba2db077310163c9",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/trial_plan.py": "6fed3f494d075339a7e5b001d43b2598640b189e038952fbd4d41200bacac587",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-grounding-v1/phase4l.yaml": "9b8bcb7e031bf9063033a1854a439a7cd0bf6730301c2d2d02ca99a76f098d6e",
+    "/data/digital-drosophila/models/male-cns-lif/phase4l.py": "e97d58d8c1f44920d0e953f8f5831ddc86fa0198784e86460e315de4116ac553",
+    "/data/digital-drosophila/models/male-cns-lif/pn-recruitment-audit-v1/publication.py": "7a79c499098b74163e7bb16adabcbc54e7069dafa204d0b99c7f4c03d79f8016",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/checksums.sha256": "493f541756064d9d65603e550628656a6f2dbf44f8b862ef905e8c3fd2427a43",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/config.json": "c19f00c81f12c4c3503d3d557bd73d0722d4d3fed7279449408c67a89a6ffcf9",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/context.py": "0fa2e0892c973fe70ecbc0613e3cb508c256b7745042f8936edf23dedc31d166",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/eligibility_bridge.py": "174fb8d14619189e74b095e77a6db18b14c93046dc431c0b55710a5aa2dd2e61",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/manifest.json": "7edeb251ecbeac5a64805fefe171a0a0bf8bba2675919ef922cc1a329c203ea8",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/overlay.py": "7f891d0ba79b393c96e75fd2dee2eddc51e57d8213eaac2779703bc2c18712b4"
+  },
+  "schema": "phase4an-epoch-postprocess-authority-v1"
+}

registry/conditioning-perf-prototype-20260930/inputs/N_frozen.authority.json

@@ -0,0 +1,292 @@
+{
+  "checkpoint_dir": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh",
+  "checkpoint_manifest_sha256": "5cec0f224be49493af884e969cb97d47ac3e000da88c6d0ac8d1b23e3025db8a",
+  "command": {
+    "compartment": "y5B'2a",
+    "d_command": 1.0,
+    "frozen": true,
+    "steps": 1200,
+    "trace_backend": "torch",
+    "us_tick": 900
+  },
+  "diagnostic_mode": "light",
+  "epoch_id": "engineering-residency-control-N_frozen",
+  "files": {
+    "am_overlay_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/overlay.py",
+      "sha256": "7f891d0ba79b393c96e75fd2dee2eddc51e57d8213eaac2779703bc2c18712b4"
+    },
+    "base_candidate": {
+      "path": "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/base-candidate.float32-mV.npy",
+      "sha256": "1218d1b328f29a7afefb0ca0b7b6421247f14ad598aa1957a6a7aacbc8cebcae"
+    },
+    "candidate_map": {
+      "path": "/data/digital-drosophila/experiments/phase4ao-conditioning-interface/inputs/static/candidate-map.npz",
+      "sha256": "29dcb57fcaefb5817fa4616b9a75285327b41d8a67cfc0f2ad2bacc14e41f2f0"
+    },
+    "canonical_kc": {
+      "path": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/kc_globals.npy",
+      "sha256": "97a570aafa089f93e642b2bb07e3a3322dabb14c3c7dd431f0c8d2b3b7951fdd"
+    },
+    "conditioning_update_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/conditioning_update.py",
+      "sha256": "96efff678cff910654eb08e86f1a17789e4e5589e340345f419c7027a7d547e2"
+    },
+    "eligibility_bridge_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/eligibility_bridge.py",
+      "sha256": "174fb8d14619189e74b095e77a6db18b14c93046dc431c0b55710a5aa2dd2e61"
+    },
+    "kc": {
+      "path": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/kc_globals.npy",
+      "sha256": "97a570aafa089f93e642b2bb07e3a3322dabb14c3c7dd431f0c8d2b3b7951fdd"
+    },
+    "mask": {
+      "path": "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/plastic-mask/plastic-edge-ids.int64.npy",
+      "sha256": "8b0fb6eb2e6c31da4d17dc20d890aa3f367e514f05642de5bad6b42a1611c05b"
+    },
+    "overlay_before": {
+      "path": "/data/digital-drosophila/experiments/phase4ap-conditioning-interface-v2/updates/D1--reference--epoch-000/delta-after.npz",
+      "sha256": "b89e407a5d93b5f1901f901b00428dc19bd20cee2d81e57b117a2fa68d200a48"
+    },
+    "overlay_manifest_before": {
+      "path": "/data/digital-drosophila/experiments/phase4ap-conditioning-interface-v2/updates/D1--reference--epoch-000/overlay-manifest.json",
+      "sha256": "38dabc55ea0569843ee70f13cf570832ecaa8f1ee7f26a7420e7ebc3ea86f6bd"
+    },
+    "phase4j_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/mb-physiology-v1/phase4j.py",
+      "sha256": "abb4574da85f00bd9ef61024c65993ef81d42651ff8d8d63c15dd69c6222471e"
+    },
+    "requests": {
+      "path": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/cases/performance--natural-light-fresh/requests.npz",
+      "sha256": "571d09c32cabd45af79f71f0f27f7adcc38b9c65daf5ca124366ea439e088143"
+    },
+    "runtime_continuation_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/runtime_continuation.py",
+      "sha256": "0b8e8e0a6a23a079dc62a88355ce355d53b3ae22f6665519a8f6aef2dcfc5aba"
+    },
+    "runtime_light_source": {
+      "path": "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/runtime_light.py",
+      "sha256": "522b8c31ea938890fe15364fccd25ccc5bded54101754909f255532e7ad01aae"
+    },
+    "spec": {
+      "path": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/cases/performance--natural-light-fresh/spec.json",
+      "sha256": "ea4c40897aceb26edfa5db934647fbc6f6946746441f843bc336f15e5d4e0a23"
+    },
+    "state": {
+      "path": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/runs/performance--natural-light-fresh/state.npz",
+      "sha256": "137d5a73a869f27df8a3f97002ca6a683c80d3d715057759fb2aad64a05d37ff"
+    }
+  },
+  "frozen_inputs": {
+    "/data/digital-drosophila/datasets/male-cns-v1.0/processed/neuron-only/neuron-index/unified-metadata.parquet": "922af16846a065c3dbfca7c11146b83ca217fcbd7392edc745f444a04eae8c63",
+    "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json": "bde79d95ef0097b827d5faf4d5658eafc009d8e9fcef1fddd645c953823e3f64",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/apl_globals.npy": "8388c8795d49cfe5b14fda54f76ef3a35030c62ba87bd8ca6334a2dcdf186f19",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/input_matrix.npy": "c4d3df703ea5f1d7402b8255cfa19d9744139ad1048827c23b151d8ba766fec6",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/kc_globals.npy": "97a570aafa089f93e642b2bb07e3a3322dabb14c3c7dd431f0c8d2b3b7951fdd",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle/output_matrix.npy": "e2d0a1ccd740e6777245ebf2efcd88bf5e1da9e47308c63ec8e83d451e134a73",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/dst.npy": "ce20f7433f78442c717ad2a7b5394cf4a3b109d990b4be0788040b7b0f4ed150",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/edge_id.npy": "49260615ff2b6432ce3dea9ce2c7ab8f83d06c2fb7491e58e08355fcedf86a30",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/nodes.npy": "5b511a98e8fbf8d65bbc70b93e75ecae19366f650b7842a45611bfad62ed83dc",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/ptr.npy": "fe43420f11e6242a11f8199ae7f097cab4b8a6db181d36f2a46b9e46670acbb4",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/signed_raw.npy": "f9884ccb8930b32420b27c69271df78034a8350fe5a5c9b76a63c259268efc09",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/src.npy": "bfd625ce690fc21eb0a8b9dede831688ab73b789045ba83ddf4baeefeddf1fc3",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full/weights.npy": "462839ffc3feb8f6c278044488082b1c8e410e7f23229d6b5e29d1b7042416a1",
+    "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation/cases/seed_validation/seed_validation-physiological-00-s1073741825/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation/cases/seed_validation/seed_validation-physiological-00-s1073741825/spec.json": "ebffa677b41e06cb776a987a496a0577bdda135cf3c067ca8017b038ff3fc5c4",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/final-status.json": "18b12c832e156bd6e5ba950f48a49fb908c62104b91bb3e78213f523c8fdc8f9",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/scientific-summary.json": "03f229fc0768d38bb7c2a3c558dbd68c2c3a622cbf96b1b16aef2819b6b67b77",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/static25-complete.json": "1a9cfd096bfc7ab826e043d450a32403a1a7176ab1f7056a3afaceb5c33ac098",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/audit/zero-complete.json": "59397f4b7874894049cc5e77d0555ddcc8274c9573bc53a4bc5f41429683166e",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/checksums.sha256": "fde235a6d781d4c860107c3aa94671811b3f39b167965034ed57f3278e012c3a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/adapter-provenance.json": "d1b64bdd7b8bc2023dba8321f74bf8ba0a9cac8ded772711f68efeeeb2297156",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-applied.float32.npy": "6228c9e8ec19cb7532e65728ec8f2bd6b080dca8379b17bd393979beaba4c6eb",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-component.json": "f94b360033b4cb643c9774e7fa31c95a65c5571ca62b73072ee29b3af80121f9",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-drive.float32.npy": "19b32ccdefea22ddc3e2efcc98b919b8fcf69887f029c17dc75bafa5b34259c5",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-inhibition.float32.npy": "d5194ea98900ca1800416712619143b731d9b3a5d1391180e6881205c7a4d663",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-pending-tail.float32.npy": "2dd2e0c79d4ee5299b8c1e8863e6c61b81f3dba08e599011887b1e1621f7c945",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-state.float32.npy": "5fe5ac53e012232b42a7e717357e9782b247f74da93640a0cfb8a078bc9d4855",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/apl-timing-audit.json": "6ceacfab219fc40146c3e753bdaa96a9e678762f1aeeec04fa303cbf9ebc09be",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/comparison.json": "becda112d4f7576318e2a825daf8f049eb3916c964252511963779899228974c",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/output-hashes.json": "74748bb4cde4769caa31ecc7c888e9e6192fffc022deee94e4378573d0dbc9cc",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/overlay-audit.json": "949d7f986ae2212d44777bd351b88e54c38db857fc062d4d232c2670d31e3085",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/overlay-input.npz": "7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/overlay-manifest.json": "96d8406b69e98ba9829a52788c6c96888493e8bf34581d6d653226b1eb2e494b",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/queue.jsonl": "3e93bbae67a18944383b2b11a63708ee31e18b8ae7084f24dcb24045c85aa9a7",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/requests.csv": "b11fb0b6d1ac9211f02f05a9809175c64b72e8bcd4c4e4da31be1efbe6a82a83",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/sealed-gpu-source.diff": "0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/source-audit.json": "d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/state.npz": "7de2f62ecbde41a11db5aa220aed2fa6128e9fb6e65d04357f5373eb21538f81",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/summary.json": "6f6fb3ffc5f9df761a7972aa97444c7c095edb359580d19103044fa54bce674f",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/static25/seed_validation-physiological-00-s1073741825-r0/tick-state-hashes.jsonl": "3428c112a32024b539218aa6f4778cfa8c19c208bbdbfb2567324294370f23ea",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/adapter-provenance.json": "46d8ad74b409145c42f9066f992166f114cef2272bb0c6ea40c58438bdd39c13",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-applied.float32.npy": "b3a535bc095db2464a75560ed11f336a9db8e843c08fd7681a1b9759b624ad8e",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-component.json": "f94b360033b4cb643c9774e7fa31c95a65c5571ca62b73072ee29b3af80121f9",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-drive.float32.npy": "8b6432e8947f4c67466b5cae28cb0d0877b61862e80e6d9b10c5734d9afa8411",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-inhibition.float32.npy": "8f9e59026dc7c7663abf8f7abc60ebf93b11a68483bc0960d375a83731acc859",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-pending-tail.float32.npy": "fc1e2d8ffa426d4118a7544129323c5f7523e9df3e298a60922ca0ecabe7c18f",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-state.float32.npy": "36ecfec747be0c700959ba1ac171b81a1f3471aa9baba41b7bb6a67be01213c2",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/apl-timing-audit.json": "850600c0560f98c1f2de35bae506c5619205375e6616137a7e8ff978000b0c3a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/comparison.json": "3e55e8edaf7e3cf4453e37cf90d7a420808977665174ccf525dfef7553418d46",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/output-hashes.json": "aabd9f46a9697440f0cc0204455e831d16b7aadfdebe3e5a8c986bfe85d05300",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/overlay-audit.json": "22d13f7d6ad27cbe117e01117d46c0457781adf3a0bf2aa6748fe7f4b484aa56",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/overlay-input.npz": "0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/overlay-manifest.json": "902933628aabc9e084b547dfdaff0f8361d353949ba3ee92439a2f35d8625d8a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/queue.jsonl": "22fbf106279d5ad314beba357137701df111bb28b57accdb09a0e299dfdf39cf",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/requests.csv": "4bcc9ef7fdc596ddac3be3b0d29f0aea2e086deeb803f3a90baba21b5490ef53",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/sealed-gpu-source.diff": "0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/source-audit.json": "d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/state.npz": "933afdc1bd0ea81174aeb334f017cfbe1bbc0a72f8eca767698275c5dca886f3",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/summary.json": "244be6a69b8276a212b1601ab7235e58c0bd9d523c88368025b29f4b4664ddcf",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/gpu/zero/seed_validation-physiological-00-s1073741825-r0/tick-state-hashes.jsonl": "0266afe78eadd1ea5bfb25026103d01d2af82d9b6ce2bcbb9d60e576ac898e91",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/manifest.json": "9e24b682935a9b18e05db7a933080c5f63ddbeb8a0c85cc0df1cfe1d06d88ab4",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/static25.json": "96d8406b69e98ba9829a52788c6c96888493e8bf34581d6d653226b1eb2e494b",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/static25.npz": "7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/zero.json": "902933628aabc9e084b547dfdaff0f8361d353949ba3ee92439a2f35d8625d8a",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/overlays/zero.npz": "0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/base-candidate.float32-mV.npy": "1218d1b328f29a7afefb0ca0b7b6421247f14ad598aa1957a6a7aacbc8cebcae",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/prepared-hashes.json": "4af0bccbb9153be0d8cb65c5e4150946be3396ca351eab52b273c86459200580",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/protocol/preregistered.json": "465886b78ada08092c2c83de278844707499718977fb6dc6a7608391da0e5304",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/regression/frozen-five.json": "905c64c8b3f7de942d55f6ecb76c27c42821691a9fd3e0c17ffb466e1de0fea0",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/regression/old-integrity-after.json": "7d3de4ba6248cc52960087bcfa2658f9b8ee34d9ac08c56380f7018c34097929",
+    "/data/digital-drosophila/experiments/phase4am-wholebrain-plastic-interface/regression/old-integrity-before.json": "7d3de4ba6248cc52960087bcfa2658f9b8ee34d9ac08c56380f7018c34097929",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s00/template-spec.json": "065e4b01b74ac6619f6533c54fdb58a345fffe7be30ae2295e50ab7015da888a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s01/template-spec.json": "38001935f07393a08f8c83595541a6ff060b0f9ca7b9fdaf357e2f77f9348994",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s02/template-spec.json": "c89d7994d40fc79591c78d11c549766b45d283145fdcebb1e3b6c964b8750b2a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s03/template-spec.json": "390f3d472a2baf3b7d14f1bb22185e027fb1c5ede8f42bfbd8e7c2051e78d0fe",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--light-s04/template-spec.json": "90a262080e33a6014679e7f3d932f61e1edb04cffcd9a2cf35440c078a9085f4",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s00/template-spec.json": "3b63e236d755714dc59b083b2ee48761ce48e9a8456770e3502798f5bd5e2ff6",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s01/template-spec.json": "595a1a67fd82b48e0db25480771a93bd289e8f65c511c43780b42dabf9c8b478",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s02/template-spec.json": "bda9afb21aebd4cf37d52a0cb83c21f179ca4fe9aca8a43e5a1cc92f2af81897",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s03/template-spec.json": "246cbb287972c7539c4f53bc2546bd9cdd0dd960e8714bce060db1bee1ba0fc9",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--chain--reference-s04/template-spec.json": "de59abaa0670a9be8d90a9dd9b41522edd277d9f75dbdb77ddeeeca1c508265f",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r0/template-spec.json": "802b717691f9a6b460a1a58044286e727ffa8393605127ee7a11ad267fbf6338",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r1/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--light-r1/template-spec.json": "f4cdfd5de0fb80dd39203425c4ff7d063b0b66f2ac887e4276043251e3ad956c",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--reference-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--fresh--reference-r0/template-spec.json": "2ee541997a8a82f9ac356e9fedf8fc70ce31f622d42d846ab6de8c5f6cdea39f",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0018/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0018/template-spec.json": "282eccfb1ee2008f0b9ae8cca4daf45bfefd664806e7d04b8712fadf90b83bb5",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0019/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0019/template-spec.json": "8cd7512a1b2cdef47aecfd26bfb7ee8b22b566dc6c6812e887b4cc3f5416e7e3",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0500/requests.npz": "aa2773a740b0e85940f3d96738a141903d5d178e40586522b603ae1c9de53e98",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/static25--prefix--reference-t0500/template-spec.json": "654043502385a40dc4396c25ab2bf6f74701a7026fc85e6789672a810e5f700e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s00/template-spec.json": "e8f6fe8e0f67cbe851c045a067485d753979f5af32d30f596f545387b306f123",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s01/template-spec.json": "b727d54f9d28e9b8482860c3ed2bb6c30d4778fe90644b2df9ebb8d0c032e148",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s02/template-spec.json": "8af5bc5ed35084f15c7d77ded8224d49f49561d48510c862410eccd4d7dc5560",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s03/template-spec.json": "7e140b41ae610cd67a8cfe2e30d633190ac2c7689a4682bba676e423b54e689d",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--light-s04/template-spec.json": "5cc7905cdca67bdf09eb0730a274644f5605178b1c97928572c5ecf2a3b5acff",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s00/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s00/template-spec.json": "452da911a5f3d6d8cbd33e96451d6f65af5e46eee57fda00125c59f6378dfba6",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s01/requests.npz": "929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s01/template-spec.json": "b943e29941af75b7c4ff333bdc0a9697d0e15131bdea46c4460ef91f894565b2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s02/requests.npz": "517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s02/template-spec.json": "412390b67001e08930f243f54954d78e7edf94b330aee2087c35748963a883db",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s03/requests.npz": "be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s03/template-spec.json": "6d5f2819be44646890cdad1969043bee5209e801b79687a8c1c2205601bc9656",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s04/requests.npz": "764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--chain--reference-s04/template-spec.json": "d8bd2b1b151582ec7495e59a15cae15279f71d444429c5c273397b63008b3440",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r0/template-spec.json": "df1a6663ea748b0dc0333540877000e5c91d493b151e134e346dee54e834e3de",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r1/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--light-r1/template-spec.json": "32dce4105aaadac4f7079264cf0a30a3f8171862edf59cceaba6624f01a5252d",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--reference-r0/requests.npz": "003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--fresh--reference-r0/template-spec.json": "a0bf214d782ddef0adb5b6f9b89c2d52566a5928b5d96316bddfe12520aa5460",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0018/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0018/template-spec.json": "8400934e175d3c20f19d863082e7df02c5279864b5191736565e9014df6e0e83",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0019/requests.npz": "adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0019/template-spec.json": "9c361dfb9af4dd7071a7f1c3c2315adddb21b42e9ed5e9a199b1cdf52fab40e7",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0500/requests.npz": "aa2773a740b0e85940f3d96738a141903d5d178e40586522b603ae1c9de53e98",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/cases/zero--prefix--reference-t0500/template-spec.json": "bda640a599d6cdf80ad435f344fcd576d91ca0afe9de732f36fa7bd54d470c1e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/overlays/static25.json": "b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/overlays/zero.json": "11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/AM-gate-authority.json": "66257eb665808e33005dd7ba14a16063064618cc48e47cb65b70f3900cec2484",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/AM-seal-verification.json": "175b5d0e2de12a9ce01c6167591dab882d9c9c6869de2d194bcd9e6732c6ed6d",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/ENGINEERING_GATE_DRAFT.md": "1ac0d65b906e1061781c967cc6a99e8a0a73df6a1ee564ed6603f88e3f5d7056",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_analysis.py": "3970d13bd43d4bc12baf4b6ad1cda3eb085e10bf4648752cfcecb6d12314c5ea",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_compare.py": "5a2403f11bc08d65a9d242ac2cf9686b850e0c3680d65659f785e9b6b50c0238",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_inputs.py": "cc8c0e83016af4836c81cd0773fc521c69fd30e6f4d021bf54d0e7897105c6d5",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_plan.py": "3c127aee723a054fda272fee458067608b521a7c443455822d97f509caded6c7",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_prepare.py": "62dedce2439407398e70beb4c718bf14e02d3e624b3db3ef6f74299115d84bc1",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_queue_audit.py": "6ddaec52f2a0b5d0c528d51230d372fe2344160aef5eccea6a95b6c5e61a574e",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_scopes.py": "1043ba217e5395c9e81e58b95a5aa396f572588872b954e549774f2b99cac5df",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/engineering_workflow.py": "76313332b8d18f121a61f7b6e2fc32ea9e893848e8ed5d049557fc08b385e674",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/runtime_continuation.py": "0b8e8e0a6a23a079dc62a88355ce355d53b3ae22f6665519a8f6aef2dcfc5aba",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/runtime_light.py": "522b8c31ea938890fe15364fccd25ccc5bded54101754909f255532e7ad01aae",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_analysis.py": "35e4ee37a1e82cf5e645d24165343049d400104c94a6d184b8aa834ba5ef2d20",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_compare.py": "87a85843d918cce6529ab94f7cb82499aa413281e803c00c030a3c340a581469",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_inputs.py": "4dcc7b775eb3c7e59ed9cc3d7591eacc0ef7bda1209edbd847e2ae79b115ef1b",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_plan.py": "c26c2c75bb27d3b8514b7d44f40369130d60147c6c8edc569b4efba4a4ad9815",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_prepare.py": "a12aa1d2cb4880a3f7a7889b89d71a859bc8c68b4badfb8f082d712cdd342627",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_queue_audit.py": "0e2bcfe25c3b5a5cd0ed5cd05a89392207191ec4db950cdb06a0137666c8adb7",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_scopes.py": "748c0777e4a8164e80c03c727df1c2decbac7747737ad1c9fb730ea5c9e208d3",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_engineering_workflow.py": "bb781b23f92b5c0eb92f8dbc54468a8e843177f6da004c444b48947b037bd705",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_runtime_continuation.py": "325c0b688d0ca1648ffdf29a8d3d4bb91d6f6115bea6f5ac30982acd6dfe8e06",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/protocol/source-snapshot/test_runtime_light.py": "887345e497e6fa9c10ffa49c490196711d8cee028c62ec7a73f42db36569be2b",
+    "/data/digital-drosophila/experiments/phase4an-engineering-validation/regression/old-integrity-before.json": "68475cc0e72039e044c8fb3aaea9c8487c6737c1b8a457641e818581d81c387c",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/mappings/dan-to-compartment.parquet": "a16f72c3121ed0ec638c1a2b249ace446e6ccee020b49679818eb42589d00662",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/mappings/dan-to-mbon-confirmed.parquet": "730d000f25667b59181d2ee6703c64591229a8beab0856197ed71e68d799d191",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/mappings/mbon-to-compartment.parquet": "54f371f7e35b9def44becd1ba9bd2872861f4876b255b2c8ec46feee6473b70c",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/plastic-mask/plastic-edge-candidates.parquet": "e5075ee3e5a0edf3a4d197453847163cc295b254f21c67203159bba204b12a76",
+    "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/plastic-mask/plastic-edge-ids.int64.npy": "8b0fb6eb2e6c31da4d17dc20d890aa3f367e514f05642de5bad6b42a1611c05b",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/odor-encoder/frozen-odor-panel.parquet": "907f16a56e024a8e2112b5751e53b0e6037b329fa110098af3d31b119c10a1a0",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/odor-encoder/mapped-glomerular-vectors.npz": "f057563152e0fa22060080af13019f319e7f36563a775eff829bbc1929c451b0",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/odor-encoder/selection.json": "1b832becf9d08935716fe9ba5e3cd3e619e7d208dfb43c4fa197c969d095f113",
+    "/data/digital-drosophila/experiments/phase4l-olfactory-grounding/receptor-mapping/olfactory-mapping.parquet": "a01d27000533e9844458a4c559cac084f1c34ca20a1104e97e6a0f72b0cc93b1",
+    "/data/digital-drosophila/models/male-cns-lif/apl-timing-lab-v1/gpu_timing.py": "af1975ba5e5e700208c0a598d3cbe648a3cf10885c6231239b6e4b28f76d173b",
+    "/data/digital-drosophila/models/male-cns-lif/apl-timing-lab-v1/timing_queue.py": "54df6d4818e2a0c26e96fb0aaf5d9b71cd964981706da937562d48af79aca14e",
+    "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/gpu_apl.py": "69f5d893f47dafff4ef7c3186c3df0b9014666b32c8f4e943b57016bec92b18a",
+    "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py": "21ceec65fe42581dc55872010e0025d660e80358905f1cf4df1dadf341a3b291",
+    "/data/digital-drosophila/models/male-cns-lif/author-fullgraph-lab-v1/oracle_full.py": "d72003d98f0f1624b12126eff50bd361c43d888f4a64d90ba9247a58976f1961",
+    "/data/digital-drosophila/models/male-cns-lif/author-runtime-lab-v1/author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15",
+    "/data/digital-drosophila/models/male-cns-lif/author-runtime-lab-v1/author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e",
+    "/data/digital-drosophila/models/male-cns-lif/author-runtime-lab-v1/gpu_backend.py": "03758d07572f4b44d272059d9308fac534268ad201b57bdd77d69fee95e67278",
+    "/data/digital-drosophila/models/male-cns-lif/mb-physiology-v1/phase4j.py": "abb4574da85f00bd9ef61024c65993ef81d42651ff8d8d63c15dd69c6222471e",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/EVALUATION_POLICY_DRAFT.md": "a84170a61564715a1532f20df4c6a330f0f9725c383db48b8f3e1a4b5fba0bc8",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/EVIDENCE_DRAFT.md": "8455c12e3a6bb1b22a6e38f9017293fe5deea37ba3ec61e13598d00dafc12296",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/PROTOCOL_DRAFT.md": "8ebecb1f3d012ddc29a1cb727269dd277629c53565e09978bf9dbf7140cb8508",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/README_DRAFT.md": "50be97f64097b681355993a8afd7f467ea187e99e88b19ca30561e08d517999f",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/biological_contract.py": "e09f0f2b5e6ec746176e3a1aa2fdee1a15385e14e96bd343d14379a759f3ae43",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/conditioning_inputs.py": "19382e066e450140bb653a3661f980ffe7cc62f412020ef57df0b6e6b3cbb8ba",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/conditioning_update.py": "96efff678cff910654eb08e86f1a17789e4e5589e340345f419c7027a7d547e2",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/draft-source-inventory.json": "2c72d47d09b4ad1949dc6cfdc170f64847ff75f95ded5d20b421fb5a75e0eb84",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/evaluation_plan.py": "991c813ff3322b230947f302b12b04ec382c3b632817f94b698101e4b17efa7d",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/evaluation_policy.py": "21331a9ff3567dc6f6399e16bb91ef486d74231f5db51799beb6dd1bf71d022b",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/metrics.py": "47319e21db3c8b030b1bafbf0703cd86fb588d23bb29436accbacdba73d08c3c",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/seed_registry.py": "0da033b132095ec3087b5d9f64e53c2e391fa50ab0b7653b31296eeb84799b7e",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_biological_contract.py": "0ce796e6ad1a4cbcb9bcb760eff628a9562b4a809cc9c177a9a0d88df68f02b3",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_conditioning_inputs.py": "95e37c770e78ce722a3007c5b371c51aec2989634cddfe5b414ac3fa817e5c22",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_conditioning_update.py": "1c25d93753932ace06abc876fe0867546b3bb330de3e602da6aec7bb4588e4bd",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_evaluation_plan.py": "21d2402025122d8665fb1f32e184fd8e30fc17242810fc70901b7f7fc8c53bfa",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_evaluation_policy.py": "421a31b76eaa547e890c291d2c38a415352d9ccad6fccc800461f522ff4c83f1",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_metrics.py": "1928894d248dd37fad0fc67bc9dcfeac27c4d8be4aec22f54b9ef20a10ea8645",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_seed_registry.py": "7aca38f3c975e3ad4f6337d83b826c09afef336381d124c22ff0eb2eb60a0834",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/test_trial_plan.py": "927678956ae9959a047b1cd258ee8dee22eb6842a96ff4b2ba2db077310163c9",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-conditioning-lab-v1/trial_plan.py": "6fed3f494d075339a7e5b001d43b2598640b189e038952fbd4d41200bacac587",
+    "/data/digital-drosophila/models/male-cns-lif/olfactory-grounding-v1/phase4l.yaml": "9b8bcb7e031bf9063033a1854a439a7cd0bf6730301c2d2d02ca99a76f098d6e",
+    "/data/digital-drosophila/models/male-cns-lif/phase4l.py": "e97d58d8c1f44920d0e953f8f5831ddc86fa0198784e86460e315de4116ac553",
+    "/data/digital-drosophila/models/male-cns-lif/pn-recruitment-audit-v1/publication.py": "7a79c499098b74163e7bb16adabcbc54e7069dafa204d0b99c7f4c03d79f8016",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/checksums.sha256": "493f541756064d9d65603e550628656a6f2dbf44f8b862ef905e8c3fd2427a43",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/config.json": "c19f00c81f12c4c3503d3d557bd73d0722d4d3fed7279449408c67a89a6ffcf9",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/context.py": "0fa2e0892c973fe70ecbc0613e3cb508c256b7745042f8936edf23dedc31d166",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/eligibility_bridge.py": "174fb8d14619189e74b095e77a6db18b14c93046dc431c0b55710a5aa2dd2e61",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/manifest.json": "7edeb251ecbeac5a64805fefe171a0a0bf8bba2675919ef922cc1a329c203ea8",
+    "/data/digital-drosophila/models/male-cns-lif/wholebrain-plastic-interface-v1/overlay.py": "7f891d0ba79b393c96e75fd2dee2eddc51e57d8213eaac2779703bc2c18712b4"
+  },
+  "schema": "phase4an-epoch-postprocess-authority-v1"
+}

registry/conditioning-perf-prototype-20260930/manifest.json

@@ -0,0 +1,685 @@
+{
+  "files": {
+    "00-M-comparison.json": {
+      "bytes": 672,
+      "sha256": "39a687e4d429487fe20e859f4572f9e5245da94d7e8c7a74d51416be56f63904"
+    },
+    "01-N-comparison.json": {
+      "bytes": 670,
+      "sha256": "4c16e45b8b4e597e4a2bb5fe67959a8964cbaa4b554b6dc369c278522f309b07"
+    },
+    "02-M-comparison.json": {
+      "bytes": 669,
+      "sha256": "e01e6117630928ae5d897543d9a80f13f041e166fe2f5cecc255f33b4a55bfb7"
+    },
+    "03-N_D0-comparison.json": {
+      "bytes": 676,
+      "sha256": "b4929d59d6adeb523682f35a1338a2606ac3bc75ba81c6036e71ff6319988175"
+    },
+    "04-N_frozen-comparison.json": {
+      "bytes": 679,
+      "sha256": "5f306ff308e74e2b46c4f29308bb304abb6b96af7b98b4a63c8f50008a784037"
+    },
+    "05-M_D0-comparison.json": {
+      "bytes": 674,
+      "sha256": "de2b9eb21c157c5e0c0df49d00b99720fb4862fda2c2ebd276bf24df6b54e611"
+    },
+    "06-M-comparison.json": {
+      "bytes": 674,
+      "sha256": "be3a1b940c47cd17937cb1a9e9fc6a3e9a3bb018e3efbc0375821404a74f038f"
+    },
+    "benchmark-plan.json": {
+      "bytes": 53491,
+      "sha256": "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+    },
+    "inputs/M_D0.authority.json": {
+      "bytes": 44124,
+      "sha256": "56d89454417c4c7d8e4dd1dc3437ad0df55ded706b9e603681bbf491338cbf04"
+    },
+    "inputs/N_D0.authority.json": {
+      "bytes": 44218,
+      "sha256": "4a7ee78ca0671efa0cb5203f7ba405ae3a53b3e23ebfcb8bf52887ce20c0f40b"
+    },
+    "inputs/N_frozen.authority.json": {
+      "bytes": 44221,
+      "sha256": "3063f74a5dbbfb6afa92ee7692bbb0626017b0451072b838be2f9e0bc58748e3"
+    },
+    "logs/00-M-fresh-E.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/00-M-fresh-V.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/01-N-fresh-E.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/01-N-fresh-V.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/02-M-fresh-E.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/02-M-fresh-V.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/03-N_D0-fresh-E.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/03-N_D0-fresh-V.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/04-N_frozen-fresh-E.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/04-N_frozen-fresh-V.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/05-M_D0-fresh-E.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/05-M_D0-fresh-V.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/06-M-fresh-E.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/06-M-fresh-V.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/resident-E.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "logs/resident-V.stderr.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "processes/00-M-fresh-E.json": {
+      "bytes": 753,
+      "sha256": "99efe36c00689aedf8b2d03125881c26089dd7070852e53e97a235fd5c566286"
+    },
+    "processes/00-M-fresh-V.json": {
+      "bytes": 772,
+      "sha256": "f4a5416aa8a846f68dbc6a07794ff63114e4c1ce103bca421b512bfe880e9f2d"
+    },
+    "processes/01-N-fresh-E.json": {
+      "bytes": 753,
+      "sha256": "8c5d547f1cc88d2cdcb45d2673fbd95e4c62f3065d8b752c4397e5904a426fbf"
+    },
+    "processes/01-N-fresh-V.json": {
+      "bytes": 772,
+      "sha256": "9f06a8339443eff51d54a9824d662f993dcd0e2984d25293bab180691e4d2b22"
+    },
+    "processes/02-M-fresh-E.json": {
+      "bytes": 752,
+      "sha256": "31595cf71a13d08075c50bf4de5780f988d8cb8b50dc19c406c3ea120d9ca1b7"
+    },
+    "processes/02-M-fresh-V.json": {
+      "bytes": 772,
+      "sha256": "cd97bf45bb88e7ec96019efa59b5e181bc3c08f9f220f8754f86cec8ca6999ac"
+    },
+    "processes/03-N_D0-fresh-E.json": {
+      "bytes": 753,
+      "sha256": "91d3ea18146ffbda446cc6ee3517db75fe7097365fa5639d0a22474e64198bf1"
+    },
+    "processes/03-N_D0-fresh-V.json": {
+      "bytes": 773,
+      "sha256": "928d1d53a117ac74dc6bb548e2fe8b164a96dd3b50e95df3d25c7b40ee8c149a"
+    },
+    "processes/04-N_frozen-fresh-E.json": {
+      "bytes": 752,
+      "sha256": "4579c057330a326802fbfac2a963667709348e6c1075608f71298bd62bab2e4d"
+    },
+    "processes/04-N_frozen-fresh-V.json": {
+      "bytes": 773,
+      "sha256": "6080b54205941320e5a44eef0d4909a36e42f1e3eb7c1a57cbca7375c0d331ed"
+    },
+    "processes/05-M_D0-fresh-E.json": {
+      "bytes": 752,
+      "sha256": "cd92d6f19c7b18a6a2bf08105b4bb843a30ff6ddf0537ffa2fe57649e7b914f5"
+    },
+    "processes/05-M_D0-fresh-V.json": {
+      "bytes": 771,
+      "sha256": "3468ad068a18e331b1788d39bf7982b18c193b710ad441c54e83bf12abd05ee9"
+    },
+    "processes/06-M-fresh-E.json": {
+      "bytes": 753,
+      "sha256": "7ab517b43442e3bcc635c76a3a465982438cc60aae8cb0f2422ff3edca005692"
+    },
+    "processes/06-M-fresh-V.json": {
+      "bytes": 773,
+      "sha256": "bf743182d595508a7938c2c2b94987017c8c576a7b1c37c3f43ab773cfc0c893"
+    },
+    "processes/resident-E.json": {
+      "bytes": 757,
+      "sha256": "b24e427266675f7076e9d9d125eee3eda194a75b16a3d4b95ec897d322179038"
+    },
+    "processes/resident-V.json": {
+      "bytes": 774,
+      "sha256": "a8aebd5ee47bbe168fde923cc59dc77010aa6e2ac8d210e66247fa95ce87829d"
+    },
+    "report.json": {
+      "bytes": 7021,
+      "sha256": "cbc17c10871514279adb6b38338511daa0588ba8f8c91129787c84fd51885339"
+    },
+    "requests/00-M-fresh-E-00.json": {
+      "bytes": 359,
+      "sha256": "0c036fcc5d60f389717dbdb79514a36b8e04ec05bac739f5972e768fdfa65016"
+    },
+    "requests/00-M-fresh-V-00.json": {
+      "bytes": 482,
+      "sha256": "87ad30611b54095773649bb7da4079a256f2ec07bd597a4493adf4127299cd67"
+    },
+    "requests/01-N-fresh-E-00.json": {
+      "bytes": 367,
+      "sha256": "285a45dda2ed0d6b4307397923f2bb32dbc1568eebef48e80c3726f9cf28d4e6"
+    },
+    "requests/01-N-fresh-V-00.json": {
+      "bytes": 490,
+      "sha256": "019f1b8e1717633f2c130bf06158c2fe6bfd41d6e61d598315da5c9a30492099"
+    },
+    "requests/02-M-fresh-E-00.json": {
+      "bytes": 359,
+      "sha256": "ff755e750ab54ddae2fb65527e735bdf7aa149a511c13c04dd3a720ead945ba3"
+    },
+    "requests/02-M-fresh-V-00.json": {
+      "bytes": 482,
+      "sha256": "e831726822ab61fda8a5278aac1c0c28909dc1c05cfda2869b5e81fe64935817"
+    },
+    "requests/03-N_D0-fresh-E-00.json": {
+      "bytes": 306,
+      "sha256": "e1d460664e725554207816e66e55e95059a52675812d6d9c38b6209a793d3ca0"
+    },
+    "requests/03-N_D0-fresh-V-00.json": {
+      "bytes": 432,
+      "sha256": "709d3eaf0f4e678072543e8f5754bc5f82c0868b9aa91169c02cac13f072c0a6"
+    },
+    "requests/04-N_frozen-fresh-E-00.json": {
+      "bytes": 314,
+      "sha256": "b16faa5981d7285a7878228a6d9bdc88eed8c536c96248df665d8d8580d22c50"
+    },
+    "requests/04-N_frozen-fresh-V-00.json": {
+      "bytes": 444,
+      "sha256": "761589d06ef5a140d8308ff54ba334eea1c2b13af9b3a55b72bf492a59e179b9"
+    },
+    "requests/05-M_D0-fresh-E-00.json": {
+      "bytes": 306,
+      "sha256": "e19cd608d72b87e7a75ef1aea53e2d037c92e3be54aa17fbd62bb5f213f2599d"
+    },
+    "requests/05-M_D0-fresh-V-00.json": {
+      "bytes": 432,
+      "sha256": "bb8a9b43ce0d7ffa752a87ea596f0f0cfe530048a6e48b030aa2e330908b3174"
+    },
+    "requests/06-M-fresh-E-00.json": {
+      "bytes": 359,
+      "sha256": "5bc882bb5c90fa3a1f6827eec002107c3293dccbccd955579fc31696be97c181"
+    },
+    "requests/06-M-fresh-V-00.json": {
+      "bytes": 482,
+      "sha256": "233829f2de1c9ce74e9457c701ed6eeea3d711852ed437d9067587e504f363e4"
+    },
+    "requests/resident-E-00.json": {
+      "bytes": 362,
+      "sha256": "9c941391195203054ff858f1aa53b5a17a02e40d523b397fa0b5d9350aff409a"
+    },
+    "requests/resident-E-01.json": {
+      "bytes": 370,
+      "sha256": "ee804ffb504351eeba8657803f307fefd0eb4621f7d3ce2131381df50a77f41d"
+    },
+    "requests/resident-E-02.json": {
+      "bytes": 362,
+      "sha256": "bf8f3de8033466d15e6e96f3374ae82e4186f36a13011cf9c2a87054107b17df"
+    },
+    "requests/resident-E-03.json": {
+      "bytes": 309,
+      "sha256": "b5aa4c631cd55aa124d070a0276d27c1bead9299478298a7339a63048d816488"
+    },
+    "requests/resident-E-04.json": {
+      "bytes": 317,
+      "sha256": "d498fab23ad4699c3d68ebe4e653c65ad8e83a134e58bca1f81a114ebd2d3fe4"
+    },
+    "requests/resident-E-05.json": {
+      "bytes": 309,
+      "sha256": "2672d9f8a16391d02c781143407daaa18abb72b2e0e16aa48c5426474dcfd69b"
+    },
+    "requests/resident-E-06.json": {
+      "bytes": 362,
+      "sha256": "a0405d5298cbe7b7192874d80167c63a695bebc809489030e6db8b4a7c0dad37"
+    },
+    "requests/resident-V-00.json": {
+      "bytes": 485,
+      "sha256": "c7f0f2a9fcd2a39c5d0b9e33fb147b9fade256ebc39d8fd8a130afb16977ac2c"
+    },
+    "requests/resident-V-01.json": {
+      "bytes": 493,
+      "sha256": "9fbeaa6c0a34ef520e150bc7ebd74586d092403df86e09a7ef80ca436a864cfa"
+    },
+    "requests/resident-V-02.json": {
+      "bytes": 485,
+      "sha256": "57efb661a6708697d939c4a5baaf81200b8a501550ff249a2c3fe5fa8795cb21"
+    },
+    "requests/resident-V-03.json": {
+      "bytes": 435,
+      "sha256": "7cd6601f279f58c36b4aa9e76d52a87766d156400f280a0fa760a43d5c049da2"
+    },
+    "requests/resident-V-04.json": {
+      "bytes": 447,
+      "sha256": "9e4d3f6a2f61e6956c599f9917a623ea68b93eef3aa990a849ed7db2cb42d7f0"
+    },
+    "requests/resident-V-05.json": {
+      "bytes": 435,
+      "sha256": "cd9da315302c2f962e97a511b972bb036befc8ae1b8e63f061d4f89817741c71"
+    },
+    "requests/resident-V-06.json": {
+      "bytes": 485,
+      "sha256": "39f5b6b99ea6b7e8021ab644563be8158a03257b83c8432d72a115b15b684b01"
+    },
+    "responses/00-M-fresh-E-00.json": {
+      "bytes": 754,
+      "sha256": "e0ce74fb5eabba2043ea2912bced998300159b44c47f3dd1afef27f597fbc3c2"
+    },
+    "responses/00-M-fresh-V-00.json": {
+      "bytes": 465,
+      "sha256": "482bb5ccca165daa4f4834954de20fb474e0d6c2f83fe569e252381c27840bea"
+    },
+    "responses/01-N-fresh-E-00.json": {
+      "bytes": 755,
+      "sha256": "7d4883394d3220cc258bb165f74d585f7c42f283023e06ac44782fe3e2e52db9"
+    },
+    "responses/01-N-fresh-V-00.json": {
+      "bytes": 463,
+      "sha256": "5853b2e0fdb643174d028d8e894b29282bacc1cd5225157f826170f7b28590f1"
+    },
+    "responses/02-M-fresh-E-00.json": {
+      "bytes": 756,
+      "sha256": "843c986f7bcbb82ea2cecd8b54db9b5e88cb69c9d003ad24d62e3bb8125cf299"
+    },
+    "responses/02-M-fresh-V-00.json": {
+      "bytes": 466,
+      "sha256": "39456b8335c900cc93ea59234ea7626b5430acfc40b49759c2e1a9ffc546f620"
+    },
+    "responses/03-N_D0-fresh-E-00.json": {
+      "bytes": 754,
+      "sha256": "44abfa7527a829165c960d73709b5fecbda63381a038a2e12a9a96b408545134"
+    },
+    "responses/03-N_D0-fresh-V-00.json": {
+      "bytes": 465,
+      "sha256": "36af90eff9eee027c9e9dedf6378989ef6d5f492e87cdccc6eb2e78c44b8b9f2"
+    },
+    "responses/04-N_frozen-fresh-E-00.json": {
+      "bytes": 752,
+      "sha256": "b35bb47e3bc849a460bc4ce80dc7a42963d340b868ef9972a0761e6e9c26d947"
+    },
+    "responses/04-N_frozen-fresh-V-00.json": {
+      "bytes": 465,
+      "sha256": "6b2074fc2b224b833a6ad40d84e9fc87330f399c1d69a89331db094058edaed5"
+    },
+    "responses/05-M_D0-fresh-E-00.json": {
+      "bytes": 754,
+      "sha256": "891425180e901c96419050d2a1d01686f1a071e37ace81a9ede821049016c5ae"
+    },
+    "responses/05-M_D0-fresh-V-00.json": {
+      "bytes": 465,
+      "sha256": "344f922e00d7825ea95eaf1d6c8ba2a2840d3eecace86ce9cba4fba02b46a196"
+    },
+    "responses/06-M-fresh-E-00.json": {
+      "bytes": 754,
+      "sha256": "c14c18bb55adf2a34acfc83cc92f07929573f45f8e92b9091c33e5acd8756cf9"
+    },
+    "responses/06-M-fresh-V-00.json": {
+      "bytes": 465,
+      "sha256": "1002e804c94132323afe39f1bf0b242ce7106dacc6c549f6a1f9f36ddac6fe17"
+    },
+    "responses/resident-E-00.json": {
+      "bytes": 754,
+      "sha256": "87b46dbbd6c249b764f106d9f9724b4893b117618e40d0658e5b748c36d794fd"
+    },
+    "responses/resident-E-01.json": {
+      "bytes": 756,
+      "sha256": "0344bc30e04e444251e21aad785548fb8fd6b579410821559c305c1b3153664a"
+    },
+    "responses/resident-E-02.json": {
+      "bytes": 754,
+      "sha256": "f48827fac98f48198ae0ae9e527682b5b7b46e76d0eca51bbae0bdf8cce1c26b"
+    },
+    "responses/resident-E-03.json": {
+      "bytes": 756,
+      "sha256": "deff02be73129009cd86829cdfb1c43f70b7343b76280c14097624d6fea61f41"
+    },
+    "responses/resident-E-04.json": {
+      "bytes": 753,
+      "sha256": "712219ec3bd51f98494169bc953efa4c72b3903e4a2f0ded525361af4917654d"
+    },
+    "responses/resident-E-05.json": {
+      "bytes": 754,
+      "sha256": "a35194007dae681de81e79e066f2e52f4e81847d21f88e8886f18a9e3d9d9876"
+    },
+    "responses/resident-E-06.json": {
+      "bytes": 754,
+      "sha256": "fe4f5ce8950bd560bab847ef7fe011ffa0b81b1ce2709b348ba1d8ddeec3ccab"
+    },
+    "responses/resident-V-00.json": {
+      "bytes": 464,
+      "sha256": "a8fdc9ff0882086e0ff9a2fd67b99dacf0b6eb18b5afa47c21f756b38a68bdb8"
+    },
+    "responses/resident-V-01.json": {
+      "bytes": 465,
+      "sha256": "fcc1773da52a87e6d1f558e3604d95babc9555ec5d5eaa08fcffaa878ba55967"
+    },
+    "responses/resident-V-02.json": {
+      "bytes": 464,
+      "sha256": "3eae756338c3e4a02f4033c4ffde131a234d7c8ef10ae3efc543695549bad031"
+    },
+    "responses/resident-V-03.json": {
+      "bytes": 464,
+      "sha256": "000c73862f6d2aed868e15a93861e7da0c88c40b5763cb0c999219fc93dba129"
+    },
+    "responses/resident-V-04.json": {
+      "bytes": 463,
+      "sha256": "dcd1bd45b5189fea3f9ea94cf6b4576a7bcc6552fcce6641e56f8ec5c40c4fde"
+    },
+    "responses/resident-V-05.json": {
+      "bytes": 464,
+      "sha256": "bb31eade6500f5afe5f48574fed6c1f9ee650ada98b0d479b249f9d49f1730ab"
+    },
+    "responses/resident-V-06.json": {
+      "bytes": 464,
+      "sha256": "deab50586b7a990ea759a45fde7ff2a7c1888b5d44534851d0148127726ba05d"
+    },
+    "updates/00-M-fresh/chain-receipt.json": {
+      "bytes": 44380,
+      "sha256": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305"
+    },
+    "updates/00-M-fresh/delta-after.npz": {
+      "bytes": 31769,
+      "sha256": "35b55ff715e797221163e812e4128a700eb05a4546d7f3f13dc5edc547aeb8e6"
+    },
+    "updates/00-M-fresh/overlay-manifest.json": {
+      "bytes": 1085,
+      "sha256": "60f77f30609859a718db1004e6da1c23730736285c5a1d845ec0da97385b01be"
+    },
+    "updates/00-M-fresh/update-receipt.json": {
+      "bytes": 7608,
+      "sha256": "d26c0fec7b1fcd8bbb5f7fb86b094c0870f1f0a4b29be1b3def77b66b6a3cbb5"
+    },
+    "updates/00-M-resident/chain-receipt.json": {
+      "bytes": 44380,
+      "sha256": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305"
+    },
+    "updates/00-M-resident/delta-after.npz": {
+      "bytes": 31769,
+      "sha256": "35b55ff715e797221163e812e4128a700eb05a4546d7f3f13dc5edc547aeb8e6"
+    },
+    "updates/00-M-resident/overlay-manifest.json": {
+      "bytes": 1085,
+      "sha256": "60f77f30609859a718db1004e6da1c23730736285c5a1d845ec0da97385b01be"
+    },
+    "updates/00-M-resident/update-receipt.json": {
+      "bytes": 7608,
+      "sha256": "d26c0fec7b1fcd8bbb5f7fb86b094c0870f1f0a4b29be1b3def77b66b6a3cbb5"
+    },
+    "updates/01-N-fresh/chain-receipt.json": {
+      "bytes": 44837,
+      "sha256": "c4a45ddcfea6b1800ccb6f737733b7e13b726e54e8f10e145ac6787527fffd9e"
+    },
+    "updates/01-N-fresh/delta-after.npz": {
+      "bytes": 32463,
+      "sha256": "af15c05aa9ce0fdcd2b47dcc8bef426a242f84efe7b45e79c345ff4d361d23b4"
+    },
+    "updates/01-N-fresh/overlay-manifest.json": {
+      "bytes": 1085,
+      "sha256": "a98095968f62fe7375e5acab89dbfbf55de6a28760f93dc1f5b48f238a4c54c5"
+    },
+    "updates/01-N-fresh/update-receipt.json": {
+      "bytes": 7637,
+      "sha256": "18c47fc5fceb4f1b52d601ed5114eec8239156677c44bfe364706a7e7d2fc972"
+    },
+    "updates/01-N-resident/chain-receipt.json": {
+      "bytes": 44837,
+      "sha256": "c4a45ddcfea6b1800ccb6f737733b7e13b726e54e8f10e145ac6787527fffd9e"
+    },
+    "updates/01-N-resident/delta-after.npz": {
+      "bytes": 32463,
+      "sha256": "af15c05aa9ce0fdcd2b47dcc8bef426a242f84efe7b45e79c345ff4d361d23b4"
+    },
+    "updates/01-N-resident/overlay-manifest.json": {
+      "bytes": 1085,
+      "sha256": "a98095968f62fe7375e5acab89dbfbf55de6a28760f93dc1f5b48f238a4c54c5"
+    },
+    "updates/01-N-resident/update-receipt.json": {
+      "bytes": 7637,
+      "sha256": "18c47fc5fceb4f1b52d601ed5114eec8239156677c44bfe364706a7e7d2fc972"
+    },
+    "updates/02-M-fresh/chain-receipt.json": {
+      "bytes": 44380,
+      "sha256": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305"
+    },
+    "updates/02-M-fresh/delta-after.npz": {
+      "bytes": 31769,
+      "sha256": "35b55ff715e797221163e812e4128a700eb05a4546d7f3f13dc5edc547aeb8e6"
+    },
+    "updates/02-M-fresh/overlay-manifest.json": {
+      "bytes": 1085,
+      "sha256": "60f77f30609859a718db1004e6da1c23730736285c5a1d845ec0da97385b01be"
+    },
+    "updates/02-M-fresh/update-receipt.json": {
+      "bytes": 7608,
+      "sha256": "d26c0fec7b1fcd8bbb5f7fb86b094c0870f1f0a4b29be1b3def77b66b6a3cbb5"
+    },
+    "updates/02-M-resident/chain-receipt.json": {
+      "bytes": 44380,
+      "sha256": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305"
+    },
+    "updates/02-M-resident/delta-after.npz": {
+      "bytes": 31769,
+      "sha256": "35b55ff715e797221163e812e4128a700eb05a4546d7f3f13dc5edc547aeb8e6"
+    },
+    "updates/02-M-resident/overlay-manifest.json": {
+      "bytes": 1085,
+      "sha256": "60f77f30609859a718db1004e6da1c23730736285c5a1d845ec0da97385b01be"
+    },
+    "updates/02-M-resident/update-receipt.json": {
+      "bytes": 7608,
+      "sha256": "d26c0fec7b1fcd8bbb5f7fb86b094c0870f1f0a4b29be1b3def77b66b6a3cbb5"
+    },
+    "updates/03-N_D0-fresh/chain-receipt.json": {
+      "bytes": 44711,
+      "sha256": "9869be774efc4d5ffbce36633438bd5187e9c826339c6abc2f682380a11ce531"
+    },
+    "updates/03-N_D0-fresh/delta-after.npz": {
+      "bytes": 32303,
+      "sha256": "b89e407a5d93b5f1901f901b00428dc19bd20cee2d81e57b117a2fa68d200a48"
+    },
+    "updates/03-N_D0-fresh/overlay-manifest.json": {
+      "bytes": 1085,
+      "sha256": "0d2a2aac09c75eb2729ccc1d5e6ec753f31334febbfe4f89d6bc1a9c591607d1"
+    },
+    "updates/03-N_D0-fresh/update-receipt.json": {
+      "bytes": 7632,
+      "sha256": "92181e3ca11089f7a1eba8b6e17284dec22a8786e81fe65e14adf69c7fd24aa5"
+    },
+    "updates/03-N_D0-resident/chain-receipt.json": {
+      "bytes": 44711,
+      "sha256": "9869be774efc4d5ffbce36633438bd5187e9c826339c6abc2f682380a11ce531"
+    },
+    "updates/03-N_D0-resident/delta-after.npz": {
+      "bytes": 32303,
+      "sha256": "b89e407a5d93b5f1901f901b00428dc19bd20cee2d81e57b117a2fa68d200a48"
+    },
+    "updates/03-N_D0-resident/overlay-manifest.json": {
+      "bytes": 1085,
+      "sha256": "0d2a2aac09c75eb2729ccc1d5e6ec753f31334febbfe4f89d6bc1a9c591607d1"
+    },
+    "updates/03-N_D0-resident/update-receipt.json": {
+      "bytes": 7632,
+      "sha256": "92181e3ca11089f7a1eba8b6e17284dec22a8786e81fe65e14adf69c7fd24aa5"
+    },
+    "updates/04-N_frozen-fresh/chain-receipt.json": {
+      "bytes": 44722,
+      "sha256": "53e51b4d3900e87eb40153c3dbe40e9e3f2b000bd9ac2dbba791e81d7aca04ae"
+    },
+    "updates/04-N_frozen-fresh/delta-after.npz": {
+      "bytes": 32303,
+      "sha256": "b89e407a5d93b5f1901f901b00428dc19bd20cee2d81e57b117a2fa68d200a48"
+    },
+    "updates/04-N_frozen-fresh/overlay-manifest.json": {
+      "bytes": 1085,
+      "sha256": "0d2a2aac09c75eb2729ccc1d5e6ec753f31334febbfe4f89d6bc1a9c591607d1"
+    },
+    "updates/04-N_frozen-fresh/update-receipt.json": {
+      "bytes": 7498,
+      "sha256": "545007d844de8b1717325d4cd79040907396019b1e7521219bb5b885ac224f33"
+    },
+    "updates/04-N_frozen-resident/chain-receipt.json": {
+      "bytes": 44722,
+      "sha256": "53e51b4d3900e87eb40153c3dbe40e9e3f2b000bd9ac2dbba791e81d7aca04ae"
+    },
+    "updates/04-N_frozen-resident/delta-after.npz": {
+      "bytes": 32303,
+      "sha256": "b89e407a5d93b5f1901f901b00428dc19bd20cee2d81e57b117a2fa68d200a48"
+    },
+    "updates/04-N_frozen-resident/overlay-manifest.json": {
+      "bytes": 1085,
+      "sha256": "0d2a2aac09c75eb2729ccc1d5e6ec753f31334febbfe4f89d6bc1a9c591607d1"
+    },
+    "updates/04-N_frozen-resident/update-receipt.json": {
+      "bytes": 7498,
+      "sha256": "545007d844de8b1717325d4cd79040907396019b1e7521219bb5b885ac224f33"
+    },
+    "updates/05-M_D0-fresh/chain-receipt.json": {
+      "bytes": 44278,
+      "sha256": "c374052af5c9da2084fefbaf3b874803c8dda4d4d23fd0979578ea0241e3ecfc"
+    },
+    "updates/05-M_D0-fresh/delta-after.npz": {
+      "bytes": 31757,
+      "sha256": "0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5"
+    },
+    "updates/05-M_D0-fresh/overlay-manifest.json": {
+      "bytes": 1085,
+      "sha256": "3be5d1a9d7dd1d8a580f272d3dca3616adbc157fafb4fbdfc89258719650c01e"
+    },
+    "updates/05-M_D0-fresh/update-receipt.json": {
+      "bytes": 7591,
+      "sha256": "ef8a17cbe35f973c58ae76884597100286ec0d70e987ef83b5c92add3d266312"
+    },
+    "updates/05-M_D0-resident/chain-receipt.json": {
+      "bytes": 44278,
+      "sha256": "c374052af5c9da2084fefbaf3b874803c8dda4d4d23fd0979578ea0241e3ecfc"
+    },
+    "updates/05-M_D0-resident/delta-after.npz": {
+      "bytes": 31757,
+      "sha256": "0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5"
+    },
+    "updates/05-M_D0-resident/overlay-manifest.json": {
+      "bytes": 1085,
+      "sha256": "3be5d1a9d7dd1d8a580f272d3dca3616adbc157fafb4fbdfc89258719650c01e"
+    },
+    "updates/05-M_D0-resident/update-receipt.json": {
+      "bytes": 7591,
+      "sha256": "ef8a17cbe35f973c58ae76884597100286ec0d70e987ef83b5c92add3d266312"
+    },
+    "updates/06-M-fresh/chain-receipt.json": {
+      "bytes": 44380,
+      "sha256": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305"
+    },
+    "updates/06-M-fresh/delta-after.npz": {
+      "bytes": 31769,
+      "sha256": "35b55ff715e797221163e812e4128a700eb05a4546d7f3f13dc5edc547aeb8e6"
+    },
+    "updates/06-M-fresh/overlay-manifest.json": {
+      "bytes": 1085,
+      "sha256": "60f77f30609859a718db1004e6da1c23730736285c5a1d845ec0da97385b01be"
+    },
+    "updates/06-M-fresh/update-receipt.json": {
+      "bytes": 7608,
+      "sha256": "d26c0fec7b1fcd8bbb5f7fb86b094c0870f1f0a4b29be1b3def77b66b6a3cbb5"
+    },
+    "updates/06-M-resident/chain-receipt.json": {
+      "bytes": 44380,
+      "sha256": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305"
+    },
+    "updates/06-M-resident/delta-after.npz": {
+      "bytes": 31769,
+      "sha256": "35b55ff715e797221163e812e4128a700eb05a4546d7f3f13dc5edc547aeb8e6"
+    },
+    "updates/06-M-resident/overlay-manifest.json": {
+      "bytes": 1085,
+      "sha256": "60f77f30609859a718db1004e6da1c23730736285c5a1d845ec0da97385b01be"
+    },
+    "updates/06-M-resident/update-receipt.json": {
+      "bytes": 7608,
+      "sha256": "d26c0fec7b1fcd8bbb5f7fb86b094c0870f1f0a4b29be1b3def77b66b6a3cbb5"
+    },
+    "validation/00-M-fresh.json": {
+      "bytes": 1865,
+      "sha256": "be69678fb053f0904cd118bc5acdc09085cb780a1997c9a18b9d9661c5922d82"
+    },
+    "validation/00-M-resident.json": {
+      "bytes": 2229,
+      "sha256": "4314d615874a8d8da77655a0125c7feb6138df0bc85c0686e94496b96a4a3459"
+    },
+    "validation/01-N-fresh.json": {
+      "bytes": 1865,
+      "sha256": "b8f4a419a55f8b057973a2e2f1e97d7869200831852b5f05e97ca10f036e5363"
+    },
+    "validation/01-N-resident.json": {
+      "bytes": 2229,
+      "sha256": "dbadc825f3d52fba6331529dda7ea613931e24977379a87ab91aba669cc9a227"
+    },
+    "validation/02-M-fresh.json": {
+      "bytes": 1865,
+      "sha256": "be69678fb053f0904cd118bc5acdc09085cb780a1997c9a18b9d9661c5922d82"
+    },
+    "validation/02-M-resident.json": {
+      "bytes": 2229,
+      "sha256": "4314d615874a8d8da77655a0125c7feb6138df0bc85c0686e94496b96a4a3459"
+    },
+    "validation/03-N_D0-fresh.json": {
+      "bytes": 1865,
+      "sha256": "375a56ec0d3cff73190778dee6babae9f531e4b94e489024cb3aabc8c3b1b81b"
+    },
+    "validation/03-N_D0-resident.json": {
+      "bytes": 2229,
+      "sha256": "559b70274970dd45ed5fe7e80afe5b9ee8462e9f01eae5a9bcc4de8d5ae87b0a"
+    },
+    "validation/04-N_frozen-fresh.json": {
+      "bytes": 1865,
+      "sha256": "3a1b503977351da83617dbef8d3282df78a1d1525e02de6b9c2b5f11103d8692"
+    },
+    "validation/04-N_frozen-resident.json": {
+      "bytes": 2229,
+      "sha256": "fc21354854418cd0418ca6cf93400355e670ebec8f6964d332bf572e57e7afbf"
+    },
+    "validation/05-M_D0-fresh.json": {
+      "bytes": 1865,
+      "sha256": "21ff335bd8f1ac9c92d98e153183978970dd55efa0ca90c530407238b25598fa"
+    },
+    "validation/05-M_D0-resident.json": {
+      "bytes": 2229,
+      "sha256": "dbedc16911deab6116e3db5cb9422329409b4a9e982d027367e4f11f9ef22415"
+    },
+    "validation/06-M-fresh.json": {
+      "bytes": 1865,
+      "sha256": "be69678fb053f0904cd118bc5acdc09085cb780a1997c9a18b9d9661c5922d82"
+    },
+    "validation/06-M-resident.json": {
+      "bytes": 2229,
+      "sha256": "4314d615874a8d8da77655a0125c7feb6138df0bc85c0686e94496b96a4a3459"
+    }
+  },
+  "manifest_self_excluded": true
+}

registry/conditioning-perf-prototype-20260930/processes/00-M-fresh-E.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "update",
+    "--mode",
+    "once",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 4.8041809019996435,
+  "mode": "once",
+  "pid": 735421,
+  "role": "update",
+  "startup_seconds": 0.03941856900200946,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 1
+}

registry/conditioning-perf-prototype-20260930/processes/00-M-fresh-V.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "verify-reference",
+    "--mode",
+    "once",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 4.153049107000697,
+  "mode": "once",
+  "pid": 735682,
+  "role": "verify-reference",
+  "startup_seconds": 0.03956143800314749,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 1
+}

registry/conditioning-perf-prototype-20260930/processes/01-N-fresh-E.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "update",
+    "--mode",
+    "once",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 4.551296638994245,
+  "mode": "once",
+  "pid": 735877,
+  "role": "update",
+  "startup_seconds": 0.041211482996004634,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 1
+}

registry/conditioning-perf-prototype-20260930/processes/01-N-fresh-V.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "verify-reference",
+    "--mode",
+    "once",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 3.902626559000055,
+  "mode": "once",
+  "pid": 736079,
+  "role": "verify-reference",
+  "startup_seconds": 0.04110846600087825,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 1
+}

registry/conditioning-perf-prototype-20260930/processes/02-M-fresh-E.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "update",
+    "--mode",
+    "once",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 4.735514142004831,
+  "mode": "once",
+  "pid": 736147,
+  "role": "update",
+  "startup_seconds": 0.04088733500248054,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 1
+}

registry/conditioning-perf-prototype-20260930/processes/02-M-fresh-V.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "verify-reference",
+    "--mode",
+    "once",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 4.103694833996997,
+  "mode": "once",
+  "pid": 736341,
+  "role": "verify-reference",
+  "startup_seconds": 0.04011784899921622,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 1
+}

registry/conditioning-perf-prototype-20260930/processes/03-N_D0-fresh-E.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "update",
+    "--mode",
+    "once",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 4.5949991710003815,
+  "mode": "once",
+  "pid": 736537,
+  "role": "update",
+  "startup_seconds": 0.04200840900011826,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 1
+}

registry/conditioning-perf-prototype-20260930/processes/03-N_D0-fresh-V.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "verify-reference",
+    "--mode",
+    "once",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 3.924993649998214,
+  "mode": "once",
+  "pid": 736675,
+  "role": "verify-reference",
+  "startup_seconds": 0.041427705000387505,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 1
+}

registry/conditioning-perf-prototype-20260930/processes/04-N_frozen-fresh-E.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "update",
+    "--mode",
+    "once",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 4.620397169004718,
+  "mode": "once",
+  "pid": 736869,
+  "role": "update",
+  "startup_seconds": 0.04003098099929048,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 1
+}

registry/conditioning-perf-prototype-20260930/processes/04-N_frozen-fresh-V.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "verify-reference",
+    "--mode",
+    "once",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 3.9045120619994123,
+  "mode": "once",
+  "pid": 737063,
+  "role": "verify-reference",
+  "startup_seconds": 0.04213572099979501,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 1
+}

registry/conditioning-perf-prototype-20260930/processes/05-M_D0-fresh-E.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "update",
+    "--mode",
+    "once",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 4.764637047999713,
+  "mode": "once",
+  "pid": 737285,
+  "role": "update",
+  "startup_seconds": 0.04027060599764809,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 1
+}

registry/conditioning-perf-prototype-20260930/processes/05-M_D0-fresh-V.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "verify-reference",
+    "--mode",
+    "once",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 4.06785895700159,
+  "mode": "once",
+  "pid": 737398,
+  "role": "verify-reference",
+  "startup_seconds": 0.04107048700097948,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 1
+}

registry/conditioning-perf-prototype-20260930/processes/06-M-fresh-E.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "update",
+    "--mode",
+    "once",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 4.7666301089993794,
+  "mode": "once",
+  "pid": 737528,
+  "role": "update",
+  "startup_seconds": 0.04145412399520865,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 1
+}

registry/conditioning-perf-prototype-20260930/processes/06-M-fresh-V.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "verify-reference",
+    "--mode",
+    "once",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 4.0638777050044155,
+  "mode": "once",
+  "pid": 737791,
+  "role": "verify-reference",
+  "startup_seconds": 0.04130304000136675,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 1
+}

registry/conditioning-perf-prototype-20260930/processes/resident-E.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "update",
+    "--mode",
+    "server",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 98.41863379300048,
+  "mode": "server",
+  "pid": 735419,
+  "role": "update",
+  "startup_seconds": 0.040455851005390286,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 7
+}

registry/conditioning-perf-prototype-20260930/processes/resident-V.json

@@ -0,0 +1,25 @@
+{
+  "actual_parent_observed_exit": 0,
+  "argv": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/tools/conditioning-perf-lab-v1/perf_probe.py",
+    "worker",
+    "--role",
+    "verify-resident",
+    "--mode",
+    "server",
+    "--plan",
+    "/tmp/malecns-cpu-residency-woqIQa/benchmark-plan.json",
+    "--plan-sha",
+    "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1"
+  ],
+  "lifetime_parent_seconds": 98.74351359399589,
+  "mode": "server",
+  "pid": 735420,
+  "role": "verify-resident",
+  "startup_seconds": 0.04034673299611313,
+  "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "task_ACKs_are_not_individual_OS_exits": true,
+  "tasks_acknowledged": 7
+}

registry/conditioning-perf-prototype-20260930/report.json

@@ -0,0 +1,214 @@
+{
+  "AR_modified": false,
+  "GPU_benchmarked": false,
+  "brain_run": false,
+  "candidate_generated": false,
+  "end_to_end_AR_speedup_not_measured": true,
+  "full_history_reaudit": false,
+  "learning_test": false,
+  "prototype_plan_sha256": "ad9b906f90eb742706acc4cfe676a845900ad850f2482d0e8fb42d8faf3d71d1",
+  "resident_process_exits": [
+    0,
+    0
+  ],
+  "scope": "7 fixed engineering replays; CPU postprocessing only. Not authorized or validated as AR replacement.",
+  "source_and_consumed_input_SHA_unchanged": true,
+  "static_hash_cache_removed": false,
+  "status": "PASS-CPU-RESIDENCY-PROTOTYPE-ONLY",
+  "timing": {
+    "fresh_E_seconds": {
+      "all_mean": 4.691093597143273,
+      "warm_mean": 4.672245713000545,
+      "warm_median": 4.677955655504775
+    },
+    "fresh_V_seconds": {
+      "all_mean": 4.017230410571626,
+      "warm_mean": 3.9945939611667804,
+      "warm_median": 3.994435677501315
+    },
+    "resident_E_seconds": {
+      "all_mean": 2.9867054258585477,
+      "warm_mean": 2.7626112083344196,
+      "warm_median": 2.7719067460020597
+    },
+    "resident_V_seconds": {
+      "all_mean": 2.28122039428646,
+      "warm_mean": 2.063014349333874,
+      "warm_median": 2.0714335105003556
+    },
+    "warm_E_only_with_original_fresh_verifier_speedup_ratio": 1.2826071514426267,
+    "warm_combined_speedup_ratio": 1.7960033513986688
+  },
+  "timing_boundary": "Parent request includes input/chain digest, request+response persistence and output verification. Fresh also includes spawn/ready/exit; resident lifetime/startup separately recorded.",
+  "total_wall_seconds": 100.45934602300258,
+  "trials": [
+    {
+      "fresh_E_seconds": 4.8041809019996435,
+      "fresh_V_seconds": 4.153049107000697,
+      "label": "M",
+      "original_fresh_validator_actual_exit": 0,
+      "position": 0,
+      "resident_E_seconds": 4.331270731003315,
+      "resident_V_seconds": 3.5904566640019766,
+      "update_comparison": {
+        "all_four_files_SHA_identical": true,
+        "arrays_bitwise_identical": true,
+        "full_update_receipt_and_trace_digests_identical": true
+      },
+      "validator_comparison": {
+        "all_scientific_fields_identical": true,
+        "explicit_differing_fields": [
+          "schema",
+          "validator_source",
+          "original_validator_source",
+          "resident_prototype",
+          "resident_cache_scope"
+        ]
+      }
+    },
+    {
+      "fresh_E_seconds": 4.551296638994245,
+      "fresh_V_seconds": 3.902626559000055,
+      "label": "N",
+      "original_fresh_validator_actual_exit": 0,
+      "position": 1,
+      "resident_E_seconds": 2.678891448005743,
+      "resident_V_seconds": 2.062450468001771,
+      "update_comparison": {
+        "all_four_files_SHA_identical": true,
+        "arrays_bitwise_identical": true,
+        "full_update_receipt_and_trace_digests_identical": true
+      },
+      "validator_comparison": {
+        "all_scientific_fields_identical": true,
+        "explicit_differing_fields": [
+          "schema",
+          "validator_source",
+          "original_validator_source",
+          "resident_prototype",
+          "resident_cache_scope"
+        ]
+      }
+    },
+    {
+      "fresh_E_seconds": 4.735514142004831,
+      "fresh_V_seconds": 4.103694833996997,
+      "label": "M",
+      "original_fresh_validator_actual_exit": 0,
+      "position": 2,
+      "resident_E_seconds": 2.857203049999953,
+      "resident_V_seconds": 2.14666489699448,
+      "update_comparison": {
+        "all_four_files_SHA_identical": true,
+        "arrays_bitwise_identical": true,
+        "full_update_receipt_and_trace_digests_identical": true
+      },
+      "validator_comparison": {
+        "all_scientific_fields_identical": true,
+        "explicit_differing_fields": [
+          "schema",
+          "validator_source",
+          "original_validator_source",
+          "resident_prototype",
+          "resident_cache_scope"
+        ]
+      }
+    },
+    {
+      "fresh_E_seconds": 4.5949991710003815,
+      "fresh_V_seconds": 3.924993649998214,
+      "label": "N_D0",
+      "original_fresh_validator_actual_exit": 0,
+      "position": 3,
+      "resident_E_seconds": 2.6922046239997144,
+      "resident_V_seconds": 1.9751014260036754,
+      "update_comparison": {
+        "all_four_files_SHA_identical": true,
+        "arrays_bitwise_identical": true,
+        "full_update_receipt_and_trace_digests_identical": true
+      },
+      "validator_comparison": {
+        "all_scientific_fields_identical": true,
+        "explicit_differing_fields": [
+          "schema",
+          "validator_source",
+          "original_validator_source",
+          "resident_prototype",
+          "resident_cache_scope"
+        ]
+      }
+    },
+    {
+      "fresh_E_seconds": 4.620397169004718,
+      "fresh_V_seconds": 3.9045120619994123,
+      "label": "N_frozen",
+      "original_fresh_validator_actual_exit": 0,
+      "position": 4,
+      "resident_E_seconds": 2.7464958280033898,
+      "resident_V_seconds": 2.027457176001917,
+      "update_comparison": {
+        "all_four_files_SHA_identical": true,
+        "arrays_bitwise_identical": true,
+        "full_update_receipt_and_trace_digests_identical": true
+      },
+      "validator_comparison": {
+        "all_scientific_fields_identical": true,
+        "explicit_differing_fields": [
+          "schema",
+          "validator_source",
+          "original_validator_source",
+          "resident_prototype",
+          "resident_cache_scope"
+        ]
+      }
+    },
+    {
+      "fresh_E_seconds": 4.764637047999713,
+      "fresh_V_seconds": 4.06785895700159,
+      "label": "M_D0",
+      "original_fresh_validator_actual_exit": 0,
+      "position": 5,
+      "resident_E_seconds": 2.7973176640007296,
+      "resident_V_seconds": 2.0859955760024604,
+      "update_comparison": {
+        "all_four_files_SHA_identical": true,
+        "arrays_bitwise_identical": true,
+        "full_update_receipt_and_trace_digests_identical": true
+      },
+      "validator_comparison": {
+        "all_scientific_fields_identical": true,
+        "explicit_differing_fields": [
+          "schema",
+          "validator_source",
+          "original_validator_source",
+          "resident_prototype",
+          "resident_cache_scope"
+        ]
+      }
+    },
+    {
+      "fresh_E_seconds": 4.7666301089993794,
+      "fresh_V_seconds": 4.0638777050044155,
+      "label": "M",
+      "original_fresh_validator_actual_exit": 0,
+      "position": 6,
+      "resident_E_seconds": 2.8035546359969885,
+      "resident_V_seconds": 2.0804165529989405,
+      "update_comparison": {
+        "all_four_files_SHA_identical": true,
+        "arrays_bitwise_identical": true,
+        "full_update_receipt_and_trace_digests_identical": true
+      },
+      "validator_comparison": {
+        "all_scientific_fields_identical": true,
+        "explicit_differing_fields": [
+          "schema",
+          "validator_source",
+          "original_validator_source",
+          "resident_prototype",
+          "resident_cache_scope"
+        ]
+      }
+    }
+  ]
+}

registry/conditioning-perf-prototype-20260930/requests/00-M-fresh-E-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/mechanical--fresh-parent.epoch.json",
+  "authority_sha256": "4616a42c255ab839346368aa0e5e4306bb3878e55fcc95b176f058b1993c9b0c",
+  "chain_sha256": null,
+  "output": "/tmp/malecns-cpu-residency-woqIQa/updates/00-M-fresh",
+  "sequence": 0,
+  "update_dir": null
+}

registry/conditioning-perf-prototype-20260930/requests/00-M-fresh-V-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/mechanical--fresh-parent.epoch.json",
+  "authority_sha256": "4616a42c255ab839346368aa0e5e4306bb3878e55fcc95b176f058b1993c9b0c",
+  "chain_sha256": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305",
+  "output": "/tmp/malecns-cpu-residency-woqIQa/validation/00-M-fresh.json",
+  "sequence": 0,
+  "update_dir": "/tmp/malecns-cpu-residency-woqIQa/updates/00-M-resident"
+}

registry/conditioning-perf-prototype-20260930/requests/01-N-fresh-E-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/performance--natural-light-fresh.epoch.json",
+  "authority_sha256": "785e3d26d06b47efe7f054883d38fe2e13711195359bf9f4b03aa88887fbfb37",
+  "chain_sha256": null,
+  "output": "/tmp/malecns-cpu-residency-woqIQa/updates/01-N-fresh",
+  "sequence": 0,
+  "update_dir": null
+}

registry/conditioning-perf-prototype-20260930/requests/01-N-fresh-V-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/performance--natural-light-fresh.epoch.json",
+  "authority_sha256": "785e3d26d06b47efe7f054883d38fe2e13711195359bf9f4b03aa88887fbfb37",
+  "chain_sha256": "c4a45ddcfea6b1800ccb6f737733b7e13b726e54e8f10e145ac6787527fffd9e",
+  "output": "/tmp/malecns-cpu-residency-woqIQa/validation/01-N-fresh.json",
+  "sequence": 0,
+  "update_dir": "/tmp/malecns-cpu-residency-woqIQa/updates/01-N-resident"
+}

registry/conditioning-perf-prototype-20260930/requests/02-M-fresh-E-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/mechanical--fresh-parent.epoch.json",
+  "authority_sha256": "4616a42c255ab839346368aa0e5e4306bb3878e55fcc95b176f058b1993c9b0c",
+  "chain_sha256": null,
+  "output": "/tmp/malecns-cpu-residency-woqIQa/updates/02-M-fresh",
+  "sequence": 0,
+  "update_dir": null
+}

registry/conditioning-perf-prototype-20260930/requests/02-M-fresh-V-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/mechanical--fresh-parent.epoch.json",
+  "authority_sha256": "4616a42c255ab839346368aa0e5e4306bb3878e55fcc95b176f058b1993c9b0c",
+  "chain_sha256": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305",
+  "output": "/tmp/malecns-cpu-residency-woqIQa/validation/02-M-fresh.json",
+  "sequence": 0,
+  "update_dir": "/tmp/malecns-cpu-residency-woqIQa/updates/02-M-resident"
+}

registry/conditioning-perf-prototype-20260930/requests/03-N_D0-fresh-E-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/tmp/malecns-cpu-residency-woqIQa/inputs/N_D0.authority.json",
+  "authority_sha256": "4a7ee78ca0671efa0cb5203f7ba405ae3a53b3e23ebfcb8bf52887ce20c0f40b",
+  "chain_sha256": null,
+  "output": "/tmp/malecns-cpu-residency-woqIQa/updates/03-N_D0-fresh",
+  "sequence": 0,
+  "update_dir": null
+}

registry/conditioning-perf-prototype-20260930/requests/03-N_D0-fresh-V-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/tmp/malecns-cpu-residency-woqIQa/inputs/N_D0.authority.json",
+  "authority_sha256": "4a7ee78ca0671efa0cb5203f7ba405ae3a53b3e23ebfcb8bf52887ce20c0f40b",
+  "chain_sha256": "9869be774efc4d5ffbce36633438bd5187e9c826339c6abc2f682380a11ce531",
+  "output": "/tmp/malecns-cpu-residency-woqIQa/validation/03-N_D0-fresh.json",
+  "sequence": 0,
+  "update_dir": "/tmp/malecns-cpu-residency-woqIQa/updates/03-N_D0-resident"
+}

registry/conditioning-perf-prototype-20260930/requests/04-N_frozen-fresh-E-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/tmp/malecns-cpu-residency-woqIQa/inputs/N_frozen.authority.json",
+  "authority_sha256": "3063f74a5dbbfb6afa92ee7692bbb0626017b0451072b838be2f9e0bc58748e3",
+  "chain_sha256": null,
+  "output": "/tmp/malecns-cpu-residency-woqIQa/updates/04-N_frozen-fresh",
+  "sequence": 0,
+  "update_dir": null
+}

registry/conditioning-perf-prototype-20260930/requests/04-N_frozen-fresh-V-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/tmp/malecns-cpu-residency-woqIQa/inputs/N_frozen.authority.json",
+  "authority_sha256": "3063f74a5dbbfb6afa92ee7692bbb0626017b0451072b838be2f9e0bc58748e3",
+  "chain_sha256": "53e51b4d3900e87eb40153c3dbe40e9e3f2b000bd9ac2dbba791e81d7aca04ae",
+  "output": "/tmp/malecns-cpu-residency-woqIQa/validation/04-N_frozen-fresh.json",
+  "sequence": 0,
+  "update_dir": "/tmp/malecns-cpu-residency-woqIQa/updates/04-N_frozen-resident"
+}

registry/conditioning-perf-prototype-20260930/requests/05-M_D0-fresh-E-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/tmp/malecns-cpu-residency-woqIQa/inputs/M_D0.authority.json",
+  "authority_sha256": "56d89454417c4c7d8e4dd1dc3437ad0df55ded706b9e603681bbf491338cbf04",
+  "chain_sha256": null,
+  "output": "/tmp/malecns-cpu-residency-woqIQa/updates/05-M_D0-fresh",
+  "sequence": 0,
+  "update_dir": null
+}

registry/conditioning-perf-prototype-20260930/requests/05-M_D0-fresh-V-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/tmp/malecns-cpu-residency-woqIQa/inputs/M_D0.authority.json",
+  "authority_sha256": "56d89454417c4c7d8e4dd1dc3437ad0df55ded706b9e603681bbf491338cbf04",
+  "chain_sha256": "c374052af5c9da2084fefbaf3b874803c8dda4d4d23fd0979578ea0241e3ecfc",
+  "output": "/tmp/malecns-cpu-residency-woqIQa/validation/05-M_D0-fresh.json",
+  "sequence": 0,
+  "update_dir": "/tmp/malecns-cpu-residency-woqIQa/updates/05-M_D0-resident"
+}

registry/conditioning-perf-prototype-20260930/requests/06-M-fresh-E-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/mechanical--fresh-parent.epoch.json",
+  "authority_sha256": "4616a42c255ab839346368aa0e5e4306bb3878e55fcc95b176f058b1993c9b0c",
+  "chain_sha256": null,
+  "output": "/tmp/malecns-cpu-residency-woqIQa/updates/06-M-fresh",
+  "sequence": 0,
+  "update_dir": null
+}

registry/conditioning-perf-prototype-20260930/requests/06-M-fresh-V-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/mechanical--fresh-parent.epoch.json",
+  "authority_sha256": "4616a42c255ab839346368aa0e5e4306bb3878e55fcc95b176f058b1993c9b0c",
+  "chain_sha256": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305",
+  "output": "/tmp/malecns-cpu-residency-woqIQa/validation/06-M-fresh.json",
+  "sequence": 0,
+  "update_dir": "/tmp/malecns-cpu-residency-woqIQa/updates/06-M-resident"
+}

registry/conditioning-perf-prototype-20260930/requests/resident-E-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/mechanical--fresh-parent.epoch.json",
+  "authority_sha256": "4616a42c255ab839346368aa0e5e4306bb3878e55fcc95b176f058b1993c9b0c",
+  "chain_sha256": null,
+  "output": "/tmp/malecns-cpu-residency-woqIQa/updates/00-M-resident",
+  "sequence": 0,
+  "update_dir": null
+}

registry/conditioning-perf-prototype-20260930/requests/resident-E-01.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/performance--natural-light-fresh.epoch.json",
+  "authority_sha256": "785e3d26d06b47efe7f054883d38fe2e13711195359bf9f4b03aa88887fbfb37",
+  "chain_sha256": null,
+  "output": "/tmp/malecns-cpu-residency-woqIQa/updates/01-N-resident",
+  "sequence": 1,
+  "update_dir": null
+}

registry/conditioning-perf-prototype-20260930/requests/resident-E-02.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/mechanical--fresh-parent.epoch.json",
+  "authority_sha256": "4616a42c255ab839346368aa0e5e4306bb3878e55fcc95b176f058b1993c9b0c",
+  "chain_sha256": null,
+  "output": "/tmp/malecns-cpu-residency-woqIQa/updates/02-M-resident",
+  "sequence": 2,
+  "update_dir": null
+}

registry/conditioning-perf-prototype-20260930/requests/resident-E-03.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/tmp/malecns-cpu-residency-woqIQa/inputs/N_D0.authority.json",
+  "authority_sha256": "4a7ee78ca0671efa0cb5203f7ba405ae3a53b3e23ebfcb8bf52887ce20c0f40b",
+  "chain_sha256": null,
+  "output": "/tmp/malecns-cpu-residency-woqIQa/updates/03-N_D0-resident",
+  "sequence": 3,
+  "update_dir": null
+}

registry/conditioning-perf-prototype-20260930/requests/resident-E-04.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/tmp/malecns-cpu-residency-woqIQa/inputs/N_frozen.authority.json",
+  "authority_sha256": "3063f74a5dbbfb6afa92ee7692bbb0626017b0451072b838be2f9e0bc58748e3",
+  "chain_sha256": null,
+  "output": "/tmp/malecns-cpu-residency-woqIQa/updates/04-N_frozen-resident",
+  "sequence": 4,
+  "update_dir": null
+}

registry/conditioning-perf-prototype-20260930/requests/resident-E-05.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/tmp/malecns-cpu-residency-woqIQa/inputs/M_D0.authority.json",
+  "authority_sha256": "56d89454417c4c7d8e4dd1dc3437ad0df55ded706b9e603681bbf491338cbf04",
+  "chain_sha256": null,
+  "output": "/tmp/malecns-cpu-residency-woqIQa/updates/05-M_D0-resident",
+  "sequence": 5,
+  "update_dir": null
+}

registry/conditioning-perf-prototype-20260930/requests/resident-E-06.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/mechanical--fresh-parent.epoch.json",
+  "authority_sha256": "4616a42c255ab839346368aa0e5e4306bb3878e55fcc95b176f058b1993c9b0c",
+  "chain_sha256": null,
+  "output": "/tmp/malecns-cpu-residency-woqIQa/updates/06-M-resident",
+  "sequence": 6,
+  "update_dir": null
+}

registry/conditioning-perf-prototype-20260930/requests/resident-V-00.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/mechanical--fresh-parent.epoch.json",
+  "authority_sha256": "4616a42c255ab839346368aa0e5e4306bb3878e55fcc95b176f058b1993c9b0c",
+  "chain_sha256": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305",
+  "output": "/tmp/malecns-cpu-residency-woqIQa/validation/00-M-resident.json",
+  "sequence": 0,
+  "update_dir": "/tmp/malecns-cpu-residency-woqIQa/updates/00-M-resident"
+}

registry/conditioning-perf-prototype-20260930/requests/resident-V-01.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/performance--natural-light-fresh.epoch.json",
+  "authority_sha256": "785e3d26d06b47efe7f054883d38fe2e13711195359bf9f4b03aa88887fbfb37",
+  "chain_sha256": "c4a45ddcfea6b1800ccb6f737733b7e13b726e54e8f10e145ac6787527fffd9e",
+  "output": "/tmp/malecns-cpu-residency-woqIQa/validation/01-N-resident.json",
+  "sequence": 1,
+  "update_dir": "/tmp/malecns-cpu-residency-woqIQa/updates/01-N-resident"
+}

registry/conditioning-perf-prototype-20260930/requests/resident-V-02.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/mechanical--fresh-parent.epoch.json",
+  "authority_sha256": "4616a42c255ab839346368aa0e5e4306bb3878e55fcc95b176f058b1993c9b0c",
+  "chain_sha256": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305",
+  "output": "/tmp/malecns-cpu-residency-woqIQa/validation/02-M-resident.json",
+  "sequence": 2,
+  "update_dir": "/tmp/malecns-cpu-residency-woqIQa/updates/02-M-resident"
+}

registry/conditioning-perf-prototype-20260930/requests/resident-V-03.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/tmp/malecns-cpu-residency-woqIQa/inputs/N_D0.authority.json",
+  "authority_sha256": "4a7ee78ca0671efa0cb5203f7ba405ae3a53b3e23ebfcb8bf52887ce20c0f40b",
+  "chain_sha256": "9869be774efc4d5ffbce36633438bd5187e9c826339c6abc2f682380a11ce531",
+  "output": "/tmp/malecns-cpu-residency-woqIQa/validation/03-N_D0-resident.json",
+  "sequence": 3,
+  "update_dir": "/tmp/malecns-cpu-residency-woqIQa/updates/03-N_D0-resident"
+}

registry/conditioning-perf-prototype-20260930/requests/resident-V-04.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/tmp/malecns-cpu-residency-woqIQa/inputs/N_frozen.authority.json",
+  "authority_sha256": "3063f74a5dbbfb6afa92ee7692bbb0626017b0451072b838be2f9e0bc58748e3",
+  "chain_sha256": "53e51b4d3900e87eb40153c3dbe40e9e3f2b000bd9ac2dbba791e81d7aca04ae",
+  "output": "/tmp/malecns-cpu-residency-woqIQa/validation/04-N_frozen-resident.json",
+  "sequence": 4,
+  "update_dir": "/tmp/malecns-cpu-residency-woqIQa/updates/04-N_frozen-resident"
+}

registry/conditioning-perf-prototype-20260930/requests/resident-V-05.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/tmp/malecns-cpu-residency-woqIQa/inputs/M_D0.authority.json",
+  "authority_sha256": "56d89454417c4c7d8e4dd1dc3437ad0df55ded706b9e603681bbf491338cbf04",
+  "chain_sha256": "c374052af5c9da2084fefbaf3b874803c8dda4d4d23fd0979578ea0241e3ecfc",
+  "output": "/tmp/malecns-cpu-residency-woqIQa/validation/05-M_D0-resident.json",
+  "sequence": 5,
+  "update_dir": "/tmp/malecns-cpu-residency-woqIQa/updates/05-M_D0-resident"
+}

registry/conditioning-perf-prototype-20260930/requests/resident-V-06.json

@@ -0,0 +1,8 @@
+{
+  "authority": "/data/digital-drosophila/experiments/phase4aq-conditioning-execution/authorities/mechanical--fresh-parent.epoch.json",
+  "authority_sha256": "4616a42c255ab839346368aa0e5e4306bb3878e55fcc95b176f058b1993c9b0c",
+  "chain_sha256": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305",
+  "output": "/tmp/malecns-cpu-residency-woqIQa/validation/06-M-resident.json",
+  "sequence": 6,
+  "update_dir": "/tmp/malecns-cpu-residency-woqIQa/updates/06-M-resident"
+}

registry/conditioning-perf-prototype-20260930/responses/00-M-fresh-E-00.json

@@ -0,0 +1,19 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "chain-receipt.json": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305",
+      "delta-after.npz": "35b55ff715e797221163e812e4128a700eb05a4546d7f3f13dc5edc547aeb8e6",
+      "overlay-manifest.json": "60f77f30609859a718db1004e6da1c23730736285c5a1d845ec0da97385b01be",
+      "update-receipt.json": "d26c0fec7b1fcd8bbb5f7fb86b094c0870f1f0a4b29be1b3def77b66b6a3cbb5"
+    },
+    "pid": 735421,
+    "request_sha256": "e3e7f6976c9e8b4fa666cb04f2a15de43672caf88f11a1716ddbcdaa0fa91881",
+    "role": "update",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 4.348067031998653
+  },
+  "rpc_parent_seconds": 4.348772582998208
+}

registry/conditioning-perf-prototype-20260930/responses/00-M-fresh-V-00.json

@@ -0,0 +1,16 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "receipt": "be69678fb053f0904cd118bc5acdc09085cb780a1997c9a18b9d9661c5922d82"
+    },
+    "pid": 735682,
+    "request_sha256": "ed5a0e642875b9a746b19b55d4834f6d26533272ee7e7d8680b66f3fb5485d7c",
+    "role": "verify-reference",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 3.5955134109972278
+  },
+  "rpc_parent_seconds": 3.596053059998667
+}

registry/conditioning-perf-prototype-20260930/responses/01-N-fresh-E-00.json

@@ -0,0 +1,19 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "chain-receipt.json": "c4a45ddcfea6b1800ccb6f737733b7e13b726e54e8f10e145ac6787527fffd9e",
+      "delta-after.npz": "af15c05aa9ce0fdcd2b47dcc8bef426a242f84efe7b45e79c345ff4d361d23b4",
+      "overlay-manifest.json": "a98095968f62fe7375e5acab89dbfbf55de6a28760f93dc1f5b48f238a4c54c5",
+      "update-receipt.json": "18c47fc5fceb4f1b52d601ed5114eec8239156677c44bfe364706a7e7d2fc972"
+    },
+    "pid": 735877,
+    "request_sha256": "d664ad8384a800e50bf53d57831b5b320d7e102716f81f99e662c9530287efaf",
+    "role": "update",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 4.143684693000978
+  },
+  "rpc_parent_seconds": 4.1443889109941665
+}

registry/conditioning-perf-prototype-20260930/responses/01-N-fresh-V-00.json

@@ -0,0 +1,16 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "receipt": "b8f4a419a55f8b057973a2e2f1e97d7869200831852b5f05e97ca10f036e5363"
+    },
+    "pid": 736079,
+    "request_sha256": "ac02163ad47ea82db84865f7239ae3c1be0943522b4bfc61e2ba2a595a41ade1",
+    "role": "verify-reference",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 3.4450594919981086
+  },
+  "rpc_parent_seconds": 3.4455602510061
+}

registry/conditioning-perf-prototype-20260930/responses/02-M-fresh-E-00.json

@@ -0,0 +1,19 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "chain-receipt.json": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305",
+      "delta-after.npz": "35b55ff715e797221163e812e4128a700eb05a4546d7f3f13dc5edc547aeb8e6",
+      "overlay-manifest.json": "60f77f30609859a718db1004e6da1c23730736285c5a1d845ec0da97385b01be",
+      "update-receipt.json": "d26c0fec7b1fcd8bbb5f7fb86b094c0870f1f0a4b29be1b3def77b66b6a3cbb5"
+    },
+    "pid": 736147,
+    "request_sha256": "18924fb9890fe690fa5c8d64582c8164169529d805915edf390a2e7d7547817d",
+    "role": "update",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 4.2779192329981015
+  },
+  "rpc_parent_seconds": 4.2786097369971685
+}

registry/conditioning-perf-prototype-20260930/responses/02-M-fresh-V-00.json

@@ -0,0 +1,16 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "receipt": "be69678fb053f0904cd118bc5acdc09085cb780a1997c9a18b9d9661c5922d82"
+    },
+    "pid": 736341,
+    "request_sha256": "532ea1058439ae5b3936b6bdd5ec1d1c3e10bc2b7be867daa4aceba6d77b4322",
+    "role": "verify-reference",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 3.6470996990028652
+  },
+  "rpc_parent_seconds": 3.6476188209999236
+}

registry/conditioning-perf-prototype-20260930/responses/03-N_D0-fresh-E-00.json

@@ -0,0 +1,19 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "chain-receipt.json": "9869be774efc4d5ffbce36633438bd5187e9c826339c6abc2f682380a11ce531",
+      "delta-after.npz": "b89e407a5d93b5f1901f901b00428dc19bd20cee2d81e57b117a2fa68d200a48",
+      "overlay-manifest.json": "0d2a2aac09c75eb2729ccc1d5e6ec753f31334febbfe4f89d6bc1a9c591607d1",
+      "update-receipt.json": "92181e3ca11089f7a1eba8b6e17284dec22a8786e81fe65e14adf69c7fd24aa5"
+    },
+    "pid": 736537,
+    "request_sha256": "2912641c39b0b75c3758525421a79b96a2b4187dc51b47559d473dd3317ed556",
+    "role": "update",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 4.136047822001274
+  },
+  "rpc_parent_seconds": 4.136928580002859
+}

registry/conditioning-perf-prototype-20260930/responses/03-N_D0-fresh-V-00.json

@@ -0,0 +1,16 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "receipt": "375a56ec0d3cff73190778dee6babae9f531e4b94e489024cb3aabc8c3b1b81b"
+    },
+    "pid": 736675,
+    "request_sha256": "042f4ad3b43631099bb52c94e4298072771ed17f082f5a5a22a98d4d73e6cf1f",
+    "role": "verify-reference",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 3.466605780995451
+  },
+  "rpc_parent_seconds": 3.4674518469983013
+}

registry/conditioning-perf-prototype-20260930/responses/04-N_frozen-fresh-E-00.json

@@ -0,0 +1,19 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "chain-receipt.json": "53e51b4d3900e87eb40153c3dbe40e9e3f2b000bd9ac2dbba791e81d7aca04ae",
+      "delta-after.npz": "b89e407a5d93b5f1901f901b00428dc19bd20cee2d81e57b117a2fa68d200a48",
+      "overlay-manifest.json": "0d2a2aac09c75eb2729ccc1d5e6ec753f31334febbfe4f89d6bc1a9c591607d1",
+      "update-receipt.json": "545007d844de8b1717325d4cd79040907396019b1e7521219bb5b885ac224f33"
+    },
+    "pid": 736869,
+    "request_sha256": "14d0820e39b2c0c2a3f1da4efb787324e6f842a1e32414e655b109171e0a0813",
+    "role": "update",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 4.16381936599646
+  },
+  "rpc_parent_seconds": 4.16447475500172
+}

registry/conditioning-perf-prototype-20260930/responses/04-N_frozen-fresh-V-00.json

@@ -0,0 +1,16 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "receipt": "3a1b503977351da83617dbef8d3282df78a1d1525e02de6b9c2b5f11103d8692"
+    },
+    "pid": 737063,
+    "request_sha256": "3cff07242fc00baede8538028aff6df997a892888ec4daaa9c6cb5e8ab45e676",
+    "role": "verify-reference",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 3.4458352779984125
+  },
+  "rpc_parent_seconds": 3.446334565000143
+}

registry/conditioning-perf-prototype-20260930/responses/05-M_D0-fresh-E-00.json

@@ -0,0 +1,19 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "chain-receipt.json": "c374052af5c9da2084fefbaf3b874803c8dda4d4d23fd0979578ea0241e3ecfc",
+      "delta-after.npz": "0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5",
+      "overlay-manifest.json": "3be5d1a9d7dd1d8a580f272d3dca3616adbc157fafb4fbdfc89258719650c01e",
+      "update-receipt.json": "ef8a17cbe35f973c58ae76884597100286ec0d70e987ef83b5c92add3d266312"
+    },
+    "pid": 737285,
+    "request_sha256": "5efcd9677ae6cacb999590e9d48e568107a070af9ae2cdfd94974d2562b243bf",
+    "role": "update",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 4.307785546996456
+  },
+  "rpc_parent_seconds": 4.308455913997022
+}

registry/conditioning-perf-prototype-20260930/responses/05-M_D0-fresh-V-00.json

@@ -0,0 +1,16 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "receipt": "21ff335bd8f1ac9c92d98e153183978970dd55efa0ca90c530407238b25598fa"
+    },
+    "pid": 737398,
+    "request_sha256": "bf6c16afd5a1fd0cc0e98b331e79834465c7f599a373288f5cf77499ff005384",
+    "role": "verify-reference",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 3.6099664270004723
+  },
+  "rpc_parent_seconds": 3.610498000998632
+}

registry/conditioning-perf-prototype-20260930/responses/06-M-fresh-E-00.json

@@ -0,0 +1,19 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "chain-receipt.json": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305",
+      "delta-after.npz": "35b55ff715e797221163e812e4128a700eb05a4546d7f3f13dc5edc547aeb8e6",
+      "overlay-manifest.json": "60f77f30609859a718db1004e6da1c23730736285c5a1d845ec0da97385b01be",
+      "update-receipt.json": "d26c0fec7b1fcd8bbb5f7fb86b094c0870f1f0a4b29be1b3def77b66b6a3cbb5"
+    },
+    "pid": 737528,
+    "request_sha256": "527a7d83c27f085503298a6b2fc0b61a33b69c4d36144bbb388e31a070c7678f",
+    "role": "update",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 4.308333585002401
+  },
+  "rpc_parent_seconds": 4.308988183998736
+}

registry/conditioning-perf-prototype-20260930/responses/06-M-fresh-V-00.json

@@ -0,0 +1,16 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "receipt": "be69678fb053f0904cd118bc5acdc09085cb780a1997c9a18b9d9661c5922d82"
+    },
+    "pid": 737791,
+    "request_sha256": "053127f012b68e72b57e5b3d864827161062e755cad248ec2667086ad901238b",
+    "role": "verify-reference",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 3.604899222998938
+  },
+  "rpc_parent_seconds": 3.6053921779966913
+}

registry/conditioning-perf-prototype-20260930/responses/resident-E-00.json

@@ -0,0 +1,19 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "chain-receipt.json": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305",
+      "delta-after.npz": "35b55ff715e797221163e812e4128a700eb05a4546d7f3f13dc5edc547aeb8e6",
+      "overlay-manifest.json": "60f77f30609859a718db1004e6da1c23730736285c5a1d845ec0da97385b01be",
+      "update-receipt.json": "d26c0fec7b1fcd8bbb5f7fb86b094c0870f1f0a4b29be1b3def77b66b6a3cbb5"
+    },
+    "pid": 735419,
+    "request_sha256": "28a7438b88eba0cd97d8ab7cb80f6cb062fc5ebcaf7b43467eb4bad5383c0957",
+    "role": "update",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 4.330023788003018
+  },
+  "rpc_parent_seconds": 4.330927196999255
+}

registry/conditioning-perf-prototype-20260930/responses/resident-E-01.json

@@ -0,0 +1,19 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "chain-receipt.json": "c4a45ddcfea6b1800ccb6f737733b7e13b726e54e8f10e145ac6787527fffd9e",
+      "delta-after.npz": "af15c05aa9ce0fdcd2b47dcc8bef426a242f84efe7b45e79c345ff4d361d23b4",
+      "overlay-manifest.json": "a98095968f62fe7375e5acab89dbfbf55de6a28760f93dc1f5b48f238a4c54c5",
+      "update-receipt.json": "18c47fc5fceb4f1b52d601ed5114eec8239156677c44bfe364706a7e7d2fc972"
+    },
+    "pid": 735419,
+    "request_sha256": "f6fc8c478fee487a2b8d5f02e79796884481698ea748bf6682c238bc626f90b4",
+    "role": "update",
+    "sequence": 1,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 2.6776581890007947
+  },
+  "rpc_parent_seconds": 2.6785497480013873
+}

registry/conditioning-perf-prototype-20260930/responses/resident-E-02.json

@@ -0,0 +1,19 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "chain-receipt.json": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305",
+      "delta-after.npz": "35b55ff715e797221163e812e4128a700eb05a4546d7f3f13dc5edc547aeb8e6",
+      "overlay-manifest.json": "60f77f30609859a718db1004e6da1c23730736285c5a1d845ec0da97385b01be",
+      "update-receipt.json": "d26c0fec7b1fcd8bbb5f7fb86b094c0870f1f0a4b29be1b3def77b66b6a3cbb5"
+    },
+    "pid": 735419,
+    "request_sha256": "ff1a36f37c3793455c4af1b1d9c03b7deda461370a4b71d4c27bb784266a3e33",
+    "role": "update",
+    "sequence": 2,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 2.855986071997904
+  },
+  "rpc_parent_seconds": 2.856830764001643
+}

registry/conditioning-perf-prototype-20260930/responses/resident-E-03.json

@@ -0,0 +1,19 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "chain-receipt.json": "9869be774efc4d5ffbce36633438bd5187e9c826339c6abc2f682380a11ce531",
+      "delta-after.npz": "b89e407a5d93b5f1901f901b00428dc19bd20cee2d81e57b117a2fa68d200a48",
+      "overlay-manifest.json": "0d2a2aac09c75eb2729ccc1d5e6ec753f31334febbfe4f89d6bc1a9c591607d1",
+      "update-receipt.json": "92181e3ca11089f7a1eba8b6e17284dec22a8786e81fe65e14adf69c7fd24aa5"
+    },
+    "pid": 735419,
+    "request_sha256": "3bb48d54f9dd5eabe9d70a196ad42f7752c46d519beccfc818b8c1c70693e0cd",
+    "role": "update",
+    "sequence": 3,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 2.6908157229991048
+  },
+  "rpc_parent_seconds": 2.6917487069949857
+}

registry/conditioning-perf-prototype-20260930/responses/resident-E-04.json

@@ -0,0 +1,19 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "chain-receipt.json": "53e51b4d3900e87eb40153c3dbe40e9e3f2b000bd9ac2dbba791e81d7aca04ae",
+      "delta-after.npz": "b89e407a5d93b5f1901f901b00428dc19bd20cee2d81e57b117a2fa68d200a48",
+      "overlay-manifest.json": "0d2a2aac09c75eb2729ccc1d5e6ec753f31334febbfe4f89d6bc1a9c591607d1",
+      "update-receipt.json": "545007d844de8b1717325d4cd79040907396019b1e7521219bb5b885ac224f33"
+    },
+    "pid": 735419,
+    "request_sha256": "dc4f37667f8ef6a8031abf3fbc6b0a0fc28c48e17fa21598388ca60505d5294d",
+    "role": "update",
+    "sequence": 4,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 2.74508142999548
+  },
+  "rpc_parent_seconds": 2.746049347006192
+}

registry/conditioning-perf-prototype-20260930/responses/resident-E-05.json

@@ -0,0 +1,19 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "chain-receipt.json": "c374052af5c9da2084fefbaf3b874803c8dda4d4d23fd0979578ea0241e3ecfc",
+      "delta-after.npz": "0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5",
+      "overlay-manifest.json": "3be5d1a9d7dd1d8a580f272d3dca3616adbc157fafb4fbdfc89258719650c01e",
+      "update-receipt.json": "ef8a17cbe35f973c58ae76884597100286ec0d70e987ef83b5c92add3d266312"
+    },
+    "pid": 735419,
+    "request_sha256": "8a9a97c08927e4299f7e661bb480a1126e656383f4abe186456cb9eb6b3954b8",
+    "role": "update",
+    "sequence": 5,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 2.796192781999707
+  },
+  "rpc_parent_seconds": 2.796998273995996
+}

registry/conditioning-perf-prototype-20260930/responses/resident-E-06.json

@@ -0,0 +1,19 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "chain-receipt.json": "e1f5d70d1f0aa41edfecc8424603ef807770b3c8097570abdc1764b851e9c305",
+      "delta-after.npz": "35b55ff715e797221163e812e4128a700eb05a4546d7f3f13dc5edc547aeb8e6",
+      "overlay-manifest.json": "60f77f30609859a718db1004e6da1c23730736285c5a1d845ec0da97385b01be",
+      "update-receipt.json": "d26c0fec7b1fcd8bbb5f7fb86b094c0870f1f0a4b29be1b3def77b66b6a3cbb5"
+    },
+    "pid": 735419,
+    "request_sha256": "b3a0c476842d51ed87607b5579b827d7ef5b81d9857cfa59aadc70ad1994cfbd",
+    "role": "update",
+    "sequence": 6,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 2.802385975002835
+  },
+  "rpc_parent_seconds": 2.803224276001856
+}

registry/conditioning-perf-prototype-20260930/responses/resident-V-00.json

@@ -0,0 +1,16 @@
+{
+  "ack": {
+    "CUDA_initialized": false,
+    "ack": true,
+    "output_sha256": {
+      "receipt": "4314d615874a8d8da77655a0125c7feb6138df0bc85c0686e94496b96a4a3459"
+    },
+    "pid": 735420,
+    "request_sha256": "bd5833ccb513a9e1c0a16c0b672c314c303049dbb54052b8f33d2b769c604e39",
+    "role": "verify-resident",
+    "sequence": 0,
+    "task_ack_is_not_process_exit": true,
+    "task_seconds": 3.5892524179944303
+  },
+  "rpc_parent_seconds": 3.590001267999469
+}