Seal Phase 4AN exact continuation engineering evidence

CURRENT.md

@@ -4,6 +4,16 @@
 
 ## 最近已封存结果
 
+Phase 4AN：**PASS-EXACT-LIGHT-CONTINUATION-ENGINEERING-NOT-LEARNING**。
+
+固定 zero/static25 输入下，32/32 次运行及 74 项比较通过；分段续跑保留精确事件、末态和延迟队列，独立 CSR 审计覆盖真实非零跨段到达。AM 双封存及 28 套旧完整性记录再次通过。没有训练，未生成 learned candidate；结论只覆盖注册的 100 ms 输入及固定切点，不是普遍动力学证明。
+
+light 的 100 ms 核心模拟约 2.15–2.19 s，单条输出约 2.60 MB，尚未达到实时。整个 32-call 执行流程约 433.97 s；首次编译、校验和保存都包含在该流程时间内。
+
+[AN 结果及预算边界](docs/progress/phase4an-interpretation.md)。注册 SHA：`7317441126f191ccc6e6d28438870b3921537ebe282a6acb163716a690057945`；实验 manifest SHA：`e8952a48cd3ea6a93c811a1183a1f7b79e19646299924e7688e5f393737a9aa2`。
+
+## 全脑固定权重接口
+
 Phase 4AM：**PASS-EXACT-WHOLEBRAIN-PLASTIC-INTERFACE-NOT-LEARNING**。
 
 独立建立 D18 whole-brain plastic-overlay 接口，不覆盖或替换旧 reference/runtime。
@@ -32,7 +42,9 @@ Phase 4AK D18 表征验证 PASS 原样保留。1.8 ms 为工程 APL 时序假设
 
 ## 当前准备与学习边界
 
-Phase 4AN 工程计划仍为 **UNREGISTERED**：32 calls / 11,074 ticks，拟比较精简报告运行及 checkpoint 连续性。实际脑运行数为 **0**。学习草案未登记，没有候选；这些工程测试不是条件化实验。
+Phase 4AN 的有限工程门已封存；21 份实际使用源码已按 SHA 锁定，lab 整个目录未封存。科学学习草案仍未登记，没有候选；工程测试不是条件化实验。
+
+完整 conditioning 草案已有 68,000 epochs 与合计 10,760 生物秒（含 idle），但 evaluation/probe 库存未完整。按当前 100 ms 样本算术外推，仅核心模拟约 64–66 小时，不能直接作为完整工期或预算。先补齐评估/控制/保持集成与有限预算，再登记小规模机制验证，不直接启动大批量训练。
 
 目标仍是“学习可以使用”，当前没有达到。接口验证或静态权重效果不能替代真实条件化。
 后续须预注册固定 olfactory A/B、具体 DAN type/compartment、至少五个互不重叠训练种子流及独立 evaluation streams；保留原 eligibility-v2、人工 US 与实际 DAN 放电的明确区分，以及配对/控制、反转、延迟奖励、保持等功能验证。

docs/progress/phase4an-interpretation.md

@@ -0,0 +1,49 @@
+# Phase 4AN — 有限轻记录与连续状态工程验证
+
+日期：2026-09-30。正式状态：`PASS-EXACT-LIGHT-CONTINUATION-ENGINEERING-NOT-LEARNING`。
+
+这是独立 D18 分支上的有限运行器验证，不是学习、记忆保持或生理模型通过。全部注册的 32 次 GPU 调用已执行，74 项比较通过；最终重新计算分析结果完全相同，AM 双封存与 28 套旧完整性记录运行后通过。AN 没有重新执行五组旧 reference，而是保留 AM 本轮已重新运行并通过的封存证据。
+
+## 固定范围
+
+166,700 neurons、25,582,938 edges，原图和 mask 不变。只使用 AM 原计划第一条 primary 的 100 ms 输入及其精确切片，分别保持 `zero`、`static25` 固定 overlay；没有新抽气味/seed、训练或试验内权重更新。
+
+每个 overlay 包括完整 reference、两次完整 light、三个 reference 前缀，以及 reference/light 各一条段长 `[5,13,1,481,500]` 的连续链。共 11,074 ticks、1.1074 累计生物秒。完整执行流程墙时 433.968245 秒，包括首次编译、校验、进程启动、保存与续跑封存，不包括之后的分析和最终封存。
+
+## 一致性与非空覆盖
+
+两种 overlay 的完整新 reference 与各自 AM 输出精确一致。完整 light、技术重复和分段链的事件、计数、最终 V/g/ref、APL 末态、规范化 spike ring 和 APL pending 均符合注册比较。reference 另比较完整逐步状态哈希、APL history 和队列，并用原 CSR 独立重建队列顺序、接受掩码、局部时钟哈希和不应期状态。
+
+两种 overlay 均有真实跨切点且非零权重、被接受的突触到达。例如 canonical edge 783780：source neuron_idx 522 在 tick 7 发放，target neuron_idx 82 在 tick 25 接收到达，跨过 tick 18 切点；原 SI effective weight 为 0.006875 V。该记录仅证明测试覆盖真实 carry，不证明唯一因果或生物学必要性。另核实同一预定切点存在 spike carry 与非零 APL pending。
+
+light 不记录完整逐步 V/g/ref/APL/队列 history，未将缺失观测补为零或假称逐步浮点全量独立验证。该结论只适用于本次固定输入、固定 overlay 和预定切点，不是所有气味、任意长度或任意 parent 状态的普遍等价证明。
+
+## 实测成本
+
+| 100 ms 完整试验 | reference | light |
+|---|---:|---:|
+| 核心模拟墙时 | 5.456–5.509 s | 2.153–2.192 s |
+| 每条封存输出 | 35.688–35.697 MB | 2.597–2.606 MB |
+| 分配显存峰值 | 518,003,712 bytes | 518,003,712 bytes |
+
+light 的运行加即时检查点封存约 5.827–5.854 s；这个数不含随后进程外核验。首次 reference 编译约 59.231 s，后续 build/cache 约 0.46 s。以上是小规模顺序试验，未测 GPU/CPU utilization，不能写成零。一次只读 CPU 比较与早期 light 运行有时间重叠，因此这不是隔离式或普适性能 benchmark，也未达到实时运行。
+
+`state.npz` 与 terminal queue 的 ZIP entry 均实际检查为无损压缩。封存前输出预算计数为 221,057,911 bytes，低于注册的 8 GiB 上限；该数字不包含随后生成的最终 manifest/checksum 控制文件。
+
+## 继续学习前的边界
+
+仅本工程实验被封存；lab 整个目录未封存，实际使用的 21 份源码/测试/协议已按 SHA 锁定并保存快照。后续不得改写它们后沿用此结论。scientific conditioning 草案尚未登记、没有训练、没有 learned candidate。
+
+当前草案已有 68,000 epochs：30,000×120 ms、30,000×180 ms 和 8,000×120 ms，总计 9,960 生物秒；另有 80 条 10 s 连续 idle，总计 10,760 生物秒。evaluation/probe inventory 尚未完整，所以这仍不是全量预算。仅按本次 100 ms 样本线性算术外推，核心模拟约 64.35–65.52 小时，运行及即时封存约 174.16–174.97 小时；气味活动、长度、缓存和 I/O 不同可能改变成本，不能当作可靠工期承诺。
+
+下一步须先补齐 evaluation/reversal/retention 集成与有限预算，再登记小规模机制验证。小规模验证不能代替五个训练 seeds、独立 evaluation seeds、全部控制及完整科学门。不得调整参数挽救 PASS；没有自动解锁游戏、RL、decoder 或视觉。
+
+## 锚点
+
+- 注册：`7317441126f191ccc6e6d28438870b3921537ebe282a6acb163716a690057945`
+- 分析：`d5ad47a85e4c22e8a482b26330957a821e394022658531a914c9080187454d03`
+- 正式状态：`16630d0d666a2467c56b647d021cbdb627a553795f6afcd7f7eb496a2737d815`
+- 实验 manifest：`e8952a48cd3ea6a93c811a1183a1f7b79e19646299924e7688e5f393737a9aa2`
+- checksums：`7c22aee142affae52dd5792d655e5839db14380ae84993f99a50bdce53a4135c`
+
+服务器目录：`experiments/phase4an-engineering-validation/`。原始大数组和轨迹仍保存在服务器；小证据/Git 交付不等于全量异机备份。

models/male-cns-lif/olfactory-conditioning-lab-v1/ENGINEERING_GATE_DRAFT.md

@@ -0,0 +1,116 @@
+# Phase 4AN GPU 工程验证门草案
+
+状态：**未注册 DRAFT；不是执行授权，尚未运行本门。** 日期：2026-09-30。
+
+本门只验证新的轻记录执行器和连续状态接口是否保存冻结 D18 动力学。它不是 conditioning、retention 学习结论，也不产生 learned candidate。AM 是否已正式完成、其最终状态和 seal SHA，必须在本门预注册时从真实证据核验，本文不代填成功状态或哈希。
+
+## 1. 固定范围与最小库存
+
+只使用一个 AM 已准备的 100 ms 全脑输入，分别安装其原有 `zero` 与 `static25` 固定 overlay。选择规则先于本门任何新 GPU 输出：从 AM `protocol/preregistered.json` 的原 `planned` 顺序取第一条 `repeat == 0` 的记录，保存其完整行、序号、case 路径及 SHA；不得按活动强弱、旧 static25 效果或运行快慢挑 case。其原始 case 实际位于 AK `cases/<cohort>/<name>`；AM `run_suite.py` 没有另造一套 case。若预注册者希望改变此规则，应先修订草案并锁定，不得在看新输出后换输入。
+
+每个 overlay 固定以下库存，所有行均使用同一原始 1000 tick 请求序列或其精确前缀/分段：
+
+| 行组 | 固定执行内容 | 新执行调用数/overlay |
+|---|---|---:|
+| Fresh 对照 | 完整 1000 tick reference r0、light r0、light r1 | 3 |
+| 连续链 | reference、light 各一条，段长 `[5, 13, 1, 481, 500]` | 10 |
+| 切点前缀 | 从初态独立运行 reference 至绝对 tick 数 18、19、500 | 3 |
+
+合计 32 次短执行，11,074 个全脑 tick，即累计 1.1074 生物秒；不是 68,000 个训练 epoch。两条链的第一段均为 fresh 5 tick，其中 reference 第一段兼作第一个切点的前缀参照，不重复运行。切点为累计 tick 数 5、18、19、500，终点为 1000：覆盖短于 18 tick 的父/子段、在绝对 tick 18 的首次合法延迟到达、19-slot 环的相位，以及较晚的活动边界。不得把部分库存完成称作完整门通过。
+
+固定参数：166,700 neurons、25,582,938 edges、`dt_ms=0.1`、18 tick synaptic delay、19 行 spike ring、18 行 graded-APL ring、LIF float64 SI 状态与旧 APL float32 操作。保留 14,232 mask、5845 fast-APL 出边置零规则及原 APL 全形矩阵。`static25` 是 AM 原 float32-mV 候选基值的固定 `-0.25 * base` overlay，经原 SI bridge 安装；不是声称 float64 原权重每项恰减 25%。两条 overlay 分别与自己的 AM 参照比较，不能要求 zero 与 static25 相等。
+
+禁止：weight updates、eligibility 推进/应用、eta 改动、DAN/US 新请求、odor/seed 新抽样、动力学调参、训练、额外 tail ticks。这里的连续链只检验工程续接，不检验记忆保留。
+
+## 2. 当前真实接口与输入派生
+
+以下是底层 Python API；本门的独立 coordinator 使用它们，不改旧模块 globals：
+
+```python
+runtime_light.run_light(case_dir, out_dir, build_root, overlay_file, overlay_manifest)
+runtime_light.run_reference(case_dir, out_dir, build_root, overlay_file, overlay_manifest)
+runtime_continuation.seal_checkpoint(checkpoint_dir)
+runtime_continuation.load_checkpoint(checkpoint_dir, expected_sha)
+runtime_continuation.run_continued(
+    case_dir, out_dir, build_root, overlay_file, overlay_manifest,
+    checkpoint_dir, mode='light'  # 或 'reference'
+)
+```
+
+本门的 comparator、有限库存 coordinator、预注册/执行 receipt 已在独立 engineering 模块实现；必须在服务器通过纯合成测试、完成只读代码审查并锁定全部源码后，才能注册执行。现有 AM comparator 对 AM adapter/provenance 和完整 1000 tick 有硬 schema 约束，不应直接冒充 AN comparator 或修改其旧 globals。
+
+在新的独占输入目录派生 spec，不改 AK/AM 原文件。完整 fresh case 保留原 `name`、model、APL、图、系数和请求；增加显式 `max_steps=1000`，仅调整新的输出预算根及已列明的非科学标签。要求 `record_history=False`。新旧 spec 的逐字段差异必须列入 receipt，不能用“大致相同”或整类忽略代替。
+
+前缀保留原请求中 `tick < end` 的行。分段 `[start, stop)` 只保留该区间原请求，局部 tick 精确减 `start`；全局 neuron_idx 不变。每段 `steps=stop-start`、`duration_ms=steps*0.1`、`max_steps=1000`。将各段请求恢复绝对 tick 后拼接，必须与原请求两个 int32 数组逐位相同、顺序相同、无丢失/重复；不能重抽随机输入。NPZ 容器 SHA 可以因新文件而不同，但数组语义必须 exact，并同时保留文件 SHA。
+
+第一段完成后立即 `seal_checkpoint`；外部 coordinator 把返回的实际 manifest SHA 绑定到下一段新 spec 的 `parent_checkpoint_manifest_sha256`，可同时写准确 `global_tick_offset`。此 SHA 是运行后产出的数据依赖，预注册应锁定派生规则而不是预造值。后续 `run_continued` 自身会产生并封存 checkpoint；父 SHA 仍须外部绑定。fresh seal 是 `state.npz` 的首次新增封存绑定，不能声称它追溯证明 seal 前文件未改：应在同一受控流程中立即比较、封存，保存前后 inventory，期间不允许第三方写入。
+
+AN overlay manifest 使用现有 `phase4an-overlay-v1` 精确键：`schema, overlay_name, overlay_sha256, mask_path, mask_sha256, base_candidate_path, base_candidate_sha256, aj_model_dir, am_overlay_path, am_overlay_sha256`。复用 AM 原 overlay 数组字节及实际 SHA，仅新建 manifest；不能把 AM 原 manifest 的额外字段直接塞给 AN，也不使用 `learned` 模式。
+
+## 3. 预注册必须完整绑定的证据
+
+在任何本门 GPU 执行前，保存不可覆盖的 input/source inventory 与其外部 SHA。至少包括：
+
+- AM 最终状态、model/experiment seal、`protocol/preregistered.json`、`prepared-hashes.json`、所选原 case spec/requests，以及 `gpu/zero/<name>-r0`、`gpu/static25/<name>-r0` 的完整 `output-hashes.json`、comparison、adapter provenance 与全部待比较 artifact。核验完整 AM seal，而非只相信单个 `pass_all`。
+- 图的 `nodes/edge_id/src/dst/ptr/signed_raw/weights.npy` 全部文件；APL `input_matrix/output_matrix/kc_globals/apl_globals.npy`；AF 原 `coefficients.json`；AM `protocol/base-candidate.float32-mV.npy`、两个 overlay NPZ/manifest、原 H mask。图和 bundle 的所有 SHA 来自外部锚定的 AM prereg inputs，不是仅由 AN 本次读入后自报。
+- AN `runtime_light.py`、`runtime_continuation.py`、对应 tests、即将实现的本门 coordinator/comparator/tests，以及本草案最终注册版。固定其实际 SHA 和源 AST 审计；不得在跑到一半后修改源代码继续使用同一 prereg。
+- `runtime_light.PINS` 的整个依赖链：AJ GPU/timing queue、AG-r2 GPU/legacy APL worker、AE backend/C++/CUDA、AF queue helper，以及 `AM_OVERLAY_SHA` 对应原 `overlay.py`。记录 `runtime_continuation.LIGHT_SHA` 与实际 light 文件一致。运行前后都重验旧来源与静态输入，不依赖时间戳缓存来替代字节哈希。
+- 新输入每份 spec/requests/manifest 的 SHA，原始记录到前缀/分段的确定性映射，以及库版本、科学 Python 原 venv 入口、GPU UUID/driver/CUDA/Torch/NumPy、编译标志和 extension 来源。Python 用 `-B`；不可通过 resolve venv executable 改变包环境。Torch import 前完成 GPU/CUDA 环境设置；仅记录并核对原 TF32/CuBLAS/确定性配置，不为追求一致或速度偷偷改默认值。
+
+AM 已完成封存并取得小证据下载包；该下载包不含全部大型轨迹，因此预注册仍必须在服务器完整校验 AM 两个 seal。实际 case 名与 seal SHA 依照上述确定规则写入预注册，不以本文代填。缺失 authority、旧输入变化或 AM 不完整时停止，不进入 GPU 门。
+
+## 4. Exact 比较，不把摘要布尔当证明
+
+所有浮点比较按原 dtype 的连续 little-endian raw bits，包括正负零；禁止 tolerance、round、只比均值或把压缩 NPZ 文件字节相等误作数组相等。所有状态要求 finite，事件、计数和请求库存必须完整。
+
+### Fresh light/reference ↔ 同 overlay AM
+
+逐数组比 `state.npz` 六键：`step/neuron_idx/counts/ref` 为 int32，`v/g` 为 float64；全部 N 个末态和全部稀疏事件相同，events 自身排序唯一且 bincount 等于 counts。light 与 reference 都保留 `requests.csv`，其五字段 `tick, neuron_idx, attempted, accepted, rejected` 必须与 AM 原输出逐行 exact；不能只比较请求总数。reference 另比每 tick `v_sha256/g_sha256/ref_sha256`、全部 APL drive/state/generated inhibition/applied h float32、pending tail 和每 tick queue。来源标签、新 spec SHA、记录范围和计时等确有差异的字段须显式白名单，不能整份忽略 provenance。
+
+AN 新 `terminal-queues.npz` 没有对应 AM 原文件时，只从 AM 已记录事实独立重建：1000 tick 最后 19 tick 的全局 sparse events 决定 raw spike ring；末行 `apl-state.float32.npy` 决定 APL state；原 `apl-pending-tail.float32.npy` 决定 chronological pending。比较全部数组及 `next_tick=1000`，不补跑 AM。
+
+light 没有全 APL trace、逐 tick V/g/ref hash 或 queue.jsonl；不能把这些缺文件当空记录、不能称 light 已做这些逐 tick 对照。但 `ReportingOnly.visit_With` 只移除 queue/hash 的两个 context item，留下 `request_output`，也保留 `writer.writerows` 和请求接受判定的 GPU→CPU 拷贝。因此 light 的门包括完整 events/counts/终态、逐行五字段请求接受记录、APL state、完整两种 pending queue、有限值覆盖、总到达/接受计数及固定权重身份与 reference exact；不能把它描述为完全无逐请求记录或完全无逐 tick CPU 同步。reference 承担完整逐 tick 状态/队列观测。light r1 要与 r0 的科学数组、请求 CSV、终态队列及有限值/总量一致，计时不是 exact 字段。
+
+### Monolithic ↔ segmented
+
+每个 overlay、每种模式分别比自己的完整 1000 tick fresh 基线，不跨 overlay 借结果。拼接所有段的 sparse events，并按 receipt offset 恢复绝对 tick；逐段 counts 用 int64 求和、验证范围后与单体 counts exact。末态 V/g/ref、最终 APL state/pending、effective weights raw SHA 必须一致；每个中间切点还与相同绝对长度的 fresh reference 前缀末态对照。切点 5 使用已记录的首段 reference，切点 18/19/500 使用预定前缀，终点使用完整基线。
+
+spike ring 不能直接比较物理行号：各自按 `terminal.next_tick % 19` 转成“下一写 slot 起”的 19 行顺序后逐位比较；continued 的 `next_tick` 是本段局部相位，绝对时间来自 receipt。APL pending 已按下一次应用顺序保存，直接逐位比较；不得把它当未来脑活动或继续衰减的完整尾迹。短段未覆盖的 spike slots 和未消费 APL prefix 还须精确等于父 carry。
+
+reference 的全部逐 tick 状态 hashes 和 APL 四种 trace 按全局时间拼接后与 monolithic 对照；不重复/跳过边界 tick。`queue.jsonl` 的 `joint_sha256` 编码了局部 tick，不能直接跨段相等比较：按全局 tick 对齐，精确比较 `count, accepted_count, ordered_edge_sha256, accepted_mask_sha256`；用完整事件、原 CSR、原 ref 规则独立重建原 source-order queue，并分别验证每份文件自己的 local-header joint hash。不能对 queue 重新按 target 排序后才声称原队列相同。**light 和 reference 两条链的请求 CSV 均须**按 offset 还原 tick、保持其余四字段和行序，拼接后与各自 monolithic CSV 逐行 exact；同时与预定请求库存对应，不能漏掉拒收请求。
+
+上述门可证明 reference 完整记录和 light 已记录状态的一致；**不能据此声称不可观测的 light 每 tick 内部 V/g bits 已被直接逐项比较。** 若正式注册要求这一更强结论，须先单独批准新只读观测器和相应 source pin，而不是运行后扩大结论。
+
+## 5. 防真空和故障门
+
+每个 overlay 都必须从当前 reference 实际记录证明：事件非空；generated 与 applied APL h 至少有非零样本；至少一个预定内部切点同时出现非空 spike carry 和非零 APL pending。还须保存至少一个真实跨边界 synaptic witness：源 spike 在边界之前、`arrival_tick=source_spike_tick+18` 位于边界之后且小于 1000；其真实 canonical edge 权重非零、到达被接受，并包含在原队列哈希重建中。记录 boundary、source/target、edge_id、spike/arrival tick、接受标志及权重，不把这个工程 witness 解释为单一生物学原因。
+
+这些仅是“确实测试过 live carry”的覆盖条件，不是调参阈值。不得强迫所有边界都有活动，也不得用空队列 exact 当作 live-carry PASS。固定 case/切点不满足时，结果为 coverage INCOMPLETE，保存全部输出；不可临时加 pulse、选另一个效果强的 case 或后移边界救场。任何扩展需新草案修订及新 prereg，明确看过既有结果。
+
+故障检查以纯临时合成测试完成：错误外部 SHA、祖先 state 篡改、局部/绝对时钟错配、未写 ring slot 或未消费 APL prefix 改值、输入数组 dtype/NaN/Inf、重复/遗漏事件、拒收被错算接受、输出/编译目录越入任一祖先或冻结输入、已有目录重用。不要故意破坏 AM 或 GPU 正式输出来造负例。
+
+## 6. 计时、压缩与磁盘预算
+
+建议注册一个独立新实验输出根，新增 artifact/build 合计硬上限 **8 GiB**，启动前另保留 **10 GiB** 空闲余量；这是待批准的工程资源上限，不是神经科学门。所有图/APL/旧输出仅只读引用，不复制大型图或全脑 dense history。每次运行前后核实已写字节和剩余空间；不足则停止并保留 partial，不删证据续跑，也不缩短注册 tick 数。
+
+32 次调用共享新的 extension build cache，但不共享可变神经/APL状态，只有声明的父 checkpoint 传状态。记录每次 wall time、已有 `diagnostic_simulation_seconds`、build/cache 时间、完整校验/压缩在 wall 中的费用及峰值 VRAM。reference r0 先行、light r0/r1 随后；明确首次编译/文件缓存顺序造成的影响，不能把一次差值称为普适性能 benchmark。可报告实测 100 ms trial 的耗时/压缩字节，不以此承诺 conditioning 大库存的总成本。
+
+压缩格式按实际来源逐项核对：当前固定 SHA 的 AJ `gpu_timing.py::run_gpu` 写 `state.npz` 的语句是 `np.savez_compressed(target, **state)`，不是 `np.savez`；AN 的 light/reference AST 派生没有替换该语句。`terminal-queues.npz` 则由 AN `_Runtime.finish` 明确使用 `np.savez_compressed`。记录各数组 uncompressed `nbytes`、这两种 NPZ 的实际压缩 bytes、全部 JSONL/CSV/NPY 及 build bytes，并在执行 receipt 核验各 NPZ entry 的实际压缩方式；不得仅凭 `.npz` 扩展名判断。不能只按 NPZ 小体积漏掉 reference APL 原始 `.npy`。reference 四种 APL trace 的主体约为每 tick 32,528 bytes；完整 1000 tick 约 32.528 MB，尚未含事件/末态/队列/头部。所有估计与最终实际 inventory 同报，不预称已节省多少磁盘；不改原输出格式或移除证据以追求预算。
+
+## 7. 执行 receipt 与停止结论
+
+新 coordinator 须 exclusive 写每行执行 receipt 和全门 inventory：注册 SHA、行 ID/overlay/mode/repeat/区间、case/requests/代码输入 SHA、进程退出码、完整 stdout/stderr、开始/结束记录、实际 completed ticks、原始 output inventory SHA、独立 comparator 结果/输入 SHA、finite coverage、weight identity、父 checkpoint 路径/外部 SHA、全局时钟、计时及磁盘字节。单独的 `summary.complete/pass_all` 不足：它可能先于 wrapper 后置核验失败写出；必须有完整 runtime provenance、无 error/failure marker，并重新验证 input/old integrity。
+
+checkpoint manifest、continuation receipt 和外部执行 inventory 各自按现有排除自身的规则封存，不能自哈希循环。新比较报告和 coordinator receipt 放在被封存 checkpoint 目录之外，避免为加报告改坏父链。恢复只可跳过经完整库存/输入/独立比较重验的已完成行；存在 partial、故障 marker 或不完整祖先则停止，不覆盖、不自动科学重试。
+
+全部库存、exact 比较、live-carry 覆盖和前后 integrity 均通过时，最高结论仅为“固定 zero/static25 的 GPU 记录模式与连续状态工程等价门通过”；`learning_pass_claimed=False`、`candidate_generated=False`、`weights_updated_during_run=False`。数值不一致为 FAIL；缺证据、预算中断或 live-carry 未覆盖为 INCOMPLETE；不把未执行项记 PASS。任何结果都不自动授权 conditioning，后续训练协议、独立输入/种子/控制与科学门仍需另行审定。
+
+## 8. 未来可另行注册的补充，不属于当前库存
+
+以下来自独立审查者的工程提案，**不自动追加到本门、不授权执行，也不是当前 32 次调用的 PASS 条件**。需要分别固定新输入、代码/比较器、父 checkpoint 来源和资源预算后重新审定；不可把本草案悄然扩为 90 次调用。
+
+第一项是独立全图 synthetic live-carry 短矩阵。可从冻结 mask 的最低 canonical KC source 及其最低 global edge ID 的真实 MBON target 定义 K、M；从冻结 APL input matrix 的非零列按预定 canonical 规则选 Q，不按新输出选人。拟定 80 tick 的两种请求表：K 在 0/1/22/44/66；必要时 Q 在 0；另一表额外 M 在 18，以覆盖到达接收/不应期拒收、child local tick 0 请求及 tick 84 尚未到期的 spike tail。Q 的实际身份和非零列须静态核验，不能仅凭前缀猜 PN/KC；预期 live/accept/reject 条件也须由实际记录证明。zero/static25 × 两表，各比 reference monolithic 与 reference/light 分段 `[5,12,1,1,18,43]`，提案合计 52 次短调用、960 tick（0.096 生物秒）。它测试人工工程请求，不是新增 odor conditioning；本门固定 AM case 的覆盖不足不能未经新注册就用该矩阵救成 PASS。
+
+第二项是在上述另注册短矩阵通过并得到明确绑定的 active checkpoint 后，再注册较长的连续 idle 工程门：zero/static25 各比较 light 一段 100,000 tick 与连续 10,000 + 90,000 tick，均零新输入、零权重更新，提案合计 6 次 continuation 调用。比较全部 sparse events、分段 counts 总和、终态 V/g/ref/APL state 及规范化 queues；不记录 10 秒逐 tick CPU hash 时，不能宣称逐 tick 浮点状态已独立对照。1 秒 checkpoint 沿同一 idle 主链续到 10 秒；任何测试 probe 必须另 fork，不能把 probe 插入主轨迹，其调用数和预算另列。所有祖先 manifest 在 fork 前后不变。即使通过，也仅证明较长时钟/状态接口，不是记忆保持或 learning PASS。
+
+源码依据：本目录 `runtime_light.py` 的 `validate_spec/load_overlay/derive_ast/_Runtime.finish/_run`；`runtime_continuation.py` 的 `rotate_spike_ring/validate_state/load_checkpoint/run_continued/audit_carried_sequence`；封存 AM `prepare.py/run_suite.py/adapter.py/comparison.py`；封存 AJ `gpu_timing.py` 与 AF `oracle_full.py::queue_summary`。本文只读这些来源，未运行 GPU、未注册或修改其内容。

models/male-cns-lif/olfactory-conditioning-lab-v1/engineering_analysis.py

@@ -0,0 +1,373 @@
+"""Deterministic, read-only CPU analysis of the registered 32-call AN gate.
+
+analyze(reg, reg_sha, verified_records) accepts the actual runtime receipts
+already verified by engineering_workflow.verify_execution.  It does not run
+that workflow, publish, seal, save, retry or import a GPU runtime.  All external
+AM seals/checkpoint chains/process receipts remain the caller's prior duty.
+This module rehashes the files it reads, executes every canonical descriptor,
+and independently reconstructs the reference queues and effective SI weights.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from pathlib import Path
+import types
+
+import numpy as np
+
+import engineering_compare as compare
+import engineering_plan as plan_module
+import engineering_queue_audit as queue_audit
+import engineering_scopes as scopes
+
+
+N, E, K = 166700, 25582938, 4064
+CANDIDATES, FAST_APL_EDGES = 14232, 5845
+AM_OVERLAY_SHA = '7f891d0ba79b393c96e75fd2dee2eddc51e57d8213eaac2779703bc2c18712b4'
+MASK_SHA = '8b0fb6eb2e6c31da4d17dc20d890aa3f367e514f05642de5bad6b42a1611c05b'
+SUCCESS = 'PASS-EXACT-LIGHT-CONTINUATION-ENGINEERING-NOT-LEARNING'
+
+
+def require(value, message):
+    if not value:
+        raise ValueError(message)
+
+
+def _canonical(value):
+    return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=False, allow_nan=False)
+
+
+def _sha_file(path):
+    h = hashlib.sha256()
+    with Path(path).open('rb') as stream:
+        for data in iter(lambda: stream.read(8 << 20), b''):
+            h.update(data)
+    return h.hexdigest()
+
+
+class _Reader:
+    """Fresh byte hashes, not stat caching; deterministic read manifest."""
+    def __init__(self, registered):
+        self.registered = registered
+        self.reads = {}
+        self.arrays = []
+
+    def bind(self, path, *, registered=True, expected=None):
+        path = Path(path)
+        require(path.is_absolute() and path.is_file() and not path.is_symlink(), 'Missing/linked/relative evidence: ' + str(path))
+        path = path.resolve(strict=True)
+        if registered:
+            require(str(path) in self.registered, 'Unregistered dependency: ' + str(path))
+            require(expected is None or expected == self.registered[str(path)], 'Conflicting external hash authority')
+            expected = self.registered[str(path)]
+        actual = _sha_file(path)
+        require(expected is None or (compare._sha(expected) and actual == expected), 'Evidence bytes changed: ' + str(path))
+        value = dict(path=str(path), bytes=path.stat().st_size, sha256=actual)
+        require(str(path) not in self.reads or self.reads[str(path)] == value, 'File changed during analysis')
+        self.reads[str(path)] = value
+        return path
+
+    def json(self, path, **kwargs):
+        return compare._json(self.bind(path, **kwargs))
+
+    def npy(self, path):
+        value = np.load(self.bind(path), mmap_mode='r', allow_pickle=False)
+        self.arrays.append(value)
+        return value
+
+    def npz(self, path, keys):
+        with np.load(self.bind(path), allow_pickle=False) as archive:
+            require(len(archive.files) == len(keys) and set(archive.files) == set(keys), 'Unexpected input NPZ keys')
+            return {name: archive[name].copy() for name in keys}
+
+    def run(self, directory, *, legacy):
+        directory = Path(directory)
+        names = ['summary.json', 'state.npz', 'apl-timing-audit.json', 'apl-pending-tail.float32.npy', 'requests.csv']
+        if legacy:
+            names.append('adapter-provenance.json')
+        else:
+            names.append('terminal-queues.npz')
+        names += [name for name in [*compare.TRACE_FILES.values(), 'tick-state-hashes.jsonl', 'queue.jsonl']
+                  if (directory / name).is_file()]
+        for name in names:
+            self.bind(directory / name, registered=legacy)
+        return compare.load_run(directory, allow_legacy_am=legacy)
+
+    def finish(self):
+        for row in self.reads.values():
+            path = Path(row['path'])
+            require(path.is_file() and path.stat().st_size == row['bytes'] and _sha_file(path) == row['sha256'],
+                    'Read evidence changed during analysis: ' + str(path))
+        return [self.reads[key] for key in sorted(self.reads)]
+
+    def close(self):
+        for value in self.arrays:
+            mmap = getattr(value, '_mmap', None)
+            if mmap is not None:
+                mmap.close()
+
+
+def _registration(reg, reg_sha, verified):
+    require(type(reg) is dict and reg.get('schema') == 'phase4an-engineering-registration-v1' and
+            reg.get('training') is False and compare._sha(reg_sha), 'Invalid engineering registration')
+    plan = plan_module.validate_plan(reg['plan'])
+    ids = [row['row_id'] for row in plan['rows']]
+    require(type(verified) is dict and set(verified) == set(ids) and set(reg['cases']) == set(ids),
+            'Exactly all 32 registered runtime receipts/cases are required')
+    exp = None
+    for row in plan['rows']:
+        identity = row['row_id']; path = Path(reg['cases'][identity]['case_dir'])
+        require(path.is_absolute() and path.name == identity and path.parent.name == 'cases', 'Invalid registered case layout')
+        if exp is None:
+            exp = path.parent.parent
+        require(path == exp / 'cases' / identity, 'Cases span inconsistent experiment roots')
+        receipt = verified[identity]
+        require(receipt.get('schema') == 'phase4an-engineering-runtime-record-v1' and receipt.get('complete') is True and
+                receipt.get('training') is False and receipt.get('registration_sha256') == reg_sha and
+                _canonical(receipt.get('row')) == _canonical(row) and compare._sha(receipt.get('checkpoint_manifest_sha256')),
+                'Runtime receipt is not the exact verified registered row: ' + identity)
+    require(exp.name == 'phase4an-engineering-validation' and exp.parent.name == 'experiments', 'Unexpected fixed engineering output root')
+    require(set(reg['overlays']) == set(reg['selected_case']['AM_outputs']) == {'zero', 'static25'}, 'Incomplete overlay/AM authority')
+    return plan, exp
+
+
+def _materialize(reader, reg, graph, stage):
+    """Use the exact pinned pure AM helper; no original globals are patched."""
+    declaration = reg['overlays'][stage]
+    meta = reader.json(declaration['overlay_manifest'])
+    require(meta.get('schema') == 'phase4an-overlay-v1' and meta.get('overlay_name') == stage and
+            meta.get('am_overlay_sha256') == AM_OVERLAY_SHA and meta.get('mask_sha256') == MASK_SHA,
+            'Original fixed overlay authority changed')
+    helper_path = reader.bind(meta['am_overlay_path'], expected=AM_OVERLAY_SHA)
+    module = types.ModuleType('phase4an_analysis_pinned_overlay')
+    module.__file__ = str(helper_path)
+    exec(compile(helper_path.read_bytes(), str(helper_path), 'exec'), module.__dict__)
+    mask = reader.npy(meta['mask_path']); base_candidate = reader.npy(meta['base_candidate_path'])
+    require(reader.reads[str(Path(meta['mask_path']).resolve())]['sha256'] == meta['mask_sha256'] and
+            reader.reads[str(Path(meta['base_candidate_path']).resolve())]['sha256'] == meta['base_candidate_sha256'],
+            'Overlay external mask/base hash mismatch')
+    overlay_file = reader.bind(declaration['overlay_file'], expected=meta['overlay_sha256'])
+    arrays = reader.npz(overlay_file, {'edge_id', 'plastic_delta_mv'})
+    require(mask.dtype == np.int64 and mask.shape == (CANDIDATES,), 'Complete frozen plastic mask required')
+    values = module.validate_arrays(arrays['edge_id'], arrays['plastic_delta_mv'], mask, base_candidate)
+    if stage == 'zero':
+        require(not np.any(values['plastic_delta_mv'] != 0), 'Zero overlay is nonzero')
+    else:
+        require(module.bit_equal(values['plastic_delta_mv'], np.multiply(np.float32(-.25), base_candidate)),
+                'static25 differs from the original float32-mV floor')
+    effective, mapping = module.materialize_numpy(graph['weights'], graph['edge_id'], graph['apl_out_mask'], values)
+    require(mapping['mapped_candidate_count'] == CANDIDATES and mapping['missing_candidate_count'] == 0 and
+            mapping['apl_overlap_count'] == 0, 'Incomplete/overlapping candidate mapping')
+    base_sha, effective_sha = module.expected_hashes(graph['weights'], graph['apl_out_mask'], mapping)
+    require(queue_audit._raw_sha(effective) == effective_sha, 'CPU materialization/hash disagreement')
+    return effective, dict(effective_weights_raw_sha256=effective_sha, base_weights_raw_sha256=base_sha,
+                          candidate_count=CANDIDATES, installed_nonzero_count=mapping['installed_nonzero_count'],
+                          apl_fast_edges_zeroed=FAST_APL_EDGES, bridge=module.BRIDGE,
+                          helper_source_sha256=AM_OVERLAY_SHA, weights_updated_during_run=False)
+
+
+def _load_context(reg, reg_sha, plan, exp):
+    reader = _Reader(reg['input_sha256'])
+    records, legacy = {}, {}
+    try:
+        actual_reg = reader.json(exp / 'protocol/preregistered.json', registered=False, expected=reg_sha)
+        require(_canonical(actual_reg) == _canonical(reg), 'Supplied registration differs from actual registered bytes')
+        for path, expected in sorted(reg['source_sha256'].items()):
+            reader.bind(path, registered=False, expected=expected)
+        original = Path(reg['selected_case']['original_dir'])
+        spec = reader.json(original / 'spec.json')
+        require(spec.get('kind') == 'fullgraph' and spec.get('steps') == 1000 and spec.get('dt_ms') == .1 and
+                spec.get('apl_delay_steps') == 18, 'Original fixed fullgraph D18 spec changed')
+        requests = reader.npz(original / 'requests.npz', {'tick', 'neuron_idx'})
+        graph_dir, bundle = Path(spec['graph_dir']), Path(spec['apl_bundle_dir'])
+        graph = {key: reader.npy(graph_dir / (key + '.npy')) for key in ('nodes', 'ptr', 'dst', 'edge_id', 'weights')}
+        require(graph['nodes'].dtype == np.int32 and np.array_equal(graph['nodes'], np.arange(N, dtype=np.int32)),
+                'Graph is not the complete canonical neuron set')
+        n, e = queue_audit._graph(graph['ptr'], graph['dst'], graph['edge_id'], graph['weights'])
+        require((n, e) == (N, E), 'Original graph dimensions changed')
+        apl = reader.npy(bundle / 'apl_globals.npy')
+        require(apl.dtype == np.int32 and apl.shape == (2,) and np.all((apl >= 0) & (apl < N)) and
+                apl[0] < apl[1], 'Invalid canonical APL source identity')
+        mask = np.zeros(E, np.bool_)
+        for source in apl:
+            mask[graph['ptr'][source]:graph['ptr'][source + 1]] = True
+        require(int(mask.sum()) == FAST_APL_EDGES, 'Frozen fast-APL source-edge mask changed')
+        graph['apl_out_mask'] = mask
+        storage = {}
+        for row in plan['rows']:
+            identity = row['row_id']; folder = exp / 'runs' / identity
+            require(folder.is_dir() and folder.resolve() == folder and not any(p.is_symlink() for p in folder.rglob('*')),
+                    'Missing/linked runtime evidence folder')
+            records[identity] = reader.run(folder, legacy=False)
+            storage[identity] = sum(p.stat().st_size for p in folder.rglob('*') if p.is_file())
+        for stage in ('zero', 'static25'):
+            legacy[stage] = reader.run(reg['selected_case']['AM_outputs'][stage], legacy=True)
+        return dict(reader=reader, records=records, legacy=legacy, graph=graph, requests=requests,
+                    storage=storage, input_scope='read-only authenticated selected original inputs and AM outputs')
+    except BaseException:
+        for record in [*records.values(), *legacy.values()]:
+            compare.close_run(record)
+        reader.close()
+        raise
+
+
+def _pair(candidate, reference):
+    checks, observed = compare._pair_checks(candidate, reference)
+    return dict(numerical_exact=all(checks.values()), checks=checks,
+                failed_checks=[key for key, value in checks.items() if not value],
+                reference_comparisons_available=observed, learning_pass_claimed=False)
+
+
+def _dispatch(descriptor, records, legacy, overlay):
+    candidates = [records[name] for name in descriptor['candidate_row_ids']]
+    reference = records[descriptor['reference_row_id']] if descriptor['reference_row_id'] is not None else None
+    kind = descriptor['check']
+    if kind == 'am_exact':
+        return compare.compare_fresh(candidates[0], legacy[overlay])
+    if kind == 'fresh_exact':
+        return compare.compare_fresh(candidates[0], reference)
+    if kind in ('prefix_of_reference', 'segment_of_reference'):
+        return scopes.compare_slice(candidates[0], reference)
+    if kind == 'segment_exact':
+        return _pair(candidates[0], reference)
+    if kind == 'checkpoint_exact':
+        return scopes.compare_checkpoint(candidates[0], reference)
+    if kind == 'parent_carry':
+        return scopes.compare_parent_carry(candidates[0], reference)
+    if kind == 'chain_exact':
+        return compare.compare_segments(reference, candidates)
+    raise ValueError('Unimplemented registered comparison: ' + str(kind))
+
+
+def _number(value, name, integer=False):
+    if value is None:
+        return None
+    require((type(value) is int if integer else type(value) in (int, float)) and math.isfinite(value) and value >= 0,
+            'Malformed observed metric: ' + name)
+    return value
+
+
+def _run_checks(row, record, expected_hash, reference):
+    compare.validate_run(record)
+    summary = record['summary']; identity = row['row_id']
+    require(len(record['state']['v']) == N and record['terminal']['apl_pending'].shape == (18, K), 'Incomplete full brain state: ' + identity)
+    checks = {key: summary.get(key) is True for key in ('complete', 'pass_all', 'all_finite', 'counts_match_sparse_events')}
+    fixed = dict(nodes=N, edges=E, steps=row['steps'], completed_ticks=row['steps'], apl_delay_steps=18,
+                 requested=len(record['requests']), total_spikes=len(record['state']['step']),
+                 accepted_requests=int(record['requests'][:, 3].sum(dtype=np.int64)),
+                 rejected_requests=int(record['requests'][:, 4].sum(dtype=np.int64)),
+                 apl_fast_edges_zeroed=FAST_APL_EDGES, kc_targets_present=K)
+    for key, value in fixed.items():
+        checks[key] = type(summary.get(key)) is int and summary[key] == value
+    checks['registered_clock'] = record['steps'] == row['steps'] and record['global_tick_offset'] == row['start']
+    checks['recording_mode'] = summary.get('diagnostic_mode') == row['mode']
+    checks['effective_weight_bytes'] = summary.get('effective_weights_raw_sha256') == expected_hash
+    checks['within_trial_weights_fixed'] = summary.get('within_trial_weight_updates') is False
+    checks['learning_not_claimed'] = summary.get('learning_pass_claimed') is False
+    expected_queue = reference['queues'][row['start']:row['stop']]
+    for field, queue_key in [('arriving_edges', 'count'), ('accepted_arriving_edges', 'accepted_count')]:
+        expected = sum(q[queue_key] for q in expected_queue)
+        checks[field] = type(summary.get(field)) is int and summary[field] == expected
+    return {name: bool(value) for name, value in checks.items()}
+
+
+def analyze(reg, reg_sha, verified_records):
+    """No writes/runs. The caller rechecks registration and receipts afterward."""
+    plan, exp = _registration(reg, reg_sha, verified_records)
+    context = _load_context(reg, reg_sha, plan, exp)
+    records, legacy = context['records'], context['legacy']
+    try:
+        require(set(records) == {r['row_id'] for r in plan['rows']} and set(legacy) == {'zero', 'static25'},
+                'Loaded evidence inventory is incomplete')
+        comparisons = []
+        for row in plan['rows']:
+            for number, descriptor in enumerate(row['expected_comparisons']):
+                try:
+                    result = _dispatch(descriptor, records, legacy, row['overlay'])
+                    require(type(result.get('numerical_exact')) is bool, 'Comparator lacks an explicit Boolean numerical gate')
+                except (ValueError, KeyError, TypeError, IndexError, OverflowError) as error:
+                    result = dict(numerical_exact=False, error_type=type(error).__name__, error=str(error),
+                                  incomplete_observation_not_fabricated=True)
+                comparisons.append(dict(descriptor_id=row['row_id'] + '/' + str(number),
+                                        descriptor=descriptor, result=result))
+        expected_descriptors = sum(len(r['expected_comparisons']) for r in plan['rows'])
+        require(len(comparisons) == expected_descriptors, 'Not every registered descriptor was evaluated')
+        overlay_reports, metric_rows, all_row_checks = {}, [], {}
+        for stage in ('zero', 'static25'):
+            effective, installation = _materialize(context['reader'], reg, context['graph'], stage)
+            stage_rows = [r for r in plan['rows'] if r['overlay'] == stage]
+            ref_row = next(r for r in stage_rows if r['kind'] == 'fresh' and r['mode'] == 'reference')
+            reference = records[ref_row['row_id']]
+            reference_chain = [records[r['row_id']] for r in stage_rows if r['kind'] == 'chain' and r['mode'] == 'reference']
+            cuts = [r['start'] for r in stage_rows if r['kind'] == 'chain' and r['mode'] == 'reference' and r['start'] > 0]
+            independent = queue_audit.audit_queues(reference, reference_chain, ptr=context['graph']['ptr'], dst=context['graph']['dst'],
+                edge_id=context['graph']['edge_id'], effective_weights=effective, requests=context['requests'], cuts=cuts)
+            del effective
+            reference_result = next(item['result'] for item in comparisons if item['descriptor']['check'] == 'chain_exact' and
+                item['descriptor']['reference_row_id'] == ref_row['row_id'])
+            light_result = next(item['result'] for item in comparisons if item['descriptor']['check'] == 'chain_exact' and
+                item['descriptor']['reference_row_id'] == plan_module._fresh_id(stage, 'light'))
+            coverage = reference_result.get('coverage', {})
+            apl_values = coverage.get('carried_APL_nonzero_applied_values')
+            simultaneous_carry = any(type(row.get('pending_source_spike_events')) is int and row['pending_source_spike_events'] > 0 and
+                type(row.get('carried_APL_nonzero_pending_values')) is int and row['carried_APL_nonzero_pending_values'] > 0
+                for row in coverage.get('boundaries', []))
+            coverage_pass = (reference_result.get('nonvacuous_temporal_coverage') is True and
+                type(apl_values) is int and apl_values > 0 and simultaneous_carry and
+                independent.get('accepted_nonzero_crossing_witness_verified') is True)
+            legacy_checks = dict(full_dimensions=type(legacy[stage]['summary'].get('nodes')) is int and legacy[stage]['summary']['nodes'] == N and
+                type(legacy[stage]['summary'].get('edges')) is int and legacy[stage]['summary']['edges'] == E,
+                effective_weight_bytes=legacy[stage]['summary'].get('effective_weights_raw_sha256') == installation['effective_weights_raw_sha256'])
+            overlay_reports[stage] = dict(installation=installation, independent_queue_audit=independent,
+                reference_numerical_exact=reference_result.get('numerical_exact') is True,
+                light_numerical_exact=light_result.get('numerical_exact') is True,
+                live_coverage_pass=coverage_pass, legacy_checks=legacy_checks,
+                same_internal_boundary_has_spike_and_APL_carry=simultaneous_carry,
+                carried_APL_nonzero_applied_values=apl_values,
+                light_standalone_coverage=light_result.get('coverage'),
+                light_per_tick_float_state_directly_observed=False,
+                reference_coverage_does_not_fabricate_light_observations=True)
+            for row in stage_rows:
+                identity = row['row_id']; record = records[identity]; summary = record['summary']; receipt = verified_records[identity]
+                checks = _run_checks(row, record, installation['effective_weights_raw_sha256'], reference)
+                all_row_checks[identity] = checks
+                metric_rows.append(dict(row_id=identity, overlay=stage, mode=row['mode'], start=row['start'], stop=row['stop'],
+                    biological_time_ms=row['steps'] * .1, runtime_and_immediate_seal_wall_seconds=_number(receipt.get('runtime_and_immediate_seal_wall_seconds'), 'runtime wall'),
+                    runtime_reported_wall_seconds=_number(summary.get('wall_seconds'), 'runtime reported wall'),
+                    diagnostic_simulation_seconds=_number(summary.get('diagnostic_simulation_seconds'), 'simulation'),
+                    build_or_cache_seconds=_number(summary.get('build_or_cache_seconds'), 'build/cache'),
+                    peak_allocated_vram_bytes=_number(summary.get('peak_allocated_vram_bytes'), 'allocated VRAM', True),
+                    peak_reserved_vram_bytes=_number(summary.get('peak_reserved_vram_bytes'), 'reserved VRAM', True),
+                    sealed_output_file_bytes=context['storage'][identity], compressed_storage=receipt.get('storage'),
+                    gpu_utilization=None, cpu_utilization=None, unobserved_metrics=['gpu_utilization', 'cpu_utilization'],
+                    checkpoint_manifest_sha256=receipt['checkpoint_manifest_sha256'],
+                    verified_runtime_receipt_canonical_sha256=hashlib.sha256(_canonical(receipt).encode('utf-8')).hexdigest()))
+        numerical = (all(item['result']['numerical_exact'] for item in comparisons) and
+                     all(all(checks.values()) for checks in all_row_checks.values()) and
+                     all(all(r['legacy_checks'].values()) and r['independent_queue_audit']['queue_ref_request_exact'] for r in overlay_reports.values()))
+        covered = all(row['live_coverage_pass'] for row in overlay_reports.values())
+        read_manifest = context['reader'].finish()
+        report = dict(schema='phase4an-engineering-analysis-v1', registration_sha256=reg_sha,
+            status='FAIL-NUMERICAL' if not numerical else (SUCCESS if covered else 'INCOMPLETE-COVERAGE'),
+            pass_all=bool(numerical and covered), numerical_exact=bool(numerical), nonvacuous_temporal_coverage=bool(covered),
+            expected_calls=32, analyzed_calls=len(records), executed_ticks=plan['total_ticks'],
+            expected_comparisons=expected_descriptors, evaluated_comparisons=len(comparisons), comparisons=comparisons,
+            run_checks=all_row_checks, failed_run_checks={identity: [k for k, ok in checks.items() if not ok] for identity, checks in all_row_checks.items() if not all(checks.values())},
+            overlay_reports=overlay_reports, metrics=metric_rows, read_manifest=read_manifest,
+            source_sha256=reg['source_sha256'], process_receipts_and_checkpoint_chains_verified_by_caller=True,
+            external_AM_full_seals_reverified_here=False, no_new_brain_runs_during_analysis=True,
+            GPU_used=False, training=False, learning_pass_claimed=False, candidate_generated=False,
+            physiology_or_memory_success_claimed=False,
+            limitations=['Fixed zero/static25 engineering trajectories only; not conditioning or learned memory.',
+                'Light intermediate V/g/ref, APL histories and per-tick queue arrays were not directly recorded.',
+                'Independent queue/ref reconstruction is conditional on recorded spikes; V/g dynamics are not independently re-simulated.',
+                'Missing performance metrics are null, not zero. No universal performance claim is made.',
+                'Caller verifies all process receipts, parent chains, registration authority and full AM/frozen seals.'])
+        _canonical(report)  # Fail rather than return non-JSON/nonfinite output.
+        return report
+    finally:
+        for record in [*records.values(), *legacy.values()]:
+            compare.close_run(record)
+        context['reader'].close()

models/male-cns-lif/olfactory-conditioning-lab-v1/engineering_compare.py

@@ -0,0 +1,413 @@
+"""Read-only CPU comparisons for the UNREGISTERED AN engineering gate.
+
+load_run(path, allow_legacy_am=False) reads actual AJ/AM/AN artifact schemas.
+Call close_run(record) after using explicitly loaded memory-mapped traces.
+compare_fresh(left, right, legacy_am=None) and compare_segments(monolithic,
+segments) accept loaded dictionaries or paths and return JSON-safe reports.
+No report is written, no GPU is imported, no training/biological PASS is claimed.
+The caller owns external source/input/root SHA pins and case selection. These
+comparisons do not replace seal verification or prove unseen inputs unchanged.
+
+AM did not save its raw spike ring: its fresh terminal ring is explicitly
+reconstructed from sparse events, never described as independently recorded.
+Reference queue joint hashes include LOCAL tick headers; cross-segment checks
+compare the separate ordered-edge/accepted-mask hashes and counts instead.
+"""
+from __future__ import annotations
+
+import csv
+import hashlib
+import json
+from pathlib import Path
+import re
+
+import numpy as np
+
+
+STATE_KEYS = ('step', 'neuron_idx', 'counts', 'v', 'g', 'ref')
+REQUEST_FIELDS = ('tick', 'neuron_idx', 'attempted', 'accepted', 'rejected')
+TRACE_FILES = {'drive': 'apl-drive.float32.npy', 'state': 'apl-state.float32.npy',
+               'generated': 'apl-inhibition.float32.npy', 'applied': 'apl-applied.float32.npy'}
+HASH_FIELDS = ('v_sha256', 'g_sha256', 'ref_sha256')
+QUEUE_FIELDS = ('count', 'accepted_count', 'ordered_edge_sha256', 'accepted_mask_sha256')
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def bit_equal(a, b):
+    return (isinstance(a, np.ndarray) and isinstance(b, np.ndarray) and a.dtype == b.dtype and a.shape == b.shape and
+            np.array_equal(np.ascontiguousarray(a).view(np.uint8), np.ascontiguousarray(b).view(np.uint8)))
+
+
+def _sha(value):
+    return isinstance(value, str) and re.fullmatch('[0-9a-f]{64}', value) is not None
+
+
+def _json(path):
+    def pairs(values):
+        result = {}
+        for key, value in values:
+            require(key not in result, 'Duplicate JSON key: ' + key)
+            result[key] = value
+        return result
+    return json.loads(Path(path).read_text(encoding='utf-8'), object_pairs_hook=pairs,
+                      parse_constant=lambda value: (_ for _ in ()).throw(ValueError('Nonfinite JSON: ' + value)))
+
+
+def _jsonl(path):
+    with Path(path).open(encoding='utf-8') as stream:
+        return [json.loads(line) for line in stream if line.strip()]
+
+
+def _npz(path, keys):
+    with np.load(path, allow_pickle=False) as archive:
+        require(len(archive.files) == len(keys) and set(archive.files) == set(keys), 'Unexpected array keys: ' + str(path))
+        return {key: archive[key].copy() for key in keys}
+
+
+def reconstructed_fresh_ring(state, steps, neurons):
+    ring = np.zeros((19, neurons), np.uint8)
+    for tick in range(max(0, steps - 19), steps):
+        first, last = np.searchsorted(state['step'], (tick, tick + 1))
+        ring[tick % 19, state['neuron_idx'][first:last]] = 1
+    return ring
+
+
+def normalized_ring(terminal):
+    ring, phase = terminal['spike_ring'], int(terminal['next_tick'])
+    return ring[(np.arange(19) + phase % 19) % 19]
+
+
+def _requests(path):
+    with Path(path).open(encoding='utf-8', newline='') as stream:
+        reader = csv.DictReader(stream)
+        require(tuple(reader.fieldnames or ()) == REQUEST_FIELDS, 'requests.csv must use the exact five AJ fields in order')
+        rows = []
+        for row in reader:
+            require(set(row) == set(REQUEST_FIELDS), 'Extra/missing request CSV field')
+            rows.append([int(row[key]) for key in REQUEST_FIELDS])
+    return np.asarray(rows, dtype=np.int64).reshape(-1, 5)
+
+
+def load_run(directory, *, allow_legacy_am=False):
+    directory = Path(directory).resolve(strict=True)
+    require(directory.is_dir(), 'Output is not a directory')
+    require(not any('error' in p.name.lower() or 'failure' in p.name.lower() for p in directory.iterdir()),
+            'Run contains error/failure evidence')
+    summary = _json(directory / 'summary.json')
+    require(summary.get('complete') is True and summary.get('pass_all') is True and summary.get('all_finite') is True and
+            summary.get('steps') == summary.get('completed_ticks'), 'Run is incomplete or failed')
+    state = _npz(directory / 'state.npz', STATE_KEYS)
+    steps, neurons = summary['steps'], len(state['v'])
+    require(summary.get('nodes') == neurons and summary.get('precision') == 'float64' and
+            summary.get('apl_precision') == 'float32' and summary.get('apl_delay_steps') == 18, 'Unexpected AN/AM numerical schema')
+    timing = _json(directory / 'apl-timing-audit.json')
+    pending = np.load(directory / 'apl-pending-tail.float32.npy', mmap_mode='r', allow_pickle=False)
+    terminal_path = directory / 'terminal-queues.npz'
+    if terminal_path.is_file():
+        terminal = _npz(terminal_path, ('spike_ring', 'apl_state', 'apl_pending', 'next_tick'))
+        origin = 'recorded_terminal_queues'
+    else:
+        require(allow_legacy_am and (directory / 'adapter-provenance.json').is_file(), 'Recorded terminal queues are missing')
+        bits = timing.get('final_apl_state_u32_bits')
+        require(isinstance(bits, list) and len(bits) == 2 and all(type(v) is int and 0 <= v < 2**32 for v in bits),
+                'AM has no exact terminal APL bits')
+        terminal = {'spike_ring': reconstructed_fresh_ring(state, steps, neurons),
+                    'apl_state': np.asarray(bits, dtype=np.uint32).view(np.float32), 'apl_pending': np.asarray(pending),
+                    'next_tick': np.asarray(steps, np.int64)}
+        origin = 'AM_spike_ring_derived_from_fresh_events_APL_bits_from_timing'
+    require(bit_equal(terminal['apl_pending'], pending), 'Terminal/pending file mismatch')
+    require(timing.get('final_apl_state_u32_bits') == terminal['apl_state'].view(np.uint32).tolist(), 'Terminal APL bit metadata mismatch')
+    continued = summary.get('checkpoint_continuation_used', False)
+    require(type(continued) is bool, 'Invalid continuation scope flag')
+    offset = summary.get('global_tick_offset', 0)
+    require(not continued or (type(offset) is int and offset > 0 and summary.get('global_next_tick') == offset + steps),
+            'Continued output lacks an explicit global clock')
+    require(continued or offset == 0, 'Fresh output has a nonzero global offset')
+    traces = {name: np.load(directory / file, mmap_mode='r', allow_pickle=False)
+              for name, file in TRACE_FILES.items() if (directory / file).is_file()}
+    reference = summary.get('diagnostic_mode') == 'reference' or origin.startswith('AM_')
+    if reference or summary.get('full_APL_history_recorded') is True:
+        require(len(traces) == 4, 'Declared reference APL history is incomplete')
+    hashes = _jsonl(directory / 'tick-state-hashes.jsonl') if (directory / 'tick-state-hashes.jsonl').is_file() else None
+    queues = _jsonl(directory / 'queue.jsonl') if (directory / 'queue.jsonl').is_file() else None
+    if reference or summary.get('full_tick_state_hashes_recorded') is True:
+        require(hashes is not None, 'Declared state hashes are missing')
+    if reference or summary.get('full_queue_hashes_recorded') is True:
+        require(queues is not None, 'Declared queue hashes are missing')
+    result = {'source': str(directory), 'state': state, 'terminal': terminal, 'requests': _requests(directory / 'requests.csv'),
+              'steps': steps, 'global_tick_offset': offset, 'summary': summary, 'traces': traces,
+              'state_hashes': hashes, 'queues': queues, 'terminal_origin': origin}
+    validate_run(result)
+    return result
+
+
+def close_run(run):
+    """Release read-only mappings opened by load_run; no files are modified."""
+    arrays = [*run.get('traces', {}).values(), *run.get('terminal', {}).values()]
+    closed = set()
+    for array in arrays:
+        current = array
+        while current is not None:
+            mapping = getattr(current, '_mmap', None)
+            if mapping is not None and id(mapping) not in closed:
+                mapping.close(); closed.add(id(mapping))
+            current = getattr(current, 'base', None)
+
+
+def validate_run(run):
+    """Array-level contract, also usable by synthetic tests without files."""
+    require(isinstance(run, dict), 'Run must be a dictionary')
+    steps, offset = run['steps'], run['global_tick_offset']
+    require(type(steps) is int and steps > 0 and type(offset) is int and offset >= 0, 'Invalid segment clock')
+    state, terminal = run['state'], run['terminal']
+    require(set(state) == set(STATE_KEYS), 'Expected exactly the six state keys')
+    n = len(state['v'])
+    require(n > 0, 'Empty neuron population')
+    for name, dtype in (('v', np.float64), ('g', np.float64), ('ref', np.int32), ('counts', np.int32)):
+        value = state[name]
+        require(value.dtype == dtype and value.shape == (n,) and np.isfinite(value).all(), 'Invalid state ' + name)
+    require(np.all((state['ref'] >= 0) & (state['ref'] <= 22)) and np.all(state['counts'] >= 0), 'Invalid ref/count values')
+    tick, node = state['step'], state['neuron_idx']
+    require(tick.dtype == node.dtype == np.int32 and tick.ndim == node.ndim == 1 and tick.shape == node.shape and
+            np.all((tick >= 0) & (tick < steps)) and np.all((node >= 0) & (node < n)), 'Invalid events')
+    keys = tick.astype(np.int64) * n + node
+    require(len(keys) < 2 or np.all(keys[1:] > keys[:-1]), 'Events must be sorted unique')
+    require(np.array_equal(np.bincount(node, minlength=n), state['counts']), 'Counts disagree with segment events')
+    request = run['requests']
+    require(isinstance(request, np.ndarray) and request.dtype == np.int64 and request.ndim == 2 and request.shape[1] == 5,
+            'Requests must be int64 rows in the five AJ fields')
+    require(np.all((request[:, 0] >= 0) & (request[:, 0] < steps)) and np.all((request[:, 1] >= 0) & (request[:, 1] < n)) and
+            np.all(request[:, 2] == 1) and np.all((request[:, 3] == 0) | (request[:, 3] == 1)) and
+            np.all(request[:, 4] == 1 - request[:, 3]), 'Invalid request values')
+    request_keys = request[:, 0] * n + request[:, 1]
+    require(len(request_keys) < 2 or np.all(request_keys[1:] > request_keys[:-1]), 'Requests must be sorted unique')
+    require(set(terminal) == {'spike_ring', 'apl_state', 'apl_pending', 'next_tick'}, 'Invalid terminal keys')
+    ring = terminal['spike_ring']
+    require(ring.dtype == np.uint8 and ring.shape == (19, n) and np.all(ring <= 1), 'Invalid spike ring')
+    phase = terminal['next_tick']
+    require(isinstance(phase, np.ndarray) and phase.dtype == np.int64 and phase.shape == () and int(phase) == steps,
+            'Terminal phase must be local segment length')
+    pending, apl_state = terminal['apl_pending'], terminal['apl_state']
+    require(pending.dtype == np.float32 and pending.ndim == 2 and pending.shape[0] == 18 and pending.shape[1] > 0 and
+            apl_state.dtype == np.float32 and apl_state.shape == (2,) and np.isfinite(pending).all() and np.isfinite(apl_state).all(),
+            'Invalid APL terminal state')
+    for t in range(max(0, steps - 19), steps):
+        expected = np.zeros(n, np.uint8)
+        first, last = np.searchsorted(tick, (t, t + 1)); expected[node[first:last]] = 1
+        require(bit_equal(ring[t % 19], expected), 'Written ring slot differs from sparse events')
+    if offset == 0 and steps < 19:
+        require(not np.any(ring[steps:]), 'Fresh uninitialized ring slots are not zero')
+    traces = run.get('traces', {})
+    require(not traces or set(traces) == set(TRACE_FILES), 'Partial APL trace set')
+    for key, trace in traces.items():
+        width = 2 if key in ('drive', 'state') else pending.shape[1]
+        require(trace.dtype == np.float32 and trace.shape == (steps, width) and np.isfinite(trace).all(), 'Invalid APL history: ' + key)
+    if traces:
+        require(bit_equal(traces['state'][-1], apl_state), 'Final APL history/state mismatch')
+        kept = min(steps, 18)
+        require(bit_equal(pending[-kept:], traces['generated'][-kept:]), 'Terminal APL queue does not retain generated suffix')
+        if steps > 18:
+            require(bit_equal(traces['applied'][18:], traces['generated'][:-18]), 'Within-segment APL delay differs from 18')
+        if offset == 0:
+            require(np.all(traces['applied'][:min(18, steps)].view(np.uint32) == 0), 'Fresh APL application padding is not positive zero')
+    hashes, queues = run.get('state_hashes'), run.get('queues')
+    if hashes is not None:
+        require(len(hashes) == steps, 'State hash coverage incomplete')
+        for t, row in enumerate(hashes):
+            require(set(row) == {'tick', *HASH_FIELDS} and type(row['tick']) is int and row['tick'] == t and
+                    all(_sha(row[key]) for key in HASH_FIELDS), 'Invalid state hash row')
+        for name in ('v', 'g', 'ref'):
+            raw = np.ascontiguousarray(state[name], dtype=state[name].dtype.newbyteorder('<')).tobytes()
+            require(hashes[-1][name + '_sha256'] == hashlib.sha256(raw).hexdigest(), 'Last state hash differs from terminal ' + name)
+    if queues is not None:
+        require(len(queues) == steps, 'Queue coverage incomplete')
+        for t, row in enumerate(queues):
+            require(set(row) == {'tick', *QUEUE_FIELDS, 'joint_sha256'} and type(row['tick']) is int and row['tick'] == t and
+                    type(row['count']) is int and type(row['accepted_count']) is int and 0 <= row['accepted_count'] <= row['count'] and
+                    all(_sha(row[key]) for key in ('ordered_edge_sha256', 'accepted_mask_sha256', 'joint_sha256')), 'Invalid queue row')
+    return run
+
+
+def _run(value, legacy=False):
+    return load_run(value, allow_legacy_am=legacy) if isinstance(value, (str, Path)) else validate_run(value)
+
+
+def _activity(run):
+    terminal = run['terminal']
+    result = {'spikes': len(run['state']['step']), 'requested': len(run['requests']),
+              'accepted_requests': int(run['requests'][:, 3].sum(dtype=np.int64)),
+              'terminal_apl_state_nonzero_values': int(np.count_nonzero(terminal['apl_state'])),
+              'terminal_pending_nonzero_values': int(np.count_nonzero(terminal['apl_pending']))}
+    traces = run.get('traces', {})
+    result['generated_h_nonzero_values'] = int(np.count_nonzero(traces['generated'])) if traces else None
+    result['applied_h_nonzero_values'] = int(np.count_nonzero(traces['applied'])) if traces else None
+    result['apl_nonzero_observed'] = bool(result['terminal_apl_state_nonzero_values'] or result['terminal_pending_nonzero_values'] or
+                                         (result['generated_h_nonzero_values'] or 0) or (result['applied_h_nonzero_values'] or 0))
+    return result
+
+
+def _pair_checks(left, right, prefix='pair'):
+    checks = {prefix + '.steps': left['steps'] == right['steps'], prefix + '.offset': left['global_tick_offset'] == right['global_tick_offset']}
+    for name in STATE_KEYS:
+        checks[prefix + '.state.' + name] = bit_equal(left['state'][name], right['state'][name])
+    checks[prefix + '.requests_five_fields'] = bit_equal(left['requests'], right['requests'])
+    for name in ('spike_ring', 'apl_state', 'apl_pending', 'next_tick'):
+        checks[prefix + '.terminal.' + name] = bit_equal(left['terminal'][name], right['terminal'][name])
+    for field in ('effective_weights_raw_sha256',):
+        a, b = left.get('summary', {}).get(field), right.get('summary', {}).get(field)
+        if a is not None or b is not None:
+            checks[prefix + '.' + field] = _sha(a) and a == b
+    availability = {'APL_traces': bool(left.get('traces')) and bool(right.get('traces')),
+                    'state_hashes': left.get('state_hashes') is not None and right.get('state_hashes') is not None,
+                    'queue_hashes': left.get('queues') is not None and right.get('queues') is not None}
+    if availability['APL_traces']:
+        for name in TRACE_FILES:
+            checks[prefix + '.trace.' + name] = bit_equal(left['traces'][name], right['traces'][name])
+    if availability['state_hashes']:
+        checks[prefix + '.state_hashes'] = left['state_hashes'] == right['state_hashes']
+    if availability['queue_hashes']:
+        checks[prefix + '.queues'] = left['queues'] == right['queues']
+    return checks, availability
+
+
+def compare_fresh(left, right, legacy_am=None):
+    left, right = _run(left), _run(right)
+    require(left['global_tick_offset'] == right['global_tick_offset'] == 0, 'Fresh comparison requires fresh runs')
+    checks, available = _pair_checks(left, right)
+    origins = [left.get('terminal_origin', 'caller_arrays'), right.get('terminal_origin', 'caller_arrays')]
+    if legacy_am is not None:
+        legacy = _run(legacy_am, legacy=True)
+        require(legacy['global_tick_offset'] == 0, 'AM control must be fresh')
+        extra, legacy_available = _pair_checks(left, legacy, 'AM')
+        checks.update(extra); available['AM'] = legacy_available
+        # The left run may be light. Do not thereby skip the independent full
+        # diagnostic comparison between the right reference and sealed AM.
+        extra, reference_available = _pair_checks(right, legacy, 'reference_vs_AM')
+        checks.update(extra); available['reference_vs_AM'] = reference_available
+        origins.append(legacy.get('terminal_origin', 'caller_arrays'))
+    activity = _activity(left)
+    exact = bool(all(checks.values()))
+    nonvacuous = activity['spikes'] > 0 and activity['apl_nonzero_observed']
+    return {'schema': 'phase4an-fresh-engineering-comparison-v1', 'numerical_exact': exact,
+            'nonvacuous_activity': nonvacuous, 'pass_all': exact and nonvacuous,
+            'status': 'FAIL-NUMERICAL' if not exact else ('PASS-FRESH-SCOPE' if nonvacuous else 'INCOMPLETE-COVERAGE'),
+            'checks': checks, 'failed_checks': [key for key, value in checks.items() if not value], 'activity': activity,
+            'reference_comparisons_available': available, 'terminal_origins': origins,
+            'cross_segment_validation_performed': False, 'temporal_validation_complete': False,
+            'scope': 'Fresh event/state/request/terminal identity only; no continuation, learning, physiology or performance PASS',
+            'independent_CSR_queue_reconstruction_performed': False,
+            'accepted_nonzero_weight_edge_witness_verified': False,
+            'external_seals_and_input_authority_verified_here': False}
+
+
+def compare_segments(monolithic, segments):
+    mono = _run(monolithic)
+    parts = [_run(value) for value in segments]
+    require(len(parts) >= 2, 'Need a monolithic run and at least two segments')
+    origin = mono['global_tick_offset']
+    if origin:
+        parent = mono.get('summary', {}).get('parent_checkpoint_manifest_sha256')
+        require(_sha(parent) and parts[0].get('summary', {}).get('parent_checkpoint_manifest_sha256') == parent,
+                'Nonzero-origin comparisons must bind the same starting parent checkpoint')
+    cursor = origin
+    for part in parts:
+        require(part['global_tick_offset'] == cursor, 'Segment clock gap/overlap/order error')
+        require(len(part['state']['v']) == len(mono['state']['v']), 'Segment population changed')
+        cursor += part['steps']
+    require(cursor == origin + mono['steps'], 'Segments do not cover the monolithic duration')
+    checks = {}
+    step = np.concatenate([part['state']['step'].astype(np.int64) + part['global_tick_offset'] for part in parts])
+    neuron = np.concatenate([part['state']['neuron_idx'] for part in parts])
+    checks['concatenated_global_events'] = np.array_equal(step, mono['state']['step'].astype(np.int64) + origin) and bit_equal(neuron, mono['state']['neuron_idx'])
+    counts = np.zeros_like(mono['state']['counts'], dtype=np.int64)
+    for part in parts:
+        counts += part['state']['counts'].astype(np.int64)
+    checks['sum_segment_counts'] = np.array_equal(counts, mono['state']['counts'].astype(np.int64))
+    requests = []
+    for part in parts:
+        rows = part['requests'].copy(); rows[:, 0] += part['global_tick_offset']; requests.append(rows)
+    mono_requests = mono['requests'].copy(); mono_requests[:, 0] += origin
+    checks['concatenated_requests_five_fields'] = bit_equal(np.concatenate(requests), mono_requests)
+    last = parts[-1]
+    for name in ('v', 'g', 'ref'):
+        checks['terminal.' + name] = bit_equal(last['state'][name], mono['state'][name])
+    checks['terminal.normalized_spike_ring'] = bit_equal(normalized_ring(last['terminal']), normalized_ring(mono['terminal']))
+    for name in ('apl_state', 'apl_pending'):
+        checks['terminal.' + name] = bit_equal(last['terminal'][name], mono['terminal'][name])
+    expected_weight = mono.get('summary', {}).get('effective_weights_raw_sha256')
+    if expected_weight is not None:
+        checks['unchanged_effective_weights'] = _sha(expected_weight) and all(part.get('summary', {}).get('effective_weights_raw_sha256') == expected_weight for part in parts)
+    trace_available = bool(mono.get('traces')) and all(part.get('traces') for part in parts)
+    hash_available = mono.get('state_hashes') is not None and all(part.get('state_hashes') is not None for part in parts)
+    queue_available = mono.get('queues') is not None and all(part.get('queues') is not None for part in parts)
+    if trace_available:
+        for name in TRACE_FILES:
+            checks['concatenated_APL.' + name] = all(bit_equal(part['traces'][name], mono['traces'][name][part['global_tick_offset'] - origin:part['global_tick_offset'] - origin + part['steps']]) for part in parts)
+    if hash_available:
+        checks['concatenated_per_tick_state_hashes'] = all(all(row[name] == mono['state_hashes'][part['global_tick_offset'] - origin + tick][name] for name in HASH_FIELDS)
+            for part in parts for tick, row in enumerate(part['state_hashes']))
+    if queue_available:
+        checks['concatenated_queue_order_and_acceptance'] = all(all(row[name] == mono['queues'][part['global_tick_offset'] - origin + tick][name] for name in QUEUE_FIELDS)
+            for part in parts for tick, row in enumerate(part['queues']))
+    boundary_rows = []
+    events = mono['state']['step'].astype(np.int64) + origin
+    for before, part in zip(parts, parts[1:]):
+        cut, stop = part['global_tick_offset'], part['global_tick_offset'] + part['steps']
+        emitted_before = (events < cut) & (events + 18 >= cut)
+        arriving_this_segment = emitted_before & (events + 18 < stop)
+        pending = before['terminal']['apl_pending']
+        consume = min(part['steps'], 18)
+        spike_carry = normalized_ring(before['terminal'])
+        # Future local arrival tick j consumes normalized slot j+1. This also
+        # covers spikes inherited from before a nonzero monolithic origin,
+        # which are legitimately absent from that run's local event log.
+        pending_spikes = int(spike_carry[1:].sum(dtype=np.int64))
+        arriving_spikes = int(spike_carry[1:consume + 1].sum(dtype=np.int64))
+        if cut - origin >= 18:
+            checks['boundary.' + str(cut) + '.ring_pending_event_count'] = pending_spikes == int(emitted_before.sum())
+        # Slots not overwritten by this short segment must remain bit-identical.
+        if part['steps'] < 19:
+            checks['boundary.' + str(cut) + '.unwritten_spike_slots'] = bit_equal(part['terminal']['spike_ring'][part['steps']:], spike_carry[part['steps']:])
+        if part['steps'] < 18:
+            checks['boundary.' + str(cut) + '.unconsumed_APL'] = bit_equal(part['terminal']['apl_pending'][:18 - part['steps']], pending[part['steps']:])
+        if part.get('traces'):
+            checks['boundary.' + str(cut) + '.applied_parent_APL'] = bit_equal(part['traces']['applied'][:consume], pending[:consume])
+        queue_rows = (part['queues'][:consume] if part.get('queues') is not None else
+                      mono['queues'][cut - origin:cut - origin + consume] if mono.get('queues') is not None else None)
+        boundary_rows.append({'global_tick': cut, 'next_segment_steps': part['steps'],
+            'pending_source_spike_events': pending_spikes, 'source_spikes_arriving_in_next_segment': arriving_spikes,
+            'visible_local_log_source_spikes_arriving_in_next_segment': int(arriving_this_segment.sum()),
+            'pending_source_spike_origin': 'recorded normalized ring slots; includes pre-origin carry',
+            'observed_carried_arriving_edges': sum(row['count'] for row in queue_rows) if queue_rows is not None else None,
+            'observed_carried_accepted_edges': sum(row['accepted_count'] for row in queue_rows) if queue_rows is not None else None,
+            'carried_APL_nonzero_pending_values': int(np.count_nonzero(pending)),
+            'carried_APL_nonzero_values_applied_in_next_segment': int(np.count_nonzero(pending[:consume])),
+            'carried_APL_nonzero_rows_applied_in_next_segment': int(np.count_nonzero(np.any(pending[:consume] != 0, axis=1)))})
+    source_arrivals = sum(row['source_spikes_arriving_in_next_segment'] for row in boundary_rows)
+    edge_counts = [row['observed_carried_arriving_edges'] for row in boundary_rows]
+    observed_edges = sum(value for value in edge_counts if value is not None) if any(value is not None for value in edge_counts) else None
+    applied_values = sum(row['carried_APL_nonzero_values_applied_in_next_segment'] for row in boundary_rows)
+    activity = _activity(mono)
+    coverage = {'boundaries': boundary_rows, 'source_spikes_crossing_boundaries_and_due_in_receiver': source_arrivals,
+                'observed_carried_arriving_edges': observed_edges, 'carried_APL_nonzero_applied_values': applied_values,
+                'boundary_pending_event_counts_may_overlap_across_short_segments': True,
+                'actual_edge_arrival_coverage_known': observed_edges is not None}
+    nonvacuous = bool(activity['spikes'] > 0 and activity['apl_nonzero_observed'] and source_arrivals > 0 and
+                      observed_edges is not None and observed_edges > 0 and applied_values > 0)
+    exact = bool(all(checks.values()))
+    return {'schema': 'phase4an-segment-engineering-comparison-v1', 'numerical_exact': exact,
+            'nonvacuous_temporal_coverage': nonvacuous, 'temporal_validation_complete': exact and nonvacuous,
+            'pass_all': exact and nonvacuous,
+            'status': 'FAIL-NUMERICAL' if not exact else ('PASS-SEGMENT-SCOPE' if nonvacuous else 'INCOMPLETE-COVERAGE'),
+            'checks': checks, 'failed_checks': [key for key, value in checks.items() if not value],
+            'activity': activity, 'coverage': coverage, 'segments': len(parts), 'steps': mono['steps'], 'global_tick_offset': origin,
+            'reference_comparisons_available': {'APL_traces': trace_available, 'state_hashes': hash_available, 'queue_hashes': queue_available},
+            'queue_joint_hash_compared': False, 'queue_joint_hash_exclusion_reason': 'local tick header differs; ordered-edge/mask hashes and counts compared when available',
+            'scope': 'Explicit finite engineering trajectory/terminal/carry checks only; no learning, physiology, or performance PASS',
+            'independent_CSR_queue_reconstruction_performed': False,
+            'accepted_nonzero_weight_edge_witness_verified': False,
+            'external_seals_and_input_authority_verified_here': False}

models/male-cns-lif/olfactory-conditioning-lab-v1/engineering_inputs.py

@@ -0,0 +1,152 @@
+"""Pure exact input derivations for a future preregistered engineering gate.
+
+No I/O, random draws, scientific execution or registration. The coordinator
+must bind the original case/overlay and every static dependency to the sealed
+AM manifest before using these helpers. A self-consistent dictionary is not
+independent input authority. Derivation outputs are copies; validate_requests
+only checks and returns its original, unmodified input.
+"""
+from __future__ import annotations
+
+import copy
+import re
+from pathlib import PurePosixPath
+
+import numpy as np
+
+
+N = 166700
+AM_HELPER_SHA = '7f891d0ba79b393c96e75fd2dee2eddc51e57d8213eaac2779703bc2c18712b4'
+MASK_SHA = '8b0fb6eb2e6c31da4d17dc20d890aa3f367e514f05642de5bad6b42a1611c05b'
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def _positive_int(value, name):
+    require(type(value) is int and 0 < value <= np.iinfo(np.int32).max, 'Invalid ' + name)
+
+
+def _sha(value):
+    return type(value) is str and re.fullmatch('[0-9a-f]{64}', value) is not None
+
+
+def _absolute(value):
+    return (type(value) is str and value.startswith('/') and not value.startswith('//') and
+            PurePosixPath(value).is_absolute() and
+            '..' not in PurePosixPath(value).parts)
+
+
+def validate_requests(requests, steps):
+    _positive_int(steps, 'steps')
+    require(type(requests) is dict and set(requests) == {'tick', 'neuron_idx'}, 'Exact sparse request schema required')
+    for key, value in requests.items():
+        require(isinstance(value, np.ndarray) and value.dtype == np.int32 and value.ndim == 1,
+                'Request requires int32 vector: ' + key)
+    tick, neuron = requests['tick'], requests['neuron_idx']
+    require(tick.shape == neuron.shape, 'Request shape mismatch')
+    require(np.all((tick >= 0) & (tick < steps)) and np.all((neuron >= 0) & (neuron < N)), 'Request outside fixed trial/canonical set')
+    key = tick.astype(np.int64) * N + neuron
+    require(len(key) < 2 or np.all(key[1:] > key[:-1]), 'Requests must be sorted and unique; no implicit deduplication')
+    return requests
+
+
+def slice_requests(requests, steps, start, stop):
+    """Half-open exact slice; translate ticks only, never redraw or reorder."""
+    validate_requests(requests, steps)
+    require(type(start) is int and type(stop) is int and 0 <= start < stop <= steps, 'Invalid half-open input interval')
+    lo, hi = np.searchsorted(requests['tick'], (start, stop))
+    result = {'tick': (requests['tick'][lo:hi] - np.int32(start)).copy(),
+              'neuron_idx': requests['neuron_idx'][lo:hi].copy()}
+    validate_requests(result, stop - start)
+    return result
+
+
+def verify_partition(original, steps, intervals, parts):
+    """Verify complete coverage plus exact request reconstruction, even blanks."""
+    validate_requests(original, steps)
+    require(type(intervals) in (list, tuple) and type(parts) in (list, tuple) and
+            len(intervals) == len(parts) > 0, 'Partition needs all intervals and parts')
+    end, reconstructed = 0, {'tick': [], 'neuron_idx': []}
+    for interval, part in zip(intervals, parts):
+        require(type(interval) in (list, tuple) and len(interval) == 2, 'Invalid interval schema')
+        start, stop = interval
+        require(type(start) is int and type(stop) is int and start == end and start < stop <= steps,
+                'Partition gap/overlap/nonpositive interval')
+        validate_requests(part, stop - start)
+        expected = slice_requests(original, steps, start, stop)
+        require(all(part[k].tobytes() == expected[k].tobytes() for k in part), 'Partition changes actual requests')
+        reconstructed['tick'].append(part['tick'].astype(np.int64) + start)
+        reconstructed['neuron_idx'].append(part['neuron_idx'])
+        end = stop
+    require(end == steps, 'Partition omits the terminal interval')
+    require(np.array_equal(np.concatenate(reconstructed['tick']), original['tick']) and
+            np.array_equal(np.concatenate(reconstructed['neuron_idx']), original['neuron_idx']), 'Reconstructed input mismatch')
+    return {'complete': True, 'intervals': [list(x) for x in intervals], 'steps': steps,
+            'requests': len(original['tick']), 'random_draws': 0, 'input_reselected': False}
+
+
+def derive_spec(original, *, start, stop, budget_root, output_budget_bytes, parent_sha=None):
+    """Explicit new case admission/budget labels; frozen model fields unchanged.
+
+    New budget_root must be outside the OLD budget tree. Full source/data/
+    ancestor containment checks remain the runtime/coordinator's responsibility.
+    A nonzero interval requires the actual parent manifest's external SHA;
+    future parent hashes must not be fabricated during preregistration.
+    """
+    require(type(original) is dict and original.get('kind') == 'fullgraph', 'Original fullgraph spec required')
+    steps = original.get('steps')
+    _positive_int(steps, 'original steps')
+    require(original.get('dt_ms') == .1 and original.get('duration_ms') == steps * .1 and
+            type(original.get('apl_delay_steps')) is int and original['apl_delay_steps'] == 18 and
+            original.get('record_history') is False and original.get('training') is False and
+            original.get('within_trial_weight_updates', False) is False, 'Original fixed D18 trial contract required')
+    require(not any('checkpoint' in k.lower() or k in ('global_tick_offset', 'resume', 'continuation', 'initial_state')
+                    for k in original), 'Original must be a fresh case')
+    require(type(start) is int and type(stop) is int and 0 <= start < stop <= steps, 'Invalid case interval')
+    require(_absolute(budget_root) and _absolute(original.get('budget_root')), 'Explicit absolute budget roots required')
+    new, old = PurePosixPath(budget_root), PurePosixPath(original['budget_root'])
+    require(not new.is_relative_to(old) and not old.is_relative_to(new), 'New output budget must not overlap old experiment tree')
+    require(type(output_budget_bytes) is int and output_budget_bytes > 0, 'Explicit positive byte budget required')
+    require((start == 0 and parent_sha is None) or (start > 0 and _sha(parent_sha)), 'Only a continued interval needs a real parent SHA')
+    result = copy.deepcopy(original)
+    result.update(steps=stop - start, duration_ms=(stop - start) * .1, max_steps=steps,
+                  budget_root=budget_root, output_budget_bytes=output_budget_bytes,
+                  within_trial_weight_updates=False,
+                  outer_protocol='phase4an-engineering-validation-no-training')
+    if start:
+        result.update(global_tick_offset=start, parent_checkpoint_manifest_sha256=parent_sha)
+    changes = {key: {'present_before': key in original, 'before': copy.deepcopy(original.get(key)),
+                     'after': copy.deepcopy(value)} for key, value in result.items()
+               if key not in original or value != original[key]}
+    allowed = {'steps', 'duration_ms', 'max_steps', 'budget_root', 'output_budget_bytes',
+               'within_trial_weight_updates', 'outer_protocol', 'global_tick_offset',
+               'parent_checkpoint_manifest_sha256'}
+    require(set(changes) <= allowed and all(result[k] == v for k, v in original.items() if k not in allowed),
+            'Unexpected scientific spec edit')
+    return result, {'input_interval': [start, stop], 'explicit_field_changes': changes,
+                    'all_other_fields_unchanged': True, 'random_draws': 0, 'training': False}
+
+
+def adapt_overlay_manifest(original, am_helper_path):
+    """Translate observed AM manifest fields; preserve original overlay bytes.
+
+    This function validates declarations only. Callers independently rehash
+    every referenced file against external AM/source authority before use.
+    """
+    require(type(original) is dict and original.get('schema') == 'phase4am-overlay-v1' and
+            original.get('overlay_name') in ('zero', 'static25') and
+            original.get('training') is False and original.get('fixed_for_whole_trial') is True,
+            'Only the fixed AM zero/static25 overlays are in this engineering gate')
+    require(original.get('mask_sha256') == MASK_SHA and _absolute(am_helper_path), 'Original mask/helper identity required')
+    names = ('overlay_name', 'overlay_sha256', 'mask_path', 'mask_sha256',
+             'base_candidate_path', 'base_candidate_sha256', 'aj_model_dir')
+    require(all(k in original for k in names), 'Missing observed AM manifest field')
+    require(all(_sha(original[k]) for k in ('overlay_sha256', 'mask_sha256', 'base_candidate_sha256')),
+            'Invalid external overlay/base SHA')
+    require(all(_absolute(original[k]) for k in ('mask_path', 'base_candidate_path', 'aj_model_dir')),
+            'Invalid external overlay/base path')
+    return dict(schema='phase4an-overlay-v1', **{k: copy.deepcopy(original[k]) for k in names},
+                am_overlay_path=am_helper_path, am_overlay_sha256=AM_HELPER_SHA)

models/male-cns-lif/olfactory-conditioning-lab-v1/engineering_plan.py

@@ -0,0 +1,153 @@
+"""Pure fixed 32-call engineering inventory; no I/O, GPU or input preparation.
+
+Rows describe required executions and comparisons, not evidence they occurred.
+The external AM reference is a symbolic role: a coordinator must bind its actual
+case, overlay, sealed outputs and hashes before execution. A validated plan does
+not prove input authority, comparison success, conditioning or learning.
+All public results are independently constructed mutable copies.
+"""
+from __future__ import annotations
+
+
+SCHEMA = 'phase4an-engineering-plan-draft-v1'
+OVERLAYS = ('zero', 'static25')
+MODES = ('reference', 'light')
+CHAIN_LENGTHS = (5, 13, 1, 481, 500)
+PREFIX_ENDS = (18, 19, 500)
+
+
+def _fresh_id(overlay, mode, repeat=0):
+    return f'{overlay}--fresh--{mode}-r{repeat}'
+
+
+def _prefix_id(overlay, end):
+    return f'{overlay}--prefix--reference-t{end:04d}'
+
+
+def _chain_id(overlay, mode, index):
+    return f'{overlay}--chain--{mode}-s{index:02d}'
+
+
+def _comparison(check, row, *, reference=None, external=None, scope, candidates=None):
+    """Exact descriptors; start/stop are always absolute, half-open ticks."""
+    return dict(check=check, reference_row_id=reference, external_reference=external,
+                candidate_row_ids=[row['row_id']] if candidates is None else list(candidates),
+                start=row['start'], stop=row['stop'], scope=scope)
+
+
+def _row(identity, overlay, mode, kind, start, stop, parent=None):
+    return dict(row_id=identity, overlay=overlay, mode=mode, kind=kind,
+                start=start, stop=stop, steps=stop - start, parent_row_id=parent,
+                expected_comparisons=[])
+
+
+def _terminal_reference(overlay, stop):
+    if stop == 5:
+        return _chain_id(overlay, 'reference', 0)
+    if stop == 1000:
+        return _fresh_id(overlay, 'reference')
+    return _prefix_id(overlay, stop)
+
+
+def build_plan():
+    """Return the sole current proposal: 32 calls / 11,074 full-graph ticks.
+
+    kind='chain' with parent_row_id=None is its fresh first segment, NOT a
+    continuation from an assumed zero checkpoint. Later segments explicitly
+    reference their predecessor. A chain's local request/event coordinates
+    are translated using start; terminal.next_tick remains its local phase.
+
+    All fresh/prefix rows globally precede chains. Reference chains precede
+    light chains, allowing the reference first segment to supply prefix 5.
+    No extra prefix-5 execution, synthetic 52-call matrix, long idle run,
+    input selection, training, parameter update or executor is implemented.
+
+    Comparison scopes:
+      reference_full/reference_prefix/reference_slice: include reference
+        tick-state hashes, APL traces, queues, requests, events and states;
+      light_recorded: requests.csv, events/counts, final state, APL state,
+        normalized pending queues and finite/weight/arrival accounting;
+      terminal_state_and_normalized_queues: no comparison of segment counts
+        against cumulative prefix counts; counts are handled by chain_exact;
+      parent_state_and_pending_queues: bound parent restoration/carry checks.
+    A comparator must implement these scopes from artifacts, not this plan's
+    existence. Shift local queue headers before comparing absolute timelines.
+    """
+    rows = []
+    for overlay in OVERLAYS:
+        for mode, repeat in (('reference', 0), ('light', 0), ('light', 1)):
+            row = _row(_fresh_id(overlay, mode, repeat), overlay, mode, 'fresh', 0, 1000)
+            scope = 'reference_full' if mode == 'reference' else 'light_recorded'
+            row['expected_comparisons'].append(_comparison(
+                'am_exact', row, external='sealed_AM_selected_case_same_overlay_r0', scope=scope))
+            if mode == 'light':
+                reference = _fresh_id(overlay, 'reference' if repeat == 0 else 'light')
+                row['expected_comparisons'].append(_comparison(
+                    'fresh_exact', row, reference=reference, scope='light_recorded'))
+            rows.append(row)
+        for end in PREFIX_ENDS:
+            row = _row(_prefix_id(overlay, end), overlay, 'reference', 'prefix', 0, end)
+            row['expected_comparisons'].append(_comparison(
+                'prefix_of_reference', row, reference=_fresh_id(overlay, 'reference'), scope='reference_prefix'))
+            rows.append(row)
+
+    for overlay in OVERLAYS:
+        for mode in MODES:
+            start, parent, members = 0, None, []
+            for index, length in enumerate(CHAIN_LENGTHS):
+                row = _row(_chain_id(overlay, mode, index), overlay, mode, 'chain', start, start + length, parent)
+                members.append(row['row_id'])
+                if mode == 'reference':
+                    row['expected_comparisons'].append(_comparison(
+                        'segment_of_reference', row, reference=_fresh_id(overlay, 'reference'), scope='reference_slice'))
+                else:
+                    row['expected_comparisons'].append(_comparison(
+                        'segment_exact', row, reference=_chain_id(overlay, 'reference', index), scope='light_recorded'))
+                terminal = _terminal_reference(overlay, row['stop'])
+                if terminal != row['row_id']:
+                    row['expected_comparisons'].append(_comparison(
+                        'checkpoint_exact', row, reference=terminal, scope='terminal_state_and_normalized_queues'))
+                if parent is not None:
+                    row['expected_comparisons'].append(_comparison(
+                        'parent_carry', row, reference=parent, scope='parent_state_and_pending_queues'))
+                if index == len(CHAIN_LENGTHS) - 1:
+                    comparison = _comparison('chain_exact', row, reference=_fresh_id(overlay, mode),
+                        scope='reference_full' if mode == 'reference' else 'light_recorded', candidates=members)
+                    comparison['start'] = 0
+                    row['expected_comparisons'].append(comparison)
+                rows.append(row)
+                start, parent = row['stop'], row['row_id']
+
+    return dict(schema=SCHEMA, overlays=list(OVERLAYS), chain_lengths=list(CHAIN_LENGTHS),
+                rows=rows, total_calls=32, total_ticks=11074,
+                training=False, candidate_generated=False)
+
+
+def _exact(actual, expected, path):
+    """JSON-shaped values with exact Python types; True is not integer 1."""
+    if type(actual) is not type(expected):
+        raise ValueError(f'Plan type mismatch at {path}')
+    if type(expected) is dict:
+        if any(type(key) is not str for key in actual) or set(actual) != set(expected):
+            raise ValueError(f'Plan fields mismatch at {path}')
+        for key in expected:
+            _exact(actual[key], expected[key], path + '.' + key)
+    elif type(expected) is list:
+        if len(actual) != len(expected):
+            raise ValueError(f'Plan inventory length mismatch at {path}')
+        for index, (left, right) in enumerate(zip(actual, expected)):
+            _exact(left, right, f'{path}[{index}]')
+    elif actual != expected:
+        raise ValueError(f'Plan value mismatch at {path}')
+
+
+def validate_plan(plan):
+    """Reject any noncanonical plan; return a new copy, never a PASS receipt.
+
+    Exact canonical reconstruction rejects unknown fields, order changes,
+    omitted/extra overlays or calls, interval gaps, false parent links and
+    weakening/removal of required comparisons. No input files are read.
+    """
+    canonical = build_plan()
+    _exact(plan, canonical, 'plan')
+    return canonical

models/male-cns-lif/olfactory-conditioning-lab-v1/engineering_prepare.py

@@ -0,0 +1,532 @@
+"""Read-only AM authority verification and exclusive AN engineering preparation.
+
+Public prepare(model_manifest_sha, experiment_manifest_sha, final_sha) requires
+three externally recorded, actual AM evidence hashes. It verifies both complete
+AM seals once, checks their declared gates, then fixes the first planned r0 case.
+It creates only templates/requests/overlay descriptors and a preregistration;
+never a GPU trajectory or fictitious future checkpoint hash. The caller records
+the returned preregistration SHA outside this experiment before execution.
+
+read_registration(expected_sha) rehashes the exact used source/input inventory
+and control anchors without rerunning either scientific gate or full AM seal.
+Future spec.json/checkpoint receipts are runtime artifacts, not preregistered
+bytes. No frozen model module globals are modified; no Torch is imported.
+"""
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+from pathlib import Path, PurePosixPath
+import re
+import shutil
+import sys
+
+import numpy as np
+
+
+ROOT = Path('/data/digital-drosophila')
+MODEL = Path(__file__).resolve().parent
+EXP = ROOT / 'experiments/phase4an-engineering-validation'
+AM_MODEL_REL = Path('models/male-cns-lif/wholebrain-plastic-interface-v1')
+AM_EXP_REL = Path('experiments/phase4am-wholebrain-plastic-interface')
+AK_REL = Path('experiments/phase4ak-apl-timing-validation')
+AI_HELPER_REL = Path('models/male-cns-lif/pn-recruitment-audit-v1/publication.py')
+AI_HELPER_SHA = '7a79c499098b74163e7bb16adabcbc54e7069dafa204d0b99c7f4c03d79f8016'
+AM_PREREG_SHA = '465886b78ada08092c2c83de278844707499718977fb6dc6a7608391da0e5304'
+AM_OVERLAY_SHA = '7f891d0ba79b393c96e75fd2dee2eddc51e57d8213eaac2779703bc2c18712b4'
+FINAL_STATUS = 'PASS-EXACT-WHOLEBRAIN-PLASTIC-INTERFACE-NOT-LEARNING'
+REG_SCHEMA = 'phase4an-engineering-registration-v1'
+BUDGET = {'output_budget_bytes': 8 * 1024**3, 'minimum_free_reserve_bytes': 10 * 1024**3}
+MODULES = ('runtime_light', 'runtime_continuation', 'engineering_inputs', 'engineering_plan',
+           'engineering_compare', 'engineering_queue_audit', 'engineering_prepare', 'engineering_workflow',
+           'engineering_scopes', 'engineering_analysis')
+SOURCE_FILES = tuple(sorted([name + '.py' for name in MODULES] + ['test_' + name + '.py' for name in MODULES] + ['ENGINEERING_GATE_DRAFT.md']))
+REFERENCES = ('auditory-10hz', 'auditory-100hz', 'olfactory-50hz', 'mechanosensory-50hz', 'gustatory-50hz')
+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')
+_MODULE_CACHE = {}
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def digest(path):
+    value = hashlib.sha256()
+    with Path(path).open('rb') as stream:
+        for block in iter(lambda: stream.read(8 << 20), b''):
+            value.update(block)
+    return value.hexdigest()
+
+
+def sha(value):
+    return type(value) is str and re.fullmatch('[0-9a-f]{64}', value) is not None
+
+
+def read(path):
+    def unique(pairs):
+        result = {}
+        for key, value in pairs:
+            require(key not in result, 'Duplicate JSON key: ' + key)
+            result[key] = value
+        return result
+    return json.loads(Path(path).read_text(encoding='utf-8'), object_pairs_hook=unique,
+                      parse_constant=lambda value: (_ for _ in ()).throw(ValueError('Nonfinite JSON: ' + value)))
+
+
+def save(path, value):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open('x', encoding='utf-8') as stream:
+        json.dump(value, stream, sort_keys=True, indent=2, ensure_ascii=False, allow_nan=False)
+        stream.write('\n')
+
+
+def load_module(name, path, expected):
+    path = Path(path).resolve(strict=True)
+    raw = path.read_bytes()
+    require(hashlib.sha256(raw).hexdigest() == expected, 'Source pin mismatch: ' + str(path))
+    identity = str(path), expected
+    if name in sys.modules:
+        require(_MODULE_CACHE.get(name) == (identity, sys.modules[name]), 'Unverified module namespace collision')
+        return sys.modules[name]
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    try:
+        exec(compile(raw, str(path), 'exec'), module.__dict__)
+    except BaseException:
+        sys.modules.pop(name, None)
+        raise
+    _MODULE_CACHE[name] = identity, module
+    return module
+
+
+def source_inventory(model):
+    model = Path(model).resolve(strict=True)
+    result = {}
+    for name in SOURCE_FILES:
+        path = model / name
+        require(path.is_file() and not path.is_symlink() and path.resolve().parent == model, 'Required engineering source missing/linked: ' + name)
+        result[str(path)] = digest(path)
+    return result
+
+
+def _relative(value):
+    require(type(value) is str and value and '\\' not in value, 'Invalid relative inventory path')
+    path = PurePosixPath(value)
+    require(not path.is_absolute() and str(path) == value and all(part not in ('', '.', '..') and ':' not in part for part in path.parts),
+            'Noncanonical relative inventory path')
+    return path
+
+
+def _safe_file(root, relative):
+    relative = _relative(relative)
+    root = Path(root).resolve(strict=True)
+    path = root
+    for part in relative.parts:
+        path = path / part
+        require(not path.is_symlink(), 'Linked authority/input file')
+    require(path.is_file() and path.resolve().is_relative_to(root), 'Missing or escaping input file')
+    return path
+
+
+def _index(rows):
+    require(type(rows) is list and rows, 'Missing sealed inventory rows')
+    result = {}
+    for row in rows:
+        require(type(row) is dict and set(row) == {'path', 'bytes', 'sha256'} and
+                type(row['bytes']) is int and row['bytes'] >= 0 and sha(row['sha256']), 'Invalid sealed inventory row')
+        _relative(row['path'])
+        require(row['path'] not in result, 'Duplicate sealed inventory row')
+        result[row['path']] = row
+    return result
+
+
+def _bind(inputs, path, expected=None):
+    path = Path(path).resolve(strict=True)
+    actual = digest(path)
+    require(expected is None or actual == expected, 'Authority/input SHA mismatch: ' + str(path))
+    require(str(path) not in inputs or inputs[str(path)] == actual, 'Conflicting authority for input')
+    inputs[str(path)] = actual
+    return path
+
+
+def _sealed_json(experiment, index, relative):
+    require(relative in index, 'Required authority absent from AM seal: ' + relative)
+    path = _safe_file(experiment, relative)
+    require(digest(path) == index[relative]['sha256'], 'Sealed JSON changed: ' + relative)
+    return read(path)
+
+
+def validate_final_status(final, scientific, before, after, refs):
+    """Check actual AM final/summary/report schemas, never infer scientific PASS."""
+    require(final.get('status') == scientific.get('status') == FINAL_STATUS, 'AM final status is not the required completed interface gate')
+    for key in ('zero_overlay_exact', 'static25_repeat_exact', 'old_integrity_pass', 'frozen_five_reference_pass',
+                'frozen_eligibility_and_mask_unchanged', 'base_weights_unchanged'):
+        require(final.get(key) is True, 'AM final gate failed/missing: ' + key)
+    require(final.get('primary_trials_per_stage') == 120 and final.get('repeats_per_stage') == 24 and
+            scientific.get('primary_trials_per_stage') == 120 and scientific.get('technical_repeats_per_stage') == 24,
+            'AM complete coverage counts changed')
+    for value in (final, scientific):
+        require(value.get('training') is False and value.get('learned_candidate') is False, 'AM interface must not claim training/learning')
+    require(scientific.get('zero_overlay_exact') is True and scientific.get('static25_repeat_exact') is True, 'Scientific summary gate mismatch')
+    require(type(before) is dict and type(after) is dict and len(before) == len(after) == 28 and set(before) == set(after),
+            'AM must retain the same complete 28-root old-integrity inventory')
+    for name in before:
+        for report in (before[name], after[name]):
+            require(type(report) is dict and report.get('pass') is True, 'Old-integrity gate failed: ' + name)
+            if 'mismatches' in report:
+                require(report['mismatches'] == [], 'Old-integrity mismatch list is nonempty')
+        for key in ('manifest_sha256', 'checksums_sha256'):
+            if key in before[name] or key in after[name]:
+                require(sha(before[name].get(key)) and before[name][key] == after[name].get(key), 'Old-root control changed: ' + name)
+    require(refs.get('pass_all') is True and type(refs.get('trials')) is list and
+            [row.get('trial') for row in refs['trials']] == list(REFERENCES), 'Five old deterministic references are incomplete or reordered')
+    for row in refs['trials']:
+        require(type(row.get('exact')) is dict and set(row['exact']) == {'step', 'neuron_idx', 'counts', 'v', 'g'} and
+                all(value is True for value in row['exact'].values()), 'Old reference arrays are not exact')
+
+
+def validate_planned(planned):
+    require(type(planned) is list and len(planned) == 144, 'AM planned coverage must be 144')
+    keys = []
+    for row in planned:
+        require(type(row) is dict and type(row.get('name')) is str and re.fullmatch('[A-Za-z0-9_-]+', row['name']) and
+                row.get('cohort') in ('seed_validation', 'novel_to_aj') and type(row.get('repeat')) is int and row['repeat'] in (0, 1),
+                'Invalid AM planned row identity')
+        keys.append((row['name'], row['repeat']))
+    require(len(set(keys)) == 144 and sum(row['repeat'] == 0 for row in planned) == 120 and sum(row['repeat'] == 1 for row in planned) == 24,
+            'AM primary/repeat set incomplete')
+    require(all((name, 0) in set(keys) for name, repeat in keys if repeat == 1), 'AM repeat lacks primary')
+    return next(dict(row) for row in planned if row['repeat'] == 0)
+
+
+def validate_stage(experiment, index, stage, planned, root):
+    """Validate all 144 declared results against the already verified AM seal."""
+    receipt = _sealed_json(experiment, index, 'audit/' + stage + '-complete.json')
+    require(receipt.get('stage') == stage and receipt.get('pass_all') is True and receipt.get('trials') == 144 and
+            receipt.get('primary_trials') == 120 and receipt.get('technical_repeats') == 24 and receipt.get('training') is False,
+            'AM stage is incomplete: ' + stage)
+    completed = receipt.get('completed')
+    require(type(completed) is list and len(completed) == 144, 'AM stage completion inventory truncated')
+    for row, done in zip(planned, completed):
+        require(done.get('name') == row['name'] and done.get('repeat') == row['repeat'], 'AM stage completion order/identity mismatch')
+        prefix = 'gpu/' + stage + '/' + row['name'] + '-r' + str(row['repeat']) + '/'
+        expected = [dict(path=key[len(prefix):], bytes=value['bytes'], sha256=value['sha256']) for key, value in sorted(index.items())
+                    if key.startswith(prefix) and key != prefix + 'output-hashes.json']
+        inventory = _sealed_json(experiment, index, prefix + 'output-hashes.json')
+        require(inventory == expected and inventory, 'AM completed output inventory differs from sealed payload')
+        require(done.get('output_hashes_sha256') == index[prefix + 'output-hashes.json']['sha256'] and
+                done.get('comparison_sha256') == index[prefix + 'comparison.json']['sha256'], 'AM stage receipt SHA mismatch')
+        summary = _sealed_json(experiment, index, prefix + 'summary.json')
+        compare = _sealed_json(experiment, index, prefix + 'comparison.json')
+        folder, case = experiment / prefix.rstrip('/'), root / AK_REL / 'cases' / row['cohort'] / row['name']
+        require(summary.get('case') == row['name'] and summary.get('complete') is True and summary.get('pass_all') is True and
+                summary.get('all_finite') is True and summary.get('steps') == summary.get('completed_ticks') == 1000,
+                'AM selected stage contains a failed/truncated trial')
+        require(compare.get('pass_all') is True and compare.get('overlay_name') == stage and compare.get('case_dir') == str(case) and
+                compare.get('right') == str(folder), 'AM comparison identity/gate mismatch')
+        require(type(compare.get('checks')) is dict and compare['checks'] and all(value is True for value in compare['checks'].values()) and
+                compare.get('failed_checks') == [] and 'error' not in compare and 'read_manifest_error' not in compare and
+                compare.get('full_queue_reconstructed') is True, 'AM comparison has a hidden negative/missing numerical gate')
+        mode = 'zero' if stage == 'zero' else ('repeat' if row['repeat'] else 'self')
+        left = root / AK_REL / 'gpu' / row['cohort'] / (row['name'] + '-r' + str(row['repeat'])) if stage == 'zero' else (
+            experiment / 'gpu' / stage / (row['name'] + '-r0') if row['repeat'] else folder)
+        require(compare.get('mode') == mode and compare.get('left') == str(left), 'AM comparison reference/mode mismatch')
+    return receipt
+
+
+def _layout(root, model, experiment):
+    root, model = Path(root).resolve(strict=True), Path(model).resolve(strict=True)
+    experiment = Path(experiment).resolve(strict=False)
+    require(experiment == root / 'experiments/phase4an-engineering-validation' and model.is_relative_to(root / 'models/male-cns-lif'),
+            'Unexpected project/output layout')
+    require(not experiment.exists() or (experiment.is_dir() and not any(experiment.iterdir())), 'Refusing populated experiment; preserve all partials')
+    return root, model, experiment
+
+
+def _budget(experiment):
+    experiment = Path(experiment)
+    used = sum(path.stat().st_size for path in experiment.rglob('*') if path.is_file()) if experiment.exists() else 0
+    require(used < BUDGET['output_budget_bytes'], '8 GiB engineering budget exhausted; preserve partials')
+    free = shutil.disk_usage(experiment.parent).free
+    require(free >= BUDGET['minimum_free_reserve_bytes'] + BUDGET['output_budget_bytes'] - used,
+            'Insufficient capacity for remaining 8 GiB budget plus 10 GiB free reserve')
+    return dict(BUDGET, used_bytes=used, free_bytes=free)
+
+
+def budget():
+    return _budget(EXP)
+
+
+def verify_authority(anchors):
+    """Full read-only AM seal recheck for the finalizer; no gate rerun."""
+    require(sys.dont_write_bytecode, 'Use python -B for immutable authority verification')
+    root = ROOT.resolve(strict=True)
+    values = [(root / AM_MODEL_REL, 'am_model_manifest_sha256'), (root / AM_EXP_REL, 'am_experiment_manifest_sha256')]
+    for directory, key in values:
+        require(sha(anchors.get(key)) and digest(directory / 'manifest.json') == anchors[key], 'External AM manifest anchor mismatch')
+    require(sha(anchors.get('am_final_sha256')) and digest(root / AM_EXP_REL / 'audit/final-status.json') == anchors['am_final_sha256'],
+            'External AM final anchor mismatch')
+    require(anchors.get('am_preregistration_sha256') == AM_PREREG_SHA and
+            digest(root / AM_EXP_REL / 'protocol/preregistered.json') == AM_PREREG_SHA, 'AM preregistration anchor mismatch')
+    require(anchors.get('AI_publication_helper_sha256') == AI_HELPER_SHA, 'Publication helper authority changed')
+    publication = load_module('phase4an_pinned_AI_publication', root / AI_HELPER_REL, AI_HELPER_SHA)
+    result = {'model': publication.verify_seal(values[0][0]), 'experiment': publication.verify_seal(values[1][0])}
+    require(result['model']['manifest_sha256'] == anchors['am_model_manifest_sha256'] and
+            result['experiment']['manifest_sha256'] == anchors['am_experiment_manifest_sha256'], 'AM seal changed during verification')
+    return result
+
+
+def _old_integrity(root, context_sha, expected):
+    """Reuse the pinned AM read-only integrity chain, not a brain runtime."""
+    context_path = root / AM_MODEL_REL / 'context.py'
+    previous_path = list(sys.path)
+    torch_before = 'torch' in sys.modules
+    try:
+        context = load_module('phase4an_sealed_AM_integrity', context_path, context_sha)
+        require(context.ROOT.resolve() == root.resolve(), 'AM integrity helper belongs to another root')
+        result = context.integrity()
+    finally:
+        sys.path[:] = previous_path
+    require(torch_before or 'torch' not in sys.modules, 'Integrity unexpectedly imported Torch')
+    require(type(result) is dict and len(result) == 28 and set(result) == set(expected) and
+            all(type(row) is dict and row.get('pass') is True for row in result.values()), 'Current 28-root old-integrity gate failed')
+    for name, row in result.items():
+        if 'mismatches' in row:
+            require(row['mismatches'] == [], 'Current old-integrity mismatch list is nonempty')
+        for key in ('manifest_sha256', 'checksums_sha256', 'reference_sha256'):
+            if key in expected[name] or key in row:
+                require(sha(row.get(key)) and row[key] == expected[name].get(key), 'Old integrity authority changed: ' + name)
+    return result
+
+
+def verify_old_integrity(registration):
+    """Rehash the pinned 28 old roots/snapshot via original CPU-only code."""
+    require(sys.dont_write_bytecode, 'Use python -B for old-integrity verification')
+    path = ROOT / AM_MODEL_REL / 'context.py'
+    expected_sha = registration['input_sha256'].get(str(path.resolve(strict=True)))
+    require(sha(expected_sha) and digest(path) == expected_sha, 'AM integrity source is not a registered input')
+    before_path = EXP / 'regression/old-integrity-before.json'
+    require(digest(before_path) == registration['input_sha256'].get(str(before_path.resolve(strict=True))), 'Before-integrity evidence changed')
+    return _old_integrity(ROOT, expected_sha, read(before_path))
+
+
+def _prepare(root, model, experiment, am_model_manifest_sha, am_experiment_manifest_sha, am_final_sha):
+    require(sys.dont_write_bytecode, 'Preparation requires python -B; old sources must remain byte-for-byte read-only')
+    require(all(sha(value) for value in (am_model_manifest_sha, am_experiment_manifest_sha, am_final_sha)), 'Three actual external AM SHA-256 anchors are mandatory')
+    root, model, experiment = _layout(root, model, experiment)
+    _budget(experiment)
+    sources = source_inventory(model)
+    inputs_module = load_module('phase4an_prepare_inputs', model / 'engineering_inputs.py', sources[str(model / 'engineering_inputs.py')])
+    plan_module = load_module('phase4an_prepare_plan', model / 'engineering_plan.py', sources[str(model / 'engineering_plan.py')])
+    runtime = load_module('phase4an_prepare_light', model / 'runtime_light.py', sources[str(model / 'runtime_light.py')])
+    publication = load_module('phase4an_pinned_AI_publication', root / AI_HELPER_REL, AI_HELPER_SHA)
+    am_model, am = root / AM_MODEL_REL, root / AM_EXP_REL
+    require(digest(am_model / 'manifest.json') == am_model_manifest_sha and digest(am / 'manifest.json') == am_experiment_manifest_sha and
+            digest(am / 'audit/final-status.json') == am_final_sha, 'External AM authority mismatch')
+    verified = {'model': publication.verify_seal(am_model), 'experiment': publication.verify_seal(am)}
+    require(verified['model']['manifest_sha256'] == am_model_manifest_sha and verified['experiment']['manifest_sha256'] == am_experiment_manifest_sha,
+            'AM controls changed during full seal verification')
+    idx = _index(verified['experiment']['files']); midx = _index(verified['model']['files'])
+    reg = _sealed_json(am, idx, 'protocol/preregistered.json')
+    require(idx['protocol/preregistered.json']['sha256'] == AM_PREREG_SHA, 'AM preregistration authority differs from the fixed anchor')
+    planned = reg.get('planned'); selected = validate_planned(planned)
+    final = _sealed_json(am, idx, 'audit/final-status.json')
+    scientific = _sealed_json(am, idx, 'audit/scientific-summary.json')
+    require(final.get('scientific_summary_sha256') == idx['audit/scientific-summary.json']['sha256'], 'AM final does not bind scientific summary')
+    before = _sealed_json(am, idx, 'regression/old-integrity-before.json')
+    after = _sealed_json(am, idx, 'regression/old-integrity-after.json')
+    refs = _sealed_json(am, idx, 'regression/frozen-five.json')
+    validate_final_status(final, scientific, before, after, refs)
+    for stage in ('zero', 'static25'):
+        validate_stage(am, idx, stage, planned, root)
+    current_old = _old_integrity(root, midx['context.py']['sha256'], after)
+    inputs = {}
+    anchors = {'am_model_manifest_sha256': am_model_manifest_sha, 'am_experiment_manifest_sha256': am_experiment_manifest_sha,
+               'am_final_sha256': am_final_sha, 'am_preregistration_sha256': AM_PREREG_SHA, 'AI_publication_helper_sha256': AI_HELPER_SHA}
+    for path, expected in ((am_model / 'manifest.json', am_model_manifest_sha), (am / 'manifest.json', am_experiment_manifest_sha),
+                           (am / 'audit/final-status.json', am_final_sha), (root / AI_HELPER_REL, AI_HELPER_SHA),
+                           (am_model / 'overlay.py', AM_OVERLAY_SHA)):
+        _bind(inputs, path, expected)
+    require(midx.get('overlay.py', {}).get('sha256') == AM_OVERLAY_SHA, 'AM model seal does not contain the pinned overlay helper')
+    for name in ('context.py', 'config.json'):
+        _bind(inputs, am_model / name, midx[name]['sha256'])
+    for path in (am_model / 'checksums.sha256', am / 'checksums.sha256'):
+        _bind(inputs, path)
+    for relative in ('protocol/preregistered.json', 'protocol/prepared-hashes.json', 'audit/scientific-summary.json', 'audit/zero-complete.json', 'audit/static25-complete.json',
+                     'regression/old-integrity-before.json', 'regression/old-integrity-after.json', 'regression/frozen-five.json'):
+        _bind(inputs, am / relative, idx[relative]['sha256'])
+    am_inputs = {}
+    for row in reg['inputs']:
+        require(set(row) == {'path', 'sha256'} and sha(row['sha256']), 'Invalid AM registered input row')
+        _relative(row['path']); require(row['path'] not in am_inputs, 'Duplicate AM registered input')
+        am_inputs[row['path']] = row['sha256']
+    def authority(path):
+        path = Path(path).resolve(strict=True)
+        require(path.is_relative_to(root), 'AM input leaves project root')
+        relative = path.relative_to(root).as_posix()
+        if path.is_relative_to(am):
+            expected = idx[path.relative_to(am).as_posix()]['sha256']
+        else:
+            require(relative in am_inputs, 'Dependency absent from AM preregistration: ' + relative)
+            expected = am_inputs[relative]
+        return _bind(inputs, path, expected)
+    original_dir = root / AK_REL / 'cases' / selected['cohort'] / selected['name']
+    authority(original_dir / 'spec.json'); authority(original_dir / 'requests.npz')
+    original = read(original_dir / 'spec.json')
+    require(original['steps'] == 1000 and original['kind'] == 'fullgraph' and original['name'] == selected['name'], 'Fixed selected AM case changed')
+    with np.load(original_dir / 'requests.npz', allow_pickle=False) as archive:
+        require(set(archive.files) == {'tick', 'neuron_idx'} and len(archive.files) == 2, 'Unexpected original request arrays')
+        requests = {key: archive[key].copy() for key in archive.files}
+    inputs_module.validate_requests(requests, 1000)
+    for name in GRAPH_FILES:
+        authority(Path(original['graph_dir']) / name)
+    for name in APL_FILES:
+        authority(Path(original['apl_bundle_dir']) / name)
+    authority(original['coefficients_path'])
+    selected_outputs = {}
+    for stage in ('zero', 'static25'):
+        prefix = 'gpu/' + stage + '/' + selected['name'] + '-r0/'
+        selected_outputs[stage] = str(am / prefix.rstrip('/'))
+        for relative, row in idx.items():
+            if relative.startswith(prefix):
+                _bind(inputs, am / relative, row['sha256'])
+    adapted = {}
+    for stage in ('zero', 'static25'):
+        old_manifest = authority(am / 'overlays' / (stage + '.json'))
+        overlay_file = authority(am / 'overlays' / (stage + '.npz'))
+        declaration = read(old_manifest)
+        require(declaration['overlay_name'] == stage and declaration['overlay_sha256'] == digest(overlay_file), 'AM overlay declaration mismatch')
+        for label in ('mask', 'base_candidate'):
+            require(digest(authority(declaration[label + '_path'])) == declaration[label + '_sha256'], 'Overlay external array authority mismatch')
+        adapted[stage] = inputs_module.adapt_overlay_manifest(declaration, str(am_model / 'overlay.py'))
+        require(adapted[stage]['am_overlay_sha256'] == AM_OVERLAY_SHA, 'Adapted helper pin differs')
+    for relative, expected in runtime.PINS.items():
+        _bind(inputs, model.parent / relative, expected)
+    plan = plan_module.validate_plan(plan_module.build_plan())
+    require(plan['total_calls'] == 32 and plan['total_ticks'] == 11074, 'Engineering plan matrix changed')
+    # No writes have occurred before all authority/source/space checks above.
+    experiment.mkdir(parents=True, exist_ok=True)
+    try:
+        for folder in ('protocol', 'cases', 'overlays', 'audit', 'runs', 'receipts', 'logs', 'regression', 'extension-build'):
+            (experiment / folder).mkdir(exist_ok=False)
+        save(experiment / 'regression/old-integrity-before.json', current_old)
+        _bind(inputs, experiment / 'regression/old-integrity-before.json')
+        for source, expected in sources.items():
+            target = experiment / 'protocol/source-snapshot' / Path(source).name
+            publication._copy_verified(Path(source), target, Path(source).stat().st_size, expected)
+            _bind(inputs, target, expected)
+        save(experiment / 'protocol/AM-seal-verification.json', verified)
+        save(experiment / 'protocol/AM-gate-authority.json', dict(anchors=anchors, all_144_per_stage_declared_gates_pass=True,
+             old_roots=28, old_references=list(REFERENCES), verification_scope='Full AM seals and finalized declared gate evidence; no new scientific execution'))
+        for name in ('AM-seal-verification.json', 'AM-gate-authority.json'):
+            _bind(inputs, experiment / 'protocol' / name)
+        overlays, cases = {}, {}
+        for stage, value in adapted.items():
+            manifest_path = experiment / 'overlays' / (stage + '.json')
+            save(manifest_path, value)
+            _bind(inputs, manifest_path)
+            overlays[stage] = {'overlay_file': str(am / 'overlays' / (stage + '.npz')), 'overlay_manifest': str(manifest_path)}
+        for row in plan['rows']:
+            case = experiment / 'cases' / row['row_id']; case.mkdir(exist_ok=False)
+            template = {'schema': 'phase4an-engineering-case-template-v1', 'row_id': row['row_id'], 'original_spec': original,
+                        'start': row['start'], 'stop': row['stop'], 'budget_root': str(experiment), 'output_budget_bytes': BUDGET['output_budget_bytes']}
+            save(case / 'template-spec.json', template)
+            part = inputs_module.slice_requests(requests, 1000, row['start'], row['stop'])
+            with (case / 'requests.npz').open('xb') as stream:
+                np.savez_compressed(stream, **part)
+            _bind(inputs, case / 'template-spec.json'); _bind(inputs, case / 'requests.npz')
+            cases[row['row_id']] = {'case_dir': str(case), 'template_spec_sha256': digest(case / 'template-spec.json'),
+                                    'requests_sha256': digest(case / 'requests.npz')}
+        require(source_inventory(model) == sources and all(digest(path) == expected for path, expected in inputs.items()), 'Source/input changed during preparation')
+        # Repeat the full AM verification after producing only small new inputs.
+        after_verified = {'model': publication.verify_seal(am_model), 'experiment': publication.verify_seal(am)}
+        require(after_verified == verified, 'AM sealed payload changed during preparation')
+        _budget(experiment)
+        registration = {'schema': REG_SCHEMA, 'plan': plan, 'selected_case': {'row': selected, 'original_dir': str(original_dir), 'AM_outputs': selected_outputs},
+            'source_sha256': sources, 'input_sha256': inputs, 'cases': cases, 'overlays': overlays, 'budget': dict(BUDGET), 'anchors': anchors,
+            'training': False, 'new_brain_runs_during_preparation': 0, 'future_checkpoint_hashes_fabricated': False,
+            'runtime_spec_derivation': 'engineering_inputs.derive_spec(template.original_spec, interval, budget, actual verified parent SHA or None)',
+            'scope': 'Fixed 32-call engineering gate only; not conditioning or learning registration'}
+        save(experiment / 'protocol/preregistered.json', registration)
+        return {'prepared': True, 'registration_path': str(experiment / 'protocol/preregistered.json'),
+                'registration_sha256': digest(experiment / 'protocol/preregistered.json'), 'calls': 32, 'brain_runs': 0}
+    except Exception as error:
+        failure = experiment / 'audit/preparation-failure.json'
+        if not failure.exists():
+            save(failure, {'prepared': False, 'type': type(error).__name__, 'message': str(error), 'partial_outputs_preserved': True})
+        raise
+
+
+def prepare(am_model_manifest_sha, am_experiment_manifest_sha, am_final_sha):
+    return _prepare(ROOT, MODEL, EXP, am_model_manifest_sha, am_experiment_manifest_sha, am_final_sha)
+
+
+def row_path(registration, row_id):
+    require(type(row_id) is str and row_id in {row['row_id'] for row in registration['plan']['rows']}, 'Unknown engineering row ID')
+    expected = EXP.resolve(strict=True) / 'cases' / row_id
+    actual = Path(registration['cases'][row_id]['case_dir'])
+    require(actual == expected and actual.resolve(strict=True) == expected and actual.is_dir(), 'Row case path is not its fixed safe mapping')
+    return actual
+
+
+def read_registration(expected_sha):
+    require(sys.dont_write_bytecode and sha(expected_sha), 'Require python -B and an external preregistration SHA')
+    path = EXP / 'protocol/preregistered.json'
+    require(digest(path) == expected_sha, 'Preregistration differs from external authority')
+    require(not (EXP / 'audit/preparation-failure.json').exists(), 'Preparation failed; preserve partials')
+    registration = read(path)
+    require(registration.get('schema') == REG_SCHEMA and registration.get('training') is False and registration.get('budget') == BUDGET,
+            'Unexpected registration schema/scope/budget')
+    require(registration['source_sha256'] == source_inventory(MODEL), 'Registered engineering sources changed or inventory incomplete')
+    for name, expected in registration['input_sha256'].items():
+        require(Path(name).is_absolute() and sha(expected) and digest(name) == expected, 'Registered input changed: ' + name)
+    plan_module = load_module('phase4an_read_plan', MODEL / 'engineering_plan.py', registration['source_sha256'][str(MODEL / 'engineering_plan.py')])
+    inputs_module = load_module('phase4an_read_inputs', MODEL / 'engineering_inputs.py', registration['source_sha256'][str(MODEL / 'engineering_inputs.py')])
+    plan_module.validate_plan(registration['plan'])
+    selected = validate_planned(read(ROOT / AM_EXP_REL / 'protocol/preregistered.json')['planned'])
+    original_dir = ROOT / AK_REL / 'cases' / selected['cohort'] / selected['name']
+    require(registration['selected_case']['row'] == selected and registration['selected_case']['original_dir'] == str(original_dir),
+            'Registered case is not the fixed first AM planned primary')
+    original = read(original_dir / 'spec.json')
+    with np.load(original_dir / 'requests.npz', allow_pickle=False) as archive:
+        require(set(archive.files) == {'tick', 'neuron_idx'} and len(archive.files) == 2, 'Unexpected original sparse request schema')
+        requests = {key: archive[key].copy() for key in archive.files}
+    inputs_module.validate_requests(requests, 1000)
+    require(set(registration['cases']) == {row['row_id'] for row in registration['plan']['rows']}, 'Registered case inventory differs from plan')
+    for row in registration['plan']['rows']:
+        case = row_path(registration, row['row_id']); entry = registration['cases'][row['row_id']]
+        require(entry['template_spec_sha256'] == digest(case / 'template-spec.json') and entry['requests_sha256'] == digest(case / 'requests.npz'),
+                'Template/request metadata does not bind registered bytes')
+        template = read(case / 'template-spec.json')
+        require(set(template) == {'schema', 'row_id', 'original_spec', 'start', 'stop', 'budget_root', 'output_budget_bytes'} and
+                template['schema'] == 'phase4an-engineering-case-template-v1' and template['original_spec'] == original and
+                template['row_id'] == row['row_id'] and template['start'] == row['start'] and template['stop'] == row['stop'] and
+                template['budget_root'] == str(EXP) and template['output_budget_bytes'] == BUDGET['output_budget_bytes'], 'Template rule differs from canonical row')
+        expected = inputs_module.slice_requests(requests, 1000, row['start'], row['stop'])
+        with np.load(case / 'requests.npz', allow_pickle=False) as archive:
+            require(len(archive.files) == 2 and set(archive.files) == set(expected) and
+                    all(archive[key].dtype == expected[key].dtype and archive[key].shape == expected[key].shape and
+                        archive[key].tobytes() == expected[key].tobytes() for key in expected), 'Registered request slice is not exact')
+    require(set(registration['overlays']) == {'zero', 'static25'}, 'Registered overlay inventory changed')
+    for stage in ('zero', 'static25'):
+        entry = registration['overlays'][stage]
+        expected_file = ROOT / AM_EXP_REL / 'overlays' / (stage + '.npz')
+        expected_manifest = EXP / 'overlays' / (stage + '.json')
+        require(entry == {'overlay_file': str(expected_file), 'overlay_manifest': str(expected_manifest)}, 'Overlay path mapping changed')
+        original_overlay = read(ROOT / AM_EXP_REL / 'overlays' / (stage + '.json'))
+        require(read(expected_manifest) == inputs_module.adapt_overlay_manifest(original_overlay, str(ROOT / AM_MODEL_REL / 'overlay.py')),
+                'Adapted overlay manifest is not the exact declared transformation')
+    anchors = registration['anchors']
+    for name, relative in (('am_model_manifest_sha256', AM_MODEL_REL / 'manifest.json'),
+                           ('am_experiment_manifest_sha256', AM_EXP_REL / 'manifest.json'),
+                           ('am_final_sha256', AM_EXP_REL / 'audit/final-status.json')):
+        require(sha(anchors[name]) and digest(ROOT / relative) == anchors[name], 'AM external anchor changed')
+    require(anchors['am_preregistration_sha256'] == AM_PREREG_SHA and digest(ROOT / AM_EXP_REL / 'protocol/preregistered.json') == AM_PREREG_SHA and
+            anchors['AI_publication_helper_sha256'] == AI_HELPER_SHA and digest(ROOT / AI_HELPER_REL) == AI_HELPER_SHA, 'Fixed AM/helper authority changed')
+    require(digest(path) == expected_sha, 'Registration changed during verification')
+    return registration

models/male-cns-lif/olfactory-conditioning-lab-v1/engineering_queue_audit.py

@@ -0,0 +1,243 @@
+"""Independent, read-only CPU queue/ref audit for the draft AN 32-call gate.
+
+The caller supplies externally authenticated records and CSR arrays.  No file
+I/O, runtime import, GPU, membrane integration, weight update or learning is
+performed.  Spikes are observed facts, not independently predicted here.
+
+queue digest bytes independently implement frozen AF oracle_full.queue_summary
+(source SHA below): header, little-endian signed int64 local tick/count, all
+global edge IDs in source/CSR order, then uint8 post-threshold acceptance bits.
+The function never target-sorts or drops zero-weight edges from the queue.
+"""
+from __future__ import annotations
+
+import hashlib
+import struct
+
+import numpy as np
+
+
+AF_QUEUE_SOURCE_SHA256 = 'd72003d98f0f1624b12126eff50bd361c43d888f4a64d90ba9247a58976f1961'
+QUEUE_HEADER = b'phase4af-queue-v1\0'
+DELAY, REFRACTORY = 18, 22
+CHUNK = 1 << 18
+QUEUE_KEYS = {'tick', 'count', 'accepted_count', 'ordered_edge_sha256', 'accepted_mask_sha256', 'joint_sha256'}
+
+
+def require(value, message):
+    if not value:
+        raise ValueError(message)
+
+
+def _array(value, dtype, shape, name):
+    require(isinstance(value, np.ndarray) and value.dtype == np.dtype(dtype) and value.shape == shape,
+            'Invalid dtype/shape: ' + name)
+
+
+def _raw_sha(value):
+    result = hashlib.sha256()
+    for start in range(0, len(value), CHUNK):
+        result.update(np.ascontiguousarray(value[start:start + CHUNK], dtype=value.dtype.newbyteorder('<')).tobytes())
+    return result.hexdigest()
+
+
+def _event_schema(tick, node, steps, n, label):
+    require(isinstance(tick, np.ndarray) and tick.ndim == 1, 'Invalid event vector: ' + label)
+    _array(tick, np.int32, tick.shape, label + '.tick')
+    _array(node, np.int32, tick.shape, label + '.neuron_idx')
+    require(np.all((tick >= 0) & (tick < steps)) and np.all((node >= 0) & (node < n)),
+            'Out-of-range event: ' + label)
+    key = tick.astype(np.int64) * n + node
+    require(len(key) < 2 or np.all(key[1:] > key[:-1]), 'Events must be sorted/unique: ' + label)
+
+
+def _record_schema(record, n, label):
+    require(isinstance(record, dict), 'Record must be a dictionary: ' + label)
+    steps, offset = record['steps'], record['global_tick_offset']
+    require(type(steps) is int and 0 < steps <= np.iinfo(np.int32).max and
+            type(offset) is int and offset >= 0, 'Invalid record clock: ' + label)
+    state = record['state']
+    require(set(state) == {'step', 'neuron_idx', 'counts', 'v', 'g', 'ref'}, 'Invalid state keys: ' + label)
+    _event_schema(state['step'], state['neuron_idx'], steps, n, label)
+    for name, dtype in [('counts', np.int32), ('ref', np.int32), ('v', np.float64), ('g', np.float64)]:
+        _array(state[name], dtype, (n,), label + '.' + name)
+        require(np.isfinite(state[name]).all(), 'Nonfinite state: ' + label + '.' + name)
+    require(np.all(state['counts'] >= 0) and np.all((state['ref'] >= 0) & (state['ref'] <= REFRACTORY)),
+            'Invalid state count/ref: ' + label)
+    rows = record['requests']
+    require(isinstance(rows, np.ndarray) and rows.ndim == 2 and rows.shape[1] == 5,
+            'Invalid request table: ' + label)
+    _array(rows, np.int64, rows.shape, label + '.requests')
+    queues, hashes = record.get('queues'), record.get('state_hashes')
+    require(isinstance(queues, list) and isinstance(hashes, list) and len(queues) == len(hashes) == steps,
+            'Complete reference queue and state hashes are required: ' + label)
+    for t, (queue, state_hash) in enumerate(zip(queues, hashes)):
+        require(isinstance(queue, dict) and set(queue) == QUEUE_KEYS and type(queue['tick']) is int and queue['tick'] == t,
+                'Invalid local queue row: ' + label)
+        require(isinstance(state_hash, dict) and set(state_hash) == {'tick', 'v_sha256', 'g_sha256', 'ref_sha256'} and
+                type(state_hash['tick']) is int and state_hash['tick'] == t,
+                'Invalid local state-hash row: ' + label)
+    return record
+
+
+def _graph(ptr, dst, edge_id, effective_weights):
+    require(isinstance(ptr, np.ndarray) and ptr.ndim == 1 and len(ptr) > 1, 'Invalid CSR ptr')
+    n, e = len(ptr) - 1, len(dst)
+    _array(ptr, np.int64, (n + 1,), 'ptr')
+    _array(dst, np.int32, (e,), 'dst')
+    _array(edge_id, np.int64, (e,), 'edge_id')
+    _array(effective_weights, np.float64, (e,), 'effective_weights_SI')
+    require(ptr[0] == 0 and ptr[-1] == e and np.all(ptr[1:] >= ptr[:-1]), 'Invalid CSR pointers')
+    for start in range(0, e, CHUNK):
+        stop = min(start + CHUNK, e)
+        require(np.all((dst[start:stop] >= 0) & (dst[start:stop] < n)), 'CSR destination out of range')
+        require(np.all(edge_id[start:stop] >= 0) and
+                np.all(np.diff(edge_id[max(0, start - 1):stop]) > 0), 'Global edge IDs must preserve canonical increasing CSR order')
+        require(np.isfinite(effective_weights[start:stop]).all(), 'Nonfinite effective SI weight')
+    return n, e
+
+
+def _queue(tick, local_tick, sources, ref, ptr, dst, edge_id, weights, boundaries):
+    """Two headers, shared source-ordered payload; memory bounded by one chunk."""
+    count = sum(int(ptr[int(s) + 1] - ptr[int(s)]) for s in sources)
+    joints = [hashlib.sha256(QUEUE_HEADER + struct.pack('<qq', t, count)) for t in (tick, local_tick)]
+    edges_hash, accepted_hash = hashlib.sha256(), hashlib.sha256()
+    for source in sources:
+        for start in range(int(ptr[source]), int(ptr[source + 1]), CHUNK):
+            stop = min(start + CHUNK, int(ptr[source + 1]))
+            data = np.ascontiguousarray(edge_id[start:stop], dtype='<i8').tobytes()
+            edges_hash.update(data)
+            for joint in joints:
+                joint.update(data)
+    accepted_count, nonzero_count, first = 0, 0, None
+    for source in sources:
+        for start in range(int(ptr[source]), int(ptr[source + 1]), CHUNK):
+            stop = min(start + CHUNK, int(ptr[source + 1]))
+            mask = np.ascontiguousarray(ref[dst[start:stop]] == 0, dtype=np.uint8)
+            accepted_count += int(mask.sum(dtype=np.int64))
+            data = mask.tobytes(); accepted_hash.update(data)
+            for joint in joints:
+                joint.update(data)
+            if boundaries:
+                live = np.flatnonzero((mask != 0) & (weights[start:stop] != 0))
+                nonzero_count += len(live)
+                if first is None and len(live):
+                    index = start + int(live[0])
+                    first = {'source_neuron_idx': int(source), 'target_neuron_idx': int(dst[index]),
+                             'global_edge_id': int(edge_id[index]), 'csr_edge_index': index,
+                             'source_spike_tick': tick - DELAY, 'arrival_tick': tick,
+                             'effective_weight_SI_volt': float(weights[index]),
+                             'effective_weight_float64_le_hex': np.asarray(weights[index], dtype='<f8').tobytes().hex(),
+                             'accepted': True, 'post_threshold_target_ref': 0,
+                             'weight_is_nonzero': True, 'evidence_is_unique_cause_or_necessity': False}
+    rows = [{'tick': t, 'count': count, 'accepted_count': accepted_count,
+             'ordered_edge_sha256': edges_hash.hexdigest(), 'accepted_mask_sha256': accepted_hash.hexdigest(),
+             'joint_sha256': joint.hexdigest()} for t, joint in zip((tick, local_tick), joints)]
+    return rows, first, nonzero_count
+
+
+def audit_queues(monolithic, segments, *, ptr, dst, edge_id, effective_weights, requests, cuts):
+    """Audit a fresh reference plus its complete reference segmentation.
+
+    All inputs are read-only. Return PASS/FAIL/INCOMPLETE JSON-safe evidence.
+    Structural input damage raises ValueError; valid but differing artifacts
+    return FAIL. ``cuts`` must be the exact internal segment boundaries.
+    No initial state is inferred for arbitrary nonzero-origin experiments.
+    """
+    n, e = _graph(ptr, dst, edge_id, effective_weights)
+    mono = _record_schema(monolithic, n, 'monolithic')
+    require(mono['global_tick_offset'] == 0, 'This audit requires the registered fresh monolithic origin')
+    require(isinstance(segments, (list, tuple)) and len(segments) >= 2, 'At least two reference segments required')
+    parts = [_record_schema(p, n, 'segment-' + str(i)) for i, p in enumerate(segments)]
+    cursor, actual_cuts = 0, []
+    for i, part in enumerate(parts):
+        require(part['global_tick_offset'] == cursor, 'Segment clock gap/overlap')
+        if i:
+            actual_cuts.append(cursor)
+        cursor += part['steps']
+    require(cursor == mono['steps'] and type(cuts) in (list, tuple) and all(type(t) is int for t in cuts) and
+            list(cuts) == actual_cuts, 'Cuts/segments must cover the exact complete monolithic interval')
+    require(isinstance(requests, dict) and set(requests) == {'tick', 'neuron_idx'}, 'Exact original request arrays required')
+    _event_schema(requests['tick'], requests['neuron_idx'], mono['steps'], n, 'original_requests')
+    records = [('monolithic', mono), *[('segment-' + str(i), p) for i, p in enumerate(parts)]]
+    differences, difference_count = [], 0
+
+    def check(value, field, **location):
+        nonlocal difference_count
+        if not value:
+            difference_count += 1
+            if len(differences) < 100:
+                differences.append({'field': field, **location})
+
+    tick, node = mono['state']['step'], mono['state']['neuron_idx']
+    for label, record in records:
+        start, stop = record['global_tick_offset'], record['global_tick_offset'] + record['steps']
+        lo, hi = np.searchsorted(tick, (start, stop))
+        check(np.array_equal(record['state']['step'].astype(np.int64) + start, tick[lo:hi]), 'events.tick', record=label)
+        check(np.array_equal(record['state']['neuron_idx'], node[lo:hi]), 'events.neuron_idx', record=label)
+        check(np.array_equal(record['state']['counts'], np.bincount(record['state']['neuron_idx'], minlength=n)), 'counts', record=label)
+    expected_requests = np.empty((len(requests['tick']), 5), np.int64)
+    if len(expected_requests):
+        expected_requests[:, 0] = requests['tick']; expected_requests[:, 1] = requests['neuron_idx']; expected_requests[:, 2] = 1
+    ref = np.zeros(n, np.int32)
+    boundary_report = {t: {'boundary_tick': t, 'accepted_nonzero_crossing_edge_events': 0, 'first_witness': None} for t in cuts}
+    due_total, accepted_total, segment_index = 0, 0, 0
+    for t in range(mono['steps']):
+        while t >= parts[segment_index]['global_tick_offset'] + parts[segment_index]['steps']:
+            segment_index += 1
+        part = parts[segment_index]; local = t - part['global_tick_offset']
+        rlo, rhi = np.searchsorted(requests['tick'], (t, t + 1))
+        requested = requests['neuron_idx'][rlo:rhi]
+        accepted_requests = ref[requested] <= 1
+        expected_requests[rlo:rhi, 3] = accepted_requests
+        expected_requests[rlo:rhi, 4] = ~accepted_requests
+        np.maximum(ref - np.int32(1), np.int32(0), out=ref)
+        slo, shi = np.searchsorted(tick, (t, t + 1)); fired = node[slo:shi]
+        check(np.all(ref[fired] == 0), 'spike_during_refractory', global_tick=t)
+        check(np.isin(requested[accepted_requests], fired, assume_unique=True).all(), 'accepted_request_without_spike', global_tick=t)
+        ref[fired] = REFRACTORY
+        sources = node[0:0]
+        if t >= DELAY:
+            dlo, dhi = np.searchsorted(tick, (t - DELAY, t - DELAY + 1)); sources = node[dlo:dhi]
+        crossing = [cut for cut in cuts if t - DELAY < cut <= t]
+        rows, witness, live_count = _queue(t, local, sources, ref, ptr, dst, edge_id, effective_weights, crossing)
+        due_total += rows[0]['count']; accepted_total += rows[0]['accepted_count']
+        ref_sha = _raw_sha(ref)
+        for label, record, at, expected in [('monolithic', mono, t, rows[0]), ('segment-' + str(segment_index), part, local, rows[1])]:
+            for key in sorted(QUEUE_KEYS):
+                check(type(record['queues'][at][key]) is type(expected[key]) and record['queues'][at][key] == expected[key],
+                      'queue.' + key, record=label, local_tick=at, global_tick=t)
+            check(record['state_hashes'][at]['ref_sha256'] == ref_sha, 'state_hash.ref_sha256', record=label, local_tick=at, global_tick=t)
+            if at == record['steps'] - 1:
+                check(np.array_equal(record['state']['ref'], ref), 'terminal.ref', record=label)
+        for cut in crossing:
+            boundary_report[cut]['accepted_nonzero_crossing_edge_events'] += live_count
+            if witness is not None and boundary_report[cut]['first_witness'] is None:
+                boundary_report[cut]['first_witness'] = {'boundary_tick': cut, **witness}
+    for label, record in records:
+        start, stop = record['global_tick_offset'], record['global_tick_offset'] + record['steps']
+        lo, hi = np.searchsorted(requests['tick'], (start, stop))
+        expected = expected_requests[lo:hi].copy(); expected[:, 0] -= start
+        check(np.array_equal(record['requests'], expected), 'requests.five_fields', record=label)
+    first_witness = min((row['first_witness'] for row in boundary_report.values() if row['first_witness'] is not None),
+                        key=lambda row: (row['arrival_tick'], row['source_neuron_idx'], row['csr_edge_index'], row['boundary_tick']), default=None)
+    exact, live = difference_count == 0, first_witness is not None
+    return {'schema': 'phase4an-independent-queue-audit-v1', 'pass_all': exact and live,
+            'status': 'FAIL-QUEUE-OR-REF' if not exact else ('PASS-QUEUE-WITNESS-SCOPE' if live else 'INCOMPLETE-NO-ACCEPTED-NONZERO-CROSSING'),
+            'queue_ref_request_exact': exact, 'accepted_nonzero_crossing_witness_verified': exact and live,
+            'difference_count': difference_count, 'differences': differences, 'differences_truncated': difference_count > len(differences),
+            'neurons': n, 'edges': e, 'steps': mono['steps'], 'segments': len(parts), 'cuts': list(cuts),
+            'arriving_edges': due_total, 'accepted_arriving_edges': accepted_total, 'rejected_arriving_edges': due_total - accepted_total,
+            'requests': len(expected_requests), 'accepted_requests': int(expected_requests[:, 3].sum(dtype=np.int64)),
+            'rejected_requests': int(expected_requests[:, 4].sum(dtype=np.int64)),
+            'first_witness': first_witness, 'boundaries': list(boundary_report.values()),
+            'same_edge_event_may_cross_multiple_boundaries': True,
+            'input_array_sha256': {name: _raw_sha(value) for name, value in [('ptr', ptr), ('dst', dst), ('edge_id', edge_id),
+                ('effective_weights_float64_SI', effective_weights), ('request_tick', requests['tick']), ('request_neuron_idx', requests['neuron_idx'])]},
+            'digest_definition': {'AF_source_sha256': AF_QUEUE_SOURCE_SHA256, 'header_hex': QUEUE_HEADER.hex(),
+                'payload_order': 'local tick/count <qq; all canonical source/CSR edge IDs <i8; all post-threshold accepted u1'},
+            'delay_steps': DELAY, 'refractory_steps': REFRACTORY,
+            'scope': 'Conditional on recorded spikes: exact ref, original requests, source-ordered real-edge arrival queues and finite-cut witness only',
+            'membrane_dynamics_independently_replayed': False, 'v_g_hashes_independently_verified': False,
+            'unique_causal_or_necessity_claim': False, 'external_seals_and_input_authority_verified_here': False,
+            'training': False, 'GPU_used': False}

models/male-cns-lif/olfactory-conditioning-lab-v1/engineering_scopes.py

@@ -0,0 +1,219 @@
+"""Pure CPU comparisons of already-loaded engineering_compare run records.
+
+No paths are accepted, no artifacts are opened, no GPU is imported. Structural
+or missing-required-observation errors raise ValueError. Valid but different
+records return numerical_exact=False. External seals, parent SHA authority and
+independent CSR/local-header queue reconstruction remain coordinator duties.
+"""
+from __future__ import annotations
+
+import hashlib
+
+import numpy as np
+
+import engineering_compare as ec
+
+
+SCHEMA = 'phase4an-engineering-scopes-v1'
+
+
+def _require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def _raw_sha(value):
+    return hashlib.sha256(np.ascontiguousarray(value, dtype=value.dtype.newbyteorder('<')).tobytes()).hexdigest()
+
+
+def _record(value, label):
+    _require(type(value) is dict, label + ' must be an already-loaded run dictionary, not a path')
+    try:
+        ec.validate_run(value)
+        summary = value['summary']
+        _require(type(summary) is dict, label + ' requires summary metadata')
+        steps, offset = value['steps'], value['global_tick_offset']
+        _require(steps <= np.iinfo(np.int32).max, label + ' steps exceed int32 event capacity')
+        for key in ('complete', 'pass_all', 'all_finite'):
+            _require(summary.get(key) is True, label + ' is incomplete or failed: ' + key)
+        for key in ('steps', 'completed_ticks'):
+            _require(type(summary.get(key)) is int and summary[key] == steps, label + ' summary clock mismatch')
+        _require(type(summary.get('nodes')) is int and summary['nodes'] == len(value['state']['v']),
+                 label + ' summary node count mismatch')
+        _require(summary.get('precision') == 'float64' and summary.get('apl_precision') == 'float32' and
+                 type(summary.get('apl_delay_steps')) is int and summary['apl_delay_steps'] == 18,
+                 label + ' numerical metadata mismatch')
+        continued = summary.get('checkpoint_continuation_used', False)
+        _require(type(continued) is bool and continued == (offset > 0), label + ' continuation scope mismatch')
+        declared_offset = summary.get('global_tick_offset', 0)
+        _require(type(declared_offset) is int and declared_offset == offset, label + ' summary offset mismatch')
+        if continued or 'global_next_tick' in summary:
+            _require(type(summary.get('global_next_tick')) is int and summary['global_next_tick'] == offset + steps,
+                     label + ' summary global end mismatch')
+        _require(ec._sha(summary.get('effective_weights_raw_sha256')), label + ' effective weight SHA is missing')
+        mode = summary.get('diagnostic_mode')
+        legacy = str(value.get('terminal_origin', '')).startswith('AM_')
+        _require(mode in ('light', 'reference') or (mode is None and legacy), label + ' recording mode is not declared')
+        observations = {'apl_traces': bool(value.get('traces')), 'state_hashes': value.get('state_hashes') is not None,
+                        'queues': value.get('queues') is not None}
+        for name, field in (('apl_traces', 'full_APL_history_recorded'),
+                            ('state_hashes', 'full_tick_state_hashes_recorded'), ('queues', 'full_queue_hashes_recorded')):
+            if field in summary:
+                _require(type(summary[field]) is bool, label + ' observation flag must be Boolean')
+            if mode == 'reference' or legacy or summary.get(field) is True:
+                _require(observations[name], label + ' declared reference observation missing: ' + name)
+        return value, observations
+    except (KeyError, TypeError, AttributeError, IndexError, OverflowError) as error:
+        raise ValueError(label + ' has an invalid run-record schema') from error
+
+
+def _common(left, right):
+    return {'same_neuron_count': len(left['state']['v']) == len(right['state']['v']),
+            'same_APL_width': left['terminal']['apl_pending'].shape[1] == right['terminal']['apl_pending'].shape[1],
+            'same_effective_weights': left['summary']['effective_weights_raw_sha256'] ==
+                                      right['summary']['effective_weights_raw_sha256']}
+
+
+def _report(comparison, checks, observed, limitations):
+    # All predicates are JSON booleans, not array scalars or success claims.
+    checks = {key: bool(value) for key, value in checks.items()}
+    return dict(schema=SCHEMA, comparison=comparison, numerical_exact=all(checks.values()),
+                checks=checks, failed_checks=[key for key, value in checks.items() if not value],
+                observed_scope=observed, limitations=list(limitations), learning_pass_claimed=False,
+                complete_dynamical_equivalence_proven=False, external_authority_verified_here=False,
+                independent_CSR_queue_reconstruction_performed=False)
+
+
+def compare_slice(candidate, monolithic):
+    """Compare candidate's absolute [start,stop) with an origin-zero full reference.
+
+    The final candidate V/g/ref bytes must match the reference's tick stop-1
+    hashes even for light candidates. Missing light intermediate observations
+    are disclosed, never replaced by fabricated zero arrays or inferred hashes.
+    """
+    candidate, observed = _record(candidate, 'candidate')
+    monolithic, full = _record(monolithic, 'monolithic')
+    _require(monolithic['global_tick_offset'] == 0, 'Monolithic slice reference must have origin zero')
+    _require(monolithic['summary'].get('diagnostic_mode') == 'reference' or
+             str(monolithic.get('terminal_origin', '')).startswith('AM_'),
+             'Monolithic slice source must be declared reference or loaded legacy AM')
+    _require(all(full.values()), 'Monolithic slice reference needs all four APL traces, state hashes and queues')
+    start, steps = candidate['global_tick_offset'], candidate['steps']
+    stop = start + steps
+    _require(stop <= monolithic['steps'], 'Candidate slice extends beyond monolithic reference')
+    checks = _common(candidate, monolithic)
+    state, whole = candidate['state'], monolithic['state']
+    lo, hi = np.searchsorted(whole['step'], (start, stop))
+    expected_ticks = (whole['step'][lo:hi].astype(np.int64) - start).astype(np.int32)
+    expected_nodes = whole['neuron_idx'][lo:hi]
+    checks['slice.event_steps'] = ec.bit_equal(state['step'], expected_ticks)
+    checks['slice.event_neurons'] = ec.bit_equal(state['neuron_idx'], expected_nodes)
+    counts = np.bincount(expected_nodes, minlength=len(whole['v'])).astype(np.int32)
+    checks['slice.segment_counts'] = ec.bit_equal(state['counts'], counts)
+    requests = monolithic['requests']
+    lo, hi = np.searchsorted(requests[:, 0], (start, stop))
+    expected_requests = requests[lo:hi].copy()
+    expected_requests[:, 0] -= start
+    checks['slice.requests_five_fields'] = ec.bit_equal(candidate['requests'], expected_requests)
+    for name in ('v', 'g', 'ref'):
+        checks['slice.final_' + name + '_raw_hash'] = _raw_sha(state[name]) == monolithic['state_hashes'][stop - 1][name + '_sha256']
+    raw_ring = ec.reconstructed_fresh_ring(whole, stop, len(whole['v']))
+    expected_ring = raw_ring[(np.arange(19) + stop % 19) % 19]
+    checks['slice.normalized_spike_ring'] = ec.bit_equal(ec.normalized_ring(candidate['terminal']), expected_ring)
+    traces = monolithic['traces']
+    checks['slice.APL_state'] = ec.bit_equal(candidate['terminal']['apl_state'], traces['state'][stop - 1])
+    pending = np.zeros((18, traces['generated'].shape[1]), dtype=np.float32)
+    kept = min(stop, 18)
+    pending[-kept:] = traces['generated'][stop - kept:stop]
+    checks['slice.APL_pending'] = ec.bit_equal(candidate['terminal']['apl_pending'], pending)
+    if observed['apl_traces']:
+        for name in ec.TRACE_FILES:
+            checks['slice.APL_trace.' + name] = ec.bit_equal(candidate['traces'][name], traces[name][start:stop])
+    if observed['state_hashes']:
+        checks['slice.per_tick_state_hashes'] = all(
+            all(left[key] == right[key] for key in ec.HASH_FIELDS)
+            for left, right in zip(candidate['state_hashes'], monolithic['state_hashes'][start:stop]))
+    if observed['queues']:
+        checks['slice.queue_order_and_acceptance'] = all(
+            all(left[key] == right[key] for key in ec.QUEUE_FIELDS)
+            for left, right in zip(candidate['queues'], monolithic['queues'][start:stop]))
+    limitations = ['External input/seal/case/parent authority is not established by these records.',
+                   'Queue joint hashes contain local tick headers; their independent CSR reconstruction is not performed here.',
+                   'Numerical equality of this observed slice is not a learning, live-coverage or complete dynamics proof.']
+    for key, label in (('apl_traces', 'APL histories'), ('state_hashes', 'intermediate V/g/ref state hashes'),
+                       ('queues', 'per-tick queue order/acceptance')):
+        if not observed[key]:
+            limitations.append('Candidate ' + label + ' are unobserved; no direct comparison is claimed.')
+    return _report('slice', checks, dict(start=start, stop=stop, segment_steps=steps,
+        events=True, segment_counts=True, requests_five_fields=True, final_state_against_reference_tick_hash=True,
+        normalized_spike_ring_from_reference_prefix_events=True, terminal_APL_state_and_pending=True,
+        candidate_APL_histories=observed['apl_traces'], candidate_per_tick_state_hashes=observed['state_hashes'],
+        candidate_per_tick_queue_fields=observed['queues'], queue_joint_hashes_compared=False), limitations)
+
+
+def compare_checkpoint(candidate, prefix):
+    """Compare equal absolute endpoints, not local phases or segment counts."""
+    candidate, _ = _record(candidate, 'candidate')
+    prefix, _ = _record(prefix, 'prefix')
+    checks = _common(candidate, prefix)
+    end = candidate['global_tick_offset'] + candidate['steps']
+    reference_end = prefix['global_tick_offset'] + prefix['steps']
+    checks['checkpoint.same_absolute_end'] = end == reference_end
+    for name in ('v', 'g', 'ref'):
+        checks['checkpoint.state.' + name] = ec.bit_equal(candidate['state'][name], prefix['state'][name])
+    checks['checkpoint.normalized_spike_ring'] = ec.bit_equal(
+        ec.normalized_ring(candidate['terminal']), ec.normalized_ring(prefix['terminal']))
+    for name in ('apl_state', 'apl_pending'):
+        checks['checkpoint.' + name] = ec.bit_equal(candidate['terminal'][name], prefix['terminal'][name])
+    return _report('checkpoint', checks, dict(candidate_absolute_end=end, reference_absolute_end=reference_end,
+        candidate_local_steps=candidate['steps'], reference_local_steps=prefix['steps'], terminal_v_g_ref=True,
+        normalized_spike_ring=True, terminal_APL_state_and_pending=True, counts_compared=False,
+        event_histories_compared=False, per_tick_state_histories_compared=False), [
+            'Segment counts and cumulative prefix counts are deliberately not compared in this endpoint scope.',
+            'Matching terminal records do not prove matching intermediate states or complete event histories.',
+            'External input/seal/parent authority and live-carry coverage remain separate gates.'])
+
+
+def compare_parent_carry(candidate, parent):
+    """Check recorded short-segment carry invariants, not unobserved restoration.
+
+    The parent ends where the candidate starts. Slots already overwritten by
+    this segment cannot be checked as initial carry from terminal data alone.
+    When present, the child's applied trace directly tests consumed APL rows.
+    """
+    candidate, observed = _record(candidate, 'candidate')
+    parent, _ = _record(parent, 'parent')
+    _require(candidate['global_tick_offset'] > 0, 'Parent-carry candidate must be a continued segment')
+    checks = _common(candidate, parent)
+    start, steps = candidate['global_tick_offset'], candidate['steps']
+    parent_end = parent['global_tick_offset'] + parent['steps']
+    checks['parent.contiguous_absolute_clock'] = parent_end == start
+    restored_ring = ec.normalized_ring(parent['terminal'])
+    unconsumed_spikes, unconsumed_apl = steps < 19, steps < 18
+    if unconsumed_spikes:
+        checks['parent.unwritten_spike_slots'] = ec.bit_equal(
+            candidate['terminal']['spike_ring'][steps:], restored_ring[steps:])
+    pending = parent['terminal']['apl_pending']
+    if unconsumed_apl:
+        checks['parent.unconsumed_APL_prefix'] = ec.bit_equal(
+            candidate['terminal']['apl_pending'][:18 - steps], pending[steps:])
+    consume = min(18, steps)
+    if observed['apl_traces']:
+        checks['parent.applied_APL_prefix'] = ec.bit_equal(candidate['traces']['applied'][:consume], pending[:consume])
+    limitations = ['Initial V/g/ref/APL-state restoration is not directly observed by this terminal-only carry scope.',
+                   'Overwritten spike slots and consumed pending slots require the separate full-reference slice/endpoint gates.',
+                   'Parent manifest hashes and ancestor provenance must be independently bound by the coordinator.',
+                   'No queue arrival/acceptance reconstruction, live-carry or learning success is claimed here.']
+    if not observed['apl_traces']:
+        limitations.append('Candidate applied APL history is unobserved; consumed parent APL values are not directly compared.')
+    carry_observed = unconsumed_spikes or unconsumed_apl or observed['apl_traces']
+    if not carry_observed:
+        limitations.append('No carry array remains directly observable in this long light segment; this scope checks clock/shape/weight identity only.')
+    return _report('parent_carry', checks, dict(parent_absolute_start=parent['global_tick_offset'],
+        parent_absolute_end=parent_end, candidate_absolute_start=start, candidate_absolute_end=start + steps,
+        candidate_local_steps=steps, unwritten_spike_slots_checked=unconsumed_spikes,
+        unwritten_spike_slot_count=max(19 - steps, 0), unconsumed_APL_prefix_checked=unconsumed_apl,
+        unconsumed_APL_row_count=max(18 - steps, 0), applied_parent_APL_prefix_checked=observed['apl_traces'],
+        applied_parent_APL_rows_compared=consume if observed['apl_traces'] else None,
+        any_carry_values_directly_compared=carry_observed,
+        initial_neural_state_restoration_directly_observed=False), limitations)

models/male-cns-lif/olfactory-conditioning-lab-v1/engineering_workflow.py

@@ -0,0 +1,421 @@
+"""Finite, no-training execution of the separately registered 32-call gate.
+
+All files are exclusive creations. A partial/failed row is preserved and is
+not retried. Runtime outputs are sealed before external reports are written.
+The preparation module owns source/input authority; no summary Boolean alone
+is accepted as proof that a subprocess or a complete engineering gate passed.
+"""
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import importlib
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import time
+import traceback
+import urllib.request
+import zipfile
+
+import numpy as np
+
+import engineering_inputs as I
+import engineering_plan as PLAN
+import runtime_light as R
+import runtime_continuation as C
+
+
+GPU = 'GPU-79f3a85d-adce-7833-7003-6488140ca596'
+ROOT = Path('/data/digital-drosophila')
+MODEL = Path(__file__).resolve().parent
+EXP = ROOT / 'experiments/phase4an-engineering-validation'
+require = R.require
+
+
+def canonical(value):
+    return json.dumps(value, sort_keys=True, separators=(',', ':'), allow_nan=False)
+
+
+def same_json(left, right):
+    return canonical(left) == canonical(right)
+
+
+def preparation():
+    return importlib.import_module('engineering_prepare')
+
+
+def row_from(registration, row_id):
+    plan = PLAN.validate_plan(registration['plan'])
+    rows = [row for row in plan['rows'] if row['row_id'] == row_id]
+    require(len(rows) == 1, 'Only an exact registered row may execute')
+    return rows[0]
+
+
+def locations(row_id):
+    require(type(row_id) is str and row_id and all(ch.isalnum() or ch in '-_' for ch in row_id),
+            'Unsafe row identity')
+    return dict(output=EXP / 'runs' / row_id,
+                runtime=EXP / 'receipts' / (row_id + '.runtime.json'),
+                execution=EXP / 'receipts' / (row_id + '.json'),
+                derivation=EXP / 'receipts' / (row_id + '.derivation.json'),
+                stdout=EXP / 'logs' / (row_id + '.stdout.log'),
+                stderr=EXP / 'logs' / (row_id + '.stderr.log'))
+
+
+def disk_budget(registration):
+    limit = registration['budget']['output_budget_bytes']
+    reserve = registration['budget']['minimum_free_reserve_bytes']
+    require(type(limit) is type(reserve) is int and limit > 0 and reserve > 0, 'Invalid registered budget')
+    files = [p for p in EXP.rglob('*') if p.is_file()]
+    require(not any(p.is_symlink() for p in EXP.rglob('*')), 'Experiment contains a linked output')
+    used = sum(p.stat().st_size for p in files)
+    free = shutil.disk_usage(EXP).free
+    require(used <= limit and free >= reserve + max(0, limit - used), 'Engineering budget/reserve exceeded; preserve partials')
+    return dict(used_bytes=used, free_bytes=free, hard_cap_bytes=limit, reserve_bytes=reserve)
+
+
+def preflight():
+    """Never evict an existing service; configure only this child process."""
+    os.environ['CUDA_VISIBLE_DEVICES'] = GPU
+    os.environ['CUDA_HOME'] = '/usr/local/cuda'
+    os.environ['PATH'] = str(ROOT / 'models/male-cns-lif/.venv/bin') + ':/usr/local/cuda/bin:' + os.environ['PATH']
+    os.environ['MAX_JOBS'] = '2'
+    os.environ['TORCH_CUDA_ARCH_LIST'] = '8.9'
+    for port in (8188, 8189, 8190):
+        with urllib.request.urlopen(f'http://192.168.10.51:{port}/queue', timeout=5) as response:
+            queue = json.load(response)
+        require(queue['queue_running'] == [] and queue['queue_pending'] == [],
+                'ComfyUI busy: defer rather than evict')
+
+
+def derive_case(template, row, parent_sha):
+    require(type(template) is dict and set(template) == {'schema', 'row_id', 'original_spec', 'start', 'stop',
+            'budget_root', 'output_budget_bytes'}, 'Unexpected registered case template fields')
+    require(template['schema'] == 'phase4an-engineering-case-template-v1' and template['row_id'] == row['row_id'] and
+            type(template['start']) is int and type(template['stop']) is int and
+            (template['start'], template['stop']) == (row['start'], row['stop']), 'Template differs from exact plan')
+    require((row['parent_row_id'] is None) == (parent_sha is None), 'Parent linkage differs from registered plan')
+    return I.derive_spec(template['original_spec'], start=row['start'], stop=row['stop'],
+        budget_root=template['budget_root'], output_budget_bytes=template['output_budget_bytes'], parent_sha=parent_sha)
+
+
+def npz_storage(path):
+    with zipfile.ZipFile(path) as archive:
+        rows = archive.infolist()
+        require(rows and all(r.compress_type == zipfile.ZIP_DEFLATED and r.filename.endswith('.npy') for r in rows),
+                'Declared lossless compressed state format differs from actual archive')
+        return dict(file_bytes=Path(path).stat().st_size,
+                    uncompressed_entry_bytes=sum(r.file_size for r in rows),
+                    compressed_entry_bytes=sum(r.compress_size for r in rows),
+                    entries=[dict(name=r.filename, bytes=r.file_size, compressed_bytes=r.compress_size,
+                                  compression=r.compress_type) for r in rows])
+
+
+def runtime_environment():
+    """Read settings after the runtime imported Torch; change none of them."""
+    torch = sys.modules.get('torch')
+    require(torch is not None and os.environ.get('CUDA_VISIBLE_DEVICES') == GPU and
+            torch.cuda.device_count() == 1 and '4090' in torch.cuda.get_device_name(0),
+            'Actual runtime is not the registered single RTX4090')
+    properties = torch.cuda.get_device_properties(0)
+    inventory = subprocess.run(['nvidia-smi', '-i', GPU,
+        '--query-gpu=uuid,name,memory.total,driver_version', '--format=csv,noheader'],
+        check=True, capture_output=True, text=True, timeout=20).stdout.strip()
+    require(inventory.startswith(GPU + ','), 'GPU hardware inventory does not match the registered UUID')
+    return dict(python_executable=sys.executable, python_version=sys.version, numpy_version=np.__version__,
+        torch_version=str(torch.__version__), torch_cuda_version=torch.version.cuda,
+        device_name=properties.name, total_memory_bytes=int(properties.total_memory),
+        gpu_uuid=GPU, nvidia_smi_inventory=inventory,
+        matmul_allow_tf32=bool(torch.backends.cuda.matmul.allow_tf32),
+        cudnn_allow_tf32=bool(torch.backends.cudnn.allow_tf32),
+        deterministic_algorithms=bool(torch.are_deterministic_algorithms_enabled()),
+        cudnn_deterministic=bool(torch.backends.cudnn.deterministic),
+        cudnn_benchmark=bool(torch.backends.cudnn.benchmark),
+        float32_matmul_precision=torch.get_float32_matmul_precision(),
+        CUBLAS_WORKSPACE_CONFIG=os.environ.get('CUBLAS_WORKSPACE_CONFIG'),
+        TORCH_CUDA_ARCH_LIST=os.environ.get('TORCH_CUDA_ARCH_LIST'),
+        settings_changed_by_environment_recorder=False,
+        environment_recorder_adds_no_timing=True,
+        build_timing_source='Use inherited summary.build_or_cache_seconds; build/cache is also included in runtime wall time')
+
+
+def verify_environment(recorded, component):
+    require(type(recorded) is type(component) is dict and
+            recorded.get('gpu_uuid') == GPU and recorded.get('settings_changed_by_environment_recorder') is False,
+            'Missing or invalid actual environment receipt')
+    require(component.get('cuda_matmul_allow_tf32') is False and
+            component.get('float32_matmul_precision') == 'highest' and
+            component.get('precision_configuration_changed_by_component') is False,
+            'Frozen AM precision configuration changed; never correct it automatically')
+    pairs = {'matmul_allow_tf32': 'cuda_matmul_allow_tf32', 'cudnn_allow_tf32': 'cudnn_allow_tf32',
+             'deterministic_algorithms': 'deterministic_algorithms', 'cudnn_deterministic': 'cudnn_deterministic',
+             'cudnn_benchmark': 'cudnn_benchmark', 'float32_matmul_precision': 'float32_matmul_precision',
+             'CUBLAS_WORKSPACE_CONFIG': 'CUBLAS_WORKSPACE_CONFIG', 'device_name': 'device_name',
+             'torch_version': 'torch', 'torch_cuda_version': 'cuda', 'numpy_version': 'numpy'}
+    for left, right in pairs.items():
+        require(left in recorded and right in component and same_json(recorded[left], component[right]),
+                'Actual runtime/APL environment disagreement: ' + left)
+    require(type(recorded['device_name']) is str and '4090' in recorded['device_name'], 'Wrong physical device class')
+
+
+def check_runtime_record(reg, reg_sha, row, record):
+    """Recheck actual bytes, runtime completion and parent chain, not intent."""
+    paths = locations(row['row_id'])
+    require(record.get('complete') is True and record.get('registration_sha256') == reg_sha and
+            same_json(record.get('row'), row) and record.get('training') is False,
+            'Runtime record is not bound to this registered row')
+    case = Path(reg['cases'][row['row_id']]['case_dir'])
+    checkpoint = C.load_checkpoint(paths['output'], record['checkpoint_manifest_sha256'])
+    summary = checkpoint['summary']
+    verify_environment(record['environment'], summary['apl_component']['environment'])
+    require(checkpoint['steps'] == row['steps'] and checkpoint['global_tick_offset'] == row['start'] and
+            checkpoint['global_next_tick'] == row['stop'] and summary['nodes'] == 166700 and summary['edges'] == 25582938 and
+            summary['diagnostic_mode'] == row['mode'], 'Runtime clock/population/mode differs from plan')
+    require(record['case_sha256'] == R.digest(case / 'spec.json') and
+            record['requests_sha256'] == R.digest(case / 'requests.npz') and
+            record['derivation_sha256'] == R.digest(paths['derivation']), 'Derived input/receipt bytes changed')
+    template = R._read_json(case / 'template-spec.json')
+    parent_pin = None
+    if row['parent_row_id'] is not None:
+        parent = verify_execution(reg, reg_sha, row_from(reg, row['parent_row_id']))
+        parent_pin = parent['checkpoint_manifest_sha256']
+    expected, derivation = derive_case(template, row, parent_pin)
+    require(same_json(R._read_json(case / 'spec.json'), expected) and
+            same_json(R._read_json(paths['derivation']), derivation), 'Case was not generated by the registered exact rule')
+    require(record['parent_checkpoint_manifest_sha256'] == parent_pin and
+            summary.get('parent_checkpoint_manifest_sha256') == parent_pin, 'Execution parent SHA mismatch')
+    require(record['checkpoint_inventory_sha256'] == R.digest(paths['output'] / C.MANIFEST), 'Checkpoint manifest changed')
+    for name in ('state.npz', 'terminal-queues.npz'):
+        require(same_json(record['storage'][name], npz_storage(paths['output'] / name)), 'Storage measurement changed')
+    return record
+
+
+def verify_execution(reg, reg_sha, row):
+    paths = locations(row['row_id'])
+    receipt = R._read_json(paths['execution'])
+    require(receipt.get('complete') is True and type(receipt.get('process_exit_code')) is int and receipt['process_exit_code'] == 0 and
+            receipt.get('registration_sha256') == reg_sha and receipt.get('row_id') == row['row_id'],
+            'Missing completed process receipt')
+    for field, key in (('runtime_record_sha256', 'runtime'), ('stdout_sha256', 'stdout'), ('stderr_sha256', 'stderr')):
+        require(receipt[field] == R.digest(paths[key]), 'Execution log/runtime receipt changed')
+    require(not (EXP / 'audit/stopped.json').exists(), 'A failed/deferred run requires explicit review, not automatic retry')
+    record = check_runtime_record(reg, reg_sha, row, R._read_json(paths['runtime']))
+    require(receipt['checkpoint_manifest_sha256'] == record['checkpoint_manifest_sha256'], 'Execution/checkpoint linkage mismatch')
+    return record
+
+
+def worker(reg_sha, row_id):
+    require(sys.dont_write_bytecode, 'Use the scientific venv with -B')
+    reg = preparation().read_registration(reg_sha)
+    row = row_from(reg, row_id)
+    paths = locations(row_id)
+    require(not paths['output'].exists() and not paths['runtime'].exists() and not paths['derivation'].exists(),
+            'Never overwrite/retry a partial row')
+    budget_before = disk_budget(reg)
+    preflight()
+    parent_sha = None
+    parent_dir = None
+    if row['parent_row_id'] is not None:
+        parent_record = verify_execution(reg, reg_sha, row_from(reg, row['parent_row_id']))
+        parent_sha = parent_record['checkpoint_manifest_sha256']
+        parent_dir = locations(row['parent_row_id'])['output']
+    case = Path(reg['cases'][row_id]['case_dir'])
+    template = R._read_json(case / 'template-spec.json')
+    spec, derivation = derive_case(template, row, parent_sha)
+    require(not (case / 'spec.json').exists(), 'Derived spec already exists; preserve partial instead of rerun')
+    R._save(case / 'spec.json', spec)
+    R._save(paths['derivation'], derivation)
+    overlay = reg['overlays'][row['overlay']]
+    start_utc = datetime.now(timezone.utc).isoformat()
+    start = time.perf_counter()
+    if parent_dir is None:
+        function = R.run_reference if row['mode'] == 'reference' else R.run_light
+        function(case, paths['output'], EXP / 'extension-build', overlay['overlay_file'], overlay['overlay_manifest'])
+        pin = C.seal_checkpoint(paths['output'])['sha256']
+    else:
+        result = C.run_continued(case, paths['output'], EXP / 'extension-build',
+            overlay['overlay_file'], overlay['overlay_manifest'], parent_dir, mode=row['mode'])
+        pin = result['checkpoint_manifest_sha256']
+    elapsed = time.perf_counter() - start
+    budget_after = disk_budget(reg)
+    record = dict(schema='phase4an-engineering-runtime-record-v1', complete=True, training=False,
+        registration_sha256=reg_sha, row=row, case_sha256=R.digest(case / 'spec.json'),
+        requests_sha256=R.digest(case / 'requests.npz'), derivation_sha256=R.digest(paths['derivation']),
+        checkpoint_manifest_sha256=pin, checkpoint_inventory_sha256=R.digest(paths['output'] / C.MANIFEST),
+        parent_checkpoint_manifest_sha256=parent_sha, runtime_and_immediate_seal_wall_seconds=elapsed,
+        started_utc=start_utc, completed_utc=datetime.now(timezone.utc).isoformat(),
+        environment=runtime_environment(),
+        budget_before=budget_before, budget_after=budget_after,
+        storage={name: npz_storage(paths['output'] / name) for name in ('state.npz', 'terminal-queues.npz')},
+        no_result_selected_retry=True, learning_pass_claimed=False)
+    # Do not write this or any later report INSIDE the sealed checkpoint.
+    check_runtime_record(reg, reg_sha, row, record)
+    preparation().read_registration(reg_sha)
+    R._save(paths['runtime'], record)
+    print('COMPLETED ENGINEERING ROW', row_id, flush=True)
+
+
+def run_registered(reg_sha):
+    require(sys.dont_write_bytecode, 'Use python -B')
+    reg = preparation().read_registration(reg_sha)
+    require(not (EXP / 'audit/stopped.json').exists() and not (EXP / 'audit/execution-complete.json').exists(),
+            'Stopped/completed gate must not be restarted')
+    started = time.perf_counter()
+    completed = []
+    try:
+        for row in reg['plan']['rows']:
+            paths = locations(row['row_id'])
+            if paths['execution'].exists():
+                verify_execution(reg, reg_sha, row)
+                completed.append(dict(row_id=row['row_id'], execution_sha256=R.digest(paths['execution']),
+                                      reverified_existing=True))
+                continue
+            require(not any(paths[k].exists() for k in ('output', 'runtime', 'stdout', 'stderr', 'derivation')),
+                    'Partial row present; no automatic retry')
+            disk_budget(reg)
+            preflight()
+            began = time.perf_counter()
+            print('START', row['row_id'], flush=True)
+            with paths['stdout'].open('xb') as out, paths['stderr'].open('xb') as err:
+                result = subprocess.run([sys.executable, '-B', str(Path(__file__)), 'worker',
+                    '--registration-sha256', reg_sha, '--row-id', row['row_id']], cwd=MODEL, stdout=out, stderr=err)
+            require(result.returncode == 0, 'Worker failed; preserve its stdout/stderr and partial output')
+            record = check_runtime_record(reg, reg_sha, row, R._read_json(paths['runtime']))
+            receipt = dict(schema='phase4an-engineering-execution-receipt-v1', complete=True,
+                process_exit_code=result.returncode, row_id=row['row_id'], registration_sha256=reg_sha,
+                runtime_record_sha256=R.digest(paths['runtime']), stdout_sha256=R.digest(paths['stdout']),
+                stderr_sha256=R.digest(paths['stderr']), process_wall_seconds=time.perf_counter() - began,
+                checkpoint_manifest_sha256=record['checkpoint_manifest_sha256'], scientific_pass_claimed=False)
+            R._save(paths['execution'], receipt)
+            verify_execution(reg, reg_sha, row)
+            completed.append(dict(row_id=row['row_id'], execution_sha256=R.digest(paths['execution']),
+                                  reverified_existing=False))
+            print('COMPLETE', row['row_id'], flush=True)
+        require(len(completed) == 32, 'Incomplete registered inventory')
+        preparation().read_registration(reg_sha)
+        R._save(EXP / 'audit/execution-complete.json', dict(complete=True, registration_sha256=reg_sha,
+            completed=completed, expected_calls=32, executed_ticks=11074, wall_seconds=time.perf_counter() - started,
+            numerical_gate_evaluated=False, training=False, learning_pass_claimed=False))
+    except Exception as error:
+        R._save(EXP / 'audit/stopped.json', dict(complete=False, type=type(error).__name__, message=str(error),
+            traceback=traceback.format_exc(), completed_before_error=completed, partial_outputs_preserved=True,
+            no_automatic_retry=True, scientific_failure_not_inferred_from_engineering_failure=True))
+        raise
+
+
+def verified_inventory(reg, reg_sha):
+    """A completed child and every planned descriptor must remain auditable."""
+    plan = PLAN.validate_plan(reg['plan'])
+    receipt = R._read_json(EXP / 'audit/execution-complete.json')
+    require(receipt.get('complete') is True and receipt.get('registration_sha256') == reg_sha and
+            type(receipt.get('expected_calls')) is int and receipt['expected_calls'] == plan['total_calls'] and
+            type(receipt.get('executed_ticks')) is int and receipt['executed_ticks'] == plan['total_ticks'] and
+            receipt.get('training') is False and receipt.get('learning_pass_claimed') is False,
+            'Execution inventory is not a complete no-training registered gate')
+    require(type(receipt.get('completed')) is list and len(receipt['completed']) == plan['total_calls'],
+            'Execution inventory truncated')
+    records = {}
+    for row, entry in zip(plan['rows'], receipt['completed']):
+        require(entry.get('row_id') == row['row_id'] and
+                entry.get('execution_sha256') == R.digest(locations(row['row_id'])['execution']),
+                'Execution completion inventory reordered or receipt changed')
+        records[row['row_id']] = verify_execution(reg, reg_sha, row)
+    return records
+
+
+def evaluate(reg_sha):
+    reg = preparation().read_registration(reg_sha)
+    records = verified_inventory(reg, reg_sha)
+    report = importlib.import_module('engineering_analysis').analyze(reg, reg_sha, records)
+    require(type(report) is dict and report.get('training') is False and report.get('learning_pass_claimed') is False,
+            'Engineering analysis must not claim training or learning')
+    preparation().read_registration(reg_sha)
+    return reg, report
+
+
+def analyze(reg_sha):
+    require(sys.dont_write_bytecode, 'Use python -B')
+    target = EXP / 'audit/engineering-analysis.json'
+    require(not target.exists() and not (EXP / 'manifest.json').exists(), 'Analysis/seal already exists; do not overwrite')
+    began = time.perf_counter()
+    _, report = evaluate(reg_sha)
+    R._save(target, report)
+    R._save(EXP / 'audit/analysis-execution.json', dict(registration_sha256=reg_sha,
+        analysis_sha256=R.digest(target), wall_seconds=time.perf_counter() - began, GPU_used=False,
+        training=False, learning_pass_claimed=False))
+    print(report['status'], flush=True)
+
+
+def seal_experiment():
+    """Seal only the new engineering experiment, not the unfinished lab model."""
+    controls = ('manifest.json', 'checksums.sha256')
+    require(not any((EXP / name).exists() for name in controls), 'Do not replace an existing or partial seal')
+    paths = sorted(EXP.rglob('*'))
+    require(not any(path.is_symlink() for path in paths), 'Cannot seal linked artifacts')
+    require(not any('__pycache__' in path.relative_to(EXP).parts for path in paths), 'Unexpected bytecode cache in new experiment')
+    rows = [dict(path=path.relative_to(EXP).as_posix(), bytes=path.stat().st_size, sha256=R.digest(path))
+            for path in paths if path.is_file()]
+    require(rows, 'Cannot seal an empty experiment')
+    # Only ROOT controls are excluded from their own hash. Nested checkpoint
+    # manifests and source snapshots are ordinary payload and remain included.
+    R._save(EXP / controls[0], dict(root=str(EXP), files=rows))
+    with (EXP / controls[1]).open('x', encoding='utf-8', newline='\n') as stream:
+        stream.writelines(row['sha256'] + '  ' + row['path'] + '\n' for row in rows)
+        stream.write(R.digest(EXP / controls[0]) + '  manifest.json\n')
+    return dict(manifest_sha256=R.digest(EXP / controls[0]), checksums_sha256=R.digest(EXP / controls[1]))
+
+
+def finalize(reg_sha):
+    require(sys.dont_write_bytecode, 'Use python -B')
+    require(not (EXP / 'manifest.json').exists() and not (EXP / 'audit/final-status.json').exists(),
+            'Final/partial seal already exists; preserve it')
+    reg, actual = evaluate(reg_sha)
+    target = EXP / 'audit/engineering-analysis.json'
+    require(same_json(actual, R._read_json(target)), 'Recomputed analysis differs from saved evidence')
+    execution = R._read_json(EXP / 'audit/analysis-execution.json')
+    require(execution.get('registration_sha256') == reg_sha and execution.get('analysis_sha256') == R.digest(target),
+            'Saved analysis is not bound to its execution receipt')
+    authority = preparation().verify_authority(reg['anchors'])
+    old = preparation().verify_old_integrity(reg)
+    R._save(EXP / 'regression/AM-seals-after.json', authority)
+    R._save(EXP / 'regression/old-integrity-after.json', old)
+    preparation().read_registration(reg_sha)
+    final = dict(schema='phase4an-engineering-final-v1', status=actual['status'],
+        registration_sha256=reg_sha, analysis_sha256=R.digest(target),
+        analysis_recomputed_exactly=True, completed_calls=32, executed_ticks=11074,
+        old_integrity_pass=True, old_integrity_roots=len(old), AM_seals_preserved=True,
+        old_five_reference_evidence='Sealed AM five-trial evidence retained; not rerun by this engineering gate',
+        training=False, learning_pass_claimed=False, learned_candidate=False,
+        model_directory_sealed=False, used_engineering_source_snapshots_sealed=True,
+        budget=disk_budget(reg),
+        scope='Finite registered 100 ms input and fixed continuation cuts only; no universal determinism, learning or physiology claim')
+    R._save(EXP / 'audit/final-status.json', final)
+    pins = seal_experiment()
+    helper = preparation().load_module('phase4an_pinned_AI_publication',
+        ROOT / preparation().AI_HELPER_REL, preparation().AI_HELPER_SHA)
+    verified = helper.verify_seal(EXP)
+    require(verified['manifest_sha256'] == pins['manifest_sha256'] and
+            verified['checksums_sha256'] == pins['checksums_sha256'], 'Final experiment seal verification failed')
+    print(canonical(dict(status=final['status'], **pins)), flush=True)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('action', choices=('run', 'worker', 'analyze', 'finalize'))
+    parser.add_argument('--registration-sha256', required=True)
+    parser.add_argument('--row-id')
+    args = parser.parse_args()
+    if args.action == 'worker':
+        require(args.row_id is not None, 'Worker requires a row ID')
+        worker(args.registration_sha256, args.row_id)
+    else:
+        require(args.row_id is None, 'Full inventory run has no selected row')
+        {'run': run_registered, 'analyze': analyze, 'finalize': finalize}[args.action](args.registration_sha256)
+
+
+if __name__ == '__main__':
+    main()

models/male-cns-lif/olfactory-conditioning-lab-v1/runtime_continuation.py

@@ -0,0 +1,478 @@
+"""Unregistered fixed-weight continuation of the reporting-only AN executor.
+
+run_continued(case, out, build, overlay, manifest, checkpoint_dir, mode='light')
+also accepts mode='reference'. Inputs/events/counts use segment-local ticks;
+summary and receipts expose global_tick_offset/global_next_tick. No training,
+weight update, early stopping, or implicit extra tail is performed.
+
+The caller must externally pin spec.parent_checkpoint_manifest_sha256. A fresh
+parent's original runtime receipt did NOT bind state.npz: seal_checkpoint adds
+that binding, after checking the available original receipts and current bytes.
+It cannot retroactively prove that an unsealed state file was never modified.
+Full graph/APL/coefficient/preregistered-input authority remains the coordinator's
+responsibility, as in runtime_light. No executable/venv path is resolved here.
+"""
+from __future__ import annotations
+
+import ast
+import copy
+import hashlib
+import importlib.util
+from pathlib import Path
+import sys
+
+import numpy as np
+
+
+LIGHT_SHA = '522b8c31ea938890fe15364fccd25ccc5bded54101754909f255532e7ad01aae'
+N = 166700
+E = 25582938
+MANIFEST = 'checkpoint-manifest.json'
+RECEIPT = 'continuation-receipt.json'
+RESTORE = '_continuation.restore(v, g, ref, counts, ring, apl_ring, apl, upload)'
+CLOCK_OLD = 'tick >= 18'
+CLOCK_NEW = 'tick + _continuation.global_offset >= 18'
+
+
+def _light():
+    path = Path(__file__).resolve().parent / 'runtime_light.py'
+    raw = path.read_bytes()
+    if hashlib.sha256(raw).hexdigest() != LIGHT_SHA:
+        raise ValueError('Fresh runtime source pin changed')
+    name = 'phase4an_continuation_pinned_light'
+    existing = sys.modules.get(name)
+    if existing is not None:
+        if getattr(existing, '__continuation_pin__', None) != LIGHT_SHA or Path(existing.__file__).resolve() != path:
+            raise ValueError('Unverified runtime module binding')
+        return existing
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    try:
+        exec(compile(raw, str(path), 'exec'), module.__dict__)
+    except BaseException:
+        sys.modules.pop(name, None)
+        raise
+    module.__continuation_pin__ = LIGHT_SHA
+    return module
+
+
+R = _light()  # Pure NumPy/stdlib; this does not import Torch or run a brain.
+
+
+def rotate_spike_ring(raw_ring, phase_tick):
+    """Parent's local next-write slot becomes the child's local slot zero."""
+    R.require(isinstance(raw_ring, np.ndarray) and raw_ring.dtype == np.uint8 and
+              raw_ring.ndim == 2 and raw_ring.shape[0] == 19, 'Invalid spike ring dtype/shape')
+    R.require(type(phase_tick) is int and phase_tick >= 0 and np.all(raw_ring <= 1), 'Invalid ring phase/content')
+    return raw_ring[(np.arange(19) + phase_tick % 19) % 19].copy()
+
+
+def _tree_hashes(directory):
+    """Exact regular-file inventory, no symlink/reparse escapes, no self-hash."""
+    directory = Path(directory).resolve(strict=True)
+    R.require(directory.is_dir(), 'Checkpoint must be a directory')
+    result = {}
+    for path in sorted(directory.rglob('*')):
+        R.require(not path.is_symlink() and path.resolve().is_relative_to(directory), 'Checkpoint contains a linked/escaping path')
+        if path.is_dir():
+            continue
+        R.require(path.is_file(), 'Checkpoint contains a nonregular entry')
+        relative = path.relative_to(directory).as_posix()
+        if relative == MANIFEST:
+            continue
+        R.require('error' not in path.name.lower() and 'failure' not in path.name.lower(), 'Parent has failure/error evidence')
+        result[relative] = R.digest(path)
+    return result
+
+
+def _npz(path, keys):
+    with np.load(path, allow_pickle=False) as archive:
+        R.require(len(archive.files) == len(keys) and set(archive.files) == set(keys), 'Unexpected checkpoint array keys: ' + str(path))
+        return {name: archive[name].copy() for name in keys}
+
+
+def validate_state(state, terminal, steps, *, fresh):
+    """Validate local events/counts and the slots written by this segment."""
+    R.require(type(steps) is int and 0 < steps <= np.iinfo(np.int32).max, 'Invalid segment length')
+    for name in ('v', 'g'):
+        value = state[name]
+        R.require(value.dtype == np.float64 and value.shape == (N,) and np.isfinite(value).all(), 'Invalid parent ' + name)
+    for name in ('ref', 'counts'):
+        value = state[name]
+        R.require(value.dtype == np.int32 and value.shape == (N,) and np.all(value >= 0), 'Invalid parent ' + name)
+    R.require(np.all(state['ref'] <= 22), 'Parent refractory counter exceeds frozen 22-step contract')
+    tick, neuron = state['step'], state['neuron_idx']
+    R.require(tick.dtype == neuron.dtype == np.int32 and tick.ndim == neuron.ndim == 1 and tick.shape == neuron.shape,
+              'Invalid sparse event dtype/shape')
+    R.require(np.all((tick >= 0) & (tick < steps)) and np.all((neuron >= 0) & (neuron < N)), 'Parent event outside segment')
+    key = tick.astype(np.int64) * N + neuron
+    R.require(len(key) < 2 or np.all(key[1:] > key[:-1]), 'Parent events must be sorted and unique')
+    R.require(np.array_equal(np.bincount(neuron, minlength=N), state['counts']), 'Parent counts are not segment-local event counts')
+    ring = terminal['spike_ring']
+    R.require(ring.dtype == np.uint8 and ring.shape == (19, N) and np.all(ring <= 1), 'Invalid parent spike ring')
+    for name, shape in (('apl_state', (2,)), ('apl_pending', (18, 4064))):
+        value = terminal[name]
+        R.require(value.dtype == np.float32 and value.shape == shape and np.isfinite(value).all(), 'Invalid terminal ' + name)
+    phase = terminal['next_tick']
+    R.require(phase.dtype == np.int64 and phase.shape == () and phase.item() == steps, 'Terminal local phase does not match segment length')
+    for local_tick in range(max(0, steps - 19), steps):
+        start, stop = np.searchsorted(tick, (local_tick, local_tick + 1))
+        expected = np.zeros(N, dtype=np.uint8)
+        expected[neuron[start:stop]] = 1
+        R.require(np.array_equal(ring[local_tick % 19], expected), 'Spike ring does not match emitted segment events')
+    if fresh and steps < 19:
+        R.require(not np.any(ring[steps:]), 'Fresh parent has nonzero uninitialized spike slots')
+    return state, terminal
+
+
+def _verify_receipt_hashes(directory, receipt):
+    for key, name in (('summary_sha256', 'summary.json'), ('finite_audit_sha256', 'finite-audit.json'),
+                      ('terminal_queues_sha256', 'terminal-queues.npz'), ('overlay_audit_sha256', 'overlay-audit.json')):
+        R.require(receipt.get(key) == R.digest(directory / name), 'Parent receipt hash mismatch: ' + name)
+    inputs = receipt.get('input_sha256')
+    R.require(isinstance(inputs, dict) and inputs, 'Parent receipt lacks immutable input bindings')
+    for name, sha in inputs.items():
+        R.require(Path(name).is_absolute() and R._sha(sha) and R.digest(name) == sha, 'Parent input/source bytes changed: ' + name)
+
+
+def _validate_record(directory, seen):
+    summary = R._read_json(directory / 'summary.json')
+    finite = R._read_json(directory / 'finite-audit.json')
+    provenance = R._read_json(directory / 'runtime-provenance.json')
+    steps = summary.get('steps')
+    R.require(summary.get('complete') is True and summary.get('pass_all') is True and summary.get('all_finite') is True and
+              summary.get('completed_ticks') == steps and summary.get('nodes') == N and summary.get('edges') == E and
+              summary.get('precision') == 'float64' and summary.get('apl_precision') == 'float32' and
+              summary.get('within_trial_weight_updates') is False, 'Parent is not a complete fixed-weight fullgraph trial')
+    R.require(finite.get('all_finite') is True and finite.get('first_failure_tick') == -1 and
+              finite.get('finite_observed_ticks') == steps, 'Parent finite coverage failed')
+    R.require(provenance.get('complete') is True and provenance.get('weights_updated_during_run') is False and
+              provenance.get('old_globals_patched') is False, 'Invalid parent runtime receipt')
+    _verify_receipt_hashes(directory, provenance)
+    fresh = provenance.get('schema') == 'phase4an-reporting-adapter-v1'
+    if fresh:
+        R.require(provenance.get('source_sha256') == LIGHT_SHA and R.digest(provenance['source_file']) == LIGHT_SHA and
+                  summary.get('checkpoint_continuation_used') is False, 'Fresh parent source/continuation scope mismatch')
+        offset = 0
+    else:
+        R.require(provenance.get('schema') == 'phase4an-continuation-runtime-v1' and
+                  provenance.get('source_sha256') == R.digest(__file__) and
+                  R.digest(provenance['source_file']) == R.digest(__file__) and
+                  summary.get('checkpoint_continuation_used') is True, 'Unrecognized continued parent source')
+        receipt = R._read_json(directory / RECEIPT)
+        R.require(receipt.get('schema') == 'phase4an-continuation-receipt-v1' and receipt.get('complete') is True,
+                  'Invalid continuation receipt')
+        R.require(receipt.get('weights_updated_during_run') is False and receipt.get('segment_steps') == steps and
+                  receipt.get('counts_scope') == 'segment_only_not_lifetime' and
+                  provenance.get('state_sha256') == R.digest(directory / 'state.npz'), 'Continued state/scope receipt mismatch')
+        expected_payload = _tree_hashes(directory)
+        expected_payload.pop(RECEIPT, None)
+        R.require(receipt.get('payload_sha256') == expected_payload, 'Continuation receipt does not bind the exact payload')
+        parent_pin = receipt.get('parent_checkpoint_manifest_sha256')
+        case_spec = _parent_spec({'summary': summary, 'provenance': provenance})
+        R.require(R._sha(parent_pin) and provenance.get('parent_checkpoint_manifest_sha256') == parent_pin and
+                  summary.get('parent_checkpoint_manifest_sha256') == parent_pin and
+                  case_spec.get('parent_checkpoint_manifest_sha256') == parent_pin,
+                  'Parent checkpoint pin disagrees across case/summary/provenance/continuation receipts')
+        R.require(Path(receipt['parent_checkpoint_dir']).is_absolute(), 'Parent checkpoint directory is not absolute')
+        parent = load_checkpoint(receipt['parent_checkpoint_dir'], parent_pin, _seen=seen)
+        offset = parent['global_next_tick']
+        R.require(receipt.get('global_tick_offset') == offset and receipt.get('global_next_tick') == offset + steps and
+                  summary.get('global_tick_offset') == offset and summary.get('global_next_tick') == offset + steps and
+                  provenance.get('global_tick_offset') == offset and provenance.get('global_next_tick') == offset + steps,
+                  'Continuation global clock chain mismatch')
+        R.require(summary.get('effective_weights_raw_sha256') == parent['summary'].get('effective_weights_raw_sha256'),
+                  'Retention effective weights changed between parent and child')
+    state = _npz(directory / 'state.npz', ('step', 'neuron_idx', 'counts', 'v', 'g', 'ref'))
+    terminal = _npz(directory / 'terminal-queues.npz', ('spike_ring', 'apl_state', 'apl_pending', 'next_tick'))
+    validate_state(state, terminal, steps, fresh=fresh)
+    initial_padding = max(18 - (offset + steps), 0)
+    R.require(np.all(terminal['apl_pending'][:initial_padding].view(np.uint32) == 0),
+              'Unconsumed original APL padding is not positive zero')
+    if not fresh:
+        if steps < 19:
+            restored = rotate_spike_ring(parent['terminal']['spike_ring'], int(parent['terminal']['next_tick']))
+            R.require(np.array_equal(terminal['spike_ring'][steps:], restored[steps:]), 'Unwritten carried spike slots changed')
+        if steps < 18:
+            carried = parent['terminal']['apl_pending'][steps:]
+            R.require(np.array_equal(terminal['apl_pending'][:18 - steps].view(np.uint32), carried.view(np.uint32)),
+                      'Unconsumed carried APL slots changed')
+    overlay = R._read_json(directory / 'overlay-audit.json')
+    R.require(overlay.get('complete') is True and overlay.get('weights_updated_during_run') is False and
+              overlay.get('effective_weights_raw_sha256') == summary.get('effective_weights_raw_sha256') and
+              overlay.get('mask_sha256') == R.MASK_SHA and overlay.get('am_helper_sha256') == R.AM_OVERLAY_SHA,
+              'Parent effective overlay receipt mismatch')
+    overlay_manifest = R._read_json(directory / 'overlay-manifest.json')
+    R.require(R.digest(directory / 'overlay-input.npz') == overlay_manifest.get('overlay_sha256') and
+              R.digest(directory / 'overlay-manifest.json') in provenance['input_sha256'].values() and
+              overlay_manifest.get('mask_sha256') == R.MASK_SHA and
+              overlay_manifest.get('base_candidate_sha256') == overlay.get('base_candidate_sha256'),
+              'Parent copied overlay inputs do not match their original receipt')
+    timing = R._read_json(directory / 'apl-timing-audit.json')
+    with (directory / 'apl-pending-tail.float32.npy').open('rb') as stream:
+        pending = np.load(stream, allow_pickle=False)
+    R.require(pending.dtype == np.float32 and pending.shape == (18, 4064) and
+              pending.tobytes() == terminal['apl_pending'].tobytes(), 'Parent terminal/pending output mismatch')
+    R.require(timing.get('pending_raw_sha256') == R._raw(pending) and timing.get('apl_delay_steps') == 18 and
+              timing.get('brain_tail_advanced') is False and
+              timing.get('final_apl_state_u32_bits') == terminal['apl_state'].view(np.uint32).tolist(), 'Parent APL terminal audit mismatch')
+    return {'directory': directory, 'summary': summary, 'provenance': provenance, 'overlay': overlay,
+            'state': state, 'terminal': terminal, 'steps': steps, 'global_tick_offset': offset,
+            'global_next_tick': offset + steps, 'fresh': fresh,
+            'ancestry_directories': [directory] if fresh else [directory, *parent['ancestry_directories']]}
+
+
+def seal_checkpoint(checkpoint_dir):
+    """Exclusive file-hash seal, not a brain run or proof of pre-seal integrity.
+
+    The returned manifest SHA must be externally pinned into the next case spec.
+    No existing receipt is overwritten. Fresh state.npz is newly bound here.
+    """
+    directory = Path(checkpoint_dir).resolve(strict=True)
+    R.require(not (directory / MANIFEST).exists(), 'Checkpoint is already sealed')
+    before = _tree_hashes(directory)
+    record = _validate_record(directory, {directory})
+    R.require(before == _tree_hashes(directory), 'Checkpoint changed while sealing')
+    value = {'schema': 'phase4an-checkpoint-v1', 'complete': True, 'files_sha256': before,
+             'segment_steps': record['steps'], 'global_tick_offset': record['global_tick_offset'],
+             'global_next_tick': record['global_next_tick'], 'counts_scope': 'segment_only',
+             'state_binding_origin': 'checkpoint seal; fresh runtime receipt did not hash state.npz',
+             'pre_seal_state_integrity_independently_proven': False}
+    R._save(directory / MANIFEST, value)
+    return {'path': str(directory / MANIFEST), 'sha256': R.digest(directory / MANIFEST), **value}
+
+
+def load_checkpoint(checkpoint_dir, expected_sha, *, _seen=None):
+    directory = Path(checkpoint_dir).resolve(strict=True)
+    R.require(R._sha(expected_sha) and R.digest(directory / MANIFEST) == expected_sha, 'Parent checkpoint manifest differs from external pin')
+    seen = set() if _seen is None else set(_seen)
+    R.require(directory not in seen, 'Checkpoint ancestry cycle')
+    seen.add(directory)
+    manifest = R._read_json(directory / MANIFEST)
+    R.require(manifest.get('schema') == 'phase4an-checkpoint-v1' and manifest.get('complete') is True and
+              manifest.get('counts_scope') == 'segment_only' and manifest.get('files_sha256') == _tree_hashes(directory),
+              'Checkpoint file inventory/hash mismatch')
+    record = _validate_record(directory, seen)
+    R.require(manifest.get('segment_steps') == record['steps'] and manifest.get('global_tick_offset') == record['global_tick_offset'] and
+              manifest.get('global_next_tick') == record['global_next_tick'], 'Checkpoint clock metadata mismatch')
+    R.require(manifest['files_sha256'] == _tree_hashes(directory) and R.digest(directory / MANIFEST) == expected_sha,
+              'Checkpoint changed while loading')
+    record.update(manifest=manifest, manifest_sha256=expected_sha)
+    return record
+
+
+def derive_continued(source_bytes, mode):
+    """One explicit arrival-admission edit plus one pre-loop restore hook."""
+    tree, inherited = R.derive_ast(source_bytes, mode)
+    original = copy.deepcopy(tree)
+    function = tree.body[-1]
+    body = next(node for node in function.body if isinstance(node, ast.Try)).body
+    candidates = [i for i, node in enumerate(body) if isinstance(node, ast.Assign) and
+                  len(node.targets) == 1 and isinstance(node.targets[0], ast.Name) and node.targets[0].id == 'apl_ring']
+    R.require(len(candidates) == 1, 'Expected one APL ring initialization')
+    body.insert(candidates[0] + 1, ast.parse(RESTORE).body[0])
+    clocks = [node for node in ast.walk(function) if isinstance(node, ast.If) and ast.unparse(node.test) == CLOCK_OLD]
+    R.require(len(clocks) == 1, 'Expected exact original local arrival-admission condition')
+    clocks[0].test = ast.parse(CLOCK_NEW, mode='eval').body
+    tree = ast.fix_missing_locations(tree)
+    # Independently reverse exactly the two edits, then require the ENTIRE AST.
+    rollback = copy.deepcopy(tree)
+    reverse_body = next(node for node in rollback.body[-1].body if isinstance(node, ast.Try)).body
+    restores = [i for i, node in enumerate(reverse_body) if ast.unparse(node) == RESTORE]
+    reverse_clocks = [node for node in ast.walk(rollback) if isinstance(node, ast.If) and ast.unparse(node.test) == CLOCK_NEW]
+    R.require(len(restores) == len(reverse_clocks) == 1, 'Ambiguous continuation edit rollback')
+    del reverse_body[restores[0]]
+    reverse_clocks[0].test = ast.parse(CLOCK_OLD, mode='eval').body
+    R.require(R._dump(rollback) == R._dump(original), 'Additional unlisted continuation AST edit')
+    audit = {'base': inherited, 'restore_hook': RESTORE, 'clock_admission_old': CLOCK_OLD,
+             'clock_admission_new': CLOCK_NEW, 'full_AST_rollback_identical': True,
+             'kernels_sorting_and_local_ring_math_unchanged': True,
+             'derived_module_ast_sha256': hashlib.sha256(R._dump(tree).encode()).hexdigest()}
+    return tree, audit
+
+
+def audit_carried_sequence(generated, applied, pending, initial_pending):
+    """Bitwise FIFO accounting with a carried queue, never a new brain step."""
+    for name, value in (('generated', generated), ('applied', applied), ('pending', pending), ('initial', initial_pending)):
+        R.require(isinstance(value, np.ndarray) and value.dtype == np.float32 and value.ndim == 2 and
+                  np.isfinite(value).all() and np.all(value >= 0), 'Invalid continued APL trace: ' + name)
+    R.require(generated.shape == applied.shape and pending.shape == initial_pending.shape == (18, generated.shape[1]),
+              'Continued APL sequence shapes differ')
+    steps = len(generated)
+    for tick in range(steps + 18):
+        actual = applied[tick] if tick < steps else pending[tick - steps]
+        expected = initial_pending[tick] if tick < 18 else generated[tick - 18]
+        R.require(np.array_equal(actual.view(np.uint32), expected.view(np.uint32)),
+                  'Carried FIFO bitwise accounting failed at local application tick ' + str(tick))
+    return {'pass_all': True, 'apl_delay_steps': 18, 'steps': steps, 'sample_bits_preserved': True,
+            'initial_queue_from_parent': True, 'initial_queue_raw_sha256': R._raw(initial_pending),
+            'full_sequence_bitwise_audit_performed': True, 'brain_tail_advanced': False}
+
+
+class ContinuedRuntime(R._Runtime):
+    def __init__(self, *args, parent, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.parent = parent
+        self.global_offset = parent['global_next_tick']
+        self.restorations = 0
+
+    def install(self, *args, **kwargs):
+        super().install(*args, **kwargs)
+        R.require(self.effective_sha == self.parent['summary']['effective_weights_raw_sha256'], 'Retention changed effective weights')
+
+    def restore(self, v, g, ref, counts, ring, apl_ring, apl, upload):
+        R.require(self.installations == 1 and self.restorations == 0, 'Restore must occur once after fixed-weight installation')
+        R.require(not bool(counts.any().item()), 'Segment counts must start at zero')
+        state, terminal = self.parent['state'], self.parent['terminal']
+        for target, value, dtype in ((v, state['v'], self.torch.float64), (g, state['g'], self.torch.float64),
+                                    (ref, state['ref'], self.torch.int32),
+                                    (ring, rotate_spike_ring(terminal['spike_ring'], int(terminal['next_tick'])), self.torch.uint8),
+                                    (apl_ring, terminal['apl_pending'], self.torch.float32),
+                                    (apl.state, terminal['apl_state'], self.torch.float32)):
+            target.copy_(upload(value, dtype))
+        self.restorations += 1
+
+    def finish(self, *args, **kwargs):
+        R.require(self.restorations == 1, 'Continuation was not restored')
+        return super().finish(*args, **kwargs)
+
+    def audit_sequence(self, generated, applied, pending, delay):
+        R.require(delay == 18, 'Continuation changed D18')
+        return audit_carried_sequence(generated, applied, pending, self.parent['terminal']['apl_pending'])
+
+    def _timing_metadata(self, value):
+        result = dict(value)
+        next_tick, steps = self.global_offset + self.spec['steps'], self.spec['steps']
+        result.pop('initial_padding_positive_zero', None)
+        result.update(initial_queue_from_parent=True, initial_queue_raw_sha256=R._raw(self.parent['terminal']['apl_pending']),
+                      global_tick_offset=self.global_offset, global_next_tick=next_tick, tick_coordinate='global',
+                      segment_steps=steps, segment_generated_rows_applied=max(steps - 18, 0),
+                      applied_parent_pending_rows=min(steps, 18),
+                      applied_initial_zero_rows=min(steps, max(18 - self.global_offset, 0)),
+                      applied_parent_generated_rows=min(steps, 18) - min(steps, max(18 - self.global_offset, 0)),
+                      pending_segment_generated_rows=min(steps, 18),
+                      pending_parent_generated_rows=max(18 - steps, 0) - max(18 - next_tick, 0),
+                      pending_generated_count=min(next_tick, 18), pending_initial_zero_prefix=max(18 - next_tick, 0),
+                      pending_application_tick_start=next_tick, pending_application_tick_stop_exclusive=next_tick + 18,
+                      pending_generated_tick_start=max(0, next_tick - 18), pending_generated_tick_stop_exclusive=next_tick,
+                      brain_tail_advanced_scope='no extra brain ticks beyond this explicit segment')
+        if self.mode == 'light':
+            result.update(generated_trace=None, applied_trace=None, full_sequence_bitwise_audit_performed=False,
+                          scope='Original D18 ring math retained with restored queue; histories not recorded')
+        return result
+
+    def timing(self, steps, pending):
+        return self._timing_metadata(super().timing(steps, pending))
+
+    def summary(self, value):
+        result = super().summary(value)
+        result.update(checkpoint_continuation_used=True, global_tick_offset=self.global_offset,
+                      global_next_tick=self.global_offset + self.spec['steps'], event_tick_scope='segment_local',
+                      counts_scope='segment_only_not_lifetime', parent_checkpoint_manifest_sha256=self.parent['manifest_sha256'])
+        result.update(pending_generated_count=min(result['global_next_tick'], 18),
+                      pending_initial_zero_prefix=max(18 - result['global_next_tick'], 0))
+        if 'apl_timing' in result:
+            result['apl_timing'] = self._timing_metadata(result['apl_timing'])
+        return result
+
+    def write_json(self, path, value):
+        if Path(path).name == 'apl-timing-audit.json':
+            value = self._timing_metadata(value)
+        return super().write_json(path, value)
+
+
+def compile_continued(aj, runtime, mode):
+    tree, audit = derive_continued(Path(aj.__file__).read_bytes(), mode)
+    namespace = dict(aj.__dict__)
+    namespace.update(__name__=__name__ + '.derived_' + mode, __file__=str(Path(__file__).resolve()),
+                     _runtime=runtime, _continuation=runtime, write_json=runtime.write_json,
+                     audit_sequence=runtime.audit_sequence)
+    audit['diagnostic_namespace_binding'] = 'audit_sequence checks parent_pending + generated, not an assumed zero-initial queue'
+    exec(compile(tree, str(Path(__file__).resolve()) + '::continued-AJ-AST-' + mode, 'exec'), namespace)
+    return namespace['run_gpu'], audit
+
+
+def _parent_spec(parent):
+    expected = parent['summary']['input_sha256']['spec.json']
+    paths = [Path(path) for path, sha in parent['provenance']['input_sha256'].items()
+             if Path(path).name == 'spec.json' and sha == expected]
+    R.require(len(paths) == 1, 'Ambiguous original parent case spec')
+    return R._read_json(paths[0])
+
+
+def run_continued(case_dir, out_dir, build_root, overlay_file, overlay_manifest, checkpoint_dir, *, mode='light'):
+    R.require(sys.dont_write_bytecode, 'Use python -B; frozen sources must not receive bytecode writes')
+    R.require(mode in ('light', 'reference'), 'Invalid diagnostic mode')
+    case_dir, out_dir, build_root = R.execution_paths(case_dir, out_dir, build_root, (checkpoint_dir,))
+    spec = R._read_json(case_dir / 'spec.json')
+    parent_sha = spec.get('parent_checkpoint_manifest_sha256')
+    fresh_admission = dict(spec)
+    fresh_admission.pop('parent_checkpoint_manifest_sha256', None)
+    R.validate_spec(fresh_admission, case_dir)
+    parent = load_checkpoint(checkpoint_dir, parent_sha)
+    # A continuation may never create output or a build cache inside ANY
+    # immutable ancestor, not only its immediate checkpoint parent. This check
+    # precedes overlay imports, Torch imports, compilation and output creation.
+    case_dir, out_dir, build_root = R.execution_paths(case_dir, out_dir, build_root, parent['ancestry_directories'])
+    if 'global_tick_offset' in spec:
+        R.require(type(spec['global_tick_offset']) is int and spec['global_tick_offset'] == parent['global_next_tick'],
+                  'Declared global offset disagrees with checkpoint chain')
+    R.require(parent['global_next_tick'] + spec['steps'] <= np.iinfo(np.int64).max, 'Absolute tick overflow')
+    helper, plan, meta, inputs = R.load_overlay(overlay_file, overlay_manifest)
+    R.require(R.digest(overlay_file) == R.digest(parent['directory'] / 'overlay-input.npz') and
+              R.digest(overlay_manifest) == R.digest(parent['directory'] / 'overlay-manifest.json'), 'Retention overlay snapshot/manifest changed')
+    previous = _parent_spec(parent)
+    for key in ('dt_ms', 'model', 'apl', 'apl_delay_steps'):
+        R.require(spec[key] == previous[key], 'Continuation changes frozen dynamics: ' + key)
+    for key in ('graph_dir', 'apl_bundle_dir'):
+        R.require(Path(spec[key]).resolve(strict=True) == Path(previous[key]).resolve(strict=True), 'Continuation changes input directory: ' + key)
+    R.require(R.digest(spec['coefficients_path']) == parent['summary']['input_sha256']['coefficients.json'], 'Continuation coefficients changed')
+    R.require(R.digest(Path(spec['graph_dir']) / 'weights.npy') == parent['summary']['input_sha256']['base_weights.npy'], 'Continuation base weights changed')
+    aj_dir = Path(meta['aj_model_dir']).resolve(strict=True)
+    protected = (aj_dir.parent, Path(meta['am_overlay_path']).resolve().parent, spec['graph_dir'], spec['apl_bundle_dir'],
+                 *parent['ancestry_directories'],
+                 *(Path(path).resolve(strict=True).parent for path in
+                   (overlay_file, overlay_manifest, meta['mask_path'], meta['base_candidate_path'], spec['coefficients_path'])))
+    case_dir, out_dir, build_root = R.execution_paths(case_dir, out_dir, build_root, protected)
+    for path in (case_dir / 'spec.json', case_dir / 'requests.npz', Path(spec['graph_dir']) / 'weights.npy',
+                 Path(spec['coefficients_path']), Path(checkpoint_dir).resolve() / MANIFEST, Path(R.__file__).resolve()):
+        inputs[str(path)] = R.digest(path)
+    source_sha = R.digest(__file__)
+    R._load('timing_queue', aj_dir / 'timing_queue.py', R.PINS['apl-timing-lab-v1/timing_queue.py'])
+    aj = R._load('phase4an_continued_sealed_aj_gpu', aj_dir / 'gpu_timing.py', R.AJ_SHA)
+    runtime = ContinuedRuntime(mode, spec, helper, plan, meta, inputs, aj.torch, overlay_file, overlay_manifest, parent=parent)
+    function, ast_audit = compile_continued(aj, runtime, mode)
+    try:
+        inherited = function(case_dir, out_dir, build_root)
+        R.require(runtime.finished and runtime.restorations == 1 and runtime.installations == 1 and inherited['complete'], 'Incomplete continuation')
+        R.require(inherited['effective_weights_raw_sha256'] == runtime.effective_sha, 'Effective weight identity changed')
+        R.require(source_sha == R.digest(__file__) and all(R.digest(path) == sha for path, sha in inputs.items()), 'Source/input changed during continuation')
+        load_checkpoint(checkpoint_dir, parent_sha)
+        summary = R._read_json(out_dir / 'summary.json')
+        R.require(summary == runtime.summary(inherited), 'Stored continuation summary mismatch')
+        provenance = {'schema': 'phase4an-continuation-runtime-v1', 'complete': True, 'mode': mode,
+                      'source_file': str(Path(__file__).resolve()), 'source_sha256': source_sha, 'fresh_runtime_sha256': LIGHT_SHA,
+                      'ast': ast_audit, 'input_sha256': inputs, 'old_globals_patched': False, 'weights_updated_during_run': False,
+                      'learning_pass_claimed': False, 'global_tick_offset': runtime.global_offset,
+                      'global_next_tick': runtime.global_offset + spec['steps'],
+                      'parent_checkpoint_manifest_sha256': parent_sha}
+        for key, name in (('summary_sha256', 'summary.json'), ('finite_audit_sha256', 'finite-audit.json'),
+                          ('terminal_queues_sha256', 'terminal-queues.npz'), ('overlay_audit_sha256', 'overlay-audit.json'),
+                          ('state_sha256', 'state.npz')):
+            provenance[key] = R.digest(out_dir / name)
+        R._save(out_dir / 'runtime-provenance.json', provenance)
+        receipt = {'schema': 'phase4an-continuation-receipt-v1', 'complete': True,
+                   'parent_checkpoint_dir': str(parent['directory']), 'parent_checkpoint_manifest_sha256': parent_sha,
+                   'global_tick_offset': runtime.global_offset, 'global_next_tick': runtime.global_offset + spec['steps'],
+                   'segment_steps': spec['steps'], 'counts_scope': 'segment_only_not_lifetime',
+                   'payload_sha256': _tree_hashes(out_dir), 'weights_updated_during_run': False,
+                   'clock_admission_edit': CLOCK_NEW, 'checkpoint_continuation_verified_by_GPU_comparison': False}
+        R._save(out_dir / RECEIPT, receipt)
+        sealed = seal_checkpoint(out_dir)
+        return dict(summary, checkpoint_manifest_sha256=sealed['sha256'])
+    except Exception as error:
+        if out_dir.is_dir() and not (out_dir / 'continuation-error.json').exists():
+            R._save(out_dir / 'continuation-error.json', {'complete': False, 'type': type(error).__name__,
+                                                        'message': str(error), 'learning_update_forbidden': True})
+        raise

models/male-cns-lif/olfactory-conditioning-lab-v1/runtime_light.py

@@ -0,0 +1,559 @@
+"""Engineering-only, fixed-weight trial execution derived from frozen AJ AST.
+
+Public APIs run_light(case_dir,out_dir,build_root,overlay_file,overlay_manifest)
+and run_reference(...) have identical arguments. Neither trains nor carries a
+previous trial's neural state. The reference retains AJ's eager diagnostics;
+the light function removes only an explicit diagnostic whitelist. Both accept
+an explicit spec.max_steps instead of AJ's 1000-step admission bound.
+
+The parent protocol owns conditioning, cue/tail schedules, frozen input/mask
+authority and success criteria. A completed trial is not a learning PASS.
+Before any scientific execution, the coordinator must verify externally fixed
+hashes for the entire graph, APL bundle, coefficients/model, and preregistered
+case spec (including max_steps). Inherited AJ consistency checks and this
+adapter's input hashes are not a replacement for those external authorities.
+"""
+from __future__ import annotations
+
+import ast
+import copy
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+import re
+import sys
+
+import numpy as np
+
+
+AJ_SHA = 'af1975ba5e5e700208c0a598d3cbe648a3cf10885c6231239b6e4b28f76d173b'
+AM_OVERLAY_SHA = '7f891d0ba79b393c96e75fd2dee2eddc51e57d8213eaac2779703bc2c18712b4'
+MASK_SHA = '8b0fb6eb2e6c31da4d17dc20d890aa3f367e514f05642de5bad6b42a1611c05b'
+V2_SHA = 'abb4574da85f00bd9ef61024c65993ef81d42651ff8d8d63c15dd69c6222471e'
+PINS = {
+    'apl-timing-lab-v1/gpu_timing.py': AJ_SHA,
+    'apl-timing-lab-v1/timing_queue.py': '54df6d4818e2a0c26e96fb0aaf5d9b71cd964981706da937562d48af79aca14e',
+    'author-apl-lab-v2/gpu_apl.py': '69f5d893f47dafff4ef7c3186c3df0b9014666b32c8f4e943b57016bec92b18a',
+    'author-apl-lab-v2/legacy_apl_worker.py': '21ceec65fe42581dc55872010e0025d660e80358905f1cf4df1dadf341a3b291',
+    'author-runtime-lab-v1/gpu_backend.py': '03758d07572f4b44d272059d9308fac534268ad201b57bdd77d69fee95e67278',
+    'author-runtime-lab-v1/author_ext.cpp': '208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15',
+    'author-runtime-lab-v1/author_ext.cu': '669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e',
+    'author-fullgraph-lab-v1/oracle_full.py': 'd72003d98f0f1624b12126eff50bd361c43d888f4a64d90ba9247a58976f1961',
+}
+_LOADED = {}
+_INSTALL = '_runtime.install(weights, graph, apl_out_mask, upload, out_dir, source_provenance, device)'
+_FINISH = '_runtime.finish(ring, apl_ring, apl, steps, out_dir)'
+_MATH_TARGETS = frozenset(('indptr', 'dst', 'global_nodes_gpu', 'base_weights', 'weights',
+    'local_apl', 'apl_out_mask', 'common_kc', 'local_kc', 'full_kc', 'kc_local_gpu', 'kc_full_gpu',
+    'v', 'g', 'ref', 'counts', 'requests', 'ring', 'apl_delay', 'apl_ring', 'requested_local_gpu',
+    'spikes', 'due', 'sources', 'degrees', 'offsets', 'edge_count', 'expanded', 'destination',
+    'order', 'ordered_edges', 'ordered_targets', 'boundary', 'starts', 'targets', 'full_spikes',
+    'drive', 'apl_state', 'h', 'slot', 'applied_h', 'delta_si'))
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+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 _read_json(path):
+    def pairs(items):
+        out = {}
+        for key, value in items:
+            require(key not in out, 'Duplicate JSON key: ' + key)
+            out[key] = value
+        return out
+    return json.loads(Path(path).read_text(encoding='utf-8'), object_pairs_hook=pairs,
+                      parse_constant=lambda value: (_ for _ in ()).throw(ValueError('Nonfinite JSON: ' + value)))
+
+
+def _save(path, value):
+    with Path(path).open('x', encoding='utf-8') as stream:
+        json.dump(value, stream, sort_keys=True, indent=2, allow_nan=False)
+        stream.write('\n')
+
+
+def _raw(value):
+    return hashlib.sha256(np.ascontiguousarray(value, dtype=value.dtype.newbyteorder('<')).tobytes()).hexdigest()
+
+
+def _sha(value):
+    return isinstance(value, str) and re.fullmatch('[0-9a-f]{64}', value) is not None
+
+
+def _load(name, path, expected):
+    path = Path(path).absolute()
+    raw = path.read_bytes()
+    require(hashlib.sha256(raw).hexdigest() == expected, 'Unpinned source: ' + str(path))
+    if name in sys.modules:
+        module = sys.modules[name]
+        require(_LOADED.get(name) == (path, expected, module), 'Existing unverified module binding: ' + name)
+        return module
+    spec = importlib.util.spec_from_file_location(name, path)
+    require(spec is not None and spec.loader is not None, 'Missing module loader')
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    try:
+        exec(compile(raw, str(path), 'exec'), module.__dict__)
+    except BaseException:
+        sys.modules.pop(name, None)
+        raise
+    _LOADED[name] = (path, expected, module)
+    return module
+
+
+def validate_spec(spec, case_dir):
+    """Admission policy only. No implicit early stopping or checkpoint support."""
+    require(type(spec.get('max_steps')) is int and 0 < spec['max_steps'] <= np.iinfo(np.int32).max,
+            'An explicit positive int32-range max_steps is mandatory')
+    require(type(spec.get('steps')) is int and 0 < spec['steps'] <= spec['max_steps'], 'steps exceeds its declared bound')
+    require(spec.get('dt_ms') == .1 and spec.get('duration_ms') == spec['steps'] * .1 and
+            type(spec.get('apl_delay_steps')) is int and spec['apl_delay_steps'] == 18,
+            'Frozen clock/duration/D18 contract changed')
+    require(spec.get('record_history') is False, 'Only wholebrain fresh-state trials are supported')
+    require(not (Path(case_dir) / 'arrays.npz').exists(), 'Initial arrays/checkpoint continuation are not supported in this version')
+    require(not any('checkpoint' in str(key).lower() or str(key) in ('initial_state', 'resume', 'continuation') for key in spec),
+            'Checkpoint/continuation configuration is unsupported')
+    require(spec.get('within_trial_weight_updates', False) is False, 'No within-trial plasticity is supported')
+    return spec
+
+
+def load_overlay(overlay_file, manifest_file):
+    """New manifest policy, frozen AM array validators; no old-global mutation.
+
+    phase4an-overlay-v1 requires overlay_name zero/static25/learned,
+    overlay_sha256, original mask_path/mask_sha256, external positive f32-mV
+    base_candidate_path/base_candidate_sha256, aj_model_dir,
+    am_overlay_path/am_overlay_sha256. Learned snapshots additionally require
+    parent_snapshot_sha256 and eligibility_v2_source_sha256=the frozen 4J pin.
+    These hashes bind provenance; the coordinator must verify the parent chain.
+    NPZ contains ONLY edge_id:int64[14232], plastic_delta_mv:float32[14232].
+    """
+    overlay_file, manifest_file = Path(overlay_file).absolute(), Path(manifest_file).absolute()
+    manifest_sha = digest(manifest_file)
+    meta = _read_json(manifest_file)
+    keys = {'schema', 'overlay_name', 'overlay_sha256', 'mask_path', 'mask_sha256',
+            'base_candidate_path', 'base_candidate_sha256', 'aj_model_dir', 'am_overlay_path', 'am_overlay_sha256'}
+    require(isinstance(meta, dict) and keys <= meta.keys() and meta['schema'] == 'phase4an-overlay-v1', 'Invalid overlay manifest schema')
+    require(meta['overlay_name'] in ('zero', 'static25', 'learned'), 'Unknown overlay snapshot type')
+    learned_keys = {'parent_snapshot_sha256', 'eligibility_v2_source_sha256'}
+    allowed = keys | (learned_keys if meta['overlay_name'] == 'learned' else set())
+    require(not (meta.keys() - allowed), 'Unknown or inapplicable overlay manifest fields')
+    require(meta['mask_sha256'] == MASK_SHA and meta['am_overlay_sha256'] == AM_OVERLAY_SHA,
+            'Original mask or frozen AM helper authority changed')
+    require(_sha(meta['overlay_sha256']) and digest(overlay_file) == meta['overlay_sha256'], 'Overlay SHA mismatch')
+    inputs = {str(overlay_file): meta['overlay_sha256'], str(manifest_file): manifest_sha}
+    for label in ('mask', 'base_candidate', 'am_overlay'):
+        path = Path(meta[label + '_path'])
+        require(path.is_absolute() and _sha(meta[label + '_sha256']) and digest(path) == meta[label + '_sha256'],
+                'Missing/mismatched anchored input: ' + label)
+        inputs[str(path)] = meta[label + '_sha256']
+    helper = _load('phase4an_sealed_am_overlay', meta['am_overlay_path'], AM_OVERLAY_SHA)
+    mask = np.load(meta['mask_path'], allow_pickle=False)
+    base = np.load(meta['base_candidate_path'], allow_pickle=False)
+    require(mask.dtype == np.int64 and mask.shape == (helper.CANDIDATE_COUNT,), 'Original complete 14,232 mask is required')
+    with np.load(overlay_file, allow_pickle=False) as archive:
+        require(len(archive.files) == 2 and set(archive.files) == {'edge_id', 'plastic_delta_mv'}, 'No embedded base or additional overlay arrays allowed')
+        plan = helper.validate_arrays(archive['edge_id'], archive['plastic_delta_mv'], mask, base)
+    delta = plan['plastic_delta_mv']
+    if meta['overlay_name'] == 'zero':
+        require(not np.any(delta != 0), 'Zero snapshot contains a nonzero delta')
+    elif meta['overlay_name'] == 'static25':
+        require(helper.bit_equal(delta, np.multiply(np.float32(-.25), base)), 'static25 must equal the original f32 floor')
+    else:
+        require(_sha(meta.get('parent_snapshot_sha256')) and meta.get('eligibility_v2_source_sha256') == V2_SHA,
+                'Learned snapshot needs parent hash and explicit frozen eligibility-v2 authority')
+    aj_dir = Path(meta['aj_model_dir'])
+    require(aj_dir.is_absolute() and aj_dir.name == 'apl-timing-lab-v1', 'AJ must use its real original directory')
+    for relative, expected in PINS.items():
+        path = aj_dir.parent / relative
+        require(digest(path) == expected, 'Sealed dependency changed: ' + relative)
+        inputs[str(path)] = expected
+    require(all(digest(path) == expected for path, expected in inputs.items()), 'Input changed while loading')
+    return helper, plan, meta, inputs
+
+
+def _dump(node):
+    return ast.dump(node, annotate_fields=True, include_attributes=False)
+
+
+def _target_roots(node):
+    if isinstance(node, ast.Name):
+        return {node.id}
+    if isinstance(node, (ast.Tuple, ast.List)):
+        return set().union(*(_target_roots(value) for value in node.elts))
+    if isinstance(node, (ast.Subscript, ast.Attribute)):
+        return _target_roots(node.value)
+    return set()
+
+
+def math_projection(function):
+    """Ordered/control-structured frozen math statements, excluding diagnostics.
+
+    Whitelist explicitly covers state/weight initialization, request mutation,
+    expansion/stable grouping, original CUDA calls, LegacyAPL and ring/g write.
+    Tests also require the entire reference loop AST to equal the original.
+    """
+    def block(statements):
+        result = []
+        for node in statements:
+            if isinstance(node, ast.FunctionDef) and node.name == 'upload':
+                result.append(copy.deepcopy(node))
+            elif isinstance(node, ast.Assign) and set().union(*(_target_roots(t) for t in node.targets)) & _MATH_TARGETS:
+                result.append(copy.deepcopy(node))
+            elif isinstance(node, ast.Expr) and isinstance(node.value, ast.Call):
+                text = ast.unparse(node.value.func)
+                if text.startswith('ext.') or text in ('requests.zero_', 'apl.spikes.zero_', 'apl_ring[slot].copy_'):
+                    result.append(copy.deepcopy(node))
+            elif isinstance(node, (ast.With, ast.Try)):
+                result.extend(block(node.body))
+            elif isinstance(node, (ast.If, ast.For)):
+                body, other = block(node.body), block(node.orelse)
+                if body or other:
+                    keep = copy.deepcopy(node)
+                    keep.body, keep.orelse = body, other
+                    result.append(keep)
+        return result
+    return _dump(ast.Module(body=block(function.body), type_ignores=[]))
+
+
+def derive_ast(source_bytes, mode):
+    """Derive only from exact AJ bytes; return ASTs plus an explicit edit receipt."""
+    require(mode in ('light', 'reference'), 'Unknown diagnostic mode')
+    require(hashlib.sha256(source_bytes).hexdigest() == AJ_SHA, 'AJ source pin mismatch')
+    source = ast.parse(source_bytes)
+    original = next(node for node in source.body if isinstance(node, ast.FunctionDef) and node.name == 'run_gpu')
+    loader = copy.deepcopy(next(node for node in source.body if isinstance(node, ast.FunctionDef) and node.name == 'load_inputs'))
+    bounds = [node for node in ast.walk(loader) if isinstance(node, ast.Compare) and
+              ast.unparse(node) == '0 < steps <= 1000']
+    require(len(bounds) == 1, 'Expected one explicit step-admission bound')
+    bounds[0].comparators[-1] = ast.parse("spec['max_steps']", mode='eval').body
+    function = copy.deepcopy(original)
+    body = next(node for node in function.body if isinstance(node, ast.Try)).body
+    anchor = next(i for i, node in enumerate(body) if ast.unparse(node) == 'effective_hash = hashlib.sha256()')
+    require(ast.unparse(body[anchor - 1]) == 'if bool(np.any(apl_out_mask)):\n    weights[upload(apl_out_mask, torch.bool)] = 0.0',
+            'Installation no longer follows APL fast-edge zeroing')
+    body.insert(anchor, ast.parse(_INSTALL).body[0])
+    sync = [i for i, node in enumerate(body) if ast.unparse(node) == 'torch.cuda.synchronize(device)']
+    require(len(sync) == 1, 'Expected one post-loop synchronization')
+    body.insert(sync[0] + 1, ast.parse(_FINISH).body[0])
+    removed, replacements = [], []
+
+    class ReportingOnly(ast.NodeTransformer):
+        def note(self, node):
+            removed.append(_dump(node))
+            return None
+
+        def visit_Assign(self, node):
+            names = set().union(*(_target_roots(t) for t in node.targets))
+            if names & {'expanded_global', 'accepted_cpu', 'queue', 'apl_cpu', 'actual', 'finite', 'row'}:
+                return self.note(node)
+            if names == {'maps'} and isinstance(node.targets[0], ast.Subscript):
+                return self.note(node)
+            if names == {'timing'}:
+                require(ast.unparse(node.value.func) == 'audit_sequence', 'Unexpected timing assignment')
+                replacements.append(_dump(node))
+                return ast.parse('timing = _runtime.timing(steps, pending)').body[0]
+            if names == {'destination'}:
+                return [node, ast.parse('_runtime.arrivals(expanded, destination, ref)').body[0]]
+            if ast.unparse(node) == 'g[kc_local_gpu] = g[kc_local_gpu] - delta_si':
+                return [node, ast.parse('_runtime.after_tick(tick, v, g, ref, drive, apl_state, h, applied_h)').body[0]]
+            return node
+
+        def visit_AugAssign(self, node):
+            if _target_roots(node.target) & {'due_total', 'accepted_due_total'}:
+                return self.note(node)
+            return node
+
+        def visit_For(self, node):
+            text = ast.unparse(node.iter)
+            if text in ("(('drive', 2), ('state', 2), ('inhibition', 4064))", 'apl_cpu.items()', 'actual.items()'):
+                return self.note(node)
+            return self.generic_visit(node)
+
+        def visit_If(self, node):
+            if ast.unparse(node.test) in ("spec['record_history']", 'not finite'):
+                return self.note(node)
+            return self.generic_visit(node)
+
+        def visit_Expr(self, node):
+            if isinstance(node.value, ast.Call) and ast.unparse(node.value.func) in ('queue_output.write', 'hash_output.write'):
+                return self.note(node)
+            return node
+
+        def visit_With(self, node):
+            targets = [getattr(item.optional_vars, 'id', None) for item in node.items]
+            if targets == ['queue_output', 'hash_output', 'request_output']:
+                replacements.append(_dump(node.items[0])); replacements.append(_dump(node.items[1]))
+                node.items = [node.items[-1]]
+            return self.generic_visit(node)
+
+    if mode == 'light':
+        function = ReportingOnly().visit(function)
+        require(len(removed) == 20 and len(replacements) == 3, 'Reporting whitelist changed; stop instead of broad rewriting')
+    loops = lambda f: [node for node in ast.walk(f) if isinstance(node, ast.For) and
+                      isinstance(node.target, ast.Name) and node.target.id == 'tick']
+    require(len(loops(original)) == len(loops(function)) == 1, 'Missing/duplicated trial loop')
+    if mode == 'reference':
+        require(_dump(loops(original)[0]) == _dump(loops(function)[0]), 'Reference loop must stay entirely unchanged')
+    original_math, derived_math = math_projection(original), math_projection(function)
+    require(original_math == derived_math, 'Ordered mathematical AST changed')
+    extra_calls = [ast.unparse(node) for node in ast.walk(function) if isinstance(node, ast.Call) and
+                   ast.unparse(node.func).startswith('_runtime.')]
+    expected_calls = [_INSTALL, _FINISH]
+    if mode == 'light':
+        expected_calls += ['_runtime.arrivals(expanded, destination, ref)',
+            '_runtime.after_tick(tick, v, g, ref, drive, apl_state, h, applied_h)',
+            '_runtime.timing(steps, pending)']
+    require(sorted(extra_calls) == sorted(expected_calls), 'Unlisted runtime callback added')
+    tree = ast.fix_missing_locations(ast.Module(body=[loader, function], type_ignores=[]))
+    sha = lambda value: hashlib.sha256(value.encode('utf-8')).hexdigest()
+    receipt = {'mode': mode, 'aj_source_sha256': AJ_SHA, 'math_ast_sha256': sha(original_math),
+        'derived_math_ast_sha256': sha(derived_math), 'mathematical_ast_identical': True,
+        'reference_entire_tick_loop_identical': mode == 'reference',
+        'admission_edit': '0 < steps <= 1000 -> 0 < steps <= spec.max_steps',
+        'pre_loop_installation': _INSTALL, 'post_loop_terminal_recording': _FINISH,
+        'added_runtime_callbacks': extra_calls,
+        'removed_diagnostic_statements': removed, 'replaced_diagnostic_nodes': replacements,
+        'derived_module_ast_sha256': sha(_dump(tree)), 'old_globals_patched': False}
+    return tree, receipt
+
+
+class FiniteObserver:
+    """GPU scalar diagnostics only; never writes a neuronal/APL input tensor."""
+    def __init__(self, torch, device):
+        self.torch = torch
+        self.ok = torch.ones((), device=device, dtype=torch.bool)
+        self.first = torch.full((), -1, device=device, dtype=torch.int64)
+        self.accepted = torch.zeros((), device=device, dtype=torch.int64)
+        self.due = 0
+        self.ticks = 0
+
+    def arrivals(self, expanded, destination, ref):
+        self.due += expanded.numel()
+        self.accepted.add_((ref[destination.long()] == 0).to(self.torch.int64).sum())
+
+    def observe(self, tick, *values):
+        require(tick == self.ticks, 'Finite observer tick coverage changed')
+        finite = self.torch.ones_like(self.ok)
+        for value in values:
+            finite.logical_and_(self.torch.isfinite(value).all())
+        self.first = self.torch.where((self.first < 0) & (~finite), self.torch.full_like(self.first, tick), self.first)
+        self.ok.logical_and_(finite)
+        self.ticks += 1
+
+    def result(self):
+        return {'all_finite': bool(self.ok.item()), 'first_failure_tick': int(self.first.item()),
+                'finite_observed_ticks': self.ticks, 'arriving_edges': self.due,
+                'accepted_arriving_edges': int(self.accepted.item())}
+
+
+def _copy_input(source, target, expected):
+    with Path(source).open('rb') as src, Path(target).open('xb') as dst:
+        for block in iter(lambda: src.read(8 << 20), b''):
+            dst.write(block)
+    require(digest(target) == expected, 'Copied input differs')
+
+
+class _Runtime:
+    def __init__(self, mode, spec, helper, plan, meta, inputs, torch, overlay_file, manifest_file):
+        self.mode, self.spec, self.helper, self.plan, self.meta, self.inputs = mode, spec, helper, plan, meta, inputs
+        self.torch, self.overlay_file, self.manifest_file = torch, Path(overlay_file).absolute(), Path(manifest_file).absolute()
+        self.observer = None
+        self.installations = 0
+        self.finished = False
+        self.result = None
+
+    def install(self, weights, graph, apl_mask, upload, out_dir, inherited, device):
+        require(self.installations == 0, 'Repeated installation is forbidden')
+        require(len(graph['nodes']) == 166700 and len(graph['edge_id']) == self.helper.EDGE_COUNT,
+                'Only the intact full graph is permitted')
+        require(int(apl_mask.sum()) == 5845, 'Original fast APL mask changed')
+        mapping = self.helper.map_installation(graph['weights'], graph['edge_id'], apl_mask, self.plan)
+        require(mapping['missing_candidate_count'] == 0, 'All original candidates must be present')
+        rows = mapping['rows']
+        if len(rows):
+            index = upload(rows, self.torch.int64)
+            nonzero = self.plan['plastic_delta_mv'] != np.float32(0)
+            change = upload(self.plan['plastic_delta_mv'][nonzero], self.torch.float64) * 0.001
+            weights[index] = weights[index] + change
+            require(self.helper.bit_equal(weights[index].cpu().numpy(), mapping['expected_si']), 'Independent SI installation mismatch')
+        raw_base, expected = self.helper.expected_hashes(graph['weights'], apl_mask, mapping)
+        actual = hashlib.sha256()
+        for start in range(0, weights.numel(), 1 << 20):
+            actual.update(weights[start:start + (1 << 20)].cpu().numpy().astype('<f8', copy=False).tobytes())
+        require(actual.hexdigest() == expected, 'Effective weight bytes differ from declared overlay')
+        self.effective_sha = expected
+        self.observer = FiniteObserver(self.torch, device)
+        self.installations += 1
+        _copy_input(self.overlay_file, out_dir / 'overlay-input.npz', self.meta['overlay_sha256'])
+        _copy_input(self.manifest_file, out_dir / 'overlay-manifest.json', self.inputs[str(self.manifest_file)])
+        _save(out_dir / 'overlay-audit.json', {'schema': 'phase4an-overlay-install-v1', 'complete': True,
+            'overlay_name': self.meta['overlay_name'], 'candidate_count': len(self.plan['edge_id']),
+            'nonzero_delta_count': len(rows), 'am_helper_sha256': AM_OVERLAY_SHA, 'mask_sha256': MASK_SHA,
+            'base_candidate_sha256': self.meta['base_candidate_sha256'], 'delta_raw_sha256': _raw(self.plan['plastic_delta_mv']),
+            'base_weights_raw_sha256': raw_base, 'effective_weights_raw_sha256': expected,
+            'delta_dtype': 'float32', 'delta_units': 'mV', 'state_dtype': 'float64', 'bridge': self.helper.BRIDGE,
+            'zero_rows_untouched': True, 'weights_updated_during_run': False, 'apl_fast_edges_zeroed': int(apl_mask.sum()),
+            'parent_snapshot_sha256': self.meta.get('parent_snapshot_sha256'),
+            'eligibility_v2_source_sha256': self.meta.get('eligibility_v2_source_sha256'),
+            'parent_chain_verified_by_runtime': False, 'inherited_AJ_provenance_only': inherited})
+
+    def arrivals(self, expanded, destination, ref):
+        self.observer.arrivals(expanded, destination, ref)
+
+    def after_tick(self, tick, v, g, ref, drive, state, h, applied):
+        self.observer.observe(tick, v, g, ref, drive, state, h, applied)
+
+    def finish(self, ring, apl_ring, apl, steps, out_dir):
+        require(not self.finished and self.installations == 1, 'Invalid terminal recording sequence')
+        if self.mode == 'light':
+            self.result = self.observer.result()
+            require(self.result['finite_observed_ticks'] == steps, 'Missing finite checks')
+        else:
+            # Reaching this point means AJ's original per-tick finite check passed.
+            self.result = {'all_finite': True, 'first_failure_tick': -1, 'finite_observed_ticks': steps}
+        _save(out_dir / 'finite-audit.json', dict(self.result, mode=self.mode,
+            scope='every completed tick; no neuronal or APL tensor mutated by observer'))
+        raw_ring, raw_apl = ring.cpu().numpy().copy(), apl_ring.cpu().numpy().copy()
+        head = steps % len(raw_apl)
+        pending = np.concatenate((raw_apl[head:], raw_apl[:head]), axis=0)
+        apl_state = apl.state.cpu().numpy().copy()
+        require(raw_ring.dtype == np.uint8 and raw_ring.shape == (19, 166700) and
+                apl_state.dtype == pending.dtype == np.float32 and apl_state.shape == (2,) and pending.shape == (18, 4064),
+                'Terminal queue dtype/shape changed')
+        with (out_dir / 'terminal-queues.npz').open('xb') as target:
+            np.savez_compressed(target, spike_ring=raw_ring, apl_state=apl_state, apl_pending=pending,
+                                next_tick=np.asarray(steps, dtype=np.int64))
+        self.finished = True
+        require(self.result['all_finite'], 'Nonfinite value observed; trial is invalid and must not produce a learning update')
+
+    def timing(self, steps, pending):
+        return {'apl_delay_steps': 18, 'steps': steps, 'pending_generated_count': min(steps, 18),
+            'pending_initial_zero_prefix': max(18 - steps, 0), 'brain_tail_advanced': False,
+            'full_sequence_bitwise_audit_performed': False,
+            'scope': 'Original D18 ring AST retained; generated/applied histories not recorded'}
+
+    def summary(self, value):
+        result = dict(value)
+        result.pop('learning', None)
+        result.update(diagnostic_mode=self.mode, within_trial_weight_updates=False,
+            outer_protocol=self.spec.get('outer_protocol'), outer_learning_status='not evaluated by this single-trial executor',
+            learning_pass_claimed=False, checkpoint_continuation_used=False,
+            max_steps=self.spec['max_steps'], explicit_steps_executed=self.spec['steps'],
+            entire_neural_trial_executed=True, hidden_early_stop=False,
+            full_APL_history_recorded=self.mode == 'reference', full_tick_state_hashes_recorded=self.mode == 'reference',
+            full_queue_hashes_recorded=self.mode == 'reference',
+            full_sequence_bitwise_audit_performed=self.mode == 'reference',
+            first_failure_tick=self.result['first_failure_tick'],
+            pass_all_scope='single fixed-weight trial finite/recording integrity only; no learning or equivalence claim')
+        if self.mode == 'light':
+            result.update(arriving_edges=self.result['arriving_edges'], accepted_arriving_edges=self.result['accepted_arriving_edges'])
+            if 'apl_timing' in result:
+                result['apl_timing'] = dict(result['apl_timing'], generated_trace=None, applied_trace=None,
+                                            full_sequence_bitwise_audit_performed=False)
+        return result
+
+    def write_json(self, path, value):
+        path = Path(path)
+        if path.name == 'summary.json':
+            value = self.summary(value)
+        elif path.name == 'apl-timing-audit.json' and self.mode == 'light':
+            value = dict(value)
+            value.update(generated_trace=None, applied_trace=None, full_sequence_bitwise_audit_performed=False)
+        _save(path, value)
+
+
+def compile_runtime(aj_module, runtime, mode):
+    """Fresh namespace; __file__ is this real adapter, not a disguised old file."""
+    tree, audit = derive_ast(Path(aj_module.__file__).read_bytes(), mode)
+    namespace = dict(aj_module.__dict__)
+    namespace.update(__name__=__name__ + '.derived_' + mode, __file__=str(Path(__file__).absolute()),
+                     _runtime=runtime, write_json=runtime.write_json)
+    exec(compile(tree, str(Path(__file__).absolute()) + '::AJ-AST-' + mode, 'exec'), namespace)
+    audit.update(derived_namespace_file=namespace['__file__'], original_module_file=str(Path(aj_module.__file__).absolute()),
+        output_metadata_binding='new write_json only labels recording/within-trial scope; no old global mutated')
+    return namespace['run_gpu'], audit
+
+
+def execution_paths(case_dir, out_dir, build_root, protected=()):
+    """Resolve directory aliases before containment checks, without any writes.
+
+    Only data/source/output directories are canonicalized here. This helper
+    must not be used for a Python executable: resolving a venv entry changes
+    interpreter semantics. The coordinator must keep input paths stable during
+    execution; this is not a defense against concurrent filesystem mutation.
+    """
+    case_dir = Path(case_dir).resolve(strict=True)
+    require(case_dir.is_dir(), 'Input case must be an existing directory')
+    out_dir, build_root = (Path(path).resolve(strict=False) for path in (out_dir, build_root))
+    require(not out_dir.exists(), 'Output must be a new directory')
+    require(not build_root.exists() or build_root.is_dir(), 'Build cache must be a directory')
+    roots = [case_dir]
+    for path in protected:
+        root = Path(path).resolve(strict=True)
+        require(root.is_dir(), 'Protected input/source root must be a directory')
+        roots.append(root)
+    require(not any(out_dir.is_relative_to(root) or build_root.is_relative_to(root) for root in roots),
+            'Output/build paths cannot write into frozen source or input directories')
+    return case_dir, out_dir, build_root
+
+
+def _run(mode, case_dir, out_dir, build_root, overlay_file, overlay_manifest):
+    require(sys.dont_write_bytecode, 'Use python -B; frozen dependencies must not receive bytecode writes')
+    case_dir, out_dir, build_root = execution_paths(case_dir, out_dir, build_root)
+    spec = validate_spec(_read_json(case_dir / 'spec.json'), case_dir)
+    helper, plan, meta, inputs = load_overlay(overlay_file, overlay_manifest)
+    own_sha = digest(__file__)
+    inputs[str(case_dir / 'spec.json')] = digest(case_dir / 'spec.json')
+    inputs[str(case_dir / 'requests.npz')] = digest(case_dir / 'requests.npz')
+    inputs[str(Path(spec['graph_dir']) / 'weights.npy')] = digest(Path(spec['graph_dir']) / 'weights.npy')
+    aj_dir = Path(meta['aj_model_dir']).resolve(strict=True)
+    protected = (aj_dir.parent, Path(meta['am_overlay_path']).resolve(strict=True).parent,
+                 Path(spec['graph_dir']), Path(spec['apl_bundle_dir']),
+                 *(Path(path).resolve(strict=True).parent for path in
+                   (overlay_file, overlay_manifest, meta['mask_path'], meta['base_candidate_path'], spec['coefficients_path'])))
+    case_dir, out_dir, build_root = execution_paths(case_dir, out_dir, build_root, protected)
+    _load('timing_queue', aj_dir / 'timing_queue.py', PINS['apl-timing-lab-v1/timing_queue.py'])
+    aj = _load('phase4an_sealed_aj_gpu', aj_dir / 'gpu_timing.py', AJ_SHA)
+    runtime = _Runtime(mode, spec, helper, plan, meta, inputs, aj.torch, overlay_file, overlay_manifest)
+    function, ast_audit = compile_runtime(aj, runtime, mode)
+    try:
+        inherited = function(case_dir, out_dir, build_root)
+        require(runtime.finished and runtime.installations == 1 and inherited['complete'], 'Incomplete single-trial execution')
+        require(inherited['effective_weights_raw_sha256'] == runtime.effective_sha, 'Effective weight identity changed during trial')
+        require(digest(__file__) == own_sha and all(digest(path) == expected for path, expected in inputs.items()),
+                'Source or input changed during execution')
+        summary = _read_json(out_dir / 'summary.json')
+        require(summary == runtime.summary(inherited), 'Stored summary does not bind actual trial')
+        _save(out_dir / 'runtime-provenance.json', {'schema': 'phase4an-reporting-adapter-v1', 'complete': True,
+            'source_file': str(Path(__file__).absolute()), 'source_sha256': own_sha, 'mode': mode, 'ast': ast_audit,
+            'input_sha256': inputs, 'old_globals_patched': False, 'math_changed': False,
+            'admission_bound_changed_explicitly': True, 'weights_updated_during_run': False,
+            'learning_pass_claimed': False, 'parent_chain_verification_owned_by_coordinator': True,
+            'summary_sha256': digest(out_dir / 'summary.json'), 'finite_audit_sha256': digest(out_dir / 'finite-audit.json'),
+            'terminal_queues_sha256': digest(out_dir / 'terminal-queues.npz'),
+            'overlay_audit_sha256': digest(out_dir / 'overlay-audit.json')})
+        return summary
+    except Exception as error:
+        if out_dir.is_dir() and not (out_dir / 'runtime-error.json').exists():
+            _save(out_dir / 'runtime-error.json', {'complete': False, 'type': type(error).__name__, 'message': str(error),
+                                                'learning_update_forbidden': True})
+        raise
+
+
+def run_light(case_dir, out_dir, build_root, overlay_file, overlay_manifest):
+    return _run('light', case_dir, out_dir, build_root, overlay_file, overlay_manifest)
+
+
+def run_reference(case_dir, out_dir, build_root, overlay_file, overlay_manifest):
+    return _run('reference', case_dir, out_dir, build_root, overlay_file, overlay_manifest)

models/male-cns-lif/olfactory-conditioning-lab-v1/test_engineering_analysis.py

@@ -0,0 +1,227 @@
+"""Synthetic/mocked dispatch + temporary-array tests; no GPU or brain runs."""
+import copy
+from contextlib import ExitStack
+import hashlib
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import Mock, patch
+
+import numpy as np
+
+import engineering_analysis as a
+import engineering_plan as p
+
+
+PIN = 'a' * 64
+WEIGHT = 'b' * 64
+
+
+def raw(value):
+    return hashlib.sha256(value.tobytes()).hexdigest()
+
+
+def record(row):
+    n, k, steps, start = 3, 2, row['steps'], row['start']
+    state = dict(step=np.empty(0, np.int32), neuron_idx=np.empty(0, np.int32), counts=np.zeros(n, np.int32),
+                 v=np.zeros(n, np.float64), g=np.zeros(n, np.float64), ref=np.zeros(n, np.int32))
+    reference = row['mode'] == 'reference'
+    summary = dict(complete=True, pass_all=True, all_finite=True, counts_match_sparse_events=True,
+        steps=steps, completed_ticks=steps, nodes=n, edges=3, requested=0, total_spikes=0, accepted_requests=0,
+        rejected_requests=0, arriving_edges=0, accepted_arriving_edges=0, apl_fast_edges_zeroed=1, kc_targets_present=k,
+        precision='float64', apl_precision='float32', apl_delay_steps=18, diagnostic_mode=row['mode'],
+        effective_weights_raw_sha256=WEIGHT, within_trial_weight_updates=False, learning_pass_claimed=False,
+        checkpoint_continuation_used=start > 0, global_tick_offset=start, global_next_tick=start + steps,
+        wall_seconds=1., diagnostic_simulation_seconds=.5, build_or_cache_seconds=.2,
+        peak_allocated_vram_bytes=1000, peak_reserved_vram_bytes=2000)
+    return dict(source=row['row_id'], state=state, steps=steps, global_tick_offset=start, summary=summary,
+        terminal=dict(spike_ring=np.zeros((19, n), np.uint8), apl_state=np.zeros(2, np.float32),
+                      apl_pending=np.zeros((18, k), np.float32), next_tick=np.asarray(steps, np.int64)),
+        requests=np.empty((0, 5), np.int64),
+        traces={name: np.zeros((steps, 2), np.float32) for name in a.compare.TRACE_FILES} if reference else {},
+        state_hashes=[dict(tick=t, v_sha256=raw(state['v']), g_sha256=raw(state['g']), ref_sha256=raw(state['ref'])) for t in range(steps)] if reference else None,
+        queues=[dict(tick=t, count=0, accepted_count=0, ordered_edge_sha256='c' * 64,
+                     accepted_mask_sha256='c' * 64, joint_sha256='d' * 64) for t in range(steps)] if reference else None)
+
+
+def fixture():
+    plan = p.build_plan(); exp = Path(tempfile.gettempdir()).resolve() / 'synthetic-project' / 'experiments/phase4an-engineering-validation'
+    reg = dict(schema='phase4an-engineering-registration-v1', plan=plan, training=False,
+        cases={r['row_id']: dict(case_dir=str(exp / 'cases' / r['row_id'])) for r in plan['rows']},
+        source_sha256={}, input_sha256={}, selected_case=dict(AM_outputs={'zero': 'mock', 'static25': 'mock'}),
+        overlays={'zero': {}, 'static25': {}})
+    verified = {r['row_id']: dict(schema='phase4an-engineering-runtime-record-v1', complete=True, training=False,
+        row=copy.deepcopy(r), registration_sha256=PIN, checkpoint_manifest_sha256=PIN,
+        runtime_and_immediate_seal_wall_seconds=2., storage={'state.npz': {'file_bytes': 10}, 'terminal-queues.npz': {'file_bytes': 20}})
+        for r in plan['rows']}
+    records = {r['row_id']: record(r) for r in plan['rows']}
+    reader = Mock(); reader.finish.return_value = []; reader.close.return_value = None
+    context = dict(reader=reader, records=records,
+        legacy={stage: record(next(r for r in plan['rows'] if r['overlay'] == stage and r['kind'] == 'fresh' and r['mode'] == 'reference')) for stage in p.OVERLAYS},
+        graph=dict(ptr=np.array([0, 1, 2, 3], np.int64), dst=np.array([1, 2, 0], np.int32), edge_id=np.arange(3, dtype=np.int64)),
+        requests=dict(tick=np.empty(0, np.int32), neuron_idx=np.empty(0, np.int32)), storage={r['row_id']: 600 for r in plan['rows']})
+    return reg, verified, context
+
+
+class Orchestration(unittest.TestCase):
+    def mocked(self, reg, verified, context, *, fail=None, live=True, queue_exact=True, joint=True):
+        calls = []
+        def ordinary(name):
+            def f(*args):
+                calls.append(name)
+                return dict(numerical_exact=name != fail, checks={}, observed_scope={'mock_only': True})
+            return f
+        def chain(mono, parts):
+            calls.append('chain_exact')
+            reference = mono['summary']['diagnostic_mode'] == 'reference'
+            return dict(numerical_exact=fail != ('reference_chain' if reference else 'light_chain'),
+                pass_all=reference and live, nonvacuous_temporal_coverage=reference and live,
+                status='PASS' if reference else 'INCOMPLETE-COVERAGE',
+                coverage={'carried_APL_nonzero_applied_values': 1 if live and reference else 0,
+                          'boundaries': [{'pending_source_spike_events': 1, 'carried_APL_nonzero_pending_values': 1 if joint else 0}]} if reference else None)
+        with ExitStack() as stack:
+            for name, value in dict(N=3, E=3, K=2, FAST_APL_EDGES=1).items():
+                stack.enter_context(patch.object(a, name, value))
+            stack.enter_context(patch.object(a, '_load_context', return_value=context))
+            stack.enter_context(patch.object(a, '_materialize', return_value=(np.ones(3, np.float64), {'effective_weights_raw_sha256': WEIGHT})))
+            stack.enter_context(patch.object(a.compare, 'compare_fresh', side_effect=ordinary('fresh')))
+            stack.enter_context(patch.object(a.scopes, 'compare_slice', side_effect=ordinary('slice')))
+            stack.enter_context(patch.object(a.scopes, 'compare_checkpoint', side_effect=ordinary('checkpoint')))
+            stack.enter_context(patch.object(a.scopes, 'compare_parent_carry', side_effect=ordinary('carry')))
+            stack.enter_context(patch.object(a, '_pair', side_effect=ordinary('pair')))
+            stack.enter_context(patch.object(a.compare, 'compare_segments', side_effect=chain))
+            queue_mock = stack.enter_context(patch.object(a.queue_audit, 'audit_queues', return_value=dict(
+                queue_ref_request_exact=queue_exact, accepted_nonzero_crossing_witness_verified=live and queue_exact)))
+            result = a.analyze(reg, PIN, verified)
+        return result, calls, queue_mock
+
+    def test_executes_all_descriptors_and_both_independent_queues(self):
+        reg, verified, ctx = fixture()
+        report, calls, queued = self.mocked(reg, verified, ctx)
+        expected = [r['row_id'] + '/' + str(i) for r in reg['plan']['rows'] for i, _ in enumerate(r['expected_comparisons'])]
+        self.assertEqual([r['descriptor_id'] for r in report['comparisons']], expected)
+        self.assertEqual(len(calls), len(expected))
+        self.assertEqual(report['evaluated_comparisons'], 74)
+        self.assertEqual(queued.call_count, 2)
+        self.assertEqual(queued.call_args.kwargs['cuts'], [5, 18, 19, 500])
+        self.assertEqual(report['status'], a.SUCCESS)
+        self.assertFalse(report['learning_pass_claimed'])
+        self.assertEqual(len(report['metrics']), 32)
+        self.assertTrue(all(row['gpu_utilization'] is None for row in report['metrics']))
+        self.assertTrue(all(r['light_standalone_coverage'] is None for r in report['overlay_reports'].values()))
+        json.dumps(report, allow_nan=False)
+        ctx['reader'].finish.assert_called_once()
+        ctx['reader'].close.assert_called_once()
+
+    def test_numerical_failure_still_evaluates_every_descriptor(self):
+        for failure in ('fresh', 'slice', 'checkpoint', 'carry', 'pair', 'reference_chain', 'light_chain'):
+            reg, verified, ctx = fixture()
+            with self.subTest(failure=failure):
+                report, calls, _ = self.mocked(reg, verified, ctx, fail=failure)
+                self.assertEqual(len(calls), 74)
+                self.assertEqual(report['status'], 'FAIL-NUMERICAL')
+                self.assertFalse(report['pass_all'])
+
+    def test_queue_failure_and_absent_live_coverage_are_distinct(self):
+        for arguments, expected in [({'queue_exact': False}, 'FAIL-NUMERICAL'),
+                                    ({'live': False}, 'INCOMPLETE-COVERAGE'), ({'joint': False}, 'INCOMPLETE-COVERAGE')]:
+            reg, verified, ctx = fixture()
+            report, _, _ = self.mocked(reg, verified, ctx, **arguments)
+            self.assertEqual(report['status'], expected)
+            self.assertFalse(report['pass_all'])
+
+    def test_receipt_inventory_alias_and_descriptor_removal_fail_closed(self):
+        for mutation in ('receipt', 'descriptor', 'pin', 'case', 'row_alias'):
+            reg, verified, ctx = fixture(); identity = reg['plan']['rows'][0]['row_id']
+            if mutation == 'receipt':
+                verified.pop(identity)
+            elif mutation == 'descriptor':
+                reg['plan']['rows'][0]['expected_comparisons'] = []
+            elif mutation == 'pin':
+                verified[identity]['registration_sha256'] = 'f' * 64
+            elif mutation == 'row_alias':
+                verified[identity]['row']['steps'] = True
+            else:
+                reg['cases'][identity]['case_dir'] += '-another'
+            with self.subTest(mutation=mutation), self.assertRaises(ValueError):
+                self.mocked(reg, verified, ctx)
+
+    def test_summary_uses_actual_AJ_requested_names_and_checks_total_accounting(self):
+        for key in ('requested', 'accepted_requests', 'arriving_edges', 'accepted_arriving_edges', 'edges', 'effective_weights_raw_sha256'):
+            reg, verified, ctx = fixture(); identity = reg['plan']['rows'][0]['row_id']
+            ctx['records'][identity]['summary'][key] = 'e' * 64 if key.endswith('sha256') else 1
+            with self.subTest(key=key):
+                report, _, _ = self.mocked(reg, verified, ctx)
+                self.assertEqual(report['status'], 'FAIL-NUMERICAL')
+                self.assertIn(identity, report['failed_run_checks'])
+
+    def test_identical_bytes_give_deterministic_report_and_unknown_is_null(self):
+        reg, verified, ctx = fixture(); identity = reg['plan']['rows'][0]['row_id']
+        ctx['records'][identity]['summary'].pop('peak_reserved_vram_bytes')
+        one, _, _ = self.mocked(reg, verified, ctx)
+        two, _, _ = self.mocked(reg, verified, ctx)
+        self.assertEqual(a._canonical(one), a._canonical(two))
+        row = next(r for r in one['metrics'] if r['row_id'] == identity)
+        self.assertIsNone(row['peak_reserved_vram_bytes'])
+
+    def test_AM_reference_full_comparison_is_not_hidden_by_light(self):
+        reg, _, ctx = fixture()
+        row = reg['plan']['rows'][0]; descriptor = row['expected_comparisons'][0]
+        ctx['records'][row['row_id']]['traces']['drive'][10, 0] = np.float32(1)
+        report = a._dispatch(descriptor, ctx['records'], ctx['legacy'], row['overlay'])
+        self.assertFalse(report['numerical_exact'])
+        self.assertIn('pair.trace.drive', report['failed_checks'])
+
+    def test_missing_loaded_population_or_reference_inventory_rejected(self):
+        reg, verified, ctx = fixture(); ctx['records'].pop(next(iter(ctx['records'])))
+        with self.assertRaises(ValueError):
+            self.mocked(reg, verified, ctx)
+
+
+class FileAndWeightInputs(unittest.TestCase):
+    def test_reader_rehashes_actual_content_and_never_uses_stat_cache(self):
+        with tempfile.TemporaryDirectory() as folder:
+            path = Path(folder).resolve() / 'data.bin'; path.write_bytes(b'AAAA')
+            reader = a._Reader({str(path): a._sha_file(path)})
+            reader.bind(path); path.write_bytes(b'BBBB')
+            with self.assertRaises(ValueError):
+                reader.bind(path)
+            with self.assertRaises(ValueError):
+                reader.finish()
+
+    def test_original_pinned_overlay_math_signed_zero_and_nonzero_only_bridge(self):
+        helper = Path(__file__).resolve().parents[1] / 'wholebrain-plastic-interface-v1/overlay.py'
+        self.assertEqual(a._sha_file(helper), a.AM_OVERLAY_SHA)
+        with tempfile.TemporaryDirectory() as folder:
+            folder = Path(folder).resolve()
+            mask = folder / 'mask.npy'; base = folder / 'base.npy'
+            np.save(mask, np.array([0], np.int64)); np.save(base, np.array([1.5], np.float32))
+            original = np.array([.002, -0., -0., .009], np.float64)
+            graph = dict(weights=original, edge_id=np.arange(4, dtype=np.int64), apl_out_mask=np.array([False, True, False, False]))
+            before = original.tobytes()
+            for stage in ('zero', 'static25'):
+                delta = np.array([-0. if stage == 'zero' else -.375], np.float32)
+                overlay = folder / (stage + '.npz'); manifest = folder / (stage + '.json')
+                np.savez_compressed(overlay, edge_id=np.array([0], np.int64), plastic_delta_mv=delta)
+                meta = dict(schema='phase4an-overlay-v1', overlay_name=stage, am_overlay_path=str(helper), am_overlay_sha256=a.AM_OVERLAY_SHA,
+                            mask_path=str(mask), mask_sha256=a._sha_file(mask), base_candidate_path=str(base), base_candidate_sha256=a._sha_file(base),
+                            overlay_sha256=a._sha_file(overlay))
+                manifest.write_text(json.dumps(meta), encoding='utf-8')
+                paths = [mask, base, overlay, manifest, helper]
+                reader = a._Reader({str(path): a._sha_file(path) for path in paths})
+                reg = {'overlays': {stage: dict(overlay_file=str(overlay), overlay_manifest=str(manifest))}}
+                with patch.object(a, 'MASK_SHA', meta['mask_sha256']), patch.object(a, 'CANDIDATES', 1), patch.object(a, 'FAST_APL_EDGES', 1):
+                    actual, info = a._materialize(reader, reg, graph, stage)
+                expected = original.copy(); expected[1] = 0.
+                if stage == 'static25':
+                    expected[0] = np.add(original[0], np.multiply(delta[0].astype(np.float64), np.float64(.001)))
+                self.assertEqual(actual.tobytes(), expected.tobytes())
+                self.assertEqual(info['effective_weights_raw_sha256'], raw(expected))
+                self.assertEqual(info['installed_nonzero_count'], 0 if stage == 'zero' else 1)
+                self.assertEqual(original.tobytes(), before)
+                reader.finish(); reader.close()
+
+
+if __name__ == '__main__':
+    unittest.main()

models/male-cns-lif/olfactory-conditioning-lab-v1/test_engineering_compare.py

@@ -0,0 +1,246 @@
+"""Synthetic artifact comparisons only; no neural equation or GPU execution."""
+import copy
+import hashlib
+import json
+from pathlib import Path
+import tempfile
+import unittest
+
+import numpy as np
+
+import engineering_compare as c
+
+
+def sha(value):
+    return hashlib.sha256(np.ascontiguousarray(value).tobytes()).hexdigest()
+
+
+def synthetic_parts(lengths, *, active=True, traces=True, queues=True):
+    n, k = 3, 2
+    total = sum(lengths)
+    all_ticks = np.array([value for value in (0, 7, 19, 21, 41, 61) if value < total], np.int32) if active else np.empty(0, np.int32)
+    all_nodes = np.array([0, 1, 2, 0, 2, 1][:len(all_ticks)], np.int32)
+    ring, apl_ring = np.zeros((19, n), np.uint8), np.zeros((18, k), np.float32)
+    phase, offset, result = 0, 0, []
+    for length in lengths:
+        ring = ring[(np.arange(19) + phase % 19) % 19].copy()
+        head = phase % 18
+        apl_ring = np.concatenate((apl_ring[head:], apl_ring[:head]))
+        event_tick, event_node, requested, hashes, queue_rows = [], [], [], [], []
+        generated, applied, drives, apl_states = [], [], [], []
+        for tick in range(length):
+            absolute = offset + tick
+            fired = all_nodes[all_ticks == absolute]
+            ring[tick % 19] = 0; ring[tick % 19, fired] = 1
+            for neuron in fired:
+                event_tick.append(tick); event_node.append(neuron)
+                requested.append([tick, int(neuron), 1, 1, 0])
+            due = ring[(tick - 18) % 19] if absolute >= 18 else np.zeros(n, np.uint8)
+            edges = np.array([int(node) * 2 + i for node in np.flatnonzero(due) for i in (0, 1)], np.int64)
+            accepted = np.ones(len(edges), np.uint8)
+            queue_rows.append({'tick': tick, 'count': len(edges), 'accepted_count': len(edges),
+                               'ordered_edge_sha256': sha(edges), 'accepted_mask_sha256': sha(accepted),
+                               'joint_sha256': hashlib.sha256(str(tick).encode() + edges.tobytes() + accepted.tobytes()).hexdigest()})
+            v = np.array([-.05, -.04, -.03], np.float64)
+            g = np.array([-0., float(absolute), -.001], np.float64)
+            ref = np.zeros(n, np.int32)
+            hashes.append({'tick': tick, 'v_sha256': sha(v), 'g_sha256': sha(g), 'ref_sha256': sha(ref)})
+            h = np.full(k, np.float32(absolute + 1 if active else 0), np.float32)
+            application = apl_ring[tick % 18].copy(); apl_ring[tick % 18] = h
+            generated.append(h); applied.append(application)
+            drives.append(np.full(2, np.float32(absolute if active else 0), np.float32))
+            apl_states.append(np.full(2, np.float32(absolute + 2 if active else 0), np.float32))
+        local_ticks, nodes = np.array(event_tick, np.int32), np.array(event_node, np.int32)
+        state = {'step': local_ticks, 'neuron_idx': nodes, 'counts': np.bincount(nodes, minlength=n).astype(np.int32), 'v': v, 'g': g, 'ref': ref}
+        head = length % 18
+        pending = np.concatenate((apl_ring[head:], apl_ring[:head]))
+        terminal = {'spike_ring': ring.copy(), 'apl_state': apl_states[-1].copy(), 'apl_pending': pending,
+                    'next_tick': np.asarray(length, np.int64)}
+        summary = {'complete': True, 'pass_all': True, 'all_finite': True, 'steps': length, 'completed_ticks': length,
+                   'nodes': n, 'precision': 'float64', 'apl_precision': 'float32', 'apl_delay_steps': 18,
+                   'checkpoint_continuation_used': offset > 0, 'global_tick_offset': offset, 'global_next_tick': offset + length,
+                   'effective_weights_raw_sha256': 'e' * 64, 'diagnostic_mode': 'reference' if traces else 'light'}
+        result.append({'source': 'synthetic', 'steps': length, 'global_tick_offset': offset, 'state': state,
+                       'requests': np.asarray(requested, np.int64).reshape(-1, 5), 'terminal': terminal,
+                       'summary': summary, 'terminal_origin': 'synthetic_recorded',
+                       'traces': {'generated': np.asarray(generated), 'applied': np.asarray(applied),
+                                  'drive': np.asarray(drives), 'state': np.asarray(apl_states)} if traces else {},
+                       'state_hashes': hashes if traces else None, 'queues': queue_rows if queues else None})
+        offset += length; phase = length
+    return result
+
+
+def write_output(path, run, *, legacy=False):
+    path.mkdir()
+    for name, value in (('summary.json', run['summary']), ('apl-timing-audit.json',
+                        {'final_apl_state_u32_bits': run['terminal']['apl_state'].view(np.uint32).tolist()})):
+        (path / name).write_text(json.dumps(value), encoding='utf-8')
+    np.savez_compressed(path / 'state.npz', **run['state'])
+    np.save(path / 'apl-pending-tail.float32.npy', run['terminal']['apl_pending'])
+    if legacy:
+        (path / 'adapter-provenance.json').write_text('{}', encoding='utf-8')
+    else:
+        np.savez_compressed(path / 'terminal-queues.npz', **run['terminal'])
+    with (path / 'requests.csv').open('w', encoding='utf-8', newline='') as stream:
+        import csv
+        writer = csv.writer(stream); writer.writerow(c.REQUEST_FIELDS); writer.writerows(run['requests'].tolist())
+    for name, file in c.TRACE_FILES.items():
+        if name in run['traces']:
+            np.save(path / file, run['traces'][name])
+    for name, file in (('state_hashes', 'tick-state-hashes.jsonl'), ('queues', 'queue.jsonl')):
+        if run[name] is not None:
+            (path / file).write_text(''.join(json.dumps(row) + '\n' for row in run[name]), encoding='utf-8')
+
+
+class Comparisons(unittest.TestCase):
+    def test_fresh_light_reference_exact_without_fabricating_light_traces(self):
+        reference = synthetic_parts([64])[0]
+        light = synthetic_parts([64], traces=False, queues=False)[0]
+        report = c.compare_fresh(light, reference)
+        self.assertTrue(report['pass_all'])
+        self.assertFalse(report['reference_comparisons_available']['APL_traces'])
+        self.assertFalse(report['temporal_validation_complete'])
+
+    def test_light_does_not_hide_reference_vs_AM_interior_trace_mismatch(self):
+        light = synthetic_parts([64], traces=False, queues=False)[0]
+        reference = synthetic_parts([64])[0]
+        legacy = copy.deepcopy(reference)
+        reference['traces']['drive'][10, 0] += np.float32(1.)
+        report = c.compare_fresh(light, reference, legacy)
+        self.assertFalse(report['pass_all'])
+        self.assertIn('reference_vs_AM.trace.drive', report['failed_checks'])
+
+    def test_nonzero_origin_monolithic_and_split_require_same_parent(self):
+        mono = synthetic_parts([20, 44])[1]
+        parts = synthetic_parts([20, 5, 39])[1:]
+        with self.assertRaisesRegex(ValueError, 'same starting parent'):
+            c.compare_segments(mono, parts)
+        mono['summary']['parent_checkpoint_manifest_sha256'] = 'a' * 64
+        parts[0]['summary']['parent_checkpoint_manifest_sha256'] = 'a' * 64
+        report = c.compare_segments(mono, parts)
+        self.assertTrue(report['pass_all'], report['failed_checks'])
+        self.assertEqual(report['global_tick_offset'], 20)
+        parts[0]['summary']['parent_checkpoint_manifest_sha256'] = 'b' * 64
+        with self.assertRaisesRegex(ValueError, 'same starting parent'):
+            c.compare_segments(mono, parts)
+
+    def test_monolithic_segments_exact_and_cross_boundary_coverage(self):
+        mono = synthetic_parts([64])[0]
+        parts = synthetic_parts([5, 12, 1, 1, 18, 19, 8])
+        report = c.compare_segments(mono, parts)
+        self.assertTrue(report['pass_all'], report['failed_checks'])
+        self.assertTrue(report['reference_comparisons_available']['APL_traces'])
+        self.assertTrue(report['reference_comparisons_available']['state_hashes'])
+        self.assertGreater(report['coverage']['observed_carried_arriving_edges'], 0)
+        self.assertGreater(report['coverage']['carried_APL_nonzero_applied_values'], 0)
+        self.assertFalse(report['queue_joint_hash_compared'])
+        self.assertNotEqual(mono['queues'][18]['joint_sha256'], parts[3]['queues'][0]['joint_sha256'])
+
+    def test_raw_ring_phase_must_be_normalized(self):
+        mono = synthetic_parts([64])[0]
+        parts = synthetic_parts([20, 44])
+        self.assertFalse(c.bit_equal(mono['terminal']['spike_ring'], parts[-1]['terminal']['spike_ring']))
+        self.assertTrue(c.bit_equal(c.normalized_ring(mono['terminal']), c.normalized_ring(parts[-1]['terminal'])))
+        self.assertTrue(c.compare_segments(mono, parts)['pass_all'])
+
+    def test_signed_zero_final_state_difference_is_not_equal(self):
+        left = synthetic_parts([64], traces=False, queues=False)[0]
+        right = copy.deepcopy(left); right['state']['g'][0] = 0.
+        report = c.compare_fresh(left, right)
+        self.assertFalse(report['numerical_exact'])
+        self.assertIn('pair.state.g', report['failed_checks'])
+
+    def test_zero_activity_is_not_a_complete_temporal_pass(self):
+        mono = synthetic_parts([64], active=False)[0]
+        parts = synthetic_parts([20, 44], active=False)
+        report = c.compare_segments(mono, parts)
+        self.assertTrue(report['numerical_exact'])
+        self.assertFalse(report['pass_all'])
+        self.assertFalse(report['temporal_validation_complete'])
+        self.assertEqual(report['status'], 'INCOMPLETE-COVERAGE')
+        self.assertFalse(c.compare_fresh(mono, copy.deepcopy(mono))['pass_all'])
+
+    def test_missing_observed_queue_coverage_is_reported_unknown_not_zero_or_pass(self):
+        mono = synthetic_parts([64], traces=False, queues=False)[0]
+        parts = synthetic_parts([20, 44], traces=False, queues=False)
+        report = c.compare_segments(mono, parts)
+        self.assertTrue(report['numerical_exact'])
+        self.assertIsNone(report['coverage']['observed_carried_arriving_edges'])
+        self.assertFalse(report['temporal_validation_complete'])
+
+    def test_request_acceptance_difference_fails_even_if_events_are_equal(self):
+        left = synthetic_parts([64])[0]; right = copy.deepcopy(left)
+        right['requests'][0, 3:] = [0, 1]
+        report = c.compare_fresh(left, right)
+        self.assertIn('pair.requests_five_fields', report['failed_checks'])
+
+    def test_clock_gaps_and_empty_segment_list_rejected(self):
+        mono = synthetic_parts([64])[0]
+        with self.assertRaises(ValueError):
+            c.compare_segments(mono, [])
+        parts = synthetic_parts([20, 44]); parts[1]['global_tick_offset'] += 1
+        with self.assertRaisesRegex(ValueError, 'clock gap'):
+            c.compare_segments(mono, parts)
+
+    def test_partial_traces_hash_coverage_and_bad_dtype_rejected(self):
+        for mutation in ('trace', 'hash', 'dtype', 'duplicate'):
+            run = synthetic_parts([64])[0]
+            if mutation == 'trace':
+                run['traces'].pop('applied')
+            elif mutation == 'hash':
+                run['state_hashes'].pop()
+            elif mutation == 'dtype':
+                run['state']['v'] = run['state']['v'].astype(np.float32)
+            else:
+                run['state']['step'][1] = run['state']['step'][0]
+                run['state']['neuron_idx'][1] = run['state']['neuron_idx'][0]
+            with self.subTest(mutation=mutation), self.assertRaises(ValueError):
+                c.validate_run(run)
+
+    def test_per_step_state_hash_and_queue_mask_mismatch_fail(self):
+        mono = synthetic_parts([64])[0]; parts = synthetic_parts([20, 44])
+        parts[1]['state_hashes'][1]['g_sha256'] = '0' * 64
+        parts[1]['queues'][1]['accepted_mask_sha256'] = '1' * 64
+        report = c.compare_segments(mono, parts)
+        self.assertFalse(report['pass_all'])
+        self.assertIn('concatenated_per_tick_state_hashes', report['failed_checks'])
+        self.assertIn('concatenated_queue_order_and_acceptance', report['failed_checks'])
+
+    def test_effective_weight_change_fails(self):
+        mono = synthetic_parts([64])[0]; parts = synthetic_parts([20, 44])
+        parts[1]['summary']['effective_weights_raw_sha256'] = 'f' * 64
+        self.assertFalse(c.compare_segments(mono, parts)['checks']['unchanged_effective_weights'])
+
+
+class FileSchemas(unittest.TestCase):
+    def test_actual_five_request_fields_and_AM_derived_ring_are_labeled(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            run = synthetic_parts([64])[0]
+            write_output(root / 'AN', run)
+            write_output(root / 'AM', run, legacy=True)
+            actual, legacy = c.load_run(root / 'AN'), c.load_run(root / 'AM', allow_legacy_am=True)
+            try:
+                self.assertIn('derived_from_fresh_events', legacy['terminal_origin'])
+                self.assertTrue(c.compare_fresh(actual, copy.deepcopy(actual), legacy)['pass_all'])
+                with self.assertRaisesRegex(ValueError, 'missing'):
+                    c.load_run(root / 'AM')
+            finally:
+                c.close_run(actual); c.close_run(legacy)
+
+    def test_missing_reference_file_or_wrong_request_header_rejected(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            run = synthetic_parts([64])[0]
+            write_output(root / 'partial', run)
+            (root / 'partial' / 'apl-applied.float32.npy').unlink()
+            with self.assertRaisesRegex(ValueError, 'incomplete'):
+                c.load_run(root / 'partial')
+            write_output(root / 'header', run)
+            (root / 'header' / 'requests.csv').write_text('tick,neuron_idx,accepted\n', encoding='utf-8')
+            with self.assertRaisesRegex(ValueError, 'five AJ'):
+                c.load_run(root / 'header')
+
+
+if __name__ == '__main__':
+    unittest.main()

models/male-cns-lif/olfactory-conditioning-lab-v1/test_engineering_inputs.py

@@ -0,0 +1,115 @@
+import copy
+import unittest
+import numpy as np
+import engineering_inputs as e
+
+
+def inputs():
+    return dict(tick=np.array([0, 4, 5, 17, 18, 18, 19, 499, 500, 999], np.int32),
+                neuron_idx=np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 166699], np.int32))
+
+
+def spec():
+    return dict(name='unchanged', kind='fullgraph', steps=1000, dt_ms=.1, duration_ms=100.,
+                apl_delay_steps=18, record_history=False, training=False,
+                model={'threshold_mv': -45, 'w_syn_mv_per_anatomical_synapse': .275},
+                apl={'gain': .01}, budget_root='/project/old', output_budget_bytes=2048,
+                graph_dir='/project/frozen-graph', seed=1073741825)
+
+
+class ExactInputs(unittest.TestCase):
+    def test_exact_boundaries_reconstruct_all_requests(self):
+        original = inputs()
+        intervals = [(0, 5), (5, 18), (18, 19), (19, 500), (500, 1000)]
+        parts = [e.slice_requests(original, 1000, *span) for span in intervals]
+        report = e.verify_partition(original, 1000, intervals, parts)
+        self.assertTrue(report['complete'])
+        self.assertEqual(parts[2]['tick'].tolist(), [0, 0])
+        self.assertEqual(parts[-1]['tick'].tolist(), [0, 499])
+        self.assertEqual(report['random_draws'], 0)
+        for value in parts:
+            for key in original:
+                self.assertFalse(np.shares_memory(original[key], value[key]))
+
+    def test_empty_intervals_are_explicit_not_lost(self):
+        original = inputs()
+        intervals = [(0, 20), (20, 499), (499, 1000)]
+        parts = [e.slice_requests(original, 1000, *span) for span in intervals]
+        self.assertEqual(len(parts[1]['tick']), 0)
+        self.assertTrue(e.verify_partition(original, 1000, intervals, parts)['complete'])
+
+    def test_bad_requests_never_silently_fixed(self):
+        for mut in ('dtype', 'duplicate', 'order', 'bounds', 'shape', 'extra'):
+            req = inputs()
+            if mut == 'dtype': req['tick'] = req['tick'].astype(np.int64)
+            elif mut == 'duplicate': req['tick'][1], req['neuron_idx'][1] = 0, 1
+            elif mut == 'order': req['tick'][1] = 10
+            elif mut == 'bounds': req['neuron_idx'][-1] = 166700
+            elif mut == 'shape': req['tick'] = req['tick'][:-1]
+            else: req['seed'] = 1
+            with self.subTest(mut=mut), self.assertRaises(ValueError):
+                e.slice_requests(req, 1000, 0, 1000)
+
+    def test_partition_gap_overlap_changed_input_and_missing_tail_rejected(self):
+        req = inputs()
+        spans = [(0, 500), (500, 1000)]
+        parts = [e.slice_requests(req, 1000, *x) for x in spans]
+        for bad in ([(0, 500), (501, 1000)], [(0, 500), (499, 1000)], [(0, 500)]):
+            with self.assertRaises(ValueError):
+                e.verify_partition(req, 1000, bad, parts[:len(bad)])
+        parts[0]['neuron_idx'][0] = 123
+        with self.assertRaisesRegex(ValueError, 'changes actual requests'):
+            e.verify_partition(req, 1000, spans, parts)
+
+    def test_fresh_prefix_and_continued_specs_preserve_original(self):
+        original = spec()
+        before = copy.deepcopy(original)
+        for start, stop, parent in ((0, 1000, None), (0, 18, None), (18, 19, 'a' * 64)):
+            derived, audit = e.derive_spec(original, start=start, stop=stop, budget_root='/project/new',
+                                         output_budget_bytes=8 * 1024**3, parent_sha=parent)
+            self.assertEqual(original, before)
+            self.assertEqual(derived['model'], original['model'])
+            self.assertEqual(derived['apl'], original['apl'])
+            self.assertIsNot(derived['model'], original['model'])
+            self.assertEqual(derived['max_steps'], 1000)
+            self.assertEqual(derived['steps'], stop - start)
+            self.assertTrue(audit['all_other_fields_unchanged'])
+            if start: self.assertEqual(derived['global_tick_offset'], start)
+
+    def test_invalid_continuation_root_and_duration_rejected(self):
+        for root in ('/project/old/sub', '/project', 'relative', '/project/../old', '//project/old', '//project/new'):
+            with self.assertRaises(ValueError):
+                e.derive_spec(spec(), start=0, stop=1000, budget_root=root, output_budget_bytes=10)
+        for start, stop, parent in ((1, 20, None), (0, 10, 'a'*64), (True, 10, None), (0, 1001, None)):
+            with self.assertRaises(ValueError):
+                e.derive_spec(spec(), start=start, stop=stop, budget_root='/project/new', output_budget_bytes=10, parent_sha=parent)
+        original = spec(); original['duration_ms'] = 1.
+        with self.assertRaises(ValueError):
+            e.derive_spec(original, start=0, stop=10, budget_root='/project/new', output_budget_bytes=10)
+
+    def test_original_clock_type_and_no_within_trial_update_match_runtime(self):
+        for key, value in (('apl_delay_steps', 18.), ('apl_delay_steps', True),
+                           ('within_trial_weight_updates', True), ('budget_root', '//project/old')):
+            original = spec(); original[key] = value
+            with self.subTest(key=key, value=value), self.assertRaises(ValueError):
+                e.derive_spec(original, start=0, stop=10, budget_root='/project/new', output_budget_bytes=10)
+
+    def test_overlay_is_declaration_translation_not_self_authorized_learned(self):
+        original = dict(schema='phase4am-overlay-v1', overlay_name='zero', training=False, fixed_for_whole_trial=True,
+                        overlay_sha256='b'*64, mask_path='/project/mask.npy', mask_sha256=e.MASK_SHA,
+                        base_candidate_path='/project/base.npy', base_candidate_sha256='c'*64,
+                        aj_model_dir='/project/apl-timing-lab-v1', old_extra_field='preserved in original only')
+        before = copy.deepcopy(original)
+        result = e.adapt_overlay_manifest(original, '/project/overlay.py')
+        self.assertEqual(original, before)
+        self.assertEqual(result['schema'], 'phase4an-overlay-v1')
+        self.assertNotIn('old_extra_field', result)
+        self.assertEqual(result['overlay_sha256'], original['overlay_sha256'])
+        for key, val in (('overlay_name', 'learned'), ('mask_sha256', 'd'*64), ('training', True), ('base_candidate_path', 'local')):
+            bad = dict(original); bad[key] = val
+            with self.subTest(key=key), self.assertRaises(ValueError):
+                e.adapt_overlay_manifest(bad, '/project/overlay.py')
+
+
+if __name__ == '__main__':
+    unittest.main()

models/male-cns-lif/olfactory-conditioning-lab-v1/test_engineering_plan.py

@@ -0,0 +1,152 @@
+"""Pure inventory/dependency tests; no I/O, GPU, scientific input or runtime."""
+import copy
+import json
+import unittest
+
+import engineering_plan as p
+
+
+class FixedPlan(unittest.TestCase):
+    def test_complete_current_inventory_not_future_supplements(self):
+        plan = p.build_plan()
+        self.assertEqual(plan['total_calls'], len(plan['rows']))
+        self.assertEqual(plan['total_calls'], 32)
+        self.assertEqual(plan['total_ticks'], sum(row['steps'] for row in plan['rows']))
+        self.assertEqual(plan['total_ticks'], 11074)
+        self.assertEqual(plan['overlays'], ['zero', 'static25'])
+        self.assertEqual(plan['chain_lengths'], [5, 13, 1, 481, 500])
+        self.assertFalse(plan['training'])
+        self.assertFalse(plan['candidate_generated'])
+        self.assertEqual(p.validate_plan(json.loads(json.dumps(plan))), plan)
+        for overlay in plan['overlays']:
+            rows = [r for r in plan['rows'] if r['overlay'] == overlay]
+            self.assertEqual(len(rows), 16)
+            self.assertEqual(sum(r['steps'] for r in rows), 5537)
+            self.assertEqual([(r['mode'], r['steps']) for r in rows if r['kind'] == 'fresh'],
+                             [('reference', 1000), ('light', 1000), ('light', 1000)])
+            self.assertEqual([r['stop'] for r in rows if r['kind'] == 'prefix'], [18, 19, 500])
+            self.assertFalse(any(r['stop'] > 1000 for r in rows))
+
+    def test_all_prerequisites_precede_rows_and_fresh_prefixes_precede_chains(self):
+        rows = p.build_plan()['rows']
+        self.assertTrue(all(r['kind'] in ('fresh', 'prefix') for r in rows[:12]))
+        self.assertTrue(all(r['kind'] == 'chain' for r in rows[12:]))
+        positions = {r['row_id']: i for i, r in enumerate(rows)}
+        self.assertEqual(len(positions), 32)
+        for index, row in enumerate(rows):
+            if row['parent_row_id'] is not None:
+                self.assertLess(positions[row['parent_row_id']], index)
+            for check in row['expected_comparisons']:
+                reference = check['reference_row_id']
+                if reference is not None:
+                    self.assertLess(positions[reference], index)
+                for candidate in check['candidate_row_ids']:
+                    self.assertLessEqual(positions[candidate], index)
+                self.assertLess(check['start'], check['stop'])
+
+    def test_each_chain_is_exact_partition_with_local_phase_distinct_from_global(self):
+        for overlay in p.OVERLAYS:
+            for mode in p.MODES:
+                chain = [r for r in p.build_plan()['rows'] if
+                         (r['overlay'], r['mode'], r['kind']) == (overlay, mode, 'chain')]
+                self.assertEqual([(r['start'], r['stop']) for r in chain],
+                                 [(0, 5), (5, 18), (18, 19), (19, 500), (500, 1000)])
+                self.assertEqual([r['steps'] % 19 for r in chain], [5, 13, 1, 6, 6])
+                self.assertEqual([r['stop'] % 19 for r in chain], [5, 18, 0, 6, 12])
+                self.assertIsNone(chain[0]['parent_row_id'])
+                for earlier, later in zip(chain, chain[1:]):
+                    self.assertEqual(later['parent_row_id'], earlier['row_id'])
+                    self.assertEqual(later['start'], earlier['stop'])
+                self.assertEqual(chain[2]['start'], 18)  # source tick 0 arrives at this child's local 0.
+                self.assertEqual(chain[2]['steps'], 1)
+                last = next(c for c in chain[-1]['expected_comparisons'] if c['check'] == 'chain_exact')
+                self.assertEqual(last['candidate_row_ids'], [r['row_id'] for r in chain])
+                self.assertEqual((last['start'], last['stop']), (0, 1000))
+
+    def test_prefix5_is_reference_first_segment_without_extra_run(self):
+        rows = p.build_plan()['rows']
+        self.assertFalse(any(r['kind'] == 'prefix' and r['stop'] == 5 for r in rows))
+        for overlay in p.OVERLAYS:
+            first = {r['mode']: r for r in rows if r['kind'] == 'chain' and
+                     r['overlay'] == overlay and r['start'] == 0}
+            refs = [c for c in first['light']['expected_comparisons'] if c['check'] == 'checkpoint_exact']
+            self.assertEqual(len(refs), 1)
+            self.assertEqual(refs[0]['reference_row_id'], first['reference']['row_id'])
+            self.assertFalse(any(c['reference_row_id'] == first['reference']['row_id']
+                                 for c in first['reference']['expected_comparisons']))
+
+    def test_fresh_am_and_light_repeat_comparisons_are_explicit(self):
+        rows = p.build_plan()['rows']
+        for overlay in p.OVERLAYS:
+            fresh = [r for r in rows if r['overlay'] == overlay and r['kind'] == 'fresh']
+            self.assertEqual(len(fresh), 3)
+            for row in fresh:
+                am = [c for c in row['expected_comparisons'] if c['check'] == 'am_exact']
+                self.assertEqual(len(am), 1)
+                self.assertEqual(am[0]['external_reference'], 'sealed_AM_selected_case_same_overlay_r0')
+                self.assertIsNone(am[0]['reference_row_id'])
+            self.assertEqual(fresh[1]['expected_comparisons'][1]['reference_row_id'], fresh[0]['row_id'])
+            self.assertEqual(fresh[2]['expected_comparisons'][1]['reference_row_id'], fresh[1]['row_id'])
+
+    def test_every_result_is_independent_not_shared_mutable_inventory(self):
+        original = p.build_plan()
+        checked = p.validate_plan(original)
+        checked['rows'][0]['expected_comparisons'][0]['candidate_row_ids'].append('mutation')
+        checked['chain_lengths'][0] = 99
+        self.assertEqual(original, p.build_plan())
+        original['rows'][0]['expected_comparisons'][0]['scope'] = 'mutation'
+        self.assertNotEqual(original, p.build_plan())
+
+    def test_exact_types_reject_bool_int_float_and_sequence_conflation(self):
+        mutations = (
+            lambda x: x.update(total_calls=32.0),
+            lambda x: x.update(training=0),
+            lambda x: x['rows'][0].update(start=False),
+            lambda x: x['rows'][14].update(steps=True),
+            lambda x: x['rows'][14].update(steps=1.0),
+            lambda x: x['rows'][0]['expected_comparisons'][0].update(start=False),
+            lambda x: x.update(rows=tuple(x['rows'])),
+        )
+        for mutate in mutations:
+            plan = p.build_plan(); mutate(plan)
+            with self.subTest(mutation=repr(mutate)), self.assertRaisesRegex(ValueError, 'type'):
+                p.validate_plan(plan)
+
+    def test_unknown_fields_missing_overlays_and_reordering_are_rejected(self):
+        mutations = (
+            lambda x: x.update(extra=True),
+            lambda x: x['rows'][0].update(extra='not allowed'),
+            lambda x: x['rows'][0]['expected_comparisons'][0].update(tolerance=0),
+            lambda x: x.update(overlays=['zero']),
+            lambda x: x['rows'].pop(0),
+            lambda x: x['rows'].append(copy.deepcopy(x['rows'][-1])),
+            lambda x: x['rows'].__setitem__(slice(0, 2), x['rows'][1::-1]),
+            lambda x: x['rows'][0].update(overlay='static25'),
+            lambda x: x['rows'][0].update(mode='light'),
+            lambda x: x['rows'][0].update(row_id='arbitrary'),
+        )
+        for mutate in mutations:
+            plan = p.build_plan(); mutate(plan)
+            with self.subTest(mutation=repr(mutate)), self.assertRaises(ValueError):
+                p.validate_plan(plan)
+
+    def test_gaps_wrong_parents_and_dropped_comparisons_never_pass(self):
+        mutations = (
+            lambda x: x['rows'][13].update(start=6, steps=12),
+            lambda x: x['rows'][13].update(stop=17, steps=12),
+            lambda x: x['rows'][13].update(parent_row_id=None),
+            lambda x: x['rows'][12].update(parent_row_id=x['rows'][13]['row_id']),
+            lambda x: x['rows'][16].update(stop=999, steps=499),
+            lambda x: x['rows'][0].update(expected_comparisons=[]),
+            lambda x: x['rows'][2]['expected_comparisons'].pop(),
+            lambda x: x['rows'][16]['expected_comparisons'][-1]['candidate_row_ids'].pop(),
+            lambda x: x['rows'][16]['expected_comparisons'][-1].update(scope='final_only'),
+        )
+        for mutate in mutations:
+            plan = p.build_plan(); mutate(plan)
+            with self.subTest(mutation=repr(mutate)), self.assertRaises(ValueError):
+                p.validate_plan(plan)
+
+
+if __name__ == '__main__':
+    unittest.main()

models/male-cns-lif/olfactory-conditioning-lab-v1/test_engineering_prepare.py

@@ -0,0 +1,216 @@
+"""Temporary-directory and small authority tests only; never touch real ROOT."""
+import copy
+import hashlib
+import json
+from pathlib import Path
+import tempfile
+import types
+import unittest
+from unittest.mock import patch
+
+import engineering_prepare as p
+
+
+LOCAL = Path(__file__).resolve().parent
+AI = LOCAL.parent / 'pn-recruitment-audit-v1/publication.py'
+
+
+def valid_status():
+    final = dict(status=p.FINAL_STATUS, primary_trials_per_stage=120, repeats_per_stage=24,
+                 zero_overlay_exact=True, static25_repeat_exact=True, old_integrity_pass=True,
+                 frozen_five_reference_pass=True, frozen_eligibility_and_mask_unchanged=True,
+                 base_weights_unchanged=True, training=False, learned_candidate=False)
+    scientific = dict(status=p.FINAL_STATUS, primary_trials_per_stage=120, technical_repeats_per_stage=24,
+                      zero_overlay_exact=True, static25_repeat_exact=True, training=False, learned_candidate=False)
+    old = {'root-' + str(i): {'pass': True, 'checked': 1, 'mismatches': [], 'manifest_sha256': 'a'*64, 'checksums_sha256': 'b'*64}
+           for i in range(28)}
+    refs = {'pass_all': True, 'trials': [{'trial': name, 'exact': {key: True for key in ('step', 'neuron_idx', 'counts', 'v', 'g')}} for name in p.REFERENCES]}
+    return final, scientific, old, copy.deepcopy(old), refs
+
+
+def planned():
+    return [dict(name='fixed-' + str(i), cohort='seed_validation' if i < 60 else 'novel_to_aj', repeat=r)
+            for i in range(120) for r in ((0, 1) if i < 24 else (0,))]
+
+
+class AuthorityTests(unittest.TestCase):
+    def test_required_final_status_and_all_28_roots_five_references(self):
+        p.validate_final_status(*valid_status())
+        for mutation in ('status', 'hidden-learning', 'root', 'reference', 'root-hash'):
+            args = copy.deepcopy(valid_status())
+            if mutation == 'status':
+                args[0]['status'] = 'INCOMPLETE'
+            elif mutation == 'hidden-learning':
+                args[1]['learned_candidate'] = True
+            elif mutation == 'root':
+                args[3].pop('root-27')
+            elif mutation == 'reference':
+                args[4]['trials'][2]['exact']['g'] = False
+            else:
+                args[3]['root-1']['manifest_sha256'] = 'c' * 64
+            with self.subTest(mutation=mutation), self.assertRaises(ValueError):
+                p.validate_final_status(*args)
+
+    def test_first_actual_planned_primary_is_selected_without_dynamic_ranking(self):
+        rows = planned()
+        self.assertEqual(p.validate_planned(rows), rows[0])
+        for altered in (rows[:-1], rows + [rows[0]], [dict(rows[0], name='../escape'), *rows[1:]],
+                        [rows[1], rows[1], *rows[2:]]):
+            with self.assertRaises(ValueError):
+                p.validate_planned(altered)
+
+    def test_three_external_sha_anchors_have_no_defaults_or_placeholders(self):
+        for anchors in ((None, 'a'*64, 'b'*64), ('', '', ''), ('x'*64, 'a'*64, 'b'*64)):
+            with self.assertRaisesRegex(ValueError, 'actual external'):
+                p._prepare(Path('not-read'), Path('not-read'), Path('not-read'), *anchors)
+
+    def test_path_inventory_rejects_duplicates_and_traversal(self):
+        for name in ('../bad', '/absolute', 'a\\b', 'a/../b', 'C:/bad'):
+            with self.assertRaises(ValueError):
+                p._relative(name)
+        row = {'path': 'good.json', 'bytes': 3, 'sha256': 'a'*64}
+        with self.assertRaisesRegex(ValueError, 'Duplicate'):
+            p._index([row, row])
+
+    def test_pinned_AI_verifier_rechecks_complete_synthetic_seal(self):
+        helper = p.load_module('phase4an_test_AI_publication', AI, p.AI_HELPER_SHA)
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory).resolve()
+            payload = root / 'small.json'; payload.write_text('{}', encoding='utf-8')
+            row = {'path': payload.name, 'bytes': payload.stat().st_size, 'sha256': p.digest(payload)}
+            p.save(root / 'manifest.json', {'root': str(root), 'files': [row]})
+            (root / 'checksums.sha256').write_text(row['sha256'] + '  small.json\n' + p.digest(root / 'manifest.json') + '  manifest.json\n', encoding='utf-8')
+            self.assertTrue(helper.verify_seal(root)['pass_all'])
+            payload.write_text('{"changed":true}', encoding='utf-8')
+            with self.assertRaises(ValueError):
+                helper.verify_seal(root)
+
+    def test_finalizer_authority_helper_checks_external_anchors_and_both_full_seals(self):
+        helper = p.load_module('phase4an_test_AI_publication', AI, p.AI_HELPER_SHA)
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory).resolve()
+            model, experiment = root / p.AM_MODEL_REL, root / p.AM_EXP_REL
+            model.mkdir(parents=True); experiment.mkdir(parents=True)
+            p.save(model / 'payload.json', {'synthetic': True})
+            p.save(experiment / 'protocol/preregistered.json', {'planned': []})
+            p.save(experiment / 'audit/final-status.json', {'status': p.FINAL_STATUS})
+            for tree in (model, experiment):
+                rows = [dict(path=path.relative_to(tree).as_posix(), bytes=path.stat().st_size, sha256=p.digest(path))
+                        for path in sorted(tree.rglob('*')) if path.is_file()]
+                p.save(tree / 'manifest.json', {'root': str(tree), 'files': rows})
+                (tree / 'checksums.sha256').write_text(''.join(row['sha256'] + '  ' + row['path'] + '\n' for row in rows) +
+                        p.digest(tree / 'manifest.json') + '  manifest.json\n', encoding='utf-8')
+            prereg = p.digest(experiment / 'protocol/preregistered.json')
+            anchors = dict(am_model_manifest_sha256=p.digest(model / 'manifest.json'),
+                am_experiment_manifest_sha256=p.digest(experiment / 'manifest.json'), am_final_sha256=p.digest(experiment / 'audit/final-status.json'),
+                am_preregistration_sha256=prereg, AI_publication_helper_sha256=p.AI_HELPER_SHA)
+            with patch.object(p, 'ROOT', root), patch.object(p, 'AM_PREREG_SHA', prereg), patch.object(p, 'load_module', return_value=helper):
+                self.assertEqual(set(p.verify_authority(anchors)), {'model', 'experiment'})
+                (model / 'payload.json').write_text('changed', encoding='utf-8')
+                with self.assertRaises(ValueError):
+                    p.verify_authority(anchors)
+
+    def test_old_integrity_bridge_restores_import_path_and_rejects_failed_root(self):
+        import sys
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory).resolve(); expected = valid_status()[3]
+            before_path = list(sys.path)
+            def good():
+                sys.path.insert(0, 'synthetic-old-context-search-path')
+                return copy.deepcopy(expected)
+            module = types.SimpleNamespace(ROOT=root, integrity=good)
+            with patch.object(p, 'load_module', return_value=module):
+                self.assertEqual(p._old_integrity(root, 'a'*64, expected), expected)
+            self.assertEqual(sys.path, before_path)
+            bad = copy.deepcopy(expected); bad['root-1']['pass'] = False
+            module.integrity = lambda: bad
+            with patch.object(p, 'load_module', return_value=module), self.assertRaisesRegex(ValueError, '28-root'):
+                p._old_integrity(root, 'a'*64, expected)
+            self.assertEqual(sys.path, before_path)
+
+    def test_all_144_stage_completions_must_match_sealed_inventory(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory).resolve(); experiment = root / p.AM_EXP_REL; experiment.mkdir(parents=True)
+            rows, index, completed = planned(), {}, []
+            def add(relative, value):
+                path = experiment / relative; p.save(path, value)
+                index[relative] = {'path': relative, 'bytes': path.stat().st_size, 'sha256': p.digest(path)}
+            for row in rows:
+                prefix = 'gpu/zero/' + row['name'] + '-r' + str(row['repeat']) + '/'
+                folder = experiment / prefix.rstrip('/')
+                case = root / p.AK_REL / 'cases' / row['cohort'] / row['name']
+                add(prefix + 'summary.json', {'case': row['name'], 'complete': True, 'pass_all': True, 'all_finite': True,
+                                             'steps': 1000, 'completed_ticks': 1000})
+                add(prefix + 'comparison.json', {'pass_all': True, 'overlay_name': 'zero', 'case_dir': str(case), 'right': str(folder),
+                    'mode': 'zero', 'left': str(root / p.AK_REL / 'gpu' / row['cohort'] / (row['name'] + '-r' + str(row['repeat']))),
+                    'checks': {'synthetic_gate': True}, 'failed_checks': [], 'full_queue_reconstructed': True})
+                inventory = [dict(path=k[len(prefix):], bytes=v['bytes'], sha256=v['sha256']) for k, v in sorted(index.items()) if k.startswith(prefix)]
+                add(prefix + 'output-hashes.json', inventory)
+                completed.append(dict(name=row['name'], repeat=row['repeat'], output_hashes_sha256=index[prefix+'output-hashes.json']['sha256'],
+                                      comparison_sha256=index[prefix+'comparison.json']['sha256']))
+            receipt = {'stage': 'zero', 'pass_all': True, 'trials': 144, 'primary_trials': 120, 'technical_repeats': 24,
+                       'training': False, 'completed': completed}
+            add('audit/zero-complete.json', receipt)
+            self.assertTrue(p.validate_stage(experiment, index, 'zero', rows, root)['pass_all'])
+            wrong = copy.deepcopy(rows); wrong[0], wrong[1] = wrong[1], wrong[0]
+            with self.assertRaisesRegex(ValueError, 'order/identity'):
+                p.validate_stage(experiment, index, 'zero', wrong, root)
+            # A missing sealed payload entry cannot be hidden by a PASS flag.
+            altered = dict(index); altered.pop('gpu/zero/fixed-0-r0/summary.json')
+            with self.assertRaises(ValueError):
+                p.validate_stage(experiment, altered, 'zero', rows, root)
+
+
+class PreparationSafetyTests(unittest.TestCase):
+    def test_exclusive_layout_allows_only_nonexistent_or_empty_experiment(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory).resolve()
+            model = root / 'models/male-cns-lif/olfactory-conditioning-lab-v1'; model.mkdir(parents=True)
+            experiment = root / 'experiments/phase4an-engineering-validation'; experiment.parent.mkdir()
+            self.assertEqual(p._layout(root, model, experiment)[2], experiment)
+            experiment.mkdir(); self.assertEqual(p._layout(root, model, experiment)[2], experiment)
+            (experiment / 'preserve.txt').write_text('partial', encoding='utf-8')
+            with self.assertRaisesRegex(ValueError, 'populated'):
+                p._layout(root, model, experiment)
+            self.assertEqual((experiment / 'preserve.txt').read_text(), 'partial')
+
+    def test_required_runtime_workflow_scope_sources_must_all_exist(self):
+        with tempfile.TemporaryDirectory() as directory:
+            model = Path(directory).resolve()
+            for name in p.SOURCE_FILES:
+                (model / name).write_text('# pure test source\n', encoding='utf-8')
+            result = p.source_inventory(model)
+            self.assertEqual(len(result), 21)
+            self.assertIn(str(model / 'engineering_workflow.py'), result)
+            self.assertIn(str(model / 'engineering_scopes.py'), result)
+            self.assertIn(str(model / 'engineering_analysis.py'), result)
+            (model / 'engineering_workflow.py').unlink()
+            with self.assertRaisesRegex(ValueError, 'Required engineering source'):
+                p.source_inventory(model)
+
+    def test_byte_budget_reserve_is_not_a_license_to_delete_partials(self):
+        with tempfile.TemporaryDirectory() as directory:
+            experiment = Path(directory).resolve() / 'new'
+            experiment.mkdir(); (experiment / 'partial').write_bytes(b'x')
+            with patch.object(p.shutil, 'disk_usage', return_value=types.SimpleNamespace(free=30 * 1024**3)):
+                self.assertEqual(p._budget(experiment)['used_bytes'], 1)
+            with patch.object(p.shutil, 'disk_usage', return_value=types.SimpleNamespace(free=5 * 1024**3)):
+                with self.assertRaisesRegex(ValueError, 'Insufficient'):
+                    p._budget(experiment)
+            self.assertTrue((experiment / 'partial').is_file())
+
+    def test_row_mapping_rejects_unplanned_or_escaping_paths(self):
+        with tempfile.TemporaryDirectory() as directory:
+            exp = Path(directory).resolve(); case = exp / 'cases/safe-row'; case.mkdir(parents=True)
+            reg = {'plan': {'rows': [{'row_id': 'safe-row'}]}, 'cases': {'safe-row': {'case_dir': str(case)}}}
+            with patch.object(p, 'EXP', exp):
+                self.assertEqual(p.row_path(reg, 'safe-row'), case)
+                with self.assertRaises(ValueError):
+                    p.row_path(reg, '../outside')
+                reg['cases']['safe-row']['case_dir'] = str(exp)
+                with self.assertRaises(ValueError):
+                    p.row_path(reg, 'safe-row')
+
+
+if __name__ == '__main__':
+    unittest.main()

models/male-cns-lif/olfactory-conditioning-lab-v1/test_engineering_queue_audit.py

@@ -0,0 +1,229 @@
+"""Small synthetic CSR/record tests only; no brain, GPU or artifact writes."""
+import ast
+import copy
+import hashlib
+import json
+from pathlib import Path
+import struct
+import unittest
+
+import numpy as np
+
+import engineering_queue_audit as audit
+
+
+def digest(array):
+    return hashlib.sha256(np.ascontiguousarray(array).tobytes()).hexdigest()
+
+
+def queue_row(tick, edges, accepted):
+    # Independent simple whole-payload construction, unlike the chunked audit.
+    edge_bytes = np.asarray(edges, dtype='<i8').tobytes()
+    mask_bytes = np.asarray(accepted, dtype=np.uint8).tobytes()
+    return dict(tick=tick, count=len(edges), accepted_count=int(sum(accepted)),
+                ordered_edge_sha256=hashlib.sha256(edge_bytes).hexdigest(),
+                accepted_mask_sha256=hashlib.sha256(mask_bytes).hexdigest(),
+                joint_sha256=hashlib.sha256(b'phase4af-queue-v1\0' + struct.pack('<qq', tick, len(edges)) + edge_bytes + mask_bytes).hexdigest())
+
+
+def fixture(*, target_fire=True, weights=None, events=None, cuts=(5, 18, 19, 37)):
+    ptr = np.array([0, 2, 3, 4, 5], np.int64)
+    dst = np.array([2, 1, 2, 0, 2], np.int32)
+    edge_id = np.array([10, 11, 20, 30, 40], np.int64)
+    weights = np.array([.001, 0., -.002, .003, .004], np.float64) if weights is None else weights
+    total, n = 60, 4
+    if events is None:
+        events = [(0, 0), (0, 1), *(([(18, 2)]) if target_fire else []), (22, 0), (23, 1), (44, 0)]
+    events = sorted(events)
+    request_events = sorted(set(events + [(1, 0)]))
+    ticks, nodes = np.array([x[0] for x in events], np.int32), np.array([x[1] for x in events], np.int32)
+    requests = {'tick': np.array([x[0] for x in request_events], np.int32),
+                'neuron_idx': np.array([x[1] for x in request_events], np.int32)}
+    refs, expanded, masks, request_rows = [], [], [], []
+    last = np.full(n, -10000, np.int64)
+    for tick in range(total):
+        for when, neuron in request_events:
+            if when == tick:
+                accepted = int(tick - last[neuron] >= 22)
+                request_rows.append([tick, neuron, 1, accepted, 1 - accepted])
+        for when, neuron in events:
+            if when == tick:
+                last[neuron] = tick
+        ref = np.maximum(22 - (tick - last), 0).astype(np.int32)
+        refs.append(ref)
+        edges = [j for when, neuron in events if when == tick - 18 for j in range(int(ptr[neuron]), int(ptr[neuron + 1]))]
+        expanded.append(np.asarray(edges, np.int64))
+        masks.append((ref[dst[edges]] == 0).astype(np.uint8))
+
+    def record(start, stop):
+        selected = (ticks >= start) & (ticks < stop)
+        ev_t, ev_n = (ticks[selected] - start).copy(), nodes[selected].copy()
+        rows = np.array([row for row in request_rows if start <= row[0] < stop], np.int64).reshape(-1, 5)
+        rows[:, 0] -= start
+        return {'steps': stop - start, 'global_tick_offset': start,
+                'summary': {'pass_all': False},  # Never treated as authority.
+                'state': {'step': ev_t, 'neuron_idx': ev_n, 'counts': np.bincount(ev_n, minlength=n).astype(np.int32),
+                          'v': np.zeros(n, np.float64), 'g': np.zeros(n, np.float64), 'ref': refs[stop - 1].copy()},
+                'requests': rows,
+                'queues': [queue_row(t - start, edge_id[expanded[t]], masks[t]) for t in range(start, stop)],
+                'state_hashes': [{'tick': t - start, 'v_sha256': digest(np.zeros(n, np.float64)),
+                                  'g_sha256': digest(np.zeros(n, np.float64)), 'ref_sha256': digest(refs[t])} for t in range(start, stop)]}
+    intervals = list(zip([0, *cuts], [*cuts, total]))
+    return {'mono': record(0, total), 'parts': [record(a, b) for a, b in intervals], 'ptr': ptr, 'dst': dst,
+            'edge_id': edge_id, 'effective_weights': weights, 'requests': requests, 'cuts': list(cuts)}
+
+
+def run(data):
+    return audit.audit_queues(data['mono'], data['parts'], **{k: data[k] for k in
+        ('ptr', 'dst', 'edge_id', 'effective_weights', 'requests', 'cuts')})
+
+
+class QueueAudit(unittest.TestCase):
+    def test_real_edge_witness_and_local_headers_cross_18_19(self):
+        data = fixture()
+        result = run(data)
+        self.assertTrue(result['pass_all'], result['differences'])
+        witness = result['first_witness']
+        self.assertEqual((witness['boundary_tick'], witness['source_spike_tick'], witness['arrival_tick']), (37, 22, 40))
+        self.assertEqual((witness['source_neuron_idx'], witness['target_neuron_idx'], witness['global_edge_id']), (0, 2, 10))
+        self.assertEqual(witness['effective_weight_float64_le_hex'], np.asarray(.001, dtype='<f8').tobytes().hex())
+        self.assertFalse(result['membrane_dynamics_independently_replayed'])
+        self.assertFalse(result['v_g_hashes_independently_verified'])
+        self.assertEqual(result['rejected_requests'], 1)
+        # The tick44 source has arrival62, beyond this 60-tick record; no tail
+        # simulation or accidental drain is performed by the audit.
+        self.assertEqual(result['arriving_edges'], 7)
+        self.assertEqual(result['accepted_arriving_edges'], 2)
+        json.dumps(result, allow_nan=False)
+        self.assertNotEqual(data['mono']['queues'][18]['joint_sha256'], data['parts'][2]['queues'][0]['joint_sha256'])
+
+    def test_current_threshold_reset_rejects_arrival_and_available_target_accepts(self):
+        rejected = fixture(); accepted = fixture(target_fire=False)
+        self.assertEqual(rejected['mono']['queues'][18]['accepted_count'], 0)
+        self.assertEqual(accepted['mono']['queues'][18]['accepted_count'], 2)
+        self.assertTrue(run(rejected)['pass_all'])
+        witness = run(accepted)['first_witness']
+        self.assertEqual((witness['source_spike_tick'], witness['arrival_tick']), (0, 18))
+
+    def test_zero_weight_edges_stay_in_queue_but_cannot_supply_witness(self):
+        data = fixture(weights=np.zeros(5, np.float64))
+        result = run(data)
+        self.assertTrue(result['queue_ref_request_exact'])
+        self.assertGreater(result['arriving_edges'], 0)
+        self.assertFalse(result['pass_all'])
+        self.assertEqual(result['status'], 'INCOMPLETE-NO-ACCEPTED-NONZERO-CROSSING')
+        self.assertIsNone(result['first_witness'])
+
+    def test_target_sorted_or_reversed_queue_fails_even_when_both_outputs_agree(self):
+        data = fixture()
+        bad = queue_row(18, [20, 11, 10], [0, 0, 0])
+        data['mono']['queues'][18] = bad
+        data['parts'][2]['queues'][0] = queue_row(0, [20, 11, 10], [0, 0, 0])
+        result = run(data)
+        self.assertFalse(result['pass_all'])
+        self.assertTrue(any(d['field'] == 'queue.ordered_edge_sha256' for d in result['differences']))
+
+    def test_global_tick_in_segment_joint_header_fails(self):
+        data = fixture()
+        data['parts'][2]['queues'][0]['joint_sha256'] = data['mono']['queues'][18]['joint_sha256']
+        result = run(data)
+        self.assertEqual(result['difference_count'], 1)
+        self.assertEqual(result['differences'][0]['field'], 'queue.joint_sha256')
+
+    def test_fake_request_acceptance_and_ref_hash_fail_independently(self):
+        for mutate in ('request', 'hash', 'terminal'):
+            data = fixture()
+            if mutate == 'request':
+                data['parts'][0]['requests'][2, 3:] = [1, 0]
+            elif mutate == 'hash':
+                data['parts'][1]['state_hashes'][3]['ref_sha256'] = 'a' * 64
+            else:
+                data['parts'][0]['state']['ref'][0] = 0
+            with self.subTest(mutate=mutate):
+                self.assertFalse(run(data)['pass_all'])
+
+    def test_impossible_spikes_during_ref_fail_even_with_self_consistent_records(self):
+        data = fixture(events=[(0, 0), (1, 0), (23, 0)])
+        result = run(data)
+        self.assertFalse(result['pass_all'])
+        self.assertTrue(any(d['field'] == 'spike_during_refractory' for d in result['differences']))
+
+    def test_original_accepted_request_cannot_disappear_from_all_outputs(self):
+        data = fixture()
+        rows = sorted(zip(data['requests']['tick'].tolist(), data['requests']['neuron_idx'].tolist()))
+        rows.append((4, 3)); rows.sort()
+        data['requests'] = {'tick': np.array([r[0] for r in rows], np.int32),
+                            'neuron_idx': np.array([r[1] for r in rows], np.int32)}
+        result = run(data)
+        self.assertFalse(result['pass_all'])
+        self.assertTrue(any(d['field'] == 'accepted_request_without_spike' for d in result['differences']))
+
+    def test_segment_events_cannot_cancel_or_substitute_nodes(self):
+        data = fixture()
+        data['parts'][0]['state']['neuron_idx'][1] = 3
+        data['parts'][0]['state']['counts'] = np.array([1, 0, 0, 1], np.int32)
+        result = run(data)
+        self.assertFalse(result['pass_all'])
+        self.assertTrue(any(d['field'] == 'events.neuron_idx' for d in result['differences']))
+
+    def test_missing_queue_or_wrong_cuts_fail_closed(self):
+        for mutate in ('missing', 'cuts', 'offset', 'dtype', 'nan'):
+            data = fixture()
+            if mutate == 'missing':
+                data['parts'][0]['queues'] = None
+            elif mutate == 'cuts':
+                data['cuts'][1] += 1
+            elif mutate == 'offset':
+                data['mono']['global_tick_offset'] = 1
+            elif mutate == 'dtype':
+                data['effective_weights'] = data['effective_weights'].astype(np.float32)
+            else:
+                data['effective_weights'][0] = np.nan
+            with self.subTest(mutate=mutate), self.assertRaises(ValueError):
+                run(data)
+
+    def test_negative_nonzero_edge_is_valid_witness_without_valence_claim(self):
+        data = fixture(target_fire=False)
+        data['effective_weights'][:2] = 0
+        result = run(data)
+        self.assertTrue(result['pass_all'])
+        self.assertEqual(result['first_witness']['global_edge_id'], 20)
+        self.assertLess(result['first_witness']['effective_weight_SI_volt'], 0)
+        self.assertFalse(result['unique_causal_or_necessity_claim'])
+
+    def test_input_arrays_are_not_modified(self):
+        data = fixture(); original = copy.deepcopy(data)
+        run(data)
+        for key in ('ptr', 'dst', 'edge_id', 'effective_weights'):
+            self.assertEqual(data[key].tobytes(), original[key].tobytes())
+        for key in data['requests']:
+            self.assertEqual(data['requests'][key].tobytes(), original['requests'][key].tobytes())
+        self.assertEqual(data['mono']['state']['ref'].tobytes(), original['mono']['state']['ref'].tobytes())
+
+    def test_frozen_AF_queue_definition_AST_crosscheck_and_chunk_order(self):
+        source = Path(__file__).resolve().parents[1] / 'author-fullgraph-lab-v1' / 'oracle_full.py'
+        raw = source.read_bytes()
+        self.assertEqual(hashlib.sha256(raw).hexdigest(), audit.AF_QUEUE_SOURCE_SHA256)
+        tree = ast.parse(raw)
+        definition = [n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == 'queue_summary']
+        self.assertEqual(len(definition), 1)
+        namespace = dict(np=np, hashlib=hashlib, struct=struct, BLOCK_BYTES=8 << 20, QUEUE_HEADER=b'phase4af-queue-v1\0')
+        exec(compile(ast.Module(body=definition, type_ignores=[]), str(source), 'exec'), namespace)
+        data = fixture()
+        saved = audit.CHUNK
+        try:
+            audit.CHUNK = 1  # Exercise edge pass then mask pass across boundaries.
+            for tick, local, sources, ref in [(18, 0, np.array([0, 1]), np.array([4, 4, 22, 0], np.int32)),
+                                               (40, 3, np.array([0]), np.zeros(4, np.int32)),
+                                               (0, 0, np.empty(0, np.int32), np.zeros(4, np.int32))]:
+                rows, _, _ = audit._queue(tick, local, sources, ref, data['ptr'], data['dst'], data['edge_id'], data['effective_weights'], [])
+                indices = np.array([j for s in sources for j in range(data['ptr'][s], data['ptr'][s + 1])], np.int64)
+                accepted = (ref[data['dst'][indices]] == 0).astype(np.uint8)
+                for at, row in zip((tick, local), rows):
+                    self.assertEqual(row, namespace['queue_summary'](at, data['edge_id'][indices], accepted, chunk_bytes=8))
+        finally:
+            audit.CHUNK = saved
+
+
+if __name__ == '__main__':
+    unittest.main()

models/male-cns-lif/olfactory-conditioning-lab-v1/test_engineering_scopes.py

@@ -0,0 +1,214 @@
+"""Pure synthetic records, deliberately not a neural simulation or file test."""
+import hashlib
+import json
+import unittest
+
+import numpy as np
+
+import engineering_scopes as s
+
+
+def sha(array):
+    return hashlib.sha256(np.ascontiguousarray(array).tobytes()).hexdigest()
+
+
+def record(start, stop, *, reference=True, blank_requests=False):
+    n, k, length = 3, 2, stop - start
+    ticks = np.array([0, 7, 19, 21, 41, 61], np.int32)
+    nodes = np.array([0, 1, 2, 0, 2, 1], np.int32)
+    selected = (ticks >= start) & (ticks < stop)
+    event_ticks, event_nodes = ticks[selected] - np.int32(start), nodes[selected].copy()
+    v = np.array([-.05, -.04, -.03], np.float64)
+    g = np.array([-0., float(stop - 1), -.001], np.float64)
+    ref = np.zeros(n, np.int32)
+    state = dict(step=event_ticks, neuron_idx=event_nodes, counts=np.bincount(event_nodes, minlength=n).astype(np.int32),
+                 v=v, g=g, ref=ref)
+    raw_global = np.zeros((19, n), np.uint8)
+    for tick, node in zip(ticks, nodes):
+        if max(0, stop - 19) <= tick < stop:
+            raw_global[tick % 19, node] = 1
+    normalized = raw_global[(np.arange(19) + stop % 19) % 19]
+    raw_local = normalized[(np.arange(19) - length % 19) % 19].copy()
+    generated_all = np.repeat(np.arange(1, stop + 1, dtype=np.float32)[:, None], k, axis=1)
+    applied_all = np.concatenate((np.zeros((18, k), np.float32), generated_all))[:stop]
+    pending = np.zeros((18, k), np.float32)
+    kept = min(stop, 18); pending[-kept:] = generated_all[-kept:]
+    apl_state = np.full(2, np.float32(stop + 1), np.float32)
+    terminal = dict(spike_ring=raw_local, apl_state=apl_state, apl_pending=pending, next_tick=np.asarray(length, np.int64))
+    trace = dict(generated=generated_all[start:stop].copy(), applied=applied_all[start:stop].copy(),
+                 drive=np.repeat(np.arange(start, stop, dtype=np.float32)[:, None], 2, axis=1),
+                 state=np.repeat(np.arange(start + 2, stop + 2, dtype=np.float32)[:, None], 2, axis=1))
+    hashes, queues = [], []
+    for local, global_tick in enumerate(range(start, stop)):
+        hashes.append(dict(tick=local, v_sha256=sha(v), g_sha256=sha(np.array([-0., float(global_tick), -.001], np.float64)),
+                           ref_sha256=sha(ref)))
+        edges, accepted = np.array([global_tick], np.int64), np.array([global_tick % 2], np.uint8)
+        queues.append(dict(tick=local, count=1, accepted_count=int(accepted.sum()), ordered_edge_sha256=sha(edges),
+                           accepted_mask_sha256=sha(accepted), joint_sha256=hashlib.sha256(
+                               str(local).encode() + edges.tobytes() + accepted.tobytes()).hexdigest()))
+    requests = np.array([[int(t), int(i), 1, 1, 0] for t, i in zip(event_ticks, event_nodes)], np.int64).reshape(-1, 5)
+    if blank_requests:
+        requests = np.empty((0, 5), np.int64)
+    summary = dict(complete=True, pass_all=True, all_finite=True, steps=length, completed_ticks=length, nodes=n,
+                   precision='float64', apl_precision='float32', apl_delay_steps=18,
+                   checkpoint_continuation_used=start > 0, global_tick_offset=start, global_next_tick=stop,
+                   effective_weights_raw_sha256='e' * 64, diagnostic_mode='reference' if reference else 'light',
+                   full_APL_history_recorded=reference, full_tick_state_hashes_recorded=reference,
+                   full_queue_hashes_recorded=reference)
+    return dict(source='synthetic', state=state, terminal=terminal, requests=requests, steps=length,
+                global_tick_offset=start, summary=summary, traces=trace if reference else {},
+                state_hashes=hashes if reference else None, queues=queues if reference else None,
+                terminal_origin='synthetic_recorded')
+
+
+class SliceTests(unittest.TestCase):
+    def test_reference_slice_all_observations_exact_and_inputs_unchanged(self):
+        candidate, whole = record(20, 44), record(0, 64)
+        before = candidate['terminal']['spike_ring'].tobytes(), whole['requests'].tobytes()
+        report = s.compare_slice(candidate, whole)
+        self.assertTrue(report['numerical_exact'], report['failed_checks'])
+        self.assertTrue(report['observed_scope']['candidate_per_tick_state_hashes'])
+        self.assertTrue(report['observed_scope']['candidate_per_tick_queue_fields'])
+        self.assertFalse(report['observed_scope']['queue_joint_hashes_compared'])
+        self.assertNotEqual(candidate['queues'][0]['joint_sha256'], whole['queues'][20]['joint_sha256'])
+        self.assertEqual(before, (candidate['terminal']['spike_ring'].tobytes(), whole['requests'].tobytes()))
+        json.dumps(report, allow_nan=False)
+
+    def test_light_uses_final_raw_hash_but_does_not_fabricate_optional_history(self):
+        report = s.compare_slice(record(20, 44, reference=False), record(0, 64))
+        self.assertTrue(report['numerical_exact'])
+        self.assertTrue(report['observed_scope']['final_state_against_reference_tick_hash'])
+        for name in ('candidate_APL_histories', 'candidate_per_tick_state_hashes', 'candidate_per_tick_queue_fields'):
+            self.assertFalse(report['observed_scope'][name])
+        self.assertNotIn('slice.per_tick_state_hashes', report['checks'])
+        self.assertTrue(any('unobserved' in item for item in report['limitations']))
+
+    def test_short_fresh_positive_zero_padding_and_prefix_events(self):
+        self.assertTrue(s.compare_slice(record(0, 5), record(0, 64))['numerical_exact'])
+        candidate = record(0, 5, reference=False)
+        candidate['terminal']['apl_pending'][0, 0] = np.float32(-0.)
+        report = s.compare_slice(candidate, record(0, 64))
+        self.assertFalse(report['checks']['slice.APL_pending'])
+
+    def test_blank_requests_are_valid_but_wrong_acceptance_is_not_equal(self):
+        self.assertTrue(s.compare_slice(record(20, 44, blank_requests=True), record(0, 64, blank_requests=True))['numerical_exact'])
+        candidate = record(20, 44)
+        candidate['requests'][0, 3:] = [0, 1]
+        report = s.compare_slice(candidate, record(0, 64))
+        self.assertFalse(report['checks']['slice.requests_five_fields'])
+
+    def test_wrong_count_or_final_hash_binding_is_invalid_not_a_pass(self):
+        for mutation in ('count', 'terminal', 'last_hash'):
+            candidate = record(20, 44)
+            if mutation == 'count': candidate['state']['counts'][0] += 1
+            elif mutation == 'terminal': candidate['state']['g'][1] += 1.
+            else: candidate['state_hashes'][-1]['g_sha256'] = '0' * 64
+            with self.subTest(mutation=mutation), self.assertRaises(ValueError):
+                s.compare_slice(candidate, record(0, 64))
+
+    def test_signed_zero_light_terminal_vs_reference_hash_is_detected(self):
+        candidate = record(20, 44, reference=False)
+        candidate['state']['g'][0] = 0.
+        report = s.compare_slice(candidate, record(0, 64))
+        self.assertFalse(report['checks']['slice.final_g_raw_hash'])
+
+    def test_interior_trace_state_hash_and_queue_mismatch_are_not_hidden(self):
+        candidate = record(20, 44)
+        candidate['traces']['drive'][1, 0] += np.float32(1.)
+        candidate['state_hashes'][1]['v_sha256'] = '0' * 64
+        candidate['queues'][1]['accepted_mask_sha256'] = '1' * 64
+        report = s.compare_slice(candidate, record(0, 64))
+        for key in ('slice.APL_trace.drive', 'slice.per_tick_state_hashes', 'slice.queue_order_and_acceptance'):
+            self.assertFalse(report['checks'][key])
+
+    def test_missing_reference_observations_and_invalid_bounds_fail_closed(self):
+        for mutation in ('light_mono', 'light_labeled_full_mono', 'mono_hashes', 'candidate_traces', 'partial_trace', 'out_of_bounds', 'nonzero_mono'):
+            candidate, mono = record(20, 44), record(0, 64)
+            if mutation == 'light_mono': mono = record(0, 64, reference=False)
+            elif mutation == 'light_labeled_full_mono': mono['summary']['diagnostic_mode'] = 'light'
+            elif mutation == 'mono_hashes': mono['state_hashes'] = None
+            elif mutation == 'candidate_traces': candidate['traces'] = {}
+            elif mutation == 'partial_trace': candidate['traces'].pop('drive')
+            elif mutation == 'out_of_bounds': candidate = record(60, 65)
+            else: mono = record(1, 65)
+            with self.subTest(mutation=mutation), self.assertRaises(ValueError):
+                s.compare_slice(candidate, mono)
+
+    def test_summary_type_scope_nonfinite_and_paths_rejected(self):
+        for mutation in ('bool', 'failed', 'offset', 'mode', 'weight', 'nan'):
+            candidate = record(20, 44)
+            if mutation == 'bool': candidate['summary']['steps'] = True
+            elif mutation == 'failed': candidate['summary']['pass_all'] = False
+            elif mutation == 'offset': candidate['summary']['global_tick_offset'] = 0
+            elif mutation == 'mode': candidate['summary']['diagnostic_mode'] = 'unknown'
+            elif mutation == 'weight': candidate['summary'].pop('effective_weights_raw_sha256')
+            else: candidate['state']['g'][0] = np.nan
+            with self.subTest(mutation=mutation), self.assertRaises(ValueError):
+                s.compare_slice(candidate, record(0, 64))
+        with self.assertRaises(ValueError): s.compare_slice('/never/open/this', record(0, 64))
+
+
+class CheckpointTests(unittest.TestCase):
+    def test_local_phase_normalization_without_segment_cumulative_counts_confusion(self):
+        candidate, prefix = record(20, 64), record(0, 64)
+        self.assertFalse(s.ec.bit_equal(candidate['terminal']['spike_ring'], prefix['terminal']['spike_ring']))
+        self.assertFalse(s.ec.bit_equal(candidate['state']['counts'], prefix['state']['counts']))
+        report = s.compare_checkpoint(candidate, prefix)
+        self.assertTrue(report['numerical_exact'], report['failed_checks'])
+        self.assertFalse(report['observed_scope']['counts_compared'])
+        self.assertFalse(report['observed_scope']['per_tick_state_histories_compared'])
+
+    def test_signed_zero_different_stop_or_effective_weights_cannot_pass(self):
+        for mutation in ('zero', 'stop', 'weight'):
+            candidate, prefix = record(20, 64, reference=False), record(0, 64, reference=False)
+            if mutation == 'zero': candidate['state']['g'][0] = 0.
+            elif mutation == 'stop': prefix = record(0, 63, reference=False)
+            else: candidate['summary']['effective_weights_raw_sha256'] = 'f' * 64
+            with self.subTest(mutation=mutation):
+                self.assertFalse(s.compare_checkpoint(candidate, prefix)['numerical_exact'])
+
+
+class ParentCarryTests(unittest.TestCase):
+    def test_short_parent_carry_observed_and_json_safe(self):
+        report = s.compare_parent_carry(record(20, 25), record(0, 20))
+        self.assertTrue(report['numerical_exact'], report['failed_checks'])
+        self.assertEqual(report['observed_scope']['unwritten_spike_slot_count'], 14)
+        self.assertEqual(report['observed_scope']['unconsumed_APL_row_count'], 13)
+        self.assertEqual(report['observed_scope']['applied_parent_APL_rows_compared'], 5)
+        json.dumps(report, allow_nan=False)
+
+    def test_unwritten_or_unconsumed_corruption_detected_even_if_terminal_is_self_consistent(self):
+        for mutation in ('ring', 'pending', 'applied'):
+            candidate = record(20, 25)
+            if mutation == 'ring': candidate['terminal']['spike_ring'][10, 0] ^= np.uint8(1)
+            elif mutation == 'pending': candidate['terminal']['apl_pending'][0, 0] += np.float32(1.)
+            else: candidate['traces']['applied'][0, 0] += np.float32(1.)
+            with self.subTest(mutation=mutation):
+                self.assertFalse(s.compare_parent_carry(candidate, record(0, 20))['numerical_exact'])
+
+    def test_light_missing_optional_applied_trace_is_not_fabricated(self):
+        report = s.compare_parent_carry(record(20, 25, reference=False), record(0, 20))
+        self.assertTrue(report['numerical_exact'])
+        self.assertFalse(report['observed_scope']['applied_parent_APL_prefix_checked'])
+        self.assertIsNone(report['observed_scope']['applied_parent_APL_rows_compared'])
+        self.assertNotIn('parent.applied_APL_prefix', report['checks'])
+
+    def test_long_segment_discloses_no_unwritten_slots_and_wrong_parent_clock_fails(self):
+        report = s.compare_parent_carry(record(20, 44), record(0, 20))
+        self.assertTrue(report['numerical_exact'])
+        self.assertFalse(report['observed_scope']['unwritten_spike_slots_checked'])
+        self.assertFalse(report['observed_scope']['unconsumed_APL_prefix_checked'])
+        self.assertEqual(report['observed_scope']['applied_parent_APL_rows_compared'], 18)
+        self.assertFalse(s.compare_parent_carry(record(20, 44), record(0, 19))['numerical_exact'])
+        with self.assertRaises(ValueError): s.compare_parent_carry(record(0, 5), record(0, 20))
+
+    def test_long_light_carry_scope_explicitly_has_no_observed_carry_array(self):
+        report = s.compare_parent_carry(record(20, 44, reference=False), record(0, 20))
+        self.assertTrue(report['numerical_exact'])
+        self.assertFalse(report['observed_scope']['any_carry_values_directly_compared'])
+        self.assertTrue(any('clock/shape/weight identity only' in line for line in report['limitations']))
+        self.assertFalse(report['complete_dynamical_equivalence_proven'])
+
+
+if __name__ == '__main__':
+    unittest.main()

models/male-cns-lif/olfactory-conditioning-lab-v1/test_engineering_workflow.py

@@ -0,0 +1,207 @@
+import copy
+import hashlib
+import json
+from pathlib import Path
+import tempfile
+import types
+import unittest
+from unittest.mock import patch
+
+import numpy as np
+
+import engineering_workflow as w
+from test_engineering_inputs import spec
+
+
+def template(row):
+    return dict(schema='phase4an-engineering-case-template-v1', row_id=row['row_id'], original_spec=spec(),
+                start=row['start'], stop=row['stop'], budget_root='/project/new', output_budget_bytes=8 * 1024**3)
+
+
+class Workflow(unittest.TestCase):
+    def test_only_exact_plan_row_and_safe_output_identity(self):
+        reg = {'plan': w.PLAN.build_plan()}
+        row = reg['plan']['rows'][0]
+        self.assertEqual(w.row_from(reg, row['row_id']), row)
+        for bad in ('unknown', '../escape', '/absolute'):
+            with self.assertRaises(ValueError): w.row_from(reg, bad)
+        for bad in ('../escape', '/absolute', 'a/b', 'a\\b', '', 'a:b'):
+            with self.assertRaises(ValueError): w.locations(bad)
+        reg['plan']['rows'][0]['steps'] = True
+        with self.assertRaises(ValueError): w.row_from(reg, row['row_id'])
+
+    def test_real_parent_is_required_only_for_later_segments(self):
+        for row in w.PLAN.build_plan()['rows']:
+            before = template(row)
+            pin = None if row['parent_row_id'] is None else 'a' * 64
+            derived, audit = w.derive_case(before, row, pin)
+            self.assertEqual(derived['steps'], row['steps'])
+            self.assertEqual(before, template(row))
+            self.assertEqual(audit['input_interval'], [row['start'], row['stop']])
+            with self.assertRaises(ValueError):
+                w.derive_case(before, row, 'a' * 64 if pin is None else None)
+
+    def test_forged_template_and_boolean_interval_rejected(self):
+        row = w.PLAN.build_plan()['rows'][0]
+        for key, value in (('schema', 'wrong'), ('row_id', 'wrong'), ('start', False), ('stop', 18)):
+            changed = template(row); changed[key] = value
+            with self.subTest(key=key), self.assertRaises(ValueError): w.derive_case(changed, row, None)
+        changed = template(row); changed['extra'] = True
+        with self.assertRaises(ValueError): w.derive_case(changed, row, None)
+
+    def test_json_comparison_does_not_conflate_booleans_and_numbers(self):
+        self.assertFalse(w.same_json({'n': True}, {'n': 1}))
+        self.assertFalse(w.same_json({'n': 1.}, {'n': 1}))
+        with self.assertRaises(ValueError): w.canonical({'n': float('nan')})
+
+    def test_actual_precision_flags_are_checked_not_merely_recorded(self):
+        component = dict(cuda_matmul_allow_tf32=False, cudnn_allow_tf32=True, deterministic_algorithms=False,
+            cudnn_deterministic=False, cudnn_benchmark=False, float32_matmul_precision='highest',
+            CUBLAS_WORKSPACE_CONFIG=None, device_name='NVIDIA GeForce RTX 4090', torch='2.test', cuda='13.0',
+            numpy='2.test', precision_configuration_changed_by_component=False)
+        recorded = dict(gpu_uuid=w.GPU, settings_changed_by_environment_recorder=False,
+            matmul_allow_tf32=False, cudnn_allow_tf32=True, deterministic_algorithms=False,
+            cudnn_deterministic=False, cudnn_benchmark=False, float32_matmul_precision='highest',
+            CUBLAS_WORKSPACE_CONFIG=None, device_name='NVIDIA GeForce RTX 4090', torch_version='2.test',
+            torch_cuda_version='13.0', numpy_version='2.test')
+        w.verify_environment(recorded, component)
+        for key, value in [('cuda_matmul_allow_tf32', True), ('float32_matmul_precision', 'high'),
+                           ('precision_configuration_changed_by_component', True), ('cudnn_allow_tf32', False)]:
+            altered = dict(component, **{key: value})
+            with self.subTest(key=key), self.assertRaises(ValueError): w.verify_environment(recorded, altered)
+        with self.assertRaises(ValueError): w.verify_environment(dict(recorded, matmul_allow_tf32=0), component)
+
+    def test_npz_real_compression_measured_not_assumed(self):
+        with tempfile.TemporaryDirectory() as name:
+            root = Path(name)
+            with (root / 'compressed.npz').open('xb') as stream:
+                np.savez_compressed(stream, v=np.zeros(50, np.float64))
+            measured = w.npz_storage(root / 'compressed.npz')
+            self.assertGreater(measured['uncompressed_entry_bytes'], measured['compressed_entry_bytes'])
+            self.assertEqual(measured['entries'][0]['compression'], 8)
+            with (root / 'stored.npz').open('xb') as stream:
+                np.savez(stream, v=np.zeros(50, np.float64))
+            with self.assertRaises(ValueError): w.npz_storage(root / 'stored.npz')
+
+    def test_resource_limit_preserves_existing_payload(self):
+        with tempfile.TemporaryDirectory() as name, patch.object(w, 'EXP', Path(name)):
+            path = Path(name) / 'payload.bin'
+            path.write_bytes(b'not deleted')
+            reg = {'budget': {'output_budget_bytes': 1, 'minimum_free_reserve_bytes': 1}}
+            with self.assertRaises(ValueError): w.disk_budget(reg)
+            self.assertEqual(path.read_bytes(), b'not deleted')
+
+    def _temporary_gate(self, root):
+        for name in ('audit', 'logs', 'receipts', 'runs', 'cases'):
+            (root / name).mkdir()
+        reg = {'plan': w.PLAN.build_plan(), 'budget': {'output_budget_bytes': 1 << 20,
+                                                     'minimum_free_reserve_bytes': 1}}
+        return reg, types.SimpleNamespace(read_registration=lambda sha: copy.deepcopy(reg))
+
+    def test_controller_refuses_partial_without_rerun_or_deletion(self):
+        with tempfile.TemporaryDirectory() as name, patch.object(w, 'EXP', Path(name)):
+            root = Path(name); reg, prep = self._temporary_gate(root)
+            paths = w.locations(reg['plan']['rows'][0]['row_id'])
+            paths['stdout'].write_bytes(b'original evidence')
+            with (patch.object(w, 'preparation', return_value=prep), patch.object(w, 'preflight') as pre,
+                  patch.object(w.subprocess, 'run') as runner):
+                with self.assertRaisesRegex(ValueError, 'Partial row'):
+                    w.run_registered('a' * 64)
+                runner.assert_not_called(); pre.assert_not_called()
+            self.assertEqual(paths['stdout'].read_bytes(), b'original evidence')
+            self.assertFalse(paths['execution'].exists())
+            self.assertTrue((root / 'audit/stopped.json').exists())
+
+    def test_nonzero_worker_exit_cannot_become_completed_receipt(self):
+        with tempfile.TemporaryDirectory() as name, patch.object(w, 'EXP', Path(name)):
+            root = Path(name); reg, prep = self._temporary_gate(root)
+            paths = w.locations(reg['plan']['rows'][0]['row_id'])
+            failure = types.SimpleNamespace(returncode=1)
+            with (patch.object(w, 'preparation', return_value=prep), patch.object(w, 'preflight'),
+                  patch.object(w.subprocess, 'run', return_value=failure) as runner):
+                with self.assertRaisesRegex(ValueError, 'Worker failed'):
+                    w.run_registered('a' * 64)
+                self.assertEqual(runner.call_count, 1)
+            self.assertTrue(paths['stdout'].exists() and paths['stderr'].exists())
+            self.assertFalse(paths['execution'].exists())
+            self.assertTrue((root / 'audit/stopped.json').exists())
+
+    def test_stopped_inventory_cannot_auto_resume(self):
+        with tempfile.TemporaryDirectory() as name, patch.object(w, 'EXP', Path(name)):
+            root = Path(name); _, prep = self._temporary_gate(root)
+            (root / 'audit/stopped.json').write_text('{}')
+            with patch.object(w, 'preparation', return_value=prep), patch.object(w.subprocess, 'run') as runner:
+                with self.assertRaisesRegex(ValueError, 'Stopped/completed'):
+                    w.run_registered('a' * 64)
+                runner.assert_not_called()
+
+    def _completion(self, reg, root):
+        entries = []
+        for row in reg['plan']['rows']:
+            path = w.locations(row['row_id'])['execution']
+            path.write_bytes(row['row_id'].encode())
+            entries.append(dict(row_id=row['row_id'], execution_sha256=w.R.digest(path), reverified_existing=False))
+        return dict(complete=True, registration_sha256='a' * 64, expected_calls=32, executed_ticks=11074,
+                    training=False, learning_pass_claimed=False, completed=entries)
+
+    def test_inventory_rechecks_every_actual_receipt(self):
+        with tempfile.TemporaryDirectory() as name, patch.object(w, 'EXP', Path(name)):
+            root = Path(name); reg, _ = self._temporary_gate(root)
+            complete = self._completion(reg, root)
+            w.R._save(root / 'audit/execution-complete.json', complete)
+            with patch.object(w, 'verify_execution', side_effect=lambda r, s, row: dict(row=row)) as verify:
+                records = w.verified_inventory(reg, 'a' * 64)
+                self.assertEqual(verify.call_count, 32)
+                self.assertEqual(list(records), [row['row_id'] for row in reg['plan']['rows']])
+
+    def test_inventory_rejects_reorder_missing_and_changed_receipt(self):
+        for corruption in ('reorder', 'missing', 'changed', 'claimed_training', 'wrong_ticks'):
+            with self.subTest(corruption=corruption), tempfile.TemporaryDirectory() as name, patch.object(w, 'EXP', Path(name)):
+                root = Path(name); reg, _ = self._temporary_gate(root)
+                complete = self._completion(reg, root)
+                if corruption == 'reorder': complete['completed'].reverse()
+                if corruption == 'missing': complete['completed'].pop()
+                if corruption == 'changed': w.locations(reg['plan']['rows'][0]['row_id'])['execution'].write_bytes(b'changed')
+                if corruption == 'claimed_training': complete['training'] = True
+                if corruption == 'wrong_ticks': complete['executed_ticks'] += 1
+                w.R._save(root / 'audit/execution-complete.json', complete)
+                with patch.object(w, 'verify_execution'), self.assertRaises(ValueError):
+                    w.verified_inventory(reg, 'a' * 64)
+
+    def test_seal_contains_nested_manifests_and_self_checksum(self):
+        with tempfile.TemporaryDirectory() as name, patch.object(w, 'EXP', Path(name)):
+            root = Path(name)
+            (root / 'runs' / 'one').mkdir(parents=True)
+            (root / 'runs/one/manifest.json').write_bytes(b'nested evidence')
+            (root / 'payload').write_bytes(b'payload')
+            result = w.seal_experiment()
+            manifest = json.loads((root / 'manifest.json').read_text())
+            self.assertEqual([row['path'] for row in manifest['files']], ['payload', 'runs/one/manifest.json'])
+            lines = (root / 'checksums.sha256').read_text().splitlines()
+            self.assertIn(result['manifest_sha256'] + '  manifest.json', lines)
+            self.assertEqual(len(lines), 3)
+            self.assertEqual(result['checksums_sha256'], hashlib.sha256((root / 'checksums.sha256').read_bytes()).hexdigest())
+            before = (root / 'manifest.json').read_bytes()
+            with self.assertRaises(ValueError): w.seal_experiment()
+            self.assertEqual((root / 'manifest.json').read_bytes(), before)
+
+    def test_seal_rejects_bytecode_instead_of_silently_losing_it(self):
+        with tempfile.TemporaryDirectory() as name, patch.object(w, 'EXP', Path(name)):
+            root = Path(name); (root / '__pycache__').mkdir()
+            (root / '__pycache__/a.pyc').write_bytes(b'cache')
+            with self.assertRaises(ValueError): w.seal_experiment()
+            self.assertFalse((root / 'manifest.json').exists())
+
+    def test_finalize_rejects_recomputed_difference_before_sealing(self):
+        with tempfile.TemporaryDirectory() as name, patch.object(w, 'EXP', Path(name)):
+            root = Path(name); _, prep = self._temporary_gate(root)
+            w.R._save(root / 'audit/engineering-analysis.json', dict(status='saved'))
+            with patch.object(w, 'evaluate', return_value=({}, {'status': 'different'})), patch.object(w, 'seal_experiment') as seal:
+                with self.assertRaisesRegex(ValueError, 'Recomputed analysis'):
+                    w.finalize('a' * 64)
+                seal.assert_not_called()
+            self.assertFalse((root / 'audit/final-status.json').exists())
+
+
+if __name__ == '__main__':
+    unittest.main()

models/male-cns-lif/olfactory-conditioning-lab-v1/test_runtime_continuation.py

@@ -0,0 +1,399 @@
+"""CPU synthetic checkpoint/clock tests; not a brain or GPU equivalence test."""
+import ast
+import copy
+import json
+from pathlib import Path
+import tempfile
+import types
+import unittest
+from unittest.mock import patch
+
+import numpy as np
+
+import runtime_continuation as c
+
+
+R = c.R
+AJ = Path(__file__).resolve().parent.parent / 'apl-timing-lab-v1/gpu_timing.py'
+
+
+class RingTests(unittest.TestCase):
+    def execute(self, start, steps, raw, phase, apl_pending, events, *, admit_global=True):
+        ring = c.rotate_spike_ring(raw, phase)
+        apl = apl_pending.copy()
+        due, applied = [], []
+        for tick in range(steps):
+            absolute = start + tick
+            ring[tick % 19] = events[absolute]
+            admitted = absolute >= 18 if admit_global else tick >= 18
+            due.append(ring[(tick - 18) % 19].copy() if admitted else np.zeros(ring.shape[1], np.uint8))
+            slot = tick % 18
+            applied.append(apl[slot].copy())
+            apl[slot] = np.float32(absolute + 1)
+        head = steps % 18
+        return ring, steps, np.concatenate((apl[head:], apl[:head])), np.asarray(due), np.asarray(applied)
+
+    def test_multi_segments_preserve_all_future_arrivals_and_apl_slots(self):
+        rng = np.random.default_rng(193)
+        events = rng.integers(0, 2, (80, 4), dtype=np.uint8)
+        initial, pending = np.zeros((19, 4), np.uint8), np.zeros((18, 2), np.float32)
+        full = self.execute(0, 80, initial, 0, pending, events)
+        for lengths in ((5, 13, 1, 22, 39), (17, 1, 1, 18, 43), (19, 19, 19, 23), (1,) * 80):
+            ring, phase, tail, offset, due, applied = initial, 0, pending, 0, [], []
+            for steps in lengths:
+                ring, phase, tail, d, a = self.execute(offset, steps, ring, phase, tail, events)
+                due.append(d); applied.append(a); offset += steps
+            np.testing.assert_array_equal(np.concatenate(due), full[3])
+            np.testing.assert_array_equal(np.concatenate(applied), full[4])
+            np.testing.assert_array_equal(c.rotate_spike_ring(ring, phase), c.rotate_spike_ring(full[0], 80))
+            np.testing.assert_array_equal(tail, full[2])
+
+    def test_parent_shorter_than_delay_needs_global_admission(self):
+        events = np.zeros((24, 2), np.uint8); events[0, 1] = 1
+        parent = self.execute(0, 5, np.zeros((19, 2), np.uint8), 0, np.zeros((18, 2), np.float32), events)
+        child = self.execute(5, 19, *parent[:3], events)
+        wrong = self.execute(5, 19, *parent[:3], events, admit_global=False)
+        self.assertEqual(child[3][13, 1], 1)  # absolute tick 18, local 13
+        self.assertEqual(wrong[3][13, 1], 0)
+
+    def test_local_tick_zero_request_uses_global_clock_and_ring_phase(self):
+        events = np.zeros((50, 3), np.uint8)
+        events[19, 2] = 1  # Synthetic US request at child's local tick zero.
+        first = self.execute(0, 19, np.zeros((19, 3), np.uint8), 0, np.zeros((18, 2), np.float32), events)
+        child = self.execute(19, 31, *first[:3], events)
+        self.assertEqual(child[3][18, 2], 1)
+        self.assertEqual(np.count_nonzero(child[3][:18, 2]), 0)
+
+    def test_rotation_is_copy_and_rejects_invalid_ring(self):
+        raw = np.zeros((19, 2), np.uint8); raw[18, 1] = 1
+        before = raw.tobytes()
+        result = c.rotate_spike_ring(raw, 19)
+        result[:] = 1
+        self.assertEqual(raw.tobytes(), before)
+        for value, phase in ((raw.astype(np.int32), 0), (raw[:18], 0), (raw, -1), (raw, True)):
+            with self.assertRaises(ValueError):
+                c.rotate_spike_ring(value, phase)
+
+
+class ASTTests(unittest.TestCase):
+    def test_only_restore_and_global_admission_edits_in_both_modes(self):
+        for mode in ('light', 'reference'):
+            tree, audit = c.derive_continued(AJ.read_bytes(), mode)
+            self.assertTrue(audit['full_AST_rollback_identical'])
+            self.assertTrue(audit['kernels_sorting_and_local_ring_math_unchanged'])
+            self.assertEqual(sum(isinstance(node, ast.If) and ast.unparse(node.test) == c.CLOCK_NEW for node in ast.walk(tree)), 1)
+            self.assertEqual(sum(isinstance(node, ast.Expr) and ast.unparse(node) == c.RESTORE for node in ast.walk(tree)), 1)
+            compile(tree, '<pure continuation AST>', 'exec')
+
+    def test_reference_loop_diff_is_exactly_admission_condition(self):
+        base, _ = R.derive_ast(AJ.read_bytes(), 'reference')
+        actual, _ = c.derive_continued(AJ.read_bytes(), 'reference')
+        loops = lambda tree: next(node for node in ast.walk(tree) if isinstance(node, ast.For) and
+                                 isinstance(node.target, ast.Name) and node.target.id == 'tick')
+        modified = copy.deepcopy(loops(actual))
+        changed = [node for node in ast.walk(modified) if isinstance(node, ast.If) and ast.unparse(node.test) == c.CLOCK_NEW]
+        changed[0].test = ast.parse(c.CLOCK_OLD, mode='eval').body
+        self.assertEqual(R._dump(modified), R._dump(loops(base)))
+
+    def test_compile_never_mutates_sealed_module_namespace(self):
+        module = types.ModuleType('fake_aj'); module.__file__ = str(AJ)
+        original = dict(module.__dict__)
+        runtime = types.SimpleNamespace(write_json=lambda *_: None, audit_sequence=lambda *_: None)
+        function, _ = c.compile_continued(module, runtime, 'light')
+        self.assertEqual(module.__dict__, original)
+        self.assertEqual(function.__globals__['__file__'], str(Path(c.__file__).resolve()))
+        self.assertIs(function.__globals__['_continuation'], runtime)
+
+
+class ArrayTarget:
+    def __init__(self, value):
+        self.value = np.array(value, copy=True)
+
+    def copy_(self, value):
+        self.value[...] = value
+
+    def any(self):
+        return np.asarray(self.value.any())
+
+
+class RestoreTests(unittest.TestCase):
+    def test_reference_fifo_audit_preserves_carried_bits_for_short_segment(self):
+        initial = np.arange(36, dtype=np.float32).reshape(18, 2)
+        initial[0, 0] = np.float32(-0.)
+        generated = np.arange(10, dtype=np.float32).reshape(5, 2)
+        joined = np.concatenate((initial, generated))
+        applied, pending = joined[:5], joined[5:]
+        result = c.audit_carried_sequence(generated, applied, pending, initial)
+        self.assertTrue(result['sample_bits_preserved'])
+        bad = applied.copy(); bad[0, 0] = np.float32(0.)
+        with self.assertRaisesRegex(ValueError, 'bitwise'):
+            c.audit_carried_sequence(generated, bad, pending, initial)
+
+    def test_timing_counts_and_ranges_use_absolute_clock_not_segment_length(self):
+        obj = object.__new__(c.ContinuedRuntime)
+        obj.global_offset, obj.spec, obj.mode = 41, {'steps': 5}, 'reference'
+        obj.parent = {'terminal': {'apl_pending': np.zeros((18, 4064), np.float32)}}
+        result = obj._timing_metadata({'pending_generated_count': 5, 'pending_initial_zero_prefix': 13,
+                                      'initial_padding_positive_zero': True})
+        self.assertEqual(result['pending_generated_count'], 18)
+        self.assertEqual(result['pending_initial_zero_prefix'], 0)
+        self.assertEqual(result['pending_application_tick_start'], 46)
+        self.assertEqual(result['pending_generated_tick_start'], 28)
+        self.assertEqual(result['pending_segment_generated_rows'], 5)
+        self.assertEqual(result['pending_parent_generated_rows'], 13)
+        self.assertEqual(result['applied_parent_generated_rows'], 5)
+        self.assertNotIn('initial_padding_positive_zero', result)
+
+    def test_restore_carries_exact_state_and_queues_but_not_segment_counts(self):
+        parent = {'global_next_tick': 41, 'state': {'v': np.array([-.05, -.04], np.float64),
+            'g': np.array([-0., -.002], np.float64), 'ref': np.array([22, 3], np.int32)},
+            'terminal': {'spike_ring': np.zeros((19, 2), np.uint8), 'next_tick': np.asarray(5, np.int64),
+                         'apl_pending': np.arange(36, dtype=np.float32).reshape(18, 2), 'apl_state': np.array([2., 3.], np.float32)}}
+        parent['terminal']['spike_ring'][4, 1] = 1
+        obj = object.__new__(c.ContinuedRuntime)
+        obj.parent, obj.installations, obj.restorations = parent, 1, 0
+        obj.torch = types.SimpleNamespace(float64=np.float64, float32=np.float32, int32=np.int32, uint8=np.uint8)
+        v, g, ref, counts = (ArrayTarget(np.zeros(2, dtype)) for dtype in (np.float64, np.float64, np.int32, np.int32))
+        ring, apl_ring = ArrayTarget(np.zeros((19, 2), np.uint8)), ArrayTarget(np.zeros((18, 2), np.float32))
+        apl = types.SimpleNamespace(state=ArrayTarget(np.zeros(2, np.float32)))
+        upload = lambda value, dtype: np.array(value, dtype=dtype, copy=True)
+        obj.restore(v, g, ref, counts, ring, apl_ring, apl, upload)
+        self.assertEqual(g.value.tobytes(), parent['state']['g'].tobytes())
+        np.testing.assert_array_equal(ref.value, parent['state']['ref'])
+        np.testing.assert_array_equal(counts.value, [0, 0])
+        np.testing.assert_array_equal(ring.value, c.rotate_spike_ring(parent['terminal']['spike_ring'], 5))
+        np.testing.assert_array_equal(apl_ring.value, parent['terminal']['apl_pending'])
+        np.testing.assert_array_equal(apl.state.value, parent['terminal']['apl_state'])
+        with self.assertRaises(ValueError):
+            obj.restore(v, g, ref, counts, ring, apl_ring, apl, upload)
+
+
+class CheckpointTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name).resolve()
+        self.n = patch.object(c, 'N', 4); self.e = patch.object(c, 'E', 6)
+        self.n.start(); self.e.start()
+
+    def tearDown(self):
+        self.e.stop(); self.n.stop(); self.tmp.cleanup()
+
+    def save(self, path, value):
+        R._save(path, value)
+
+    def make(self, name, steps=5, parent=None, corrupt_carry=None):
+        directory = self.root / name; directory.mkdir()
+        inputs = self.root / (name + '-inputs'); inputs.mkdir()
+        spec = {'steps': steps}
+        if parent is not None:
+            spec['parent_checkpoint_manifest_sha256'] = parent['manifest_sha256']
+        self.save(inputs / 'spec.json', spec)
+        overlay_bytes = b'synthetic-bound-overlay-not-a-brain'
+        (inputs / 'overlay.npz').write_bytes(overlay_bytes)
+        meta = {'overlay_sha256': R.digest(inputs / 'overlay.npz'), 'mask_sha256': R.MASK_SHA,
+                'base_candidate_sha256': 'b' * 64}
+        self.save(inputs / 'overlay-manifest.json', meta)
+        (directory / 'overlay-input.npz').write_bytes(overlay_bytes)
+        self.save(directory / 'overlay-manifest.json', meta)
+        event_tick, event_neuron = np.array([0], np.int32), np.array([1], np.int32)
+        counts = np.array([0, 1, 0, 0], np.int32)
+        state = {'step': event_tick, 'neuron_idx': event_neuron, 'counts': counts,
+                 'v': np.full(4, -.052, np.float64), 'g': np.array([-0., -.003, 0., 1.], np.float64),
+                 'ref': np.array([0, 22, 3, 0], np.int32)}
+        ring = np.zeros((19, 4), np.uint8) if parent is None else c.rotate_spike_ring(parent['terminal']['spike_ring'], parent['steps'])
+        for tick in range(steps):
+            ring[tick % 19] = 0
+            if tick == 0:
+                ring[0, 1] = 1
+        pending = np.zeros((18, 4064), np.float32)
+        if corrupt_carry == 'spike':
+            ring[18, 0] ^= np.uint8(1)
+        elif corrupt_carry == 'apl':
+            pending[0, 0] = np.float32(1.)
+        terminal = {'spike_ring': ring, 'apl_pending': pending, 'apl_state': np.array([1., 2.], np.float32),
+                    'next_tick': np.asarray(steps, np.int64)}
+        np.savez_compressed(directory / 'state.npz', **state)
+        np.savez_compressed(directory / 'terminal-queues.npz', **terminal)
+        np.save(directory / 'apl-pending-tail.float32.npy', pending)
+        self.save(directory / 'apl-timing-audit.json', {'apl_delay_steps': 18, 'brain_tail_advanced': False,
+                  'pending_raw_sha256': R._raw(pending), 'final_apl_state_u32_bits': terminal['apl_state'].view(np.uint32).tolist()})
+        offset = 0 if parent is None else parent['global_next_tick']
+        summary = {'complete': True, 'pass_all': True, 'all_finite': True, 'steps': steps, 'completed_ticks': steps,
+                   'nodes': 4, 'edges': 6, 'precision': 'float64', 'apl_precision': 'float32',
+                   'within_trial_weight_updates': False, 'checkpoint_continuation_used': parent is not None,
+                   'effective_weights_raw_sha256': 'e'*64, 'global_tick_offset': offset, 'global_next_tick': offset + steps,
+                   'input_sha256': {'spec.json': R.digest(inputs / 'spec.json')}}
+        if parent is not None:
+            summary['parent_checkpoint_manifest_sha256'] = parent['manifest_sha256']
+        self.save(directory / 'summary.json', summary)
+        self.save(directory / 'finite-audit.json', {'all_finite': True, 'first_failure_tick': -1, 'finite_observed_ticks': steps})
+        self.save(directory / 'overlay-audit.json', {'complete': True, 'weights_updated_during_run': False,
+                  'effective_weights_raw_sha256': 'e'*64, 'mask_sha256': R.MASK_SHA, 'am_helper_sha256': R.AM_OVERLAY_SHA,
+                  'base_candidate_sha256': 'b'*64})
+        provenance = {'schema': 'phase4an-reporting-adapter-v1' if parent is None else 'phase4an-continuation-runtime-v1',
+                      'complete': True, 'weights_updated_during_run': False, 'old_globals_patched': False,
+                      'source_file': R.__file__ if parent is None else c.__file__,
+                      'source_sha256': c.LIGHT_SHA if parent is None else R.digest(c.__file__),
+                      'input_sha256': {str(path): R.digest(path) for path in inputs.iterdir()}}
+        if parent is not None:
+            provenance.update(parent_checkpoint_manifest_sha256=parent['manifest_sha256'],
+                              global_tick_offset=offset, global_next_tick=offset + steps)
+        for key, file in (('summary_sha256', 'summary.json'), ('finite_audit_sha256', 'finite-audit.json'),
+                          ('terminal_queues_sha256', 'terminal-queues.npz'), ('overlay_audit_sha256', 'overlay-audit.json'),
+                          ('state_sha256', 'state.npz')):
+            provenance[key] = R.digest(directory / file)
+        self.save(directory / 'runtime-provenance.json', provenance)
+        if parent is not None:
+            self.save(directory / c.RECEIPT, {'schema': 'phase4an-continuation-receipt-v1', 'complete': True,
+                      'parent_checkpoint_dir': str(parent['directory']), 'parent_checkpoint_manifest_sha256': parent['manifest_sha256'],
+                      'segment_steps': steps, 'counts_scope': 'segment_only_not_lifetime', 'weights_updated_during_run': False,
+                      'global_tick_offset': offset, 'global_next_tick': offset + steps, 'payload_sha256': c._tree_hashes(directory)})
+        return directory
+
+    def test_fresh_seal_is_exclusive_and_binds_state_bytes(self):
+        directory = self.make('fresh')
+        sealed = c.seal_checkpoint(directory)
+        loaded = c.load_checkpoint(directory, sealed['sha256'])
+        self.assertEqual(loaded['global_next_tick'], 5)
+        self.assertEqual(loaded['state']['g'].tobytes(), np.array([-0., -.003, 0., 1.], np.float64).tobytes())
+        self.assertIn('state.npz', sealed['files_sha256'])
+        self.assertFalse(sealed['pre_seal_state_integrity_independently_proven'])
+        with self.assertRaisesRegex(ValueError, 'already sealed'):
+            c.seal_checkpoint(directory)
+        with (directory / 'state.npz').open('ab') as stream:
+            stream.write(b'tampered')
+        with self.assertRaisesRegex(ValueError, 'inventory/hash'):
+            c.load_checkpoint(directory, sealed['sha256'])
+
+    def test_multisegment_receipts_bind_absolute_offset_and_local_phase(self):
+        parent = None
+        total = 0
+        for i, steps in enumerate((5, 13, 1, 19)):
+            directory = self.make('segment-' + str(i), steps, parent)
+            sealed = c.seal_checkpoint(directory)
+            parent = c.load_checkpoint(directory, sealed['sha256'])
+            total += steps
+            self.assertEqual(parent['global_next_tick'], total)
+            self.assertEqual(parent['terminal']['next_tick'].item(), steps)
+            self.assertEqual(parent['ancestry_directories'], [self.root / ('segment-' + str(j)) for j in range(i, -1, -1)])
+        self.assertEqual(total, 38)
+
+    def test_run_rejects_output_and_build_in_every_ancestor_before_overlay_or_gpu(self):
+        parent = None
+        for i in range(3):
+            directory = self.make('ancestor-' + str(i), 20, parent)
+            seal = c.seal_checkpoint(directory)
+            parent = c.load_checkpoint(directory, seal['sha256'])
+        case = self.root / 'next-case'; case.mkdir()
+        self.save(case / 'spec.json', {'max_steps': 5, 'steps': 5, 'dt_ms': .1, 'duration_ms': .5,
+                  'apl_delay_steps': 18, 'record_history': False,
+                  'parent_checkpoint_manifest_sha256': parent['manifest_sha256']})
+        before = {path: c._tree_hashes(path) for path in parent['ancestry_directories']}
+        with patch.object(R, 'load_overlay', side_effect=AssertionError('Overlay/GPU preparation must not begin')) as overlay:
+            for ancestor in parent['ancestry_directories']:
+                for forbidden in (ancestor, ancestor / 'new-child'):
+                    for output, build in ((forbidden, self.root / 'safe-build'), (self.root / 'safe-output', forbidden)):
+                        with self.subTest(ancestor=ancestor.name, output=output, build=build), self.assertRaises(ValueError):
+                            c.run_continued(case, output, build, self.root / 'unused-overlay.npz',
+                                            self.root / 'unused-manifest.json', parent['directory'])
+            overlay.assert_not_called()
+        self.assertEqual(before, {path: c._tree_hashes(path) for path in parent['ancestry_directories']})
+        self.assertFalse((self.root / 'safe-output').exists())
+        self.assertFalse((self.root / 'safe-build').exists())
+
+    def test_reject_bad_external_pin_extra_file_and_error_marker(self):
+        directory = self.make('fresh')
+        sealed = c.seal_checkpoint(directory)
+        with self.assertRaisesRegex(ValueError, 'external pin'):
+            c.load_checkpoint(directory, '0' * 64)
+        (directory / 'unexpected.bin').write_bytes(b'extra')
+        with self.assertRaisesRegex(ValueError, 'inventory/hash'):
+            c.load_checkpoint(directory, sealed['sha256'])
+        failure = self.make('failure')
+        self.save(failure / 'runtime-error.json', {'complete': False})
+        with self.assertRaisesRegex(ValueError, 'failure/error'):
+            c.seal_checkpoint(failure)
+
+    def test_self_consistent_receipts_do_not_hide_unwritten_carry_slot_corruption(self):
+        directory = self.make('parent', 20)
+        sealed = c.seal_checkpoint(directory)
+        parent = c.load_checkpoint(directory, sealed['sha256'])
+        for kind, message in (('spike', 'carried spike'), ('apl', 'carried APL')):
+            child = self.make('bad-' + kind, 5, parent, corrupt_carry=kind)
+            # The synthetic writer hashes its incorrect output consistently;
+            # the independent parent-to-child carry invariant must still reject.
+            with self.subTest(kind=kind), self.assertRaisesRegex(ValueError, message):
+                c.seal_checkpoint(child)
+
+    def test_reject_partial_receipt_and_modified_original_input(self):
+        directory = self.make('bad-receipt')
+        (directory / 'summary.json').write_text('{}', encoding='utf-8')
+        with self.assertRaises(ValueError):
+            c.seal_checkpoint(directory)
+        directory = self.make('modified-input')
+        (self.root / 'modified-input-inputs' / 'spec.json').write_text('{}', encoding='utf-8')
+        with self.assertRaisesRegex(ValueError, 'input/source'):
+            c.seal_checkpoint(directory)
+
+    def test_descendant_rejects_mutated_ancestor_even_if_own_files_are_unchanged(self):
+        directory = self.make('ancestor', 20)
+        sealed = c.seal_checkpoint(directory)
+        parent = c.load_checkpoint(directory, sealed['sha256'])
+        child = self.make('descendant', 5, parent)
+        child_seal = c.seal_checkpoint(child)
+        with (directory / 'state.npz').open('ab') as stream:
+            stream.write(b'ancestor changed after child seal')
+        with self.assertRaisesRegex(ValueError, 'inventory/hash'):
+            c.load_checkpoint(child, child_seal['sha256'])
+
+    def test_self_consistent_hashes_cannot_hide_parent_pin_or_weight_disagreement(self):
+        directory = self.make('bound-parent', 20)
+        sealed = c.seal_checkpoint(directory)
+        parent = c.load_checkpoint(directory, sealed['sha256'])
+        def rewrite(path, value):
+            path.write_text(json.dumps(value, sort_keys=True), encoding='utf-8')
+        for kind in ('case', 'summary', 'provenance', 'weights'):
+            child = self.make('bound-child-' + kind, 5, parent)
+            spec_path = self.root / ('bound-child-' + kind + '-inputs') / 'spec.json'
+            summary = R._read_json(child / 'summary.json')
+            provenance = R._read_json(child / 'runtime-provenance.json')
+            if kind == 'case':
+                spec = R._read_json(spec_path); spec['parent_checkpoint_manifest_sha256'] = '0' * 64
+                rewrite(spec_path, spec)
+                summary['input_sha256']['spec.json'] = R.digest(spec_path)
+                provenance['input_sha256'][str(spec_path)] = R.digest(spec_path)
+            elif kind in ('summary', 'provenance'):
+                target = summary if kind == 'summary' else provenance
+                target['parent_checkpoint_manifest_sha256'] = '0' * 64
+            else:
+                summary['effective_weights_raw_sha256'] = 'f' * 64
+                audit = R._read_json(child / 'overlay-audit.json'); audit['effective_weights_raw_sha256'] = 'f' * 64
+                rewrite(child / 'overlay-audit.json', audit)
+                provenance['overlay_audit_sha256'] = R.digest(child / 'overlay-audit.json')
+            rewrite(child / 'summary.json', summary)
+            provenance['summary_sha256'] = R.digest(child / 'summary.json')
+            rewrite(child / 'runtime-provenance.json', provenance)
+            receipt = R._read_json(child / c.RECEIPT)
+            receipt['payload_sha256'] = c._tree_hashes(child); receipt['payload_sha256'].pop(c.RECEIPT)
+            rewrite(child / c.RECEIPT, receipt)
+            # All individual byte hashes are now consistent. Only semantic
+            # cross-receipt binding or parent/child weight equality rejects it.
+            with self.subTest(kind=kind), self.assertRaisesRegex(ValueError, 'weights changed|pin disagrees'):
+                c.seal_checkpoint(child)
+
+    def test_reject_invalid_state_dtype_events_ref_and_ring(self):
+        directory = self.make('arrays')
+        state = c._npz(directory / 'state.npz', ('step', 'neuron_idx', 'counts', 'v', 'g', 'ref'))
+        terminal = c._npz(directory / 'terminal-queues.npz', ('spike_ring', 'apl_state', 'apl_pending', 'next_tick'))
+        for key, value in (('v', state['v'].astype(np.float32)), ('g', np.full(4, np.nan)),
+                           ('ref', np.full(4, 23, np.int32)), ('step', np.array([5], np.int32)),
+                           ('counts', np.zeros(4, np.int32))):
+            with self.subTest(key=key), self.assertRaises(ValueError):
+                c.validate_state(dict(state, **{key: value}), terminal, 5, fresh=True)
+        bad = dict(terminal, spike_ring=terminal['spike_ring'].copy()); bad['spike_ring'][0, 1] = 0
+        with self.assertRaisesRegex(ValueError, 'emitted'):
+            c.validate_state(state, bad, 5, fresh=True)
+
+
+if __name__ == '__main__':
+    unittest.main()

models/male-cns-lif/olfactory-conditioning-lab-v1/test_runtime_light.py

@@ -0,0 +1,298 @@
+"""Synthetic AST/array diagnostics only. No real brain/GPU or old-file writes."""
+import ast
+import copy
+import json
+from pathlib import Path
+import tempfile
+import types
+import unittest
+from unittest.mock import patch
+
+import numpy as np
+
+import runtime_light as r
+
+
+AJ = Path(__file__).absolute().parent.parent / 'apl-timing-lab-v1/gpu_timing.py'
+AM = Path(__file__).absolute().parent.parent / 'wholebrain-plastic-interface-v1/overlay.py'
+
+
+class ScalarTensor:
+    """Tiny NumPy scalar stub for diagnostic algebra, not a neuron simulator."""
+    def __init__(self, value):
+        self.value = np.asarray(value)
+
+    def logical_and_(self, other):
+        self.value = self.value & other.value
+        return self
+
+    def __lt__(self, other):
+        return ScalarTensor(self.value < other)
+
+    def __and__(self, other):
+        return ScalarTensor(self.value & other.value)
+
+    def __invert__(self):
+        return ScalarTensor(~self.value)
+
+    def all(self):
+        return ScalarTensor(self.value.all())
+
+    def item(self):
+        return self.value.item()
+
+
+class TorchScalars:
+    bool, int64 = np.bool_, np.int64
+    ones = staticmethod(lambda shape, device, dtype: ScalarTensor(np.ones(shape, dtype)))
+    zeros = staticmethod(lambda shape, device, dtype: ScalarTensor(np.zeros(shape, dtype)))
+    full = staticmethod(lambda shape, value, device, dtype: ScalarTensor(np.full(shape, value, dtype)))
+    ones_like = staticmethod(lambda value: ScalarTensor(np.ones_like(value.value)))
+    full_like = staticmethod(lambda value, fill: ScalarTensor(np.full_like(value.value, fill)))
+    isfinite = staticmethod(lambda value: ScalarTensor(np.isfinite(value)))
+    where = staticmethod(lambda condition, first, other: ScalarTensor(np.where(condition.value, first.value, other.value)))
+
+
+class AstTests(unittest.TestCase):
+    def source(self):
+        if not AJ.is_file():
+            self.skipTest('Original pinned AJ source is not installed')
+        return AJ.read_bytes()
+
+    def test_math_projection_equal_light_and_reference_and_guard_explicit(self):
+        for mode in ('light', 'reference'):
+            tree, audit = r.derive_ast(self.source(), mode)
+            self.assertTrue(audit['mathematical_ast_identical'])
+            self.assertEqual(audit['math_ast_sha256'], audit['derived_math_ast_sha256'])
+            self.assertIn("spec['max_steps']", ast.unparse(tree.body[0]))
+            compile(tree, '<synthetic-AST-check>', 'exec')
+
+    def test_reference_entire_tick_loop_remains_identical(self):
+        source = ast.parse(self.source())
+        original = next(node for node in source.body if isinstance(node, ast.FunctionDef) and node.name == 'run_gpu')
+        tree, _ = r.derive_ast(self.source(), 'reference')
+        tick = lambda f: next(n for n in ast.walk(f) if isinstance(n, ast.For) and isinstance(n.target, ast.Name) and n.target.id == 'tick')
+        self.assertEqual(r._dump(tick(original)), r._dump(tick(tree.body[-1])))
+
+    def test_light_retains_events_requests_kernels_and_no_full_state_cpu_copy(self):
+        tree, _ = r.derive_ast(self.source(), 'light')
+        function = tree.body[-1]
+        tick = next(n for n in ast.walk(function) if isinstance(n, ast.For) and isinstance(n.target, ast.Name) and n.target.id == 'tick')
+        text = ast.unparse(tick)
+        for expected in ('ext.state_step', 'ext.fill_edges', 'ext.apply_arrivals', 'apl.advance',
+                         'event_steps.append', 'event_nodes.append', 'writer.writerows', '_runtime.after_tick',
+                         'apl_ring[slot].clone()', 'apl_ring[slot].copy_(h)'):
+            self.assertIn(expected, text)
+        for forbidden in ('v.cpu()', 'g.cpu()', 'ref.cpu()', 'drive.cpu()', 'h.cpu()', 'queue_summary(',
+                          'queue_output', 'hash_output', 'np.isfinite'):
+            self.assertNotIn(forbidden, text)
+
+    def test_altered_math_is_detected_and_source_pin_rejects_comments(self):
+        tree, audit = r.derive_ast(self.source(), 'light')
+        function = copy.deepcopy(tree.body[-1])
+        node = next(n for n in ast.walk(function) if isinstance(n, ast.Assign) and
+                    ast.unparse(n) == 'g[kc_local_gpu] = g[kc_local_gpu] - delta_si')
+        node.value.op = ast.Add()
+        self.assertNotEqual(r.math_projection(function), r.math_projection(tree.body[-1]))
+        with self.assertRaises(ValueError):
+            r.derive_ast(self.source() + b'\n# altered\n', 'light')
+
+    def test_fresh_namespace_no_fake_file_no_old_globals_changed(self):
+        self.source()
+        module = types.ModuleType('synthetic_AJ')
+        module.__file__ = str(AJ)
+        module.marker = object()
+        before = dict(module.__dict__)
+        runtime = types.SimpleNamespace(write_json=lambda *_: None)
+        function, audit = r.compile_runtime(module, runtime, 'light')
+        self.assertEqual(before, module.__dict__)
+        self.assertEqual(function.__globals__['__file__'], str(Path(r.__file__).absolute()))
+        self.assertNotEqual(function.__globals__['__file__'], str(AJ))
+        self.assertFalse(audit['old_globals_patched'])
+
+
+class ContractTests(unittest.TestCase):
+    def spec(self, steps=1200):
+        return dict(max_steps=steps, steps=steps, dt_ms=.1, duration_ms=steps*.1,
+                    apl_delay_steps=18, record_history=False)
+
+    def test_directory_parent_traversal_cannot_bypass_input_or_source_boundaries(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory).resolve()
+            case, models, graph, bundle = (root / name for name in ('case', 'models', 'graph', 'bundle'))
+            for path in (case, models, graph, bundle, root / 'new'):
+                path.mkdir()
+            safe = root / 'new'
+            for protected in (case, models, graph, bundle):
+                alias = safe / '..' / protected.name / 'cache'
+                for output, build in ((alias, safe / 'build'), (safe / 'out', alias)):
+                    with self.subTest(protected=protected.name, output=output), self.assertRaisesRegex(ValueError, 'cannot write'):
+                        r.execution_paths(case, output, build, (models, graph, bundle))
+            actual = r.execution_paths(case, safe / '..' / 'safe-output', safe / '..' / 'safe-build', (models, graph, bundle))
+            self.assertEqual(actual, (case, root / 'safe-output', root / 'safe-build'))
+            self.assertFalse((root / 'safe-output').exists())
+            self.assertFalse((root / 'safe-build').exists())
+
+    def test_directory_link_alias_cannot_bypass_protected_boundary(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory).resolve()
+            case, models = root / 'case', root / 'models'
+            case.mkdir(); models.mkdir()
+            alias = root / 'alias-to-models'
+            try:
+                alias.symlink_to(models, target_is_directory=True)
+            except (OSError, NotImplementedError) as error:
+                self.skipTest('Directory symlink unavailable on this host: ' + str(error))
+            for output, build in ((alias / 'out', root / 'build'), (root / 'out', alias / 'build')):
+                with self.subTest(output=output), self.assertRaisesRegex(ValueError, 'cannot write'):
+                    r.execution_paths(case, output, build, (models,))
+            # A protected root supplied through an alias is also canonicalized.
+            with self.assertRaisesRegex(ValueError, 'cannot write'):
+                r.execution_paths(case, root / 'out', models / 'build', (alias,))
+
+    def test_explicit_bounds_1000_1200_retention_no_hidden_duration(self):
+        with tempfile.TemporaryDirectory() as directory:
+            for steps in (1000, 1200, 100000):
+                self.assertEqual(r.validate_spec(self.spec(steps), directory)['steps'], steps)
+            for update in ({'max_steps': 999}, {'max_steps': True}, {'steps': 1200.},
+                           {'duration_ms': 100.}, {'dt_ms': .2}, {'apl_delay_steps': 0},
+                           {'within_trial_weight_updates': True}, {'checkpoint': None}):
+                with self.subTest(update=update), self.assertRaises(ValueError):
+                    r.validate_spec(dict(self.spec(), **update), directory)
+            Path(directory, 'arrays.npz').write_bytes(b'unsupported checkpoint')
+            with self.assertRaises(ValueError):
+                r.validate_spec(self.spec(), directory)
+
+    def test_finite_observer_remembers_nan_that_later_disappears(self):
+        observer = r.FiniteObserver(TorchScalars, 'CPU-test-stub')
+        initial = np.array([1., -2.], np.float64)
+        saved = initial.tobytes()
+        observer.observe(0, initial)
+        observer.observe(1, np.array([np.nan], np.float32))
+        observer.observe(2, np.array([0.], np.float64))
+        result = observer.result()
+        self.assertFalse(result['all_finite'])
+        self.assertEqual(result['first_failure_tick'], 1)
+        self.assertEqual(result['finite_observed_ticks'], 3)
+        self.assertEqual(saved, initial.tobytes())
+        with self.assertRaises(ValueError):
+            observer.observe(4, initial)
+
+    def test_finite_observer_all_valid_reports_minus_one(self):
+        observer = r.FiniteObserver(TorchScalars, 'CPU-test-stub')
+        for tick in range(4):
+            observer.observe(tick, np.array([1, 0], np.int32), np.array([-0., 1.], np.float64))
+        self.assertTrue(observer.result()['all_finite'])
+        self.assertEqual(observer.result()['first_failure_tick'], -1)
+
+    def test_summary_has_no_fake_outer_learning_claim_and_light_audit_is_not_full(self):
+        obj = object.__new__(r._Runtime)
+        obj.mode, obj.spec = 'light', dict(max_steps=1200, steps=1200, outer_protocol='conditioning-owned-by-parent')
+        obj.result = dict(first_failure_tick=-1, arriving_edges=11, accepted_arriving_edges=7)
+        inherited = dict(learning=False, arriving_edges=0, accepted_arriving_edges=0, complete=True,
+                         apl_timing={'generated_trace': 'absent.npy', 'applied_trace': 'absent.npy'})
+        final = obj.summary(inherited)
+        self.assertNotIn('learning', final)
+        self.assertFalse(final['within_trial_weight_updates'])
+        self.assertFalse(final['learning_pass_claimed'])
+        self.assertFalse(final['full_sequence_bitwise_audit_performed'])
+        self.assertEqual(final['arriving_edges'], 11)
+        self.assertIsNone(final['apl_timing']['generated_trace'])
+        self.assertIsNone(final['apl_timing']['applied_trace'])
+        self.assertFalse(obj.timing(1200, np.zeros((18, 4064), np.float32))['full_sequence_bitwise_audit_performed'])
+        self.assertEqual(inherited['arriving_edges'], 0)
+
+    def test_terminal_queue_schema_chronological_pending_and_fresh_tick(self):
+        class CPUArray:
+            def __init__(self, array):
+                self.value = array
+
+            def cpu(self):
+                return self
+
+            def numpy(self):
+                return self.value
+
+        ring = np.zeros((19, 166700), np.uint8)
+        ring[2, 3] = 1
+        apl_ring = np.repeat(np.arange(18, dtype=np.float32)[:, None], 4064, axis=1)
+        apl = types.SimpleNamespace(state=CPUArray(np.array([1., 2.], np.float32)))
+        obj = object.__new__(r._Runtime)
+        obj.mode, obj.installations, obj.finished = 'light', 1, False
+        obj.observer = types.SimpleNamespace(result=lambda: dict(all_finite=True, first_failure_tick=-1,
+            finite_observed_ticks=1200, arriving_edges=11, accepted_arriving_edges=7))
+        with tempfile.TemporaryDirectory() as directory:
+            obj.finish(CPUArray(ring), CPUArray(apl_ring), apl, 1200, Path(directory))
+            with np.load(Path(directory)/'terminal-queues.npz', allow_pickle=False) as output:
+                self.assertEqual(set(output.files), {'spike_ring', 'apl_state', 'apl_pending', 'next_tick'})
+                self.assertEqual(output['spike_ring'].dtype, np.uint8)
+                self.assertEqual(output['spike_ring'].tobytes(), ring.tobytes())
+                self.assertEqual(output['next_tick'].dtype, np.int64)
+                self.assertEqual(output['next_tick'].item(), 1200)
+                expected = np.concatenate((apl_ring[1200 % 18:], apl_ring[:1200 % 18]))
+                np.testing.assert_array_equal(output['apl_pending'], expected)
+            self.assertTrue(obj.finished)
+            with self.assertRaises(ValueError):
+                obj.finish(CPUArray(ring), CPUArray(apl_ring), apl, 1200, Path(directory))
+
+    def test_pinned_overlay_helpers_toy_units_and_missing_nonzero_fail_closed(self):
+        if not AM.is_file():
+            self.skipTest('Original frozen AM overlay helper not installed')
+        helper = r._load('phase4an_test_overlay_helper', AM, r.AM_OVERLAY_SHA)
+        ids, base32 = np.array([3, 9], np.int64), np.array([.275, 1.1], np.float32)
+        delta = np.float32(-.25) * base32
+        plan = helper.validate_arrays(ids, delta, ids, base32)
+        base = np.array([.000275, .0011], np.float64)
+        result, _ = helper.materialize_numpy(base, ids, np.zeros(2, bool), plan)
+        self.assertTrue(helper.bit_equal(result, base + delta.astype(np.float64) * .001))
+        with self.assertRaises(ValueError):
+            helper.map_installation(base[:1], ids[:1], np.zeros(1, bool), plan)
+        with self.assertRaises(ValueError):
+            helper.validate_arrays(ids, np.array([.1, 0], np.float32), ids, base32)
+
+    def test_manifest_cannot_self_authorize_replacement_mask(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory)
+            manifest = dict(schema='phase4an-overlay-v1', overlay_name='learned', overlay_sha256='0'*64,
+                mask_path=str(path/'mask.npy'), mask_sha256='0'*64, base_candidate_path=str(path/'base.npy'),
+                base_candidate_sha256='0'*64, aj_model_dir=str(AJ.parent), am_overlay_path=str(AM),
+                am_overlay_sha256=r.AM_OVERLAY_SHA)
+            (path/'manifest.json').write_text(json.dumps(manifest), encoding='utf-8')
+            with self.assertRaisesRegex(ValueError, 'authority'):
+                r.load_overlay(path/'delta.npz', path/'manifest.json')
+
+    def test_learned_manifest_uses_external_base_and_requires_parent_v2(self):
+        if not AM.is_file() or not AJ.is_file():
+            self.skipTest('Pinned static source dependencies are not installed')
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory)
+            ids = np.arange(14232, dtype=np.int64)
+            base = np.full(14232, .275, np.float32)
+            delta = np.zeros(14232, np.float32); delta[0] = np.float32(-.00275)
+            np.save(path/'mask.npy', ids); np.save(path/'base.npy', base)
+            np.savez(path/'delta.npz', edge_id=ids, plastic_delta_mv=delta)
+            mask_sha = r.digest(path/'mask.npy')
+            manifest = dict(schema='phase4an-overlay-v1', overlay_name='learned',
+                overlay_sha256=r.digest(path/'delta.npz'), mask_path=str(path/'mask.npy'), mask_sha256=mask_sha,
+                base_candidate_path=str(path/'base.npy'), base_candidate_sha256=r.digest(path/'base.npy'),
+                aj_model_dir=str(AJ.parent), am_overlay_path=str(AM), am_overlay_sha256=r.AM_OVERLAY_SHA,
+                parent_snapshot_sha256='a'*64, eligibility_v2_source_sha256=r.V2_SHA)
+            (path/'manifest.json').write_text(json.dumps(manifest), encoding='utf-8')
+            # Only the authority fixture is patched; production pin remains fixed.
+            with patch.object(r, 'MASK_SHA', mask_sha):
+                helper, plan, meta, inputs = r.load_overlay(path/'delta.npz', path/'manifest.json')
+                self.assertEqual(plan['plastic_delta_mv'].tobytes(), delta.tobytes())
+                self.assertFalse(plan['plastic_delta_mv'].flags.writeable)
+                self.assertEqual(meta['parent_snapshot_sha256'], 'a'*64)
+                unexpected = dict(manifest, within_trial_weight_updates=True)
+                (path/'manifest.json').write_text(json.dumps(unexpected), encoding='utf-8')
+                with self.assertRaisesRegex(ValueError, 'Unknown'):
+                    r.load_overlay(path/'delta.npz', path/'manifest.json')
+                manifest.pop('parent_snapshot_sha256')
+                (path/'manifest.json').write_text(json.dumps(manifest), encoding='utf-8')
+                with self.assertRaisesRegex(ValueError, 'parent'):
+                    r.load_overlay(path/'delta.npz', path/'manifest.json')
+
+
+if __name__ == '__main__':
+    unittest.main()

registry/phase4an-engineering-validation/evidence/audit/analysis-execution.json

@@ -0,0 +1,8 @@
+{
+  "GPU_used": false,
+  "analysis_sha256": "d5ad47a85e4c22e8a482b26330957a821e394022658531a914c9080187454d03",
+  "learning_pass_claimed": false,
+  "registration_sha256": "7317441126f191ccc6e6d28438870b3921537ebe282a6acb163716a690057945",
+  "training": false,
+  "wall_seconds": 40.56493683200097
+}

registry/phase4an-engineering-validation/evidence/audit/execution-complete.json

@@ -0,0 +1,172 @@
+{
+  "complete": true,
+  "completed": [
+    {
+      "execution_sha256": "1a6e73ee71f969125a3a69d1f46b0765a6bf574b55fe9704be07be364e64b4c4",
+      "reverified_existing": false,
+      "row_id": "zero--fresh--reference-r0"
+    },
+    {
+      "execution_sha256": "099d02a5b31e3ff6e0c620bb285d444fa192fa15022b78632a05774e002b3c89",
+      "reverified_existing": false,
+      "row_id": "zero--fresh--light-r0"
+    },
+    {
+      "execution_sha256": "36da6e49ba3575ddc0bf36a839e58e959abc08f3db2e728f40a9d88e22ace1bb",
+      "reverified_existing": false,
+      "row_id": "zero--fresh--light-r1"
+    },
+    {
+      "execution_sha256": "f06f286b82f9b196347253684eef229a3f156d3109fcb9b15141c41ac0f47533",
+      "reverified_existing": false,
+      "row_id": "zero--prefix--reference-t0018"
+    },
+    {
+      "execution_sha256": "1eea2cc407e3a01ccf6d5cedf2aa19eb3be1bb75b9df3e5cb31a7eed38a96762",
+      "reverified_existing": false,
+      "row_id": "zero--prefix--reference-t0019"
+    },
+    {
+      "execution_sha256": "49b34a635e2e029b430224bf3a067ced408f81273a7b17f33a783b64431cd765",
+      "reverified_existing": false,
+      "row_id": "zero--prefix--reference-t0500"
+    },
+    {
+      "execution_sha256": "9479f44277df44557ffbc2f5251fc523f07e9fa4fab4575023510bc6ff26bab6",
+      "reverified_existing": false,
+      "row_id": "static25--fresh--reference-r0"
+    },
+    {
+      "execution_sha256": "83cee3b7447cf8ccace47b499145542351dda52498f9165c5b02eff5b31c490d",
+      "reverified_existing": false,
+      "row_id": "static25--fresh--light-r0"
+    },
+    {
+      "execution_sha256": "86cdde61b7c2581f28d5bed9271fbf0a2f764c01ac95b360b221c9436177e731",
+      "reverified_existing": false,
+      "row_id": "static25--fresh--light-r1"
+    },
+    {
+      "execution_sha256": "601feb3ffefc15c3ccf98a36b89eb16559a9672b325393b43e9559cecabedfda",
+      "reverified_existing": false,
+      "row_id": "static25--prefix--reference-t0018"
+    },
+    {
+      "execution_sha256": "e3f380e6fba8c92111f54af259531f64177c58401e915898c80f34f178fe78df",
+      "reverified_existing": false,
+      "row_id": "static25--prefix--reference-t0019"
+    },
+    {
+      "execution_sha256": "d61cd75530c74b579b334bc715a9de2226606855ccc4c011fcac6cf89570cdf4",
+      "reverified_existing": false,
+      "row_id": "static25--prefix--reference-t0500"
+    },
+    {
+      "execution_sha256": "ab843922c457b8ebbed58f6bd057d1219fa523100ded700d6c5fb3eae39bd6bd",
+      "reverified_existing": false,
+      "row_id": "zero--chain--reference-s00"
+    },
+    {
+      "execution_sha256": "0d9ce5b903e3b60510778a47d9797b8c45455c7509e9a2872039e3f87f90cd91",
+      "reverified_existing": false,
+      "row_id": "zero--chain--reference-s01"
+    },
+    {
+      "execution_sha256": "8e7d08743ee87c12bf98e20b853117c883601489b7824ad4a24354eb684ef4fe",
+      "reverified_existing": false,
+      "row_id": "zero--chain--reference-s02"
+    },
+    {
+      "execution_sha256": "420090f9378d8f236d2a478af22e009364b5613eb7ec0f76228a08baafed4dd8",
+      "reverified_existing": false,
+      "row_id": "zero--chain--reference-s03"
+    },
+    {
+      "execution_sha256": "98fc0809ab600d49ea7c15284364cfcc40797e14e23dd5dee56f7a206a269b8a",
+      "reverified_existing": false,
+      "row_id": "zero--chain--reference-s04"
+    },
+    {
+      "execution_sha256": "0fd5857a719d09737124116cc9342386474859e19c55c015c614db4c751e799e",
+      "reverified_existing": false,
+      "row_id": "zero--chain--light-s00"
+    },
+    {
+      "execution_sha256": "2e038c35dc563a558dd0025a63262497551d4a65d542d34f30bb2a1812566cda",
+      "reverified_existing": false,
+      "row_id": "zero--chain--light-s01"
+    },
+    {
+      "execution_sha256": "a0836cffbc3a7857937b578ee084c955f0b1851b4c2455d3576951256128d5e5",
+      "reverified_existing": false,
+      "row_id": "zero--chain--light-s02"
+    },
+    {
+      "execution_sha256": "bd7d4d7315d6336031c9176a54fd65baf01ecd5722cf8885b351054d9d9d9485",
+      "reverified_existing": false,
+      "row_id": "zero--chain--light-s03"
+    },
+    {
+      "execution_sha256": "f2936dfa1b16a0aac6ff1be109a0f0c3b13ed895c5284fab9fae6dd297839e12",
+      "reverified_existing": false,
+      "row_id": "zero--chain--light-s04"
+    },
+    {
+      "execution_sha256": "5ec0ca4d44c8c0f7f029b3b0cdacd4a522fac06ab61dea7930a7bbc38660f04d",
+      "reverified_existing": false,
+      "row_id": "static25--chain--reference-s00"
+    },
+    {
+      "execution_sha256": "49c6e3a38ec64acce20f2580567ebe065adfc68b96a8b5d4e38933245a1f7494",
+      "reverified_existing": false,
+      "row_id": "static25--chain--reference-s01"
+    },
+    {
+      "execution_sha256": "1ee9097792abf54b989a2a06dfa41336216540cdf29aebb635ba72abff57d609",
+      "reverified_existing": false,
+      "row_id": "static25--chain--reference-s02"
+    },
+    {
+      "execution_sha256": "85193748d4675d875ff9bd53abbf82f3c00720c706d662694aaaee75741f263f",
+      "reverified_existing": false,
+      "row_id": "static25--chain--reference-s03"
+    },
+    {
+      "execution_sha256": "b8a9ed7667b384ee0e9939dea363196fab0eba8695422d7e868e92d3c3a56398",
+      "reverified_existing": false,
+      "row_id": "static25--chain--reference-s04"
+    },
+    {
+      "execution_sha256": "69fb7a48f6af11d36ed0db8609bb2f70884275e9d86cae829b876e2417312eaa",
+      "reverified_existing": false,
+      "row_id": "static25--chain--light-s00"
+    },
+    {
+      "execution_sha256": "cf3f86c0f93fa9144e860311262eacb7883395850e9ec5ddbc0e9b1bb2d3eb78",
+      "reverified_existing": false,
+      "row_id": "static25--chain--light-s01"
+    },
+    {
+      "execution_sha256": "b5d51f20ad942805ea10c8cfd59fda3e10b55b95e4da73b074a197d9495e0f2f",
+      "reverified_existing": false,
+      "row_id": "static25--chain--light-s02"
+    },
+    {
+      "execution_sha256": "cd1bcdbc73127f7837e889a3aeee8bea7e3d76fb31b1797fdb6a34ae1c55cec9",
+      "reverified_existing": false,
+      "row_id": "static25--chain--light-s03"
+    },
+    {
+      "execution_sha256": "4e16145b7e065bf891478a3e2b75d0ae568179a9e963e487c36fad13132a3802",
+      "reverified_existing": false,
+      "row_id": "static25--chain--light-s04"
+    }
+  ],
+  "executed_ticks": 11074,
+  "expected_calls": 32,
+  "learning_pass_claimed": false,
+  "numerical_gate_evaluated": false,
+  "registration_sha256": "7317441126f191ccc6e6d28438870b3921537ebe282a6acb163716a690057945",
+  "training": false,
+  "wall_seconds": 433.96824523499527
+}

registry/phase4an-engineering-validation/evidence/audit/final-status.json

@@ -0,0 +1,25 @@
+{
+  "AM_seals_preserved": true,
+  "analysis_recomputed_exactly": true,
+  "analysis_sha256": "d5ad47a85e4c22e8a482b26330957a821e394022658531a914c9080187454d03",
+  "budget": {
+    "free_bytes": 649401114624,
+    "hard_cap_bytes": 8589934592,
+    "reserve_bytes": 10737418240,
+    "used_bytes": 221057911
+  },
+  "completed_calls": 32,
+  "executed_ticks": 11074,
+  "learned_candidate": false,
+  "learning_pass_claimed": false,
+  "model_directory_sealed": false,
+  "old_five_reference_evidence": "Sealed AM five-trial evidence retained; not rerun by this engineering gate",
+  "old_integrity_pass": true,
+  "old_integrity_roots": 28,
+  "registration_sha256": "7317441126f191ccc6e6d28438870b3921537ebe282a6acb163716a690057945",
+  "schema": "phase4an-engineering-final-v1",
+  "scope": "Finite registered 100 ms input and fixed continuation cuts only; no universal determinism, learning or physiology claim",
+  "status": "PASS-EXACT-LIGHT-CONTINUATION-ENGINEERING-NOT-LEARNING",
+  "training": false,
+  "used_engineering_source_snapshots_sealed": true
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--light-s00/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 0.5,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 5,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--light-s00/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--chain--light-s00",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 5
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--light-s01/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 1.3,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 5,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "e1eb04c098b366870cb05869af9a4277d85fb7722f87202ac9e3b97e768d30cb",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 13,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--light-s01/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--chain--light-s01",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 5,
+  "stop": 18
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--light-s02/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 0.1,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 18,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "e3885149662d9abf9666a76953784b508398a08be963b8165cbbb3548b4e2b13",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 1,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--light-s02/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--chain--light-s02",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 18,
+  "stop": 19
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--light-s03/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 48.1,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 19,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "ba542fc65ca165c6d1027ce0c056bf8f0b6360b0ad98f4f909240e34419655a8",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 481,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--light-s03/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--chain--light-s03",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 19,
+  "stop": 500
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--light-s04/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 50.0,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 500,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "7a46fe8914e903760a720caee920070d8dde2e1ecf91190948b3541bbf366505",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 500,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--light-s04/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--chain--light-s04",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 500,
+  "stop": 1000
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--reference-s00/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 0.5,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 5,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--reference-s00/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--chain--reference-s00",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 5
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--reference-s01/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 1.3,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 5,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "9b3529f7ee0e6363af7254489c452638f0f37ac3a62ccce8461ab1b4c6e9189a",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 13,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--reference-s01/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--chain--reference-s01",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 5,
+  "stop": 18
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--reference-s02/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 0.1,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 18,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "26df7763cb02fb1e1610398b72860027dfdc788237ca5a4c20140f013cc22559",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 1,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--reference-s02/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--chain--reference-s02",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 18,
+  "stop": 19
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--reference-s03/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 48.1,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 19,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "a4d2ea258823ca6685aa3538ffd99f011c68a063110fa47965827a537950424b",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 481,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--reference-s03/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--chain--reference-s03",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 19,
+  "stop": 500
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--reference-s04/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 50.0,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 500,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "0b8da3d954e9b66df6fa24ab139a8cf0dca650f294bf68783e6c050357790715",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 500,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--chain--reference-s04/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--chain--reference-s04",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 500,
+  "stop": 1000
+}

registry/phase4an-engineering-validation/evidence/cases/static25--fresh--light-r0/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 100.0,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 1000,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--fresh--light-r0/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--fresh--light-r0",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 1000
+}

registry/phase4an-engineering-validation/evidence/cases/static25--fresh--light-r1/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 100.0,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 1000,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--fresh--light-r1/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--fresh--light-r1",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 1000
+}

registry/phase4an-engineering-validation/evidence/cases/static25--fresh--reference-r0/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 100.0,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 1000,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--fresh--reference-r0/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--fresh--reference-r0",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 1000
+}

registry/phase4an-engineering-validation/evidence/cases/static25--prefix--reference-t0018/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 1.8,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 18,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--prefix--reference-t0018/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--prefix--reference-t0018",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 18
+}

registry/phase4an-engineering-validation/evidence/cases/static25--prefix--reference-t0019/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 1.9000000000000001,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 19,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--prefix--reference-t0019/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--prefix--reference-t0019",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 19
+}

registry/phase4an-engineering-validation/evidence/cases/static25--prefix--reference-t0500/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 50.0,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 500,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/static25--prefix--reference-t0500/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "static25--prefix--reference-t0500",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 500
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--light-s00/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 0.5,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 5,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--light-s00/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--chain--light-s00",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 5
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--light-s01/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 1.3,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 5,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "7c15a5a78a6197eec593c553c3625261b47c40a2ee22515ccda5b5d67eefed2e",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 13,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--light-s01/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--chain--light-s01",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 5,
+  "stop": 18
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--light-s02/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 0.1,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 18,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "3bcfbc0516e918a4ff42ce4c0cf25129ac1b0fcf8fdb0baa9f55923a02b45f9b",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 1,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--light-s02/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--chain--light-s02",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 18,
+  "stop": 19
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--light-s03/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 48.1,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 19,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "61b16179c796301e05f4c6f6989d0d31e0e8da0d7d38f086aecacc9b61d5bfcb",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 481,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--light-s03/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--chain--light-s03",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 19,
+  "stop": 500
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--light-s04/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 50.0,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 500,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "97db003dc84cf99bb92e815fbcbea0796270884da37803b8746041b695d546d3",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 500,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--light-s04/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--chain--light-s04",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 500,
+  "stop": 1000
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--reference-s00/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 0.5,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 5,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--reference-s00/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--chain--reference-s00",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 5
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--reference-s01/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 1.3,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 5,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "01ad785a6d5e94a8e83c80a3d48e91f245432b446c8fc907d9644850f9370d01",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 13,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--reference-s01/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--chain--reference-s01",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 5,
+  "stop": 18
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--reference-s02/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 0.1,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 18,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "4be0d1ac31613a5ba3fafae8d80e1a1be55f0ce2a56b54c4b3abbb24fd5705bd",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 1,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--reference-s02/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--chain--reference-s02",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 18,
+  "stop": 19
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--reference-s03/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 48.1,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 19,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "670ca9c79c29791df8f2107272ef50010e97b1d7dbe2f7ea85d519364f903647",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 481,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--reference-s03/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--chain--reference-s03",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 19,
+  "stop": 500
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--reference-s04/spec.json

@@ -0,0 +1,51 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 50.0,
+  "expected_external_events": 105.90211181640625,
+  "global_tick_offset": 500,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "parent_checkpoint_manifest_sha256": "7d06d07087c1c39396b9160ce39e5cf31b8b1893f098f0bb78397b927084a504",
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 500,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--chain--reference-s04/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--chain--reference-s04",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 500,
+  "stop": 1000
+}

registry/phase4an-engineering-validation/evidence/cases/zero--fresh--light-r0/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 100.0,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 1000,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--fresh--light-r0/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--fresh--light-r0",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 1000
+}

registry/phase4an-engineering-validation/evidence/cases/zero--fresh--light-r1/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 100.0,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 1000,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--fresh--light-r1/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--fresh--light-r1",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 1000
+}

registry/phase4an-engineering-validation/evidence/cases/zero--fresh--reference-r0/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 100.0,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 1000,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--fresh--reference-r0/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--fresh--reference-r0",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 1000
+}

registry/phase4an-engineering-validation/evidence/cases/zero--prefix--reference-t0018/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 1.8,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 18,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--prefix--reference-t0018/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--prefix--reference-t0018",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 18
+}

registry/phase4an-engineering-validation/evidence/cases/zero--prefix--reference-t0019/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 1.9000000000000001,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 19,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--prefix--reference-t0019/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--prefix--reference-t0019",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 19
+}

registry/phase4an-engineering-validation/evidence/cases/zero--prefix--reference-t0500/spec.json

@@ -0,0 +1,49 @@
+{
+  "apl": {
+    "gain": 0.01,
+    "normalization": 1.0,
+    "tau_ms": 20.0
+  },
+  "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+  "apl_delay_steps": 18,
+  "apl_precision": "float32",
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+  "dt_ms": 0.1,
+  "duration_ms": 50.0,
+  "expected_external_events": 105.90211181640625,
+  "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+  "kind": "fullgraph",
+  "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+  "max_steps": 1000,
+  "mode": "physiological",
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "refractory_ms": 2.2,
+    "reset_potential_mv": -52.0,
+    "resting_potential_mv": -52.0,
+    "synaptic_delay_ms": 1.8,
+    "synaptic_tau_ms": 5.0,
+    "threshold_mv": -45.0,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "name": "seed_validation-physiological-00-s1073741825",
+  "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+  "odor_index": 0,
+  "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+  "outer_protocol": "phase4an-engineering-validation-no-training",
+  "output_budget_bytes": 8589934592,
+  "precision": "float64",
+  "rate_sum_hz": 1059.0211181640625,
+  "record_history": false,
+  "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "seed": 1073741825,
+  "source_panel_row": 0,
+  "source_panel_split": "calibration",
+  "steps": 500,
+  "target_count": 48,
+  "training": false,
+  "validation_cohort": "seed_validation",
+  "within_trial_weight_updates": false
+}

registry/phase4an-engineering-validation/evidence/cases/zero--prefix--reference-t0500/template-spec.json

@@ -0,0 +1,54 @@
+{
+  "budget_root": "/data/digital-drosophila/experiments/phase4an-engineering-validation",
+  "original_spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 18,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4ak-apl-timing-validation",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "fullgraph",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "seed_validation-physiological-00-s1073741825",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 1073741825,
+    "source_panel_row": 0,
+    "source_panel_split": "calibration",
+    "steps": 1000,
+    "target_count": 48,
+    "training": false,
+    "validation_cohort": "seed_validation"
+  },
+  "output_budget_bytes": 8589934592,
+  "row_id": "zero--prefix--reference-t0500",
+  "schema": "phase4an-engineering-case-template-v1",
+  "start": 0,
+  "stop": 500
+}

registry/phase4an-engineering-validation/evidence/checksums.sha256

@@ -0,0 +1,901 @@
+5bddbfb94f999aaee354408241557f44bd3d019311f2a12c81cbb2a71f47b6de  audit/analysis-execution.json
+d5ad47a85e4c22e8a482b26330957a821e394022658531a914c9080187454d03  audit/engineering-analysis.json
+7163399ac2205a2232e7b5e7b758df7a98d979d3e6f25109894cc6d32f0e0d28  audit/execution-complete.json
+16630d0d666a2467c56b647d021cbdb627a553795f6afcd7f7eb496a2737d815  audit/final-status.json
+517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a  cases/static25--chain--light-s00/requests.npz
+ddb53c3d067aa3c85c81f2525db59dc6ab8eda1bfeb910fd7a3828222499e5ff  cases/static25--chain--light-s00/spec.json
+065e4b01b74ac6619f6533c54fdb58a345fffe7be30ae2295e50ab7015da888a  cases/static25--chain--light-s00/template-spec.json
+929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2  cases/static25--chain--light-s01/requests.npz
+c29fcf0d124c07d169e9357ff07b5cd9dcb6d6676562d9ba4db85c6c8f24e613  cases/static25--chain--light-s01/spec.json
+38001935f07393a08f8c83595541a6ff060b0f9ca7b9fdaf357e2f77f9348994  cases/static25--chain--light-s01/template-spec.json
+517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a  cases/static25--chain--light-s02/requests.npz
+34db8114208a21487dc5d07ba5f7700caefc0a5add81cb8fd7f0767bbed2b017  cases/static25--chain--light-s02/spec.json
+c89d7994d40fc79591c78d11c549766b45d283145fdcebb1e3b6c964b8750b2a  cases/static25--chain--light-s02/template-spec.json
+be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1  cases/static25--chain--light-s03/requests.npz
+3256a11c89da8ad99d2504bacf02c7b8ca8dba0679b5697250f3d071e6074d55  cases/static25--chain--light-s03/spec.json
+390f3d472a2baf3b7d14f1bb22185e027fb1c5ede8f42bfbd8e7c2051e78d0fe  cases/static25--chain--light-s03/template-spec.json
+764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e  cases/static25--chain--light-s04/requests.npz
+c10065bca4e8cec618c817ed8e86a42b51ef4849804e4369a18586cda34b3205  cases/static25--chain--light-s04/spec.json
+90a262080e33a6014679e7f3d932f61e1edb04cffcd9a2cf35440c078a9085f4  cases/static25--chain--light-s04/template-spec.json
+517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a  cases/static25--chain--reference-s00/requests.npz
+ddb53c3d067aa3c85c81f2525db59dc6ab8eda1bfeb910fd7a3828222499e5ff  cases/static25--chain--reference-s00/spec.json
+3b63e236d755714dc59b083b2ee48761ce48e9a8456770e3502798f5bd5e2ff6  cases/static25--chain--reference-s00/template-spec.json
+929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2  cases/static25--chain--reference-s01/requests.npz
+bcc2974b14b4a4e74e86c75d6806ecd15af8b26107fcd22f9ea6cf9f0423258e  cases/static25--chain--reference-s01/spec.json
+595a1a67fd82b48e0db25480771a93bd289e8f65c511c43780b42dabf9c8b478  cases/static25--chain--reference-s01/template-spec.json
+517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a  cases/static25--chain--reference-s02/requests.npz
+38488bbf4491c1d50f7c81726894584ab4b7f5cc1189e9aca88207b6d97e3203  cases/static25--chain--reference-s02/spec.json
+bda9afb21aebd4cf37d52a0cb83c21f179ca4fe9aca8a43e5a1cc92f2af81897  cases/static25--chain--reference-s02/template-spec.json
+be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1  cases/static25--chain--reference-s03/requests.npz
+557096e8e0b28def2e3c7039e7f5b79d75f5539744f7a0fa3fbd2eb403fd87eb  cases/static25--chain--reference-s03/spec.json
+246cbb287972c7539c4f53bc2546bd9cdd0dd960e8714bce060db1bee1ba0fc9  cases/static25--chain--reference-s03/template-spec.json
+764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e  cases/static25--chain--reference-s04/requests.npz
+ee7a4c6678992ab2c193178c5cb0cb26a546e89bc62cd73f2bcb9be8b6393c9e  cases/static25--chain--reference-s04/spec.json
+de59abaa0670a9be8d90a9dd9b41522edd277d9f75dbdb77ddeeeca1c508265f  cases/static25--chain--reference-s04/template-spec.json
+003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091  cases/static25--fresh--light-r0/requests.npz
+67c84138bab13ad1790020924064e6ead8b3d739c62bb44013d5b1f8cf40299e  cases/static25--fresh--light-r0/spec.json
+802b717691f9a6b460a1a58044286e727ffa8393605127ee7a11ad267fbf6338  cases/static25--fresh--light-r0/template-spec.json
+003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091  cases/static25--fresh--light-r1/requests.npz
+67c84138bab13ad1790020924064e6ead8b3d739c62bb44013d5b1f8cf40299e  cases/static25--fresh--light-r1/spec.json
+f4cdfd5de0fb80dd39203425c4ff7d063b0b66f2ac887e4276043251e3ad956c  cases/static25--fresh--light-r1/template-spec.json
+003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091  cases/static25--fresh--reference-r0/requests.npz
+67c84138bab13ad1790020924064e6ead8b3d739c62bb44013d5b1f8cf40299e  cases/static25--fresh--reference-r0/spec.json
+2ee541997a8a82f9ac356e9fedf8fc70ce31f622d42d846ab6de8c5f6cdea39f  cases/static25--fresh--reference-r0/template-spec.json
+adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570  cases/static25--prefix--reference-t0018/requests.npz
+534981eeebd53acfaac8915f181e54db2e761231ec95c9b389f00fbc9cfb586f  cases/static25--prefix--reference-t0018/spec.json
+282eccfb1ee2008f0b9ae8cca4daf45bfefd664806e7d04b8712fadf90b83bb5  cases/static25--prefix--reference-t0018/template-spec.json
+adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570  cases/static25--prefix--reference-t0019/requests.npz
+fbeccc9b36c505dce773095e159b031e0abd41f83ed9dbd69c2f4d5145d50f0c  cases/static25--prefix--reference-t0019/spec.json
+8cd7512a1b2cdef47aecfd26bfb7ee8b22b566dc6c6812e887b4cc3f5416e7e3  cases/static25--prefix--reference-t0019/template-spec.json
+aa2773a740b0e85940f3d96738a141903d5d178e40586522b603ae1c9de53e98  cases/static25--prefix--reference-t0500/requests.npz
+5a728bef0c5a786989989b11ccb550b4f36622471d0169e355f8a5195e803913  cases/static25--prefix--reference-t0500/spec.json
+654043502385a40dc4396c25ab2bf6f74701a7026fc85e6789672a810e5f700e  cases/static25--prefix--reference-t0500/template-spec.json
+517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a  cases/zero--chain--light-s00/requests.npz
+ddb53c3d067aa3c85c81f2525db59dc6ab8eda1bfeb910fd7a3828222499e5ff  cases/zero--chain--light-s00/spec.json
+e8f6fe8e0f67cbe851c045a067485d753979f5af32d30f596f545387b306f123  cases/zero--chain--light-s00/template-spec.json
+929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2  cases/zero--chain--light-s01/requests.npz
+616f9dbb93e9cc8b6bf6420d2e213afead3a1af0d580082c11653e0e14f434f6  cases/zero--chain--light-s01/spec.json
+b727d54f9d28e9b8482860c3ed2bb6c30d4778fe90644b2df9ebb8d0c032e148  cases/zero--chain--light-s01/template-spec.json
+517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a  cases/zero--chain--light-s02/requests.npz
+33739fcd9a34cb385163ac9b678fd44dfd56fff19c67054005790876b19ee48c  cases/zero--chain--light-s02/spec.json
+8af5bc5ed35084f15c7d77ded8224d49f49561d48510c862410eccd4d7dc5560  cases/zero--chain--light-s02/template-spec.json
+be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1  cases/zero--chain--light-s03/requests.npz
+c395303842c48cc82c34db3ab0e1490e3f2b68326e5477ad8996d62b41cb7643  cases/zero--chain--light-s03/spec.json
+7e140b41ae610cd67a8cfe2e30d633190ac2c7689a4682bba676e423b54e689d  cases/zero--chain--light-s03/template-spec.json
+764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e  cases/zero--chain--light-s04/requests.npz
+2e6291cb22891c66e08f9b90d4f6b7daf9e67b29352b7e0e8a62defa9f907644  cases/zero--chain--light-s04/spec.json
+5cc7905cdca67bdf09eb0730a274644f5605178b1c97928572c5ecf2a3b5acff  cases/zero--chain--light-s04/template-spec.json
+517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a  cases/zero--chain--reference-s00/requests.npz
+ddb53c3d067aa3c85c81f2525db59dc6ab8eda1bfeb910fd7a3828222499e5ff  cases/zero--chain--reference-s00/spec.json
+452da911a5f3d6d8cbd33e96451d6f65af5e46eee57fda00125c59f6378dfba6  cases/zero--chain--reference-s00/template-spec.json
+929f5b8a23043c0a10790d7cc0683ff81a6049b4e714db86b1fb54cb7f3ca8f2  cases/zero--chain--reference-s01/requests.npz
+6d90561b4235d3c0c5316ca5abbdbcaeb84b4b324e2b258c2da34d55990f6abf  cases/zero--chain--reference-s01/spec.json
+b943e29941af75b7c4ff333bdc0a9697d0e15131bdea46c4460ef91f894565b2  cases/zero--chain--reference-s01/template-spec.json
+517b500f350b0825f7cc9c639beb62d06764de286b13e0835cb26c5f83ff106a  cases/zero--chain--reference-s02/requests.npz
+d1bb8f215583a91592b405d86134eea2ff0e7cb5bb1e09fc3c3a8d99cf819f75  cases/zero--chain--reference-s02/spec.json
+412390b67001e08930f243f54954d78e7edf94b330aee2087c35748963a883db  cases/zero--chain--reference-s02/template-spec.json
+be049a344735ad19157ea86c6e911ea9042127ace736fe98bcdddf6b3c1425d1  cases/zero--chain--reference-s03/requests.npz
+72e5e05e201adeeb2be2436ebb3f9ca35b605cc81de7dcbace4a5a76326a115e  cases/zero--chain--reference-s03/spec.json
+6d5f2819be44646890cdad1969043bee5209e801b79687a8c1c2205601bc9656  cases/zero--chain--reference-s03/template-spec.json
+764259eb618a2ee9393b67ec2713cd0c68763a3e55bbd35e261f5c38ea044b0e  cases/zero--chain--reference-s04/requests.npz
+33200448de1970e83b99237f94b02284a023241ba878d8f47f1ca83251e9485e  cases/zero--chain--reference-s04/spec.json
+d8bd2b1b151582ec7495e59a15cae15279f71d444429c5c273397b63008b3440  cases/zero--chain--reference-s04/template-spec.json
+003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091  cases/zero--fresh--light-r0/requests.npz
+67c84138bab13ad1790020924064e6ead8b3d739c62bb44013d5b1f8cf40299e  cases/zero--fresh--light-r0/spec.json
+df1a6663ea748b0dc0333540877000e5c91d493b151e134e346dee54e834e3de  cases/zero--fresh--light-r0/template-spec.json
+003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091  cases/zero--fresh--light-r1/requests.npz
+67c84138bab13ad1790020924064e6ead8b3d739c62bb44013d5b1f8cf40299e  cases/zero--fresh--light-r1/spec.json
+32dce4105aaadac4f7079264cf0a30a3f8171862edf59cceaba6624f01a5252d  cases/zero--fresh--light-r1/template-spec.json
+003a6f6306787b67391735c41dd8b14c689beaaab3ab71a5e9afb376d3cbb091  cases/zero--fresh--reference-r0/requests.npz
+67c84138bab13ad1790020924064e6ead8b3d739c62bb44013d5b1f8cf40299e  cases/zero--fresh--reference-r0/spec.json
+a0bf214d782ddef0adb5b6f9b89c2d52566a5928b5d96316bddfe12520aa5460  cases/zero--fresh--reference-r0/template-spec.json
+adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570  cases/zero--prefix--reference-t0018/requests.npz
+534981eeebd53acfaac8915f181e54db2e761231ec95c9b389f00fbc9cfb586f  cases/zero--prefix--reference-t0018/spec.json
+8400934e175d3c20f19d863082e7df02c5279864b5191736565e9014df6e0e83  cases/zero--prefix--reference-t0018/template-spec.json
+adc91d6f97531e8f94b0bbee6b67b1c62b0303bb90b2ad0aa0adf0af9f990570  cases/zero--prefix--reference-t0019/requests.npz
+fbeccc9b36c505dce773095e159b031e0abd41f83ed9dbd69c2f4d5145d50f0c  cases/zero--prefix--reference-t0019/spec.json
+9c361dfb9af4dd7071a7f1c3c2315adddb21b42e9ed5e9a199b1cdf52fab40e7  cases/zero--prefix--reference-t0019/template-spec.json
+aa2773a740b0e85940f3d96738a141903d5d178e40586522b603ae1c9de53e98  cases/zero--prefix--reference-t0500/requests.npz
+5a728bef0c5a786989989b11ccb550b4f36622471d0169e355f8a5195e803913  cases/zero--prefix--reference-t0500/spec.json
+bda640a599d6cdf80ad435f344fcd576d91ca0afe9de732f36fa7bd54d470c1e  cases/zero--prefix--reference-t0500/template-spec.json
+08dad899a5b5953c910653df1e2d0deea25774993247bb0481e9a7226196c01e  extension-build/author_cuda_8b92086ce274b694/.ninja_deps
+c933cf20577c21213c02b866e31ff3018ffdd7891b8d1e78b479075499497fcc  extension-build/author_cuda_8b92086ce274b694/.ninja_log
+af0e447e2a763b34d872ebf5ac8e2ffb47dd6035010383964763bc2fcb27e350  extension-build/author_cuda_8b92086ce274b694/author_cuda_8b92086ce274b694.so
+b379970317d4d6d97c0d428e7fd218883c44b7ee137511e9154df6c73f51a628  extension-build/author_cuda_8b92086ce274b694/author_ext.cuda.o
+f9092f2ef8da90ee89cfb89075d1e0891456f4bcbf6d9d405c65696a92f8cc49  extension-build/author_cuda_8b92086ce274b694/author_ext.o
+75c123c6847475e58245ed925446ae65ffcb58f336d6b4cb928e7f47e4de8a50  extension-build/author_cuda_8b92086ce274b694/build.ninja
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  extension-build/author_cuda_8b92086ce274b694/lock
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--chain--light-s00.stderr.log
+a8914ea1648f779de118286907c4a1b1f4e5bc748cc734e6abc0757ea01e9b0f  logs/static25--chain--light-s00.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--chain--light-s01.stderr.log
+5df0ddef73c57fd56b891c69e1177a41a072f2f9bed8e5b9ec41e399badb02af  logs/static25--chain--light-s01.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--chain--light-s02.stderr.log
+c1fce7b291ecfe94d413325aeda502528d8ce8a1282c82b5007da4227df06975  logs/static25--chain--light-s02.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--chain--light-s03.stderr.log
+5cae770692eb5330f242e9b3817ca84ec70e0b9b09ba1ba82d831ead66295f99  logs/static25--chain--light-s03.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--chain--light-s04.stderr.log
+339f02325c11599a7723c93e668221b1111cdefe5094203d31896cecba7fa671  logs/static25--chain--light-s04.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--chain--reference-s00.stderr.log
+d07baacc8d9b02c9c8c806aec082109a88423825cec56ec8f04660d12412e4df  logs/static25--chain--reference-s00.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--chain--reference-s01.stderr.log
+d6620036700f715cd7492eaa60bbc674ee052eddae3a1f5a98ae370fa6e627ae  logs/static25--chain--reference-s01.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--chain--reference-s02.stderr.log
+d19a2b51b2eea5294c1e8149ca7521d961ebc5af57ef301cfc2b270722437375  logs/static25--chain--reference-s02.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--chain--reference-s03.stderr.log
+a63ff43c90fd7e231cf8c92cff363ae5bb2f9cec14da374192a471deb85f4660  logs/static25--chain--reference-s03.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--chain--reference-s04.stderr.log
+ff46304c4dc8fc5d6ec279090c7d7e31a59e71630a49693efc539a9d2026a76f  logs/static25--chain--reference-s04.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--fresh--light-r0.stderr.log
+d60fac810df233507a1093e09481174ad24f8d0efd6a550f6ac3d16b53fca7bf  logs/static25--fresh--light-r0.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--fresh--light-r1.stderr.log
+3a9e1bcbaccb384ccee3b3b2b1271c9300237235e67621c13ca269e4ff2c7c30  logs/static25--fresh--light-r1.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--fresh--reference-r0.stderr.log
+2d4bb1c9465c4a16137ece838f05ea0a3c84f67a9fd60fe8cfe0ae78809efafd  logs/static25--fresh--reference-r0.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--prefix--reference-t0018.stderr.log
+89a495cfb8f44d07f69c6b22c15f9d385e418ceaff9ca2a3d3359f4c9ee44a62  logs/static25--prefix--reference-t0018.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--prefix--reference-t0019.stderr.log
+55113d1c38cdfe8c46205d7ab908d2213ad8ee61146a4dd6a2acbe8d0b26f123  logs/static25--prefix--reference-t0019.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/static25--prefix--reference-t0500.stderr.log
+738a4b6b18e8502ac1cce710362e36f80e9d73c3c7658292abc154974eede002  logs/static25--prefix--reference-t0500.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--chain--light-s00.stderr.log
+3babc52c94e68512278687051547d37aea27fc3df8d56ecdd295aa3423588dfb  logs/zero--chain--light-s00.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--chain--light-s01.stderr.log
+6cfbde7603928a48527dc69dbc8fff25aee3d573d96a78ffbbe9cc36794deec1  logs/zero--chain--light-s01.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--chain--light-s02.stderr.log
+8cbb7655946977f254d3877f9b5125a052118389d5c67adb2eac50ec6e2525a5  logs/zero--chain--light-s02.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--chain--light-s03.stderr.log
+d3323bc0aca8b024c4ad4a2f907cc8c0cf540750d662b556c96db1db079b0e8f  logs/zero--chain--light-s03.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--chain--light-s04.stderr.log
+dd30bffc1726f678429d49c8b917778aeb94a3d693a42e3f37b41220a254c6e1  logs/zero--chain--light-s04.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--chain--reference-s00.stderr.log
+109a8e00d97390ae78c1afc3635ee44a160ddcbe3f4f10181f033fd2e331c056  logs/zero--chain--reference-s00.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--chain--reference-s01.stderr.log
+dbc332683c73131f9245cd7de27d4fded303cacfa481490177dd9551be0944e7  logs/zero--chain--reference-s01.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--chain--reference-s02.stderr.log
+f970a34a6b7198db75609f8524053cd897303c34dfc68fbbea241bf2233a46c1  logs/zero--chain--reference-s02.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--chain--reference-s03.stderr.log
+8368d8d91b58feca3f305103c86bf10fab9d8791c11714a229feee64fb53fced  logs/zero--chain--reference-s03.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--chain--reference-s04.stderr.log
+029ffc9b372430ba3fe7437a885c85f41c6deed249469af350ba9df221abcf18  logs/zero--chain--reference-s04.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--fresh--light-r0.stderr.log
+71a1f1b0dc9d977522f41e619471a50a3278032600eb4f3ffd5502680e6a9125  logs/zero--fresh--light-r0.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--fresh--light-r1.stderr.log
+8c29087862f7d8b9a361787df12ec099d6fef7b536d3057228a2f1ebcd1f4e09  logs/zero--fresh--light-r1.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--fresh--reference-r0.stderr.log
+e7c749668db2d2b3ee28b59c524bd5de0bae7365379dfa8702de827a2d0251b7  logs/zero--fresh--reference-r0.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--prefix--reference-t0018.stderr.log
+3f31fc5d6f9e3f4a54fee90c50d968a0cf81a7e64e9e233e6f65ccaf8d76e6ff  logs/zero--prefix--reference-t0018.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--prefix--reference-t0019.stderr.log
+f33e40ba1cfd49f2105d8fea8a49eeadeeadc8ed9d08c53a0fdaf5b085865d5d  logs/zero--prefix--reference-t0019.stdout.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  logs/zero--prefix--reference-t0500.stderr.log
+bbd479014693caa69287d6f2eafbe60b920c7f04fa5a232a61844b1412991943  logs/zero--prefix--reference-t0500.stdout.log
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  overlays/static25.json
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  overlays/zero.json
+66257eb665808e33005dd7ba14a16063064618cc48e47cb65b70f3900cec2484  protocol/AM-gate-authority.json
+175b5d0e2de12a9ce01c6167591dab882d9c9c6869de2d194bcd9e6732c6ed6d  protocol/AM-seal-verification.json
+7317441126f191ccc6e6d28438870b3921537ebe282a6acb163716a690057945  protocol/preregistered.json
+1ac0d65b906e1061781c967cc6a99e8a0a73df6a1ee564ed6603f88e3f5d7056  protocol/source-snapshot/ENGINEERING_GATE_DRAFT.md
+3970d13bd43d4bc12baf4b6ad1cda3eb085e10bf4648752cfcecb6d12314c5ea  protocol/source-snapshot/engineering_analysis.py
+5a2403f11bc08d65a9d242ac2cf9686b850e0c3680d65659f785e9b6b50c0238  protocol/source-snapshot/engineering_compare.py
+cc8c0e83016af4836c81cd0773fc521c69fd30e6f4d021bf54d0e7897105c6d5  protocol/source-snapshot/engineering_inputs.py
+3c127aee723a054fda272fee458067608b521a7c443455822d97f509caded6c7  protocol/source-snapshot/engineering_plan.py
+62dedce2439407398e70beb4c718bf14e02d3e624b3db3ef6f74299115d84bc1  protocol/source-snapshot/engineering_prepare.py
+6ddaec52f2a0b5d0c528d51230d372fe2344160aef5eccea6a95b6c5e61a574e  protocol/source-snapshot/engineering_queue_audit.py
+1043ba217e5395c9e81e58b95a5aa396f572588872b954e549774f2b99cac5df  protocol/source-snapshot/engineering_scopes.py
+76313332b8d18f121a61f7b6e2fc32ea9e893848e8ed5d049557fc08b385e674  protocol/source-snapshot/engineering_workflow.py
+0b8e8e0a6a23a079dc62a88355ce355d53b3ae22f6665519a8f6aef2dcfc5aba  protocol/source-snapshot/runtime_continuation.py
+522b8c31ea938890fe15364fccd25ccc5bded54101754909f255532e7ad01aae  protocol/source-snapshot/runtime_light.py
+35e4ee37a1e82cf5e645d24165343049d400104c94a6d184b8aa834ba5ef2d20  protocol/source-snapshot/test_engineering_analysis.py
+87a85843d918cce6529ab94f7cb82499aa413281e803c00c030a3c340a581469  protocol/source-snapshot/test_engineering_compare.py
+4dcc7b775eb3c7e59ed9cc3d7591eacc0ef7bda1209edbd847e2ae79b115ef1b  protocol/source-snapshot/test_engineering_inputs.py
+c26c2c75bb27d3b8514b7d44f40369130d60147c6c8edc569b4efba4a4ad9815  protocol/source-snapshot/test_engineering_plan.py
+a12aa1d2cb4880a3f7a7889b89d71a859bc8c68b4badfb8f082d712cdd342627  protocol/source-snapshot/test_engineering_prepare.py
+0e2bcfe25c3b5a5cd0ed5cd05a89392207191ec4db950cdb06a0137666c8adb7  protocol/source-snapshot/test_engineering_queue_audit.py
+748c0777e4a8164e80c03c727df1c2decbac7747737ad1c9fb730ea5c9e208d3  protocol/source-snapshot/test_engineering_scopes.py
+bb781b23f92b5c0eb92f8dbc54468a8e843177f6da004c444b48947b037bd705  protocol/source-snapshot/test_engineering_workflow.py
+325c0b688d0ca1648ffdf29a8d3d4bb91d6f6115bea6f5ac30982acd6dfe8e06  protocol/source-snapshot/test_runtime_continuation.py
+887345e497e6fa9c10ffa49c490196711d8cee028c62ec7a73f42db36569be2b  protocol/source-snapshot/test_runtime_light.py
+817766a56484ba383462d89e7648e1dd238a2e00bb2b824504e6262d76355deb  receipts/static25--chain--light-s00.derivation.json
+69fb7a48f6af11d36ed0db8609bb2f70884275e9d86cae829b876e2417312eaa  receipts/static25--chain--light-s00.json
+9400c4ae2449fbdce0a317cd4398cbdf6b1597b68c9010d4d8e2001c7e2788e8  receipts/static25--chain--light-s00.runtime.json
+5a2e7395aa5387345be5c95ae37f2294b8641e3bdacb785077628082d0ae850c  receipts/static25--chain--light-s01.derivation.json
+cf3f86c0f93fa9144e860311262eacb7883395850e9ec5ddbc0e9b1bb2d3eb78  receipts/static25--chain--light-s01.json
+f6f17ea84079a8d98465f429d6eb1b0f79f333a1948431a3ff800cb2174465bd  receipts/static25--chain--light-s01.runtime.json
+843fc8a4be08679681bb8a9855e9e5ce63fc2f4c96aad33e11ccac1545439497  receipts/static25--chain--light-s02.derivation.json
+b5d51f20ad942805ea10c8cfd59fda3e10b55b95e4da73b074a197d9495e0f2f  receipts/static25--chain--light-s02.json
+ff5398be834fbc68fe5374145024162258f2a191c519015254651f66cd853442  receipts/static25--chain--light-s02.runtime.json
+1a878637be0632b541b61c4364d9e4c9c0a4dd7e09cbf0f7372b582374a6b9e0  receipts/static25--chain--light-s03.derivation.json
+cd1bcdbc73127f7837e889a3aeee8bea7e3d76fb31b1797fdb6a34ae1c55cec9  receipts/static25--chain--light-s03.json
+97c5419cb4060d9c3c24ab35e420a7a130d606c7345297ea0703744f5ef2edf2  receipts/static25--chain--light-s03.runtime.json
+86ffb5bf2a9db6fe3f62b7180be82bed665e894e05eae112a6c5b82fcf3f601b  receipts/static25--chain--light-s04.derivation.json
+4e16145b7e065bf891478a3e2b75d0ae568179a9e963e487c36fad13132a3802  receipts/static25--chain--light-s04.json
+da5edb58d7f1f4ba07d71391fafa0fd645b3c528147457f8b31056a53242fa24  receipts/static25--chain--light-s04.runtime.json
+817766a56484ba383462d89e7648e1dd238a2e00bb2b824504e6262d76355deb  receipts/static25--chain--reference-s00.derivation.json
+5ec0ca4d44c8c0f7f029b3b0cdacd4a522fac06ab61dea7930a7bbc38660f04d  receipts/static25--chain--reference-s00.json
+94a92952f25666c066addccd5df7cb5e1743b37ae9fed0565c6975843cc2490b  receipts/static25--chain--reference-s00.runtime.json
+481d91030d37fab8ab61935744d9fbb9f0f57ddf25ee4271658771b28b189ece  receipts/static25--chain--reference-s01.derivation.json
+49c6e3a38ec64acce20f2580567ebe065adfc68b96a8b5d4e38933245a1f7494  receipts/static25--chain--reference-s01.json
+bf9f1c0c8f65c7b77e47f2ab43748747d9738db750e70ab044548c90f1d6d135  receipts/static25--chain--reference-s01.runtime.json
+e04bb42ec8b562e6be8779b90ac61933c637c54e6954327f0ad1468cbbecf232  receipts/static25--chain--reference-s02.derivation.json
+1ee9097792abf54b989a2a06dfa41336216540cdf29aebb635ba72abff57d609  receipts/static25--chain--reference-s02.json
+e57184070d6b37c31b35820502747a652a6b773a5d3b22eaa491cb0c06bd1b27  receipts/static25--chain--reference-s02.runtime.json
+b01505e9068238f4aded3eab346ace5043f48270618d13c12bb637cc8db6523a  receipts/static25--chain--reference-s03.derivation.json
+85193748d4675d875ff9bd53abbf82f3c00720c706d662694aaaee75741f263f  receipts/static25--chain--reference-s03.json
+f256d3569fee444d851b6e16eac920aca744a1b5900f241c39f38e8cc6dee501  receipts/static25--chain--reference-s03.runtime.json
+bd5faed882110abe97015650dc7ff7f7e194670520d30ff7773126773d8e0bd5  receipts/static25--chain--reference-s04.derivation.json
+b8a9ed7667b384ee0e9939dea363196fab0eba8695422d7e868e92d3c3a56398  receipts/static25--chain--reference-s04.json
+9b4bcbee75d5221e689666e58bd927624bb10aa04f4cebd3b9cb1ac68b36b206  receipts/static25--chain--reference-s04.runtime.json
+d3a4bb58fefadff205151d9824f1ae7af5a59a28d4d97e7bbfec6ffe48079aa9  receipts/static25--fresh--light-r0.derivation.json
+83cee3b7447cf8ccace47b499145542351dda52498f9165c5b02eff5b31c490d  receipts/static25--fresh--light-r0.json
+21a6add7cb67d76c317ee0adccbde24e17de6f66dc2e7eb16163a376736d4500  receipts/static25--fresh--light-r0.runtime.json
+d3a4bb58fefadff205151d9824f1ae7af5a59a28d4d97e7bbfec6ffe48079aa9  receipts/static25--fresh--light-r1.derivation.json
+86cdde61b7c2581f28d5bed9271fbf0a2f764c01ac95b360b221c9436177e731  receipts/static25--fresh--light-r1.json
+5600b9bed927201d5b095eb677451300e99c71112b404f4241639c3e82e81c24  receipts/static25--fresh--light-r1.runtime.json
+d3a4bb58fefadff205151d9824f1ae7af5a59a28d4d97e7bbfec6ffe48079aa9  receipts/static25--fresh--reference-r0.derivation.json
+9479f44277df44557ffbc2f5251fc523f07e9fa4fab4575023510bc6ff26bab6  receipts/static25--fresh--reference-r0.json
+212af7746d375dfdec0fa9fdaac84de9ee323182bf2ddef8e4e1f5209a748e91  receipts/static25--fresh--reference-r0.runtime.json
+65b115618f193a5b7b7ddacbb4040f3564c426d2b97130fce642dffaf53a5568  receipts/static25--prefix--reference-t0018.derivation.json
+601feb3ffefc15c3ccf98a36b89eb16559a9672b325393b43e9559cecabedfda  receipts/static25--prefix--reference-t0018.json
+31ab36a846b1c572a3830e2c0afd32da0b68c0836ec0d0a963defd5d82310744  receipts/static25--prefix--reference-t0018.runtime.json
+4c5e34a864b200a29a17c0a3c33579aa226c9c86bfc4b9ae5525e00f400d9279  receipts/static25--prefix--reference-t0019.derivation.json
+e3f380e6fba8c92111f54af259531f64177c58401e915898c80f34f178fe78df  receipts/static25--prefix--reference-t0019.json
+43b452923fb221ae6b2d9a27ec57240f4799b09b5ba1e300c7aead5ccff7f6fb  receipts/static25--prefix--reference-t0019.runtime.json
+5c54b053c2a7cec1fa5106fbc72fc41a03168da4eba68bb8db88b2d7910507b6  receipts/static25--prefix--reference-t0500.derivation.json
+d61cd75530c74b579b334bc715a9de2226606855ccc4c011fcac6cf89570cdf4  receipts/static25--prefix--reference-t0500.json
+0b0cb7db049668c0217fc1613b796ea061f78806ef2bb1ae80d051b97d744633  receipts/static25--prefix--reference-t0500.runtime.json
+817766a56484ba383462d89e7648e1dd238a2e00bb2b824504e6262d76355deb  receipts/zero--chain--light-s00.derivation.json
+0fd5857a719d09737124116cc9342386474859e19c55c015c614db4c751e799e  receipts/zero--chain--light-s00.json
+6bad229951b64fdfc8c10186e899051b04fc7022be19bba858dade38b145132c  receipts/zero--chain--light-s00.runtime.json
+29f23c65ef708b0688eed37b0de1cf5ee115cb54a966a6e5d79f232795075ddf  receipts/zero--chain--light-s01.derivation.json
+2e038c35dc563a558dd0025a63262497551d4a65d542d34f30bb2a1812566cda  receipts/zero--chain--light-s01.json
+529eee86ecfd21acbbc011d9d148272aa104b7e2e6a980c2b6b0419dcd0393d0  receipts/zero--chain--light-s01.runtime.json
+5cb5b89d76859178d9e203667066616eb93849591500694ce83c15650cef81e6  receipts/zero--chain--light-s02.derivation.json
+a0836cffbc3a7857937b578ee084c955f0b1851b4c2455d3576951256128d5e5  receipts/zero--chain--light-s02.json
+d21a6b7b6cbf15cd880d40e3ddf22d06d26a898f51ffa527801aa6f7d6aef5eb  receipts/zero--chain--light-s02.runtime.json
+d3db21ca94683e4506df9e032c13ede46d154d2ab76206fc131a6db8f8f7b3fa  receipts/zero--chain--light-s03.derivation.json
+bd7d4d7315d6336031c9176a54fd65baf01ecd5722cf8885b351054d9d9d9485  receipts/zero--chain--light-s03.json
+6896e2a2eedb9d8e94a11c3131e3142904bdfe30c03996451f9fdf0628f5b99f  receipts/zero--chain--light-s03.runtime.json
+31a5f242e0a8c2d77e5d002bf35a2a28286c39e54d7db031b24824b508741202  receipts/zero--chain--light-s04.derivation.json
+f2936dfa1b16a0aac6ff1be109a0f0c3b13ed895c5284fab9fae6dd297839e12  receipts/zero--chain--light-s04.json
+86e11dbe8df489041f3da35c5d3ee831343ce3d1e098a7e897039f0ba005d270  receipts/zero--chain--light-s04.runtime.json
+817766a56484ba383462d89e7648e1dd238a2e00bb2b824504e6262d76355deb  receipts/zero--chain--reference-s00.derivation.json
+ab843922c457b8ebbed58f6bd057d1219fa523100ded700d6c5fb3eae39bd6bd  receipts/zero--chain--reference-s00.json
+d469108942db00e4fbb2a7b7040325308641e6a405be13b93c51b406ca889aff  receipts/zero--chain--reference-s00.runtime.json
+255b2b3e6825a3f17f5dbfa2b7dfd193f41539f2446514811f4c21dbbefa6399  receipts/zero--chain--reference-s01.derivation.json
+0d9ce5b903e3b60510778a47d9797b8c45455c7509e9a2872039e3f87f90cd91  receipts/zero--chain--reference-s01.json
+3506b72bc8cf76560229ec40e5ebc5935a459ee9369011b5830e7a7701079b53  receipts/zero--chain--reference-s01.runtime.json
+18791a4fc66607470d1a5bf0cf0f36ceab0d4abddd3f1aaa46bf98b6f48b0752  receipts/zero--chain--reference-s02.derivation.json
+8e7d08743ee87c12bf98e20b853117c883601489b7824ad4a24354eb684ef4fe  receipts/zero--chain--reference-s02.json
+9c55e8be5c4e690dc88adaf6570be49a7ebaa14c370777765e5f7acb10d608e4  receipts/zero--chain--reference-s02.runtime.json
+9623d3ffb8db90cc4f477c831ee58650b8293b759dfd2ea91360db72589bc261  receipts/zero--chain--reference-s03.derivation.json
+420090f9378d8f236d2a478af22e009364b5613eb7ec0f76228a08baafed4dd8  receipts/zero--chain--reference-s03.json
+8d833796fa45c674ece9c9722bcca59a40cc65768a3a396adf34d1fe61badae7  receipts/zero--chain--reference-s03.runtime.json
+99fd0a5ef2aa4fa090c6fae1aa603a30be5adb1da247febed0841731e6fb487c  receipts/zero--chain--reference-s04.derivation.json
+98fc0809ab600d49ea7c15284364cfcc40797e14e23dd5dee56f7a206a269b8a  receipts/zero--chain--reference-s04.json
+487b2cad28e8adea2cccd29da2150d80dffd139565c2ff47f74db271ef5efd18  receipts/zero--chain--reference-s04.runtime.json
+d3a4bb58fefadff205151d9824f1ae7af5a59a28d4d97e7bbfec6ffe48079aa9  receipts/zero--fresh--light-r0.derivation.json
+099d02a5b31e3ff6e0c620bb285d444fa192fa15022b78632a05774e002b3c89  receipts/zero--fresh--light-r0.json
+e0893b05c197c0ed0a56b597267b1d5d4ea2fc323504f8ff238ba27744655bcc  receipts/zero--fresh--light-r0.runtime.json
+d3a4bb58fefadff205151d9824f1ae7af5a59a28d4d97e7bbfec6ffe48079aa9  receipts/zero--fresh--light-r1.derivation.json
+36da6e49ba3575ddc0bf36a839e58e959abc08f3db2e728f40a9d88e22ace1bb  receipts/zero--fresh--light-r1.json
+347e24167e785df30091308dbf5900981bb9ffd422ca71980a2e8a893237904f  receipts/zero--fresh--light-r1.runtime.json
+d3a4bb58fefadff205151d9824f1ae7af5a59a28d4d97e7bbfec6ffe48079aa9  receipts/zero--fresh--reference-r0.derivation.json
+1a6e73ee71f969125a3a69d1f46b0765a6bf574b55fe9704be07be364e64b4c4  receipts/zero--fresh--reference-r0.json
+4ddf3396aae5da1cf9c8d416039fea5f7619831d405fcaebcf0f24cc5e116953  receipts/zero--fresh--reference-r0.runtime.json
+65b115618f193a5b7b7ddacbb4040f3564c426d2b97130fce642dffaf53a5568  receipts/zero--prefix--reference-t0018.derivation.json
+f06f286b82f9b196347253684eef229a3f156d3109fcb9b15141c41ac0f47533  receipts/zero--prefix--reference-t0018.json
+7565c66430321fb14fb1de284b24e6a82246b61e6134a38242da86221612da9f  receipts/zero--prefix--reference-t0018.runtime.json
+4c5e34a864b200a29a17c0a3c33579aa226c9c86bfc4b9ae5525e00f400d9279  receipts/zero--prefix--reference-t0019.derivation.json
+1eea2cc407e3a01ccf6d5cedf2aa19eb3be1bb75b9df3e5cb31a7eed38a96762  receipts/zero--prefix--reference-t0019.json
+176a7d952ed81882c231512814ca1e7be04767f52bae83c1ca74fbe1d23ae91d  receipts/zero--prefix--reference-t0019.runtime.json
+5c54b053c2a7cec1fa5106fbc72fc41a03168da4eba68bb8db88b2d7910507b6  receipts/zero--prefix--reference-t0500.derivation.json
+49b34a635e2e029b430224bf3a067ced408f81273a7b17f33a783b64431cd765  receipts/zero--prefix--reference-t0500.json
+df18488b891cbb3609868b10dd3e3e7d17ffa5b37590e91e43ea97563cc67fdf  receipts/zero--prefix--reference-t0500.runtime.json
+175b5d0e2de12a9ce01c6167591dab882d9c9c6869de2d194bcd9e6732c6ed6d  regression/AM-seals-after.json
+68475cc0e72039e044c8fb3aaea9c8487c6737c1b8a457641e818581d81c387c  regression/old-integrity-after.json
+68475cc0e72039e044c8fb3aaea9c8487c6737c1b8a457641e818581d81c387c  regression/old-integrity-before.json
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--chain--light-s00/apl-component.json
+f4c6097555e9bca1551d23df2751afd3d8ae6914559233707de894b51c9dd200  runs/static25--chain--light-s00/apl-pending-tail.float32.npy
+e683ba6046e405c6787e6861cfff6b2d5df8b38be7684351810dc2bb8fb65b76  runs/static25--chain--light-s00/apl-timing-audit.json
+e1eb04c098b366870cb05869af9a4277d85fb7722f87202ac9e3b97e768d30cb  runs/static25--chain--light-s00/checkpoint-manifest.json
+4d5ecd025cf500818de9c269269596c604b385c795a80442384ae688cb907066  runs/static25--chain--light-s00/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--chain--light-s00/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--chain--light-s00/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--chain--light-s00/overlay-manifest.json
+d2250de77a7723e0237f53b54038377b5502ccf3a549cc08f3344a1e924b99ac  runs/static25--chain--light-s00/requests.csv
+ec67e5a4d47948e7152b0c532fc74fd8e0571fd8697cba760352bbfbd4763d48  runs/static25--chain--light-s00/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--chain--light-s00/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--chain--light-s00/source-audit.json
+67943c878314d88e6c34ee89a08ec61dfb9c66c43279766f54946556962b67a3  runs/static25--chain--light-s00/state.npz
+dfcae9b785dcaa579d813185df194ce69a18e672738deaa63766a61585e59acc  runs/static25--chain--light-s00/summary.json
+749a93983ffcf0b89e2b0f67f51bc11134c575d7e8d0230d6ebe333fa20c28ab  runs/static25--chain--light-s00/terminal-queues.npz
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--chain--light-s01/apl-component.json
+3b0d33abfbd75b2e48c3d48bff3f3374a9f3845543cd2626ca341d1c4532286d  runs/static25--chain--light-s01/apl-pending-tail.float32.npy
+a82b3b00fd2366b13e8f89945c353cbff49fd43258d00723cc471eff795c2ef6  runs/static25--chain--light-s01/apl-timing-audit.json
+e3885149662d9abf9666a76953784b508398a08be963b8165cbbb3548b4e2b13  runs/static25--chain--light-s01/checkpoint-manifest.json
+2d4871c9f09b5ad486637bb9233c49d6c2398dce409019cac72b77f6c1cfd221  runs/static25--chain--light-s01/continuation-receipt.json
+ff22fb288988dea3ac624bcec27359837bdfa4dab244768b252e65e2e1acfa46  runs/static25--chain--light-s01/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--chain--light-s01/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--chain--light-s01/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--chain--light-s01/overlay-manifest.json
+9e9b4d0a5057a967246555f30a70b9c145b4247ae77722ba562441483182faa8  runs/static25--chain--light-s01/requests.csv
+659f9383bafcc3d222325fb8d61be7af5be34e48a34180614b11d7ca2fae78c3  runs/static25--chain--light-s01/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--chain--light-s01/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--chain--light-s01/source-audit.json
+93ef29574754b862a88c665589190732acc69f9fecdbf57295f71d9a3ccc99c7  runs/static25--chain--light-s01/state.npz
+0b4f6774478e8e79b551527838bf230a2c1fae1547920979c002149fff924bc9  runs/static25--chain--light-s01/summary.json
+cf00897e9128b83a01d32c1c7208449911f34a776fb9a88f78273a91aabf0986  runs/static25--chain--light-s01/terminal-queues.npz
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--chain--light-s02/apl-component.json
+1f730d8d9b512d19d1cb4af20c85dcb56d60dde2a6fcdea5000f9078415850d3  runs/static25--chain--light-s02/apl-pending-tail.float32.npy
+bf13d66b8834c17b1c68a0d107b1b48258cb2179b548ece5e2c2142fe2ca3df5  runs/static25--chain--light-s02/apl-timing-audit.json
+ba542fc65ca165c6d1027ce0c056bf8f0b6360b0ad98f4f909240e34419655a8  runs/static25--chain--light-s02/checkpoint-manifest.json
+37a6a7ad9440dc3c61f97a783a915ff4e7c52b32a12cb89f5aaf8aa17b62af36  runs/static25--chain--light-s02/continuation-receipt.json
+f11b37717ad3c092a481adcf78f7caffd688650bf4cb56ab644175721e63a9e8  runs/static25--chain--light-s02/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--chain--light-s02/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--chain--light-s02/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--chain--light-s02/overlay-manifest.json
+d2250de77a7723e0237f53b54038377b5502ccf3a549cc08f3344a1e924b99ac  runs/static25--chain--light-s02/requests.csv
+b9547378fa968408fcaed0a2997e98d1f065d2864d4e531703739b6e9d281312  runs/static25--chain--light-s02/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--chain--light-s02/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--chain--light-s02/source-audit.json
+e73da12668986893b8fe7d412e2efaa8ebf53478b12bd6081c92f3ab7d0d1960  runs/static25--chain--light-s02/state.npz
+82e68ff0074b239038c267a13fcfab9ca0ae034a6d731a9777a5b1d5c126c5bb  runs/static25--chain--light-s02/summary.json
+c62e42ea853eba86b021529340bb106425043080632d41a935d107ec32f467b1  runs/static25--chain--light-s02/terminal-queues.npz
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--chain--light-s03/apl-component.json
+c222b8012c2e3edbff7fad90e8dcd51db47b2a541d7109be2872acb96ac94c30  runs/static25--chain--light-s03/apl-pending-tail.float32.npy
+a640b2790c05c73b86d69e667f2a63510ec1937d04ded8e9e0035d1557d0dd79  runs/static25--chain--light-s03/apl-timing-audit.json
+7a46fe8914e903760a720caee920070d8dde2e1ecf91190948b3541bbf366505  runs/static25--chain--light-s03/checkpoint-manifest.json
+41e56da038e2d8d4c85fcf7be0c5380a4219d153d8c9709a8d61d9c0d8aa5a48  runs/static25--chain--light-s03/continuation-receipt.json
+78de62547a9d43e37543dedb92ef79687676c58a031269f447d5f1545cf08c9c  runs/static25--chain--light-s03/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--chain--light-s03/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--chain--light-s03/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--chain--light-s03/overlay-manifest.json
+f485d562e1be7230112ed27f211d3053ac715bee49416a0062ac71210cac5d56  runs/static25--chain--light-s03/requests.csv
+4030d42ef51df0cf987be0fe43a7f8ce8d041c7ed5d484a35953bbbcb4e593cd  runs/static25--chain--light-s03/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--chain--light-s03/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--chain--light-s03/source-audit.json
+1ac87260cb29f8358e26f9603dcba748833ae597fb848e28169915b2c2ad75cd  runs/static25--chain--light-s03/state.npz
+b18796a661d050f5f577750ca9811eb9e34d9dc74cdb7b61d0f45df18cb3e515  runs/static25--chain--light-s03/summary.json
+8faf854dcef4d8ff8c66413fd560313dcbbd9df8cdd386fd491521d492f9298b  runs/static25--chain--light-s03/terminal-queues.npz
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--chain--light-s04/apl-component.json
+2dd2e0c79d4ee5299b8c1e8863e6c61b81f3dba08e599011887b1e1621f7c945  runs/static25--chain--light-s04/apl-pending-tail.float32.npy
+e9988f2d7a7ac7894a576572301bb99a8d1bcc953420c898170dc048a4a66561  runs/static25--chain--light-s04/apl-timing-audit.json
+b06f62b9290d5b41883dad249eb32cc2d1978beb5d1f8f92652c52c6202433f5  runs/static25--chain--light-s04/checkpoint-manifest.json
+b69961a06417b0d44688e3b02fa4fbc4c308976971256e15c00a856eaf91a266  runs/static25--chain--light-s04/continuation-receipt.json
+3c654cdf657f9566f5daa467d94e80d225feaf53858cd87a446c4c0893d97662  runs/static25--chain--light-s04/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--chain--light-s04/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--chain--light-s04/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--chain--light-s04/overlay-manifest.json
+ea59d983198a1ddb9ca97927561380667ce05d855f8d87dcb4cc89d8b778030f  runs/static25--chain--light-s04/requests.csv
+ce7bddc8556a8d7e2fc60316786290fedf724eab5c149559d2ed95b88dbaba9b  runs/static25--chain--light-s04/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--chain--light-s04/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--chain--light-s04/source-audit.json
+67ecca5b227ec7942c273e2ebecf9d82b4fadd688a4c3fb39e361f6ca1a38c6b  runs/static25--chain--light-s04/state.npz
+816ee6c491e3ba9e125b178741aa862679772c1861646f216d4ff3a0d83adda7  runs/static25--chain--light-s04/summary.json
+279fc5d68f2630b8bb634d01546f529a250a54976ed5f3daef82b8be9d1b683f  runs/static25--chain--light-s04/terminal-queues.npz
+f1c06741513c8fca5911c4389abae361c2d5d04ca81896b4d8d87941146446d1  runs/static25--chain--reference-s00/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--chain--reference-s00/apl-component.json
+d3795834abfcadbbeb0f1ba994182acd9e27d997d308be4c4ec95a8b5de215e0  runs/static25--chain--reference-s00/apl-drive.float32.npy
+f1c06741513c8fca5911c4389abae361c2d5d04ca81896b4d8d87941146446d1  runs/static25--chain--reference-s00/apl-inhibition.float32.npy
+f4c6097555e9bca1551d23df2751afd3d8ae6914559233707de894b51c9dd200  runs/static25--chain--reference-s00/apl-pending-tail.float32.npy
+d3795834abfcadbbeb0f1ba994182acd9e27d997d308be4c4ec95a8b5de215e0  runs/static25--chain--reference-s00/apl-state.float32.npy
+f9123943d2616754e13637d92d6e2b3f3539a58df2b934879d40e227cf14ad4d  runs/static25--chain--reference-s00/apl-timing-audit.json
+9b3529f7ee0e6363af7254489c452638f0f37ac3a62ccce8461ab1b4c6e9189a  runs/static25--chain--reference-s00/checkpoint-manifest.json
+56d70ced7cb5b01d0e7fe74ef6d539cf8e80412b99a0e4f73a8197dea0ed914f  runs/static25--chain--reference-s00/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--chain--reference-s00/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--chain--reference-s00/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--chain--reference-s00/overlay-manifest.json
+081cb361f63c9afe550371b67f2bfa784c63396af1b40cdbc34e26c395bdbd96  runs/static25--chain--reference-s00/queue.jsonl
+d2250de77a7723e0237f53b54038377b5502ccf3a549cc08f3344a1e924b99ac  runs/static25--chain--reference-s00/requests.csv
+2f2812e6892b4d12836e2e686876f010e1f67521054a37198412fbeab1dc2228  runs/static25--chain--reference-s00/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--chain--reference-s00/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--chain--reference-s00/source-audit.json
+67943c878314d88e6c34ee89a08ec61dfb9c66c43279766f54946556962b67a3  runs/static25--chain--reference-s00/state.npz
+6d32eaf71092cea2bc56a84a750a0146578892aecc8dc82d2735dec7a1220813  runs/static25--chain--reference-s00/summary.json
+749a93983ffcf0b89e2b0f67f51bc11134c575d7e8d0230d6ebe333fa20c28ab  runs/static25--chain--reference-s00/terminal-queues.npz
+c96bf4166cdda9ba70e3f0f2382d3d65d78abd725fc071cc49be7b2d34d2d83b  runs/static25--chain--reference-s00/tick-state-hashes.jsonl
+1f1c042aaaf27898fbdbbe5e9ed0bde7617eae632801faac21e10d07d234e9bf  runs/static25--chain--reference-s01/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--chain--reference-s01/apl-component.json
+9a4600c8a58e8bab325e379a4cc99e960afcf475e13c3157737db053a91b3304  runs/static25--chain--reference-s01/apl-drive.float32.npy
+514da41968400fa6865cfb2f19398e6d29fa32958bf217a54c644fcddc417f52  runs/static25--chain--reference-s01/apl-inhibition.float32.npy
+3b0d33abfbd75b2e48c3d48bff3f3374a9f3845543cd2626ca341d1c4532286d  runs/static25--chain--reference-s01/apl-pending-tail.float32.npy
+89dac2c9bc0b766424ab963f22c5706381728bb5f48a179bf30c5244084098bb  runs/static25--chain--reference-s01/apl-state.float32.npy
+7954927d3b1f5a2116a391830b004a2c82e9dcb19143bff7444f12f04591e9b5  runs/static25--chain--reference-s01/apl-timing-audit.json
+26df7763cb02fb1e1610398b72860027dfdc788237ca5a4c20140f013cc22559  runs/static25--chain--reference-s01/checkpoint-manifest.json
+911325d7926e6655b7d894f8182b9608390dcb9568c798f6e03018bec40148d5  runs/static25--chain--reference-s01/continuation-receipt.json
+bf5ad06fff9de0534f3431881cc615aea335773307fed93d870d9d0bcae9528a  runs/static25--chain--reference-s01/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--chain--reference-s01/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--chain--reference-s01/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--chain--reference-s01/overlay-manifest.json
+59dcafed60163245561db96222a74c7077a39efe4160681d03d1387738726dd0  runs/static25--chain--reference-s01/queue.jsonl
+9e9b4d0a5057a967246555f30a70b9c145b4247ae77722ba562441483182faa8  runs/static25--chain--reference-s01/requests.csv
+268e40ec67aeac9134a31602553d74b0261061bb0428e7b7eeb24a79c687a78f  runs/static25--chain--reference-s01/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--chain--reference-s01/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--chain--reference-s01/source-audit.json
+93ef29574754b862a88c665589190732acc69f9fecdbf57295f71d9a3ccc99c7  runs/static25--chain--reference-s01/state.npz
+8c48b202bdb088026674622734c6cd07eb48e1b4f221377d0ce40cd4a1ce0f80  runs/static25--chain--reference-s01/summary.json
+cf00897e9128b83a01d32c1c7208449911f34a776fb9a88f78273a91aabf0986  runs/static25--chain--reference-s01/terminal-queues.npz
+c5859a1dd79ec0403139e23c1e262fb2521a1534dac7c584afad437b44ec8d22  runs/static25--chain--reference-s01/tick-state-hashes.jsonl
+8b3bc91ea0e86a20feccfb2327e65b92e3e4aa2de93782a4eb1d757e687ff0fe  runs/static25--chain--reference-s02/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--chain--reference-s02/apl-component.json
+ae978ab20d186085d5a14508a08f4d42e3d54167e9517379bbeaa40e2c424b8c  runs/static25--chain--reference-s02/apl-drive.float32.npy
+8c846229ace8008635319ff5125fc77a0588f99bc23da4b1cf215e2660dd144c  runs/static25--chain--reference-s02/apl-inhibition.float32.npy
+1f730d8d9b512d19d1cb4af20c85dcb56d60dde2a6fcdea5000f9078415850d3  runs/static25--chain--reference-s02/apl-pending-tail.float32.npy
+5a33b8bdc6829523b3b6eb5ef7189823a06e59f6e6effb1e25164cf0966e5701  runs/static25--chain--reference-s02/apl-state.float32.npy
+7c6e6b649d7fe7514ff3bbfa1d9d72e1f1746f693c7dff0a15afc91c86a9175e  runs/static25--chain--reference-s02/apl-timing-audit.json
+a4d2ea258823ca6685aa3538ffd99f011c68a063110fa47965827a537950424b  runs/static25--chain--reference-s02/checkpoint-manifest.json
+6dbce80909cbd2ddc2860b7a924dd631cc203419826dfa4fb38f01a94c71ae73  runs/static25--chain--reference-s02/continuation-receipt.json
+7fe8fdc62c85adc3187ac92c4c136af4037784cde7b87f95d381e53b184ad486  runs/static25--chain--reference-s02/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--chain--reference-s02/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--chain--reference-s02/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--chain--reference-s02/overlay-manifest.json
+91a4d67c2c5d3efcc20534451768b0152c3cee354f06cb0108fee5ed17a2f73c  runs/static25--chain--reference-s02/queue.jsonl
+d2250de77a7723e0237f53b54038377b5502ccf3a549cc08f3344a1e924b99ac  runs/static25--chain--reference-s02/requests.csv
+25cbca33e003a47c3aec5f4b41d66459a7e06c8db90c381e84a2cda788a9e97c  runs/static25--chain--reference-s02/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--chain--reference-s02/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--chain--reference-s02/source-audit.json
+e73da12668986893b8fe7d412e2efaa8ebf53478b12bd6081c92f3ab7d0d1960  runs/static25--chain--reference-s02/state.npz
+1eece4d03226ee7a3483e090224ad06a927d1229996d3af7977afeaa6e645222  runs/static25--chain--reference-s02/summary.json
+c62e42ea853eba86b021529340bb106425043080632d41a935d107ec32f467b1  runs/static25--chain--reference-s02/terminal-queues.npz
+c0c09c5f8a0038f5c569848d26e4bd7470cf3826cb77838a0bdd1de9f8c583d7  runs/static25--chain--reference-s02/tick-state-hashes.jsonl
+6e4db049606110d7f8fb744658f491a702258f4c0039b6f1de4eedd1a268c1d4  runs/static25--chain--reference-s03/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--chain--reference-s03/apl-component.json
+5091e42124e93db94d2b8c75ba3d6c210f0a29b6621226a2d15b16df3d4364a2  runs/static25--chain--reference-s03/apl-drive.float32.npy
+69f42a802f4f766dce86f33e2c44b1268b9686a2fc10b0c41460f17187bd25df  runs/static25--chain--reference-s03/apl-inhibition.float32.npy
+c222b8012c2e3edbff7fad90e8dcd51db47b2a541d7109be2872acb96ac94c30  runs/static25--chain--reference-s03/apl-pending-tail.float32.npy
+6337cfb5adf42fd92ea63651fb85d29aed5115d37d0353690f2236ff2eaa776c  runs/static25--chain--reference-s03/apl-state.float32.npy
+606417b3ea730e4123beb62bcba35148c517490e8fe058bc3a0a574c7a449e0f  runs/static25--chain--reference-s03/apl-timing-audit.json
+0b8da3d954e9b66df6fa24ab139a8cf0dca650f294bf68783e6c050357790715  runs/static25--chain--reference-s03/checkpoint-manifest.json
+6319f971eb68640d1c801d2ed53933f4bdce62195d7bb5572d225823a69b9a15  runs/static25--chain--reference-s03/continuation-receipt.json
+048b38a7d3af3e9204ff83c5f47623e65c6cd11e694e3fb2326079423e4db8b9  runs/static25--chain--reference-s03/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--chain--reference-s03/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--chain--reference-s03/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--chain--reference-s03/overlay-manifest.json
+e76c008a5e6926b743a41628204c22b96c65d71a545005e0cf9e2a49036f5f2b  runs/static25--chain--reference-s03/queue.jsonl
+f485d562e1be7230112ed27f211d3053ac715bee49416a0062ac71210cac5d56  runs/static25--chain--reference-s03/requests.csv
+46aed69967b93abacbf33dd4e2692974ee56aea5b96a3dca813c414f95884bd7  runs/static25--chain--reference-s03/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--chain--reference-s03/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--chain--reference-s03/source-audit.json
+1ac87260cb29f8358e26f9603dcba748833ae597fb848e28169915b2c2ad75cd  runs/static25--chain--reference-s03/state.npz
+6b54c3b6a12d3d2f6a018592665be8c2f92c326c5eafa7368b77186cb48586e5  runs/static25--chain--reference-s03/summary.json
+8faf854dcef4d8ff8c66413fd560313dcbbd9df8cdd386fd491521d492f9298b  runs/static25--chain--reference-s03/terminal-queues.npz
+421ebcda58bbbc4c502ecce1a648fa623a554e60d1418d87a1da108564e9445b  runs/static25--chain--reference-s03/tick-state-hashes.jsonl
+7de2da212e8a0d33bf1e8dcd0c98296d52284dd4523bd89b15577f4b82194cd0  runs/static25--chain--reference-s04/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--chain--reference-s04/apl-component.json
+adf895727284c908b2d1f262b5f5984508fd859fc0a33b58e619bf9ec2dbe2da  runs/static25--chain--reference-s04/apl-drive.float32.npy
+4ac23f93c28a8bf6009dc19719523cb2be3c4625af494eb86bc58ff06e2365db  runs/static25--chain--reference-s04/apl-inhibition.float32.npy
+2dd2e0c79d4ee5299b8c1e8863e6c61b81f3dba08e599011887b1e1621f7c945  runs/static25--chain--reference-s04/apl-pending-tail.float32.npy
+616cffd9b2c3216adb22d21af3d8c2751e61c7e11a70bc062a2dc96d07fd0c63  runs/static25--chain--reference-s04/apl-state.float32.npy
+19839fbba619ef7c260e559f3c588bd42c05810c365fb3cf1ea0e79988034870  runs/static25--chain--reference-s04/apl-timing-audit.json
+84f8fdec76adec84be053a30fe720de12f89711aad9679325486ed60d4901e65  runs/static25--chain--reference-s04/checkpoint-manifest.json
+ed99f64655e6680733132b52ce9c7b25a5db9071434cb1d11fd2e53f9a6f0c28  runs/static25--chain--reference-s04/continuation-receipt.json
+d581bb0d3c1a7f7c9f3afcff7bdbdcd7f32c9a9db798bcde1e0c869c38fd13ad  runs/static25--chain--reference-s04/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--chain--reference-s04/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--chain--reference-s04/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--chain--reference-s04/overlay-manifest.json
+8f22feee1d6cadb46efddce7c79b3a3c66ad727825c2165e7efd3a551961fe50  runs/static25--chain--reference-s04/queue.jsonl
+ea59d983198a1ddb9ca97927561380667ce05d855f8d87dcb4cc89d8b778030f  runs/static25--chain--reference-s04/requests.csv
+6a2b572ab789b98ab351ada603e28d6d81e93c1c00f1ec5593ca8a5044ee92e2  runs/static25--chain--reference-s04/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--chain--reference-s04/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--chain--reference-s04/source-audit.json
+67ecca5b227ec7942c273e2ebecf9d82b4fadd688a4c3fb39e361f6ca1a38c6b  runs/static25--chain--reference-s04/state.npz
+77a48ed4ed8e189ed1553f92387811f0efc7a832015067a00ce84b37776e6149  runs/static25--chain--reference-s04/summary.json
+279fc5d68f2630b8bb634d01546f529a250a54976ed5f3daef82b8be9d1b683f  runs/static25--chain--reference-s04/terminal-queues.npz
+9a056a54dceab68d40ab582a6600db6be668ad21cdd8857685fa82383ddb5107  runs/static25--chain--reference-s04/tick-state-hashes.jsonl
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--fresh--light-r0/apl-component.json
+2dd2e0c79d4ee5299b8c1e8863e6c61b81f3dba08e599011887b1e1621f7c945  runs/static25--fresh--light-r0/apl-pending-tail.float32.npy
+0774772ba473c5dc4d5c636ecc9a5a2e44779f2647c58f1c84adc381495ec411  runs/static25--fresh--light-r0/apl-timing-audit.json
+967aa8574fe357a2874d78e029c64833402a1724060c5b1f27d014af0ee47ed2  runs/static25--fresh--light-r0/checkpoint-manifest.json
+abc4a3320d906ac02a9c73026680b92f4fdc2bc55740c128390f8e94b17dbbcb  runs/static25--fresh--light-r0/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--fresh--light-r0/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--fresh--light-r0/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--fresh--light-r0/overlay-manifest.json
+b11fb0b6d1ac9211f02f05a9809175c64b72e8bcd4c4e4da31be1efbe6a82a83  runs/static25--fresh--light-r0/requests.csv
+ab1b4823b9d8e0562b879236bd04ccad162d3e41129cd7ce029221e1b7c5c85b  runs/static25--fresh--light-r0/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--fresh--light-r0/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--fresh--light-r0/source-audit.json
+7de2f62ecbde41a11db5aa220aed2fa6128e9fb6e65d04357f5373eb21538f81  runs/static25--fresh--light-r0/state.npz
+9f863a708fabc72cc460d84a9adc2ef7b060349e5edcd6858a72dd2d28b5e012  runs/static25--fresh--light-r0/summary.json
+05565f934549e68b2f8900c80b7b5e5887802abb6de30154718c6e297e12daa5  runs/static25--fresh--light-r0/terminal-queues.npz
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--fresh--light-r1/apl-component.json
+2dd2e0c79d4ee5299b8c1e8863e6c61b81f3dba08e599011887b1e1621f7c945  runs/static25--fresh--light-r1/apl-pending-tail.float32.npy
+0774772ba473c5dc4d5c636ecc9a5a2e44779f2647c58f1c84adc381495ec411  runs/static25--fresh--light-r1/apl-timing-audit.json
+ee804c485192544704b18c3b32212c75955324d2f949a481e018da58b71de5ac  runs/static25--fresh--light-r1/checkpoint-manifest.json
+abc4a3320d906ac02a9c73026680b92f4fdc2bc55740c128390f8e94b17dbbcb  runs/static25--fresh--light-r1/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--fresh--light-r1/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--fresh--light-r1/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--fresh--light-r1/overlay-manifest.json
+b11fb0b6d1ac9211f02f05a9809175c64b72e8bcd4c4e4da31be1efbe6a82a83  runs/static25--fresh--light-r1/requests.csv
+7231cac0a7d0318f4ca60590d1c3f0f6574a31cbdffaf06406690394b3396f90  runs/static25--fresh--light-r1/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--fresh--light-r1/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--fresh--light-r1/source-audit.json
+7de2f62ecbde41a11db5aa220aed2fa6128e9fb6e65d04357f5373eb21538f81  runs/static25--fresh--light-r1/state.npz
+32ce77695fb4934adec3eda3b45f186f07a886d30a852cf11f33afa0c4825aa1  runs/static25--fresh--light-r1/summary.json
+05565f934549e68b2f8900c80b7b5e5887802abb6de30154718c6e297e12daa5  runs/static25--fresh--light-r1/terminal-queues.npz
+6228c9e8ec19cb7532e65728ec8f2bd6b080dca8379b17bd393979beaba4c6eb  runs/static25--fresh--reference-r0/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--fresh--reference-r0/apl-component.json
+19b32ccdefea22ddc3e2efcc98b919b8fcf69887f029c17dc75bafa5b34259c5  runs/static25--fresh--reference-r0/apl-drive.float32.npy
+d5194ea98900ca1800416712619143b731d9b3a5d1391180e6881205c7a4d663  runs/static25--fresh--reference-r0/apl-inhibition.float32.npy
+2dd2e0c79d4ee5299b8c1e8863e6c61b81f3dba08e599011887b1e1621f7c945  runs/static25--fresh--reference-r0/apl-pending-tail.float32.npy
+5fe5ac53e012232b42a7e717357e9782b247f74da93640a0cfb8a078bc9d4855  runs/static25--fresh--reference-r0/apl-state.float32.npy
+ea4f779b1cddc07f4db6158655ee27231dbc69d45fc206c35e104db43949ef9f  runs/static25--fresh--reference-r0/apl-timing-audit.json
+e90e3d3d457c1f86feada9206104f5883d13b1744a2fce340262f3b1a58c43dd  runs/static25--fresh--reference-r0/checkpoint-manifest.json
+738c9121fb7ff24213440dcad0206b59f810cccbcb26a3a13daa2ed5e115b960  runs/static25--fresh--reference-r0/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--fresh--reference-r0/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--fresh--reference-r0/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--fresh--reference-r0/overlay-manifest.json
+3e93bbae67a18944383b2b11a63708ee31e18b8ae7084f24dcb24045c85aa9a7  runs/static25--fresh--reference-r0/queue.jsonl
+b11fb0b6d1ac9211f02f05a9809175c64b72e8bcd4c4e4da31be1efbe6a82a83  runs/static25--fresh--reference-r0/requests.csv
+6e2575196d319c12745da19312875ef29e48e1758ea8df39b59ba63b1db9300f  runs/static25--fresh--reference-r0/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--fresh--reference-r0/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--fresh--reference-r0/source-audit.json
+7de2f62ecbde41a11db5aa220aed2fa6128e9fb6e65d04357f5373eb21538f81  runs/static25--fresh--reference-r0/state.npz
+430141b99fa885f4b28d9df47cde62ca42b457e5ca4be378ef629403b023a36c  runs/static25--fresh--reference-r0/summary.json
+05565f934549e68b2f8900c80b7b5e5887802abb6de30154718c6e297e12daa5  runs/static25--fresh--reference-r0/terminal-queues.npz
+3428c112a32024b539218aa6f4778cfa8c19c208bbdbfb2567324294370f23ea  runs/static25--fresh--reference-r0/tick-state-hashes.jsonl
+f4c6097555e9bca1551d23df2751afd3d8ae6914559233707de894b51c9dd200  runs/static25--prefix--reference-t0018/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--prefix--reference-t0018/apl-component.json
+786d0df4e095e384e1508a05f7ae53fa99549a76f4fefb9abd46956ded2538e9  runs/static25--prefix--reference-t0018/apl-drive.float32.npy
+3b0d33abfbd75b2e48c3d48bff3f3374a9f3845543cd2626ca341d1c4532286d  runs/static25--prefix--reference-t0018/apl-inhibition.float32.npy
+3b0d33abfbd75b2e48c3d48bff3f3374a9f3845543cd2626ca341d1c4532286d  runs/static25--prefix--reference-t0018/apl-pending-tail.float32.npy
+96e37646488edb27895a4747f6312fd87b5a4adf7c8a1587fd9f4c6d19acf40d  runs/static25--prefix--reference-t0018/apl-state.float32.npy
+652d4e3c745097ad598eff149b1730e395cd50bdbc5b2813517f90f0ea6f97a4  runs/static25--prefix--reference-t0018/apl-timing-audit.json
+2eaabd01b41f9d97057a0a79264b2c9ca18442ab8de2f50d3ada906b9cc4d43a  runs/static25--prefix--reference-t0018/checkpoint-manifest.json
+5309d5c19506445ab9c010263b34433f74c57f5df99b2829b27a338c80553a42  runs/static25--prefix--reference-t0018/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--prefix--reference-t0018/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--prefix--reference-t0018/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--prefix--reference-t0018/overlay-manifest.json
+31167ee501ed919292b7a3803cb3f342bdbaaba0a9420c52d7493ce60ea1f02a  runs/static25--prefix--reference-t0018/queue.jsonl
+078d18f36364578cb8e2f51a82dec0dd068ae61727a40d4c8afc15c82ae9cd62  runs/static25--prefix--reference-t0018/requests.csv
+d669c5ae11f29d772664f45ca67fd0c6050ad0e4c8a0522df34e69bbc74f21de  runs/static25--prefix--reference-t0018/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--prefix--reference-t0018/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--prefix--reference-t0018/source-audit.json
+da0c8ac8c1da272c4eb1457ae641819ff54d429b04c59fae5170a647a912af12  runs/static25--prefix--reference-t0018/state.npz
+9f50513b7ec6d50cd1dff16b5b0c7a1e845252141d7093d0ba394638a8453b02  runs/static25--prefix--reference-t0018/summary.json
+d2b280bb73888521fb2c0747cc09b9c1836bc301aa1bfe2409149c704f67aae2  runs/static25--prefix--reference-t0018/terminal-queues.npz
+e86786098be7fda04adb06730658f95736ac18fc5d2cd9ff8bb77f0c694e3e4b  runs/static25--prefix--reference-t0018/tick-state-hashes.jsonl
+f902ffb12382261a3993d233eeb3b0b691e4ad9d4b76c36332ee81881ce50bf8  runs/static25--prefix--reference-t0019/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--prefix--reference-t0019/apl-component.json
+b46c32d5185a7f57b2dcdd4817437b9cf557983cec23d740dd8f65c5e04f0244  runs/static25--prefix--reference-t0019/apl-drive.float32.npy
+053ac45481cfca6b6e2ac4dc56142bcf53e8c97935fcf104a793f8ea1a55e11b  runs/static25--prefix--reference-t0019/apl-inhibition.float32.npy
+1f730d8d9b512d19d1cb4af20c85dcb56d60dde2a6fcdea5000f9078415850d3  runs/static25--prefix--reference-t0019/apl-pending-tail.float32.npy
+fe7b33b71fa087406370e5b75dbe4056251e2ba4c57a7f21ef4a1ac282509a8d  runs/static25--prefix--reference-t0019/apl-state.float32.npy
+dd872831fb1699007cc9fe0a6d95f6b22d37f510dc1b8c26643778c309866399  runs/static25--prefix--reference-t0019/apl-timing-audit.json
+d467a97926538fe1b2b5bb0c659ddb532993bc74404991b0ee4bce4c87007145  runs/static25--prefix--reference-t0019/checkpoint-manifest.json
+038a3638ab2b13c25fee6178399cd0efb11923383d945116b42d4eeb019d48b5  runs/static25--prefix--reference-t0019/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--prefix--reference-t0019/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--prefix--reference-t0019/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--prefix--reference-t0019/overlay-manifest.json
+a17831e0c0df6636ac1d0592d95b023f659c5ba1bc820ff7393cf7b51b3ac06d  runs/static25--prefix--reference-t0019/queue.jsonl
+078d18f36364578cb8e2f51a82dec0dd068ae61727a40d4c8afc15c82ae9cd62  runs/static25--prefix--reference-t0019/requests.csv
+c45508ae5df49ab51f082a20a865e2f6f361642748b16d3bc49a452b93a7ed79  runs/static25--prefix--reference-t0019/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--prefix--reference-t0019/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--prefix--reference-t0019/source-audit.json
+bcac86eacdc89e7a313891594adc60b30abc2b8632c70b6e7d35bee88d9e85ef  runs/static25--prefix--reference-t0019/state.npz
+94ab49bd487dc7a283f9cf9b1dca9dc25a2a6b50789f2ab285b9cf9bf647275a  runs/static25--prefix--reference-t0019/summary.json
+7b53244c354dcb34f4b51b44265a3e94a7ddc05af816cbca2e7b0dc3c95658ae  runs/static25--prefix--reference-t0019/terminal-queues.npz
+072dd7c530a45bbf03ff24e910f784839ffaf2c45342c817d1e25964b6158b22  runs/static25--prefix--reference-t0019/tick-state-hashes.jsonl
+add634d007828f026845264a0b93a5c4b5195d60e728c8504e110137222b62bf  runs/static25--prefix--reference-t0500/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/static25--prefix--reference-t0500/apl-component.json
+94a25d3735669b3fe387d632b07dd7a382281f1445b77bf5d3988d040739665c  runs/static25--prefix--reference-t0500/apl-drive.float32.npy
+794b18eecb4f3d7db1f2ef258cb2c3c262bd2bf10415b9784b94879f01230267  runs/static25--prefix--reference-t0500/apl-inhibition.float32.npy
+c222b8012c2e3edbff7fad90e8dcd51db47b2a541d7109be2872acb96ac94c30  runs/static25--prefix--reference-t0500/apl-pending-tail.float32.npy
+ee4f8b2d3f6026c1ba5eec5b4e01e18194815d9bb0cee9d56dc77aa93872450b  runs/static25--prefix--reference-t0500/apl-state.float32.npy
+524801a43cc532c797d71c12f41e3d55bc53c061f6dd9135759a532f4d8af351  runs/static25--prefix--reference-t0500/apl-timing-audit.json
+416bb062900efbcd70d07c650a6e0d3143419dd00ae6cf338945bbfafd850ff9  runs/static25--prefix--reference-t0500/checkpoint-manifest.json
+d581bb0d3c1a7f7c9f3afcff7bdbdcd7f32c9a9db798bcde1e0c869c38fd13ad  runs/static25--prefix--reference-t0500/finite-audit.json
+03fa596094d386840f2a8e00e59d76eb4dea10b5835a8270e32dce50e7640c38  runs/static25--prefix--reference-t0500/overlay-audit.json
+7805bd2f86de91777bca86c52870607a2e091ed74b901319b896055ad3463f6d  runs/static25--prefix--reference-t0500/overlay-input.npz
+b0ee003192fbdfd869f8b23c9bbab0ff99079b7bd2bf1dc33b7afef40785a143  runs/static25--prefix--reference-t0500/overlay-manifest.json
+6c48e15ad128e5518860abe1cc2f4a8492156bdfa0387d748c94d5f800fb123b  runs/static25--prefix--reference-t0500/queue.jsonl
+adf325481c75c9a35aa8874fadbf84067ee5eb530cf5fdb99faaff091d128ed9  runs/static25--prefix--reference-t0500/requests.csv
+8292f362ed1431979c99b2e9d0eb250b8fdf1439c7ced3ba8ea842f8957cd44e  runs/static25--prefix--reference-t0500/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/static25--prefix--reference-t0500/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/static25--prefix--reference-t0500/source-audit.json
+14d6d10397532cac10847c99064823b8a806e572848311096b4deae8db9d36f2  runs/static25--prefix--reference-t0500/state.npz
+e8872f06e4f5c21e08dc8861b7682c589ed20bd90263bcc5c6c4d0e8545ff7f8  runs/static25--prefix--reference-t0500/summary.json
+723cee6e7200100bb05d108f13ca90f4c7740cc07f74645775801c1d9582e0b2  runs/static25--prefix--reference-t0500/terminal-queues.npz
+e8f5d61c866031e48dcc0b121f2443bf46d46029aa0f93efa976fc7513e1a3d5  runs/static25--prefix--reference-t0500/tick-state-hashes.jsonl
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--chain--light-s00/apl-component.json
+f4c6097555e9bca1551d23df2751afd3d8ae6914559233707de894b51c9dd200  runs/zero--chain--light-s00/apl-pending-tail.float32.npy
+e683ba6046e405c6787e6861cfff6b2d5df8b38be7684351810dc2bb8fb65b76  runs/zero--chain--light-s00/apl-timing-audit.json
+7c15a5a78a6197eec593c553c3625261b47c40a2ee22515ccda5b5d67eefed2e  runs/zero--chain--light-s00/checkpoint-manifest.json
+4d5ecd025cf500818de9c269269596c604b385c795a80442384ae688cb907066  runs/zero--chain--light-s00/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--chain--light-s00/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--chain--light-s00/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--chain--light-s00/overlay-manifest.json
+d2250de77a7723e0237f53b54038377b5502ccf3a549cc08f3344a1e924b99ac  runs/zero--chain--light-s00/requests.csv
+583ac2f17db4e6f29cf049b033c8877383b886bade220b8b8350657e0084ac70  runs/zero--chain--light-s00/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--chain--light-s00/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--chain--light-s00/source-audit.json
+67943c878314d88e6c34ee89a08ec61dfb9c66c43279766f54946556962b67a3  runs/zero--chain--light-s00/state.npz
+357c640840a54db7c798cfb157f4fadf97ce9f16b6dca5958939ce689a237eef  runs/zero--chain--light-s00/summary.json
+749a93983ffcf0b89e2b0f67f51bc11134c575d7e8d0230d6ebe333fa20c28ab  runs/zero--chain--light-s00/terminal-queues.npz
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--chain--light-s01/apl-component.json
+3b0d33abfbd75b2e48c3d48bff3f3374a9f3845543cd2626ca341d1c4532286d  runs/zero--chain--light-s01/apl-pending-tail.float32.npy
+a82b3b00fd2366b13e8f89945c353cbff49fd43258d00723cc471eff795c2ef6  runs/zero--chain--light-s01/apl-timing-audit.json
+3bcfbc0516e918a4ff42ce4c0cf25129ac1b0fcf8fdb0baa9f55923a02b45f9b  runs/zero--chain--light-s01/checkpoint-manifest.json
+29743398a8cdf48b0e9ec249cb77445d18e947f8f76d77a715a660c91cab2717  runs/zero--chain--light-s01/continuation-receipt.json
+ff22fb288988dea3ac624bcec27359837bdfa4dab244768b252e65e2e1acfa46  runs/zero--chain--light-s01/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--chain--light-s01/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--chain--light-s01/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--chain--light-s01/overlay-manifest.json
+9e9b4d0a5057a967246555f30a70b9c145b4247ae77722ba562441483182faa8  runs/zero--chain--light-s01/requests.csv
+a01167b8168aa1a9367b2265ce722d04939ea43ef3e49cfa5092b530b1e0ce54  runs/zero--chain--light-s01/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--chain--light-s01/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--chain--light-s01/source-audit.json
+93ef29574754b862a88c665589190732acc69f9fecdbf57295f71d9a3ccc99c7  runs/zero--chain--light-s01/state.npz
+a3d08747b5094df2e75bd9e3c5dc7bd8e2354d3db2aef0a58c5957e0147982d5  runs/zero--chain--light-s01/summary.json
+cf00897e9128b83a01d32c1c7208449911f34a776fb9a88f78273a91aabf0986  runs/zero--chain--light-s01/terminal-queues.npz
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--chain--light-s02/apl-component.json
+1f730d8d9b512d19d1cb4af20c85dcb56d60dde2a6fcdea5000f9078415850d3  runs/zero--chain--light-s02/apl-pending-tail.float32.npy
+bf13d66b8834c17b1c68a0d107b1b48258cb2179b548ece5e2c2142fe2ca3df5  runs/zero--chain--light-s02/apl-timing-audit.json
+61b16179c796301e05f4c6f6989d0d31e0e8da0d7d38f086aecacc9b61d5bfcb  runs/zero--chain--light-s02/checkpoint-manifest.json
+d312355d4f4d4d2b68de8e3e8dfd424b6bf1fa55b9e3f8834dca8fa2c5e604c5  runs/zero--chain--light-s02/continuation-receipt.json
+f11b37717ad3c092a481adcf78f7caffd688650bf4cb56ab644175721e63a9e8  runs/zero--chain--light-s02/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--chain--light-s02/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--chain--light-s02/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--chain--light-s02/overlay-manifest.json
+d2250de77a7723e0237f53b54038377b5502ccf3a549cc08f3344a1e924b99ac  runs/zero--chain--light-s02/requests.csv
+b2a79c7379f99ad1beec238a3910658b4f88d15d2f153424e896b0f637d6ef2a  runs/zero--chain--light-s02/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--chain--light-s02/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--chain--light-s02/source-audit.json
+e73da12668986893b8fe7d412e2efaa8ebf53478b12bd6081c92f3ab7d0d1960  runs/zero--chain--light-s02/state.npz
+00148e47ae577a3e9b2cebe2f3f0892a293d2dcf921714232cfa3f40d0eda775  runs/zero--chain--light-s02/summary.json
+c62e42ea853eba86b021529340bb106425043080632d41a935d107ec32f467b1  runs/zero--chain--light-s02/terminal-queues.npz
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--chain--light-s03/apl-component.json
+8f990c4598e6604cc33eed5d2247e92bb6098c827a504d0265dbb95a9cd6a277  runs/zero--chain--light-s03/apl-pending-tail.float32.npy
+6869c76a69ee6017aaae46e82d2b88846d4c815ad1a5eaa261b86952d3b204a3  runs/zero--chain--light-s03/apl-timing-audit.json
+97db003dc84cf99bb92e815fbcbea0796270884da37803b8746041b695d546d3  runs/zero--chain--light-s03/checkpoint-manifest.json
+08f7563eb2cde422f35f02b329cfc4d9cd4a3f367bd25c71f8e659df6a31cc55  runs/zero--chain--light-s03/continuation-receipt.json
+bc6bed2daa41d4da6889855500104c569bb2719d61235bc29016cce9e2cf66ea  runs/zero--chain--light-s03/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--chain--light-s03/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--chain--light-s03/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--chain--light-s03/overlay-manifest.json
+bf0cc878e78bdbc1272833829ab7ac0dd3734e1b84a8f4c6d61c4f3ac05bae5f  runs/zero--chain--light-s03/requests.csv
+71506e5e0eea3964987a1d0eaade3be6268b478d6a9ec4c5c0244fd254b57977  runs/zero--chain--light-s03/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--chain--light-s03/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--chain--light-s03/source-audit.json
+39fed967ede12bd1f085c60aabe527bd5138b5af8f20063d80374e15e689e92e  runs/zero--chain--light-s03/state.npz
+1d753fe8c8ef4a3f1860beb329d38481a2d513fc01b1a23e5459eed930436f48  runs/zero--chain--light-s03/summary.json
+5140f54c237a9574f1ec163220dc8a8047fcf87ff1914a5a8bb27dcff2d35171  runs/zero--chain--light-s03/terminal-queues.npz
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--chain--light-s04/apl-component.json
+fc1e2d8ffa426d4118a7544129323c5f7523e9df3e298a60922ca0ecabe7c18f  runs/zero--chain--light-s04/apl-pending-tail.float32.npy
+9e875aafc55f7262ef202b3ce212a74a3d162fb979bf73b6311ac673cbf7a85e  runs/zero--chain--light-s04/apl-timing-audit.json
+385b9b1b62d0f184c8766ca28548f2f5553fb01a8f3cd1ad6ff68e6c08fe16f5  runs/zero--chain--light-s04/checkpoint-manifest.json
+d55caf73ebce88295e08c19811498955282d2738baafd60b5ed4b62c3d69efac  runs/zero--chain--light-s04/continuation-receipt.json
+a05afce6c67cea10bc322ff0030ec422a9ddbd29c60bd313995332e70da4fc99  runs/zero--chain--light-s04/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--chain--light-s04/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--chain--light-s04/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--chain--light-s04/overlay-manifest.json
+1a6f62e6b9e67770a5ed6344ae54dc001505704c13c515d4c6e033aba0993f4b  runs/zero--chain--light-s04/requests.csv
+86f748bfd55b949ab85cfffcf1c398991fcedae2534eac6adc08907d003f1eae  runs/zero--chain--light-s04/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--chain--light-s04/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--chain--light-s04/source-audit.json
+b79df8b2c159057fdfdb40fa960d8b9c23bdded285509f9fb3c08ca5b4497fe3  runs/zero--chain--light-s04/state.npz
+583461c010f7104493676a7a2340683d215e84b5c1c7466949158d92e65df727  runs/zero--chain--light-s04/summary.json
+ef4b594ae6e22c1cbea7b1b80393fc313f6ace376e77bb6609ba44871eb0767e  runs/zero--chain--light-s04/terminal-queues.npz
+f1c06741513c8fca5911c4389abae361c2d5d04ca81896b4d8d87941146446d1  runs/zero--chain--reference-s00/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--chain--reference-s00/apl-component.json
+d3795834abfcadbbeb0f1ba994182acd9e27d997d308be4c4ec95a8b5de215e0  runs/zero--chain--reference-s00/apl-drive.float32.npy
+f1c06741513c8fca5911c4389abae361c2d5d04ca81896b4d8d87941146446d1  runs/zero--chain--reference-s00/apl-inhibition.float32.npy
+f4c6097555e9bca1551d23df2751afd3d8ae6914559233707de894b51c9dd200  runs/zero--chain--reference-s00/apl-pending-tail.float32.npy
+d3795834abfcadbbeb0f1ba994182acd9e27d997d308be4c4ec95a8b5de215e0  runs/zero--chain--reference-s00/apl-state.float32.npy
+f9123943d2616754e13637d92d6e2b3f3539a58df2b934879d40e227cf14ad4d  runs/zero--chain--reference-s00/apl-timing-audit.json
+01ad785a6d5e94a8e83c80a3d48e91f245432b446c8fc907d9644850f9370d01  runs/zero--chain--reference-s00/checkpoint-manifest.json
+56d70ced7cb5b01d0e7fe74ef6d539cf8e80412b99a0e4f73a8197dea0ed914f  runs/zero--chain--reference-s00/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--chain--reference-s00/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--chain--reference-s00/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--chain--reference-s00/overlay-manifest.json
+081cb361f63c9afe550371b67f2bfa784c63396af1b40cdbc34e26c395bdbd96  runs/zero--chain--reference-s00/queue.jsonl
+d2250de77a7723e0237f53b54038377b5502ccf3a549cc08f3344a1e924b99ac  runs/zero--chain--reference-s00/requests.csv
+0c91d3a0e978c78e1636bf11846ddd0b56ceef2376f3f1dbff6eb428c404b123  runs/zero--chain--reference-s00/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--chain--reference-s00/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--chain--reference-s00/source-audit.json
+67943c878314d88e6c34ee89a08ec61dfb9c66c43279766f54946556962b67a3  runs/zero--chain--reference-s00/state.npz
+a79e66e788f70070dd7d4bbc8ac937e93619aa63922d3569108afcce1f8c1f42  runs/zero--chain--reference-s00/summary.json
+749a93983ffcf0b89e2b0f67f51bc11134c575d7e8d0230d6ebe333fa20c28ab  runs/zero--chain--reference-s00/terminal-queues.npz
+c96bf4166cdda9ba70e3f0f2382d3d65d78abd725fc071cc49be7b2d34d2d83b  runs/zero--chain--reference-s00/tick-state-hashes.jsonl
+1f1c042aaaf27898fbdbbe5e9ed0bde7617eae632801faac21e10d07d234e9bf  runs/zero--chain--reference-s01/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--chain--reference-s01/apl-component.json
+9a4600c8a58e8bab325e379a4cc99e960afcf475e13c3157737db053a91b3304  runs/zero--chain--reference-s01/apl-drive.float32.npy
+514da41968400fa6865cfb2f19398e6d29fa32958bf217a54c644fcddc417f52  runs/zero--chain--reference-s01/apl-inhibition.float32.npy
+3b0d33abfbd75b2e48c3d48bff3f3374a9f3845543cd2626ca341d1c4532286d  runs/zero--chain--reference-s01/apl-pending-tail.float32.npy
+89dac2c9bc0b766424ab963f22c5706381728bb5f48a179bf30c5244084098bb  runs/zero--chain--reference-s01/apl-state.float32.npy
+7954927d3b1f5a2116a391830b004a2c82e9dcb19143bff7444f12f04591e9b5  runs/zero--chain--reference-s01/apl-timing-audit.json
+4be0d1ac31613a5ba3fafae8d80e1a1be55f0ce2a56b54c4b3abbb24fd5705bd  runs/zero--chain--reference-s01/checkpoint-manifest.json
+664432cdb79a5afbae67531a9f9b990167f3ababa6a7c8e881e9841ff8c346c0  runs/zero--chain--reference-s01/continuation-receipt.json
+bf5ad06fff9de0534f3431881cc615aea335773307fed93d870d9d0bcae9528a  runs/zero--chain--reference-s01/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--chain--reference-s01/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--chain--reference-s01/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--chain--reference-s01/overlay-manifest.json
+59dcafed60163245561db96222a74c7077a39efe4160681d03d1387738726dd0  runs/zero--chain--reference-s01/queue.jsonl
+9e9b4d0a5057a967246555f30a70b9c145b4247ae77722ba562441483182faa8  runs/zero--chain--reference-s01/requests.csv
+84baed1ae5d453b789f5ed9ff06fbe787d18395bdb611ffe756c9256ffaa916b  runs/zero--chain--reference-s01/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--chain--reference-s01/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--chain--reference-s01/source-audit.json
+93ef29574754b862a88c665589190732acc69f9fecdbf57295f71d9a3ccc99c7  runs/zero--chain--reference-s01/state.npz
+0c8ff599c93cef11c5ed8c019785c7304361054f64a03520f78819ebc74f29ef  runs/zero--chain--reference-s01/summary.json
+cf00897e9128b83a01d32c1c7208449911f34a776fb9a88f78273a91aabf0986  runs/zero--chain--reference-s01/terminal-queues.npz
+c5859a1dd79ec0403139e23c1e262fb2521a1534dac7c584afad437b44ec8d22  runs/zero--chain--reference-s01/tick-state-hashes.jsonl
+8b3bc91ea0e86a20feccfb2327e65b92e3e4aa2de93782a4eb1d757e687ff0fe  runs/zero--chain--reference-s02/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--chain--reference-s02/apl-component.json
+ae978ab20d186085d5a14508a08f4d42e3d54167e9517379bbeaa40e2c424b8c  runs/zero--chain--reference-s02/apl-drive.float32.npy
+8c846229ace8008635319ff5125fc77a0588f99bc23da4b1cf215e2660dd144c  runs/zero--chain--reference-s02/apl-inhibition.float32.npy
+1f730d8d9b512d19d1cb4af20c85dcb56d60dde2a6fcdea5000f9078415850d3  runs/zero--chain--reference-s02/apl-pending-tail.float32.npy
+5a33b8bdc6829523b3b6eb5ef7189823a06e59f6e6effb1e25164cf0966e5701  runs/zero--chain--reference-s02/apl-state.float32.npy
+7c6e6b649d7fe7514ff3bbfa1d9d72e1f1746f693c7dff0a15afc91c86a9175e  runs/zero--chain--reference-s02/apl-timing-audit.json
+670ca9c79c29791df8f2107272ef50010e97b1d7dbe2f7ea85d519364f903647  runs/zero--chain--reference-s02/checkpoint-manifest.json
+5de41af972d382dc672c43c77343c6c02321d29dc6b652e40350e4fa7ec5b1b2  runs/zero--chain--reference-s02/continuation-receipt.json
+7fe8fdc62c85adc3187ac92c4c136af4037784cde7b87f95d381e53b184ad486  runs/zero--chain--reference-s02/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--chain--reference-s02/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--chain--reference-s02/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--chain--reference-s02/overlay-manifest.json
+91a4d67c2c5d3efcc20534451768b0152c3cee354f06cb0108fee5ed17a2f73c  runs/zero--chain--reference-s02/queue.jsonl
+d2250de77a7723e0237f53b54038377b5502ccf3a549cc08f3344a1e924b99ac  runs/zero--chain--reference-s02/requests.csv
+1c7ddbd49568d94d4f83e82ac8a1846308d3d494b8f9448a65e33e775a1b2e2d  runs/zero--chain--reference-s02/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--chain--reference-s02/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--chain--reference-s02/source-audit.json
+e73da12668986893b8fe7d412e2efaa8ebf53478b12bd6081c92f3ab7d0d1960  runs/zero--chain--reference-s02/state.npz
+8ed3bada34ab7a7beab8e5a1c4b897eb782c9451fa8e9b142f25202f994cfd6a  runs/zero--chain--reference-s02/summary.json
+c62e42ea853eba86b021529340bb106425043080632d41a935d107ec32f467b1  runs/zero--chain--reference-s02/terminal-queues.npz
+c0c09c5f8a0038f5c569848d26e4bd7470cf3826cb77838a0bdd1de9f8c583d7  runs/zero--chain--reference-s02/tick-state-hashes.jsonl
+40f5e76e9743ff231577b45fa5fb28a61b56e63e744a2edf0e269523d42ec1ba  runs/zero--chain--reference-s03/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--chain--reference-s03/apl-component.json
+ef47e4cee995504243550b48a7665007419c8c512c116ee7312f11ba5b70f654  runs/zero--chain--reference-s03/apl-drive.float32.npy
+27f4bd3da4cb101595d5f9b88ca8162cf5d544cbf90048aed697f8434698ec16  runs/zero--chain--reference-s03/apl-inhibition.float32.npy
+8f990c4598e6604cc33eed5d2247e92bb6098c827a504d0265dbb95a9cd6a277  runs/zero--chain--reference-s03/apl-pending-tail.float32.npy
+bfee2aa531d7e87c1db652c5e4fb41a467dd4ec6f5b5e80866f46a92a1df5b84  runs/zero--chain--reference-s03/apl-state.float32.npy
+d03ae83816b801d763bae7871c938621405145aed4ed88351db723e6230284d2  runs/zero--chain--reference-s03/apl-timing-audit.json
+7d06d07087c1c39396b9160ce39e5cf31b8b1893f098f0bb78397b927084a504  runs/zero--chain--reference-s03/checkpoint-manifest.json
+aeea580f2eb345ad135ce8a5112a82a66afbd105a9ff5d929ab8107d3a04d86d  runs/zero--chain--reference-s03/continuation-receipt.json
+048b38a7d3af3e9204ff83c5f47623e65c6cd11e694e3fb2326079423e4db8b9  runs/zero--chain--reference-s03/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--chain--reference-s03/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--chain--reference-s03/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--chain--reference-s03/overlay-manifest.json
+cb1d8970bdfa133348308a296f47022c0595c12fa101aefdd9053f73ce4bc299  runs/zero--chain--reference-s03/queue.jsonl
+bf0cc878e78bdbc1272833829ab7ac0dd3734e1b84a8f4c6d61c4f3ac05bae5f  runs/zero--chain--reference-s03/requests.csv
+abdd7dda65fce4a0d4b37fc53a69d8b9b8475d52f917a2f2e8268ea507c073ed  runs/zero--chain--reference-s03/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--chain--reference-s03/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--chain--reference-s03/source-audit.json
+39fed967ede12bd1f085c60aabe527bd5138b5af8f20063d80374e15e689e92e  runs/zero--chain--reference-s03/state.npz
+9571eee391b8ca523afbe14ded5bebd61caf22e1af32ea7ba2999f7e3d7d5485  runs/zero--chain--reference-s03/summary.json
+5140f54c237a9574f1ec163220dc8a8047fcf87ff1914a5a8bb27dcff2d35171  runs/zero--chain--reference-s03/terminal-queues.npz
+5f2bfd378ee2df1deaf630b96b111cbfb1d8ba55e80dde6e0e2b0fe53a5978c8  runs/zero--chain--reference-s03/tick-state-hashes.jsonl
+c1450e6d7810e5c249534aade9da4a46aa681b5e99f6ff4598c16088d656efe2  runs/zero--chain--reference-s04/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--chain--reference-s04/apl-component.json
+63a934273e5fa60562cdbd141666c3ab2d6ff39483832a7dfd5368b8e06d68db  runs/zero--chain--reference-s04/apl-drive.float32.npy
+c03168a440cd20ec2e6f5dd452998861e24f86517830272f6dc642dbca9c73be  runs/zero--chain--reference-s04/apl-inhibition.float32.npy
+fc1e2d8ffa426d4118a7544129323c5f7523e9df3e298a60922ca0ecabe7c18f  runs/zero--chain--reference-s04/apl-pending-tail.float32.npy
+7e9e0e218f2002d6e0c6cb72969133a08da46469ea8ed45187b963b303f72930  runs/zero--chain--reference-s04/apl-state.float32.npy
+f1cd871ccd389920d6374cba317d0642c59182ebf34052340ac3130b16bcbf2a  runs/zero--chain--reference-s04/apl-timing-audit.json
+a8864ab9ce28e52a0ca21ed388f19459007cc12281a18e55dee2779b60a6ec77  runs/zero--chain--reference-s04/checkpoint-manifest.json
+f53bfbe7a0f6ec6f74b424c6eec988d91112f161d7e72ed15b4381991cb35d1c  runs/zero--chain--reference-s04/continuation-receipt.json
+d581bb0d3c1a7f7c9f3afcff7bdbdcd7f32c9a9db798bcde1e0c869c38fd13ad  runs/zero--chain--reference-s04/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--chain--reference-s04/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--chain--reference-s04/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--chain--reference-s04/overlay-manifest.json
+7114b8d823b83e7dd8bc65e82b0688c1704bcaf601e527b00e64a7ac4449f5ea  runs/zero--chain--reference-s04/queue.jsonl
+1a6f62e6b9e67770a5ed6344ae54dc001505704c13c515d4c6e033aba0993f4b  runs/zero--chain--reference-s04/requests.csv
+949a200d2e5392dd20a38e88b2f80c723383b2cd71bdea62be83e9dad3d03444  runs/zero--chain--reference-s04/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--chain--reference-s04/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--chain--reference-s04/source-audit.json
+b79df8b2c159057fdfdb40fa960d8b9c23bdded285509f9fb3c08ca5b4497fe3  runs/zero--chain--reference-s04/state.npz
+0a4cf0d9238a0de8553829cad8e24f5b7b8e70bb31ef1ae4ca6ad76c2c574f16  runs/zero--chain--reference-s04/summary.json
+ef4b594ae6e22c1cbea7b1b80393fc313f6ace376e77bb6609ba44871eb0767e  runs/zero--chain--reference-s04/terminal-queues.npz
+654b6dcf15a7c0428ed6be6bac96d44cf8af205a42f01fd06dce1dfca367922c  runs/zero--chain--reference-s04/tick-state-hashes.jsonl
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--fresh--light-r0/apl-component.json
+fc1e2d8ffa426d4118a7544129323c5f7523e9df3e298a60922ca0ecabe7c18f  runs/zero--fresh--light-r0/apl-pending-tail.float32.npy
+cf1dc0658c942cf5f7e09c9c8dfa7ec49e5762d97e7c7cda1ccca3688552cbf5  runs/zero--fresh--light-r0/apl-timing-audit.json
+c324a7b4b847a96a49fa92f93617e5fc13ace140619bef48384da38a0e1551bf  runs/zero--fresh--light-r0/checkpoint-manifest.json
+4542696366df32a26cb71337d5999684d0d0c6e3d81a06430558ec8b793e6c12  runs/zero--fresh--light-r0/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--fresh--light-r0/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--fresh--light-r0/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--fresh--light-r0/overlay-manifest.json
+4bcc9ef7fdc596ddac3be3b0d29f0aea2e086deeb803f3a90baba21b5490ef53  runs/zero--fresh--light-r0/requests.csv
+7e2f1e3a4fd6b2ae86b34e8be3b67c7ffa645cd1bb1a069b9a555f2ee15c8a20  runs/zero--fresh--light-r0/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--fresh--light-r0/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--fresh--light-r0/source-audit.json
+933afdc1bd0ea81174aeb334f017cfbe1bbc0a72f8eca767698275c5dca886f3  runs/zero--fresh--light-r0/state.npz
+5170c782bd90a0d25dc6a82a41f0ef4fafacde304d9f5bf57dd851f7024970c5  runs/zero--fresh--light-r0/summary.json
+cf43a90cc755aaa3aa7a34401dda5da2619e52aa915c3c841c487100e92eb947  runs/zero--fresh--light-r0/terminal-queues.npz
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--fresh--light-r1/apl-component.json
+fc1e2d8ffa426d4118a7544129323c5f7523e9df3e298a60922ca0ecabe7c18f  runs/zero--fresh--light-r1/apl-pending-tail.float32.npy
+cf1dc0658c942cf5f7e09c9c8dfa7ec49e5762d97e7c7cda1ccca3688552cbf5  runs/zero--fresh--light-r1/apl-timing-audit.json
+474d4b831f99efdb791ed11d18674919355b032092708fcd2923118f7883395a  runs/zero--fresh--light-r1/checkpoint-manifest.json
+4542696366df32a26cb71337d5999684d0d0c6e3d81a06430558ec8b793e6c12  runs/zero--fresh--light-r1/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--fresh--light-r1/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--fresh--light-r1/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--fresh--light-r1/overlay-manifest.json
+4bcc9ef7fdc596ddac3be3b0d29f0aea2e086deeb803f3a90baba21b5490ef53  runs/zero--fresh--light-r1/requests.csv
+3bacbb31a56eb30f74714a774795e3695a54c3412df9a64e4c9a182c039ce088  runs/zero--fresh--light-r1/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--fresh--light-r1/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--fresh--light-r1/source-audit.json
+933afdc1bd0ea81174aeb334f017cfbe1bbc0a72f8eca767698275c5dca886f3  runs/zero--fresh--light-r1/state.npz
+fbdda7b83cbb13f2c0f9c2309dad2c1001c726515f3ea1cabd9b32e61838f419  runs/zero--fresh--light-r1/summary.json
+cf43a90cc755aaa3aa7a34401dda5da2619e52aa915c3c841c487100e92eb947  runs/zero--fresh--light-r1/terminal-queues.npz
+b3a535bc095db2464a75560ed11f336a9db8e843c08fd7681a1b9759b624ad8e  runs/zero--fresh--reference-r0/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--fresh--reference-r0/apl-component.json
+8b6432e8947f4c67466b5cae28cb0d0877b61862e80e6d9b10c5734d9afa8411  runs/zero--fresh--reference-r0/apl-drive.float32.npy
+8f9e59026dc7c7663abf8f7abc60ebf93b11a68483bc0960d375a83731acc859  runs/zero--fresh--reference-r0/apl-inhibition.float32.npy
+fc1e2d8ffa426d4118a7544129323c5f7523e9df3e298a60922ca0ecabe7c18f  runs/zero--fresh--reference-r0/apl-pending-tail.float32.npy
+36ecfec747be0c700959ba1ac171b81a1f3471aa9baba41b7bb6a67be01213c2  runs/zero--fresh--reference-r0/apl-state.float32.npy
+d2d8c4375d967b7a9a0fccba9bdd70b4d5c558b4a268c9221c105575480ae5ab  runs/zero--fresh--reference-r0/apl-timing-audit.json
+f5b68645f57b7221654ab25ae217a266f1d4a571494b56a49e44752fa9c64da9  runs/zero--fresh--reference-r0/checkpoint-manifest.json
+738c9121fb7ff24213440dcad0206b59f810cccbcb26a3a13daa2ed5e115b960  runs/zero--fresh--reference-r0/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--fresh--reference-r0/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--fresh--reference-r0/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--fresh--reference-r0/overlay-manifest.json
+22fbf106279d5ad314beba357137701df111bb28b57accdb09a0e299dfdf39cf  runs/zero--fresh--reference-r0/queue.jsonl
+4bcc9ef7fdc596ddac3be3b0d29f0aea2e086deeb803f3a90baba21b5490ef53  runs/zero--fresh--reference-r0/requests.csv
+399b314d757631301f57efa5acbda84e53bef688cf7c410e5ed6d8877bf6652f  runs/zero--fresh--reference-r0/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--fresh--reference-r0/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--fresh--reference-r0/source-audit.json
+933afdc1bd0ea81174aeb334f017cfbe1bbc0a72f8eca767698275c5dca886f3  runs/zero--fresh--reference-r0/state.npz
+e8994b989c65f7519fba987ec965472e6caf9c826eec85348ae4dd4d2d0a207e  runs/zero--fresh--reference-r0/summary.json
+cf43a90cc755aaa3aa7a34401dda5da2619e52aa915c3c841c487100e92eb947  runs/zero--fresh--reference-r0/terminal-queues.npz
+0266afe78eadd1ea5bfb25026103d01d2af82d9b6ce2bcbb9d60e576ac898e91  runs/zero--fresh--reference-r0/tick-state-hashes.jsonl
+f4c6097555e9bca1551d23df2751afd3d8ae6914559233707de894b51c9dd200  runs/zero--prefix--reference-t0018/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--prefix--reference-t0018/apl-component.json
+786d0df4e095e384e1508a05f7ae53fa99549a76f4fefb9abd46956ded2538e9  runs/zero--prefix--reference-t0018/apl-drive.float32.npy
+3b0d33abfbd75b2e48c3d48bff3f3374a9f3845543cd2626ca341d1c4532286d  runs/zero--prefix--reference-t0018/apl-inhibition.float32.npy
+3b0d33abfbd75b2e48c3d48bff3f3374a9f3845543cd2626ca341d1c4532286d  runs/zero--prefix--reference-t0018/apl-pending-tail.float32.npy
+96e37646488edb27895a4747f6312fd87b5a4adf7c8a1587fd9f4c6d19acf40d  runs/zero--prefix--reference-t0018/apl-state.float32.npy
+652d4e3c745097ad598eff149b1730e395cd50bdbc5b2813517f90f0ea6f97a4  runs/zero--prefix--reference-t0018/apl-timing-audit.json
+f170d4f77221bf2e106b31e5913de8cdcdf19b4dd7b2368705fe29b48c2176ab  runs/zero--prefix--reference-t0018/checkpoint-manifest.json
+5309d5c19506445ab9c010263b34433f74c57f5df99b2829b27a338c80553a42  runs/zero--prefix--reference-t0018/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--prefix--reference-t0018/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--prefix--reference-t0018/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--prefix--reference-t0018/overlay-manifest.json
+31167ee501ed919292b7a3803cb3f342bdbaaba0a9420c52d7493ce60ea1f02a  runs/zero--prefix--reference-t0018/queue.jsonl
+078d18f36364578cb8e2f51a82dec0dd068ae61727a40d4c8afc15c82ae9cd62  runs/zero--prefix--reference-t0018/requests.csv
+18b7e22ca0a9af4b8c3fcabc504f19911fcac37443d6f915168c345b4ac43643  runs/zero--prefix--reference-t0018/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--prefix--reference-t0018/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--prefix--reference-t0018/source-audit.json
+da0c8ac8c1da272c4eb1457ae641819ff54d429b04c59fae5170a647a912af12  runs/zero--prefix--reference-t0018/state.npz
+b4de6d62ced85e4a957e6a00cd20c77cb6c224df85342e8a0d3d4228ce661221  runs/zero--prefix--reference-t0018/summary.json
+d2b280bb73888521fb2c0747cc09b9c1836bc301aa1bfe2409149c704f67aae2  runs/zero--prefix--reference-t0018/terminal-queues.npz
+e86786098be7fda04adb06730658f95736ac18fc5d2cd9ff8bb77f0c694e3e4b  runs/zero--prefix--reference-t0018/tick-state-hashes.jsonl
+f902ffb12382261a3993d233eeb3b0b691e4ad9d4b76c36332ee81881ce50bf8  runs/zero--prefix--reference-t0019/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--prefix--reference-t0019/apl-component.json
+b46c32d5185a7f57b2dcdd4817437b9cf557983cec23d740dd8f65c5e04f0244  runs/zero--prefix--reference-t0019/apl-drive.float32.npy
+053ac45481cfca6b6e2ac4dc56142bcf53e8c97935fcf104a793f8ea1a55e11b  runs/zero--prefix--reference-t0019/apl-inhibition.float32.npy
+1f730d8d9b512d19d1cb4af20c85dcb56d60dde2a6fcdea5000f9078415850d3  runs/zero--prefix--reference-t0019/apl-pending-tail.float32.npy
+fe7b33b71fa087406370e5b75dbe4056251e2ba4c57a7f21ef4a1ac282509a8d  runs/zero--prefix--reference-t0019/apl-state.float32.npy
+dd872831fb1699007cc9fe0a6d95f6b22d37f510dc1b8c26643778c309866399  runs/zero--prefix--reference-t0019/apl-timing-audit.json
+d136be24c76c5435ef82231b24e6534d265bc90beed96610a509eac71d5256c0  runs/zero--prefix--reference-t0019/checkpoint-manifest.json
+038a3638ab2b13c25fee6178399cd0efb11923383d945116b42d4eeb019d48b5  runs/zero--prefix--reference-t0019/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--prefix--reference-t0019/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--prefix--reference-t0019/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--prefix--reference-t0019/overlay-manifest.json
+a17831e0c0df6636ac1d0592d95b023f659c5ba1bc820ff7393cf7b51b3ac06d  runs/zero--prefix--reference-t0019/queue.jsonl
+078d18f36364578cb8e2f51a82dec0dd068ae61727a40d4c8afc15c82ae9cd62  runs/zero--prefix--reference-t0019/requests.csv
+91b5e9e2015d961ccbac177f920371c361d212c03769ff264ded6e2ed97a0079  runs/zero--prefix--reference-t0019/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--prefix--reference-t0019/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--prefix--reference-t0019/source-audit.json
+bcac86eacdc89e7a313891594adc60b30abc2b8632c70b6e7d35bee88d9e85ef  runs/zero--prefix--reference-t0019/state.npz
+35673b9fcbe682ab98ab3f4babb05d151cc91522279fb10ad2b520adf7587803  runs/zero--prefix--reference-t0019/summary.json
+7b53244c354dcb34f4b51b44265a3e94a7ddc05af816cbca2e7b0dc3c95658ae  runs/zero--prefix--reference-t0019/terminal-queues.npz
+072dd7c530a45bbf03ff24e910f784839ffaf2c45342c817d1e25964b6158b22  runs/zero--prefix--reference-t0019/tick-state-hashes.jsonl
+d24f161f31abb6dd6d57dc0a74b5bca65ae2b35325d50f16815d9442f0dd73b9  runs/zero--prefix--reference-t0500/apl-applied.float32.npy
+7a49a1a8fbe42b3965913b8e483ef729ba1f13c211f8da7f10b4b2cd142e6882  runs/zero--prefix--reference-t0500/apl-component.json
+f8501880df7d53b60d22258457f584db10e76db2510d3a2013c87b80676e43d5  runs/zero--prefix--reference-t0500/apl-drive.float32.npy
+fea94545b7bdc2b4e2e439e09e2b610f9e23404d5b5935b0ade3db75f9175f1a  runs/zero--prefix--reference-t0500/apl-inhibition.float32.npy
+8f990c4598e6604cc33eed5d2247e92bb6098c827a504d0265dbb95a9cd6a277  runs/zero--prefix--reference-t0500/apl-pending-tail.float32.npy
+088a2194a613eff7650ddb6c74a81f6d17ee2c0d1145058eaacab6e37a227861  runs/zero--prefix--reference-t0500/apl-state.float32.npy
+253e599852f3ba8c6e22f258dab2c3832c68e578d2ce28287b86c57a452a839d  runs/zero--prefix--reference-t0500/apl-timing-audit.json
+2e72393a6676ba738739d61f6992289c2d11793449a5efb15a40c6525ae7924a  runs/zero--prefix--reference-t0500/checkpoint-manifest.json
+d581bb0d3c1a7f7c9f3afcff7bdbdcd7f32c9a9db798bcde1e0c869c38fd13ad  runs/zero--prefix--reference-t0500/finite-audit.json
+bb8ddbcdb4f17c36a7352f0aa863f68e0ba92c3c8507bd99b85df224035d9379  runs/zero--prefix--reference-t0500/overlay-audit.json
+0b219eab09c30dc3af31fef7e6395a9bec1234090abbb72db096da833fed82c5  runs/zero--prefix--reference-t0500/overlay-input.npz
+11b668978f3070dad26d99d9310bebefa0731fa0d4e361e8dc0ef02a213277c2  runs/zero--prefix--reference-t0500/overlay-manifest.json
+10ced8f9b403e850c430dbe68d3f84e7f6458f0f57ca46effcef7d86f5cdbde9  runs/zero--prefix--reference-t0500/queue.jsonl
+46d029c30d77cf99a69617f02957ecc7cea2b942a46caaee5157ff28283869a9  runs/zero--prefix--reference-t0500/requests.csv
+24ae913b96c3c8b8fa4804a99e822b8fde7bded231d274d9592bfedf08440237  runs/zero--prefix--reference-t0500/runtime-provenance.json
+0584f865885b18e6a36870a7ecfbbc98d7a94274fa5e9e073e7cf97597d78a03  runs/zero--prefix--reference-t0500/sealed-gpu-source.diff
+d644f0265632f117bba0e045d26fb266765b1d005a89426b6242f3de034be935  runs/zero--prefix--reference-t0500/source-audit.json
+399dede1263e20c74edaa4e294bcfc3453dc6b10271a200534b608c59fc75aae  runs/zero--prefix--reference-t0500/state.npz
+ba9d1046ed7536816e2c82ee2ca25181207cdc2d0277f8e929eef529e8544ffa  runs/zero--prefix--reference-t0500/summary.json
+c6b90eaa65808847d512bead4a983493a88d2ef368b48f6d389501771113e62a  runs/zero--prefix--reference-t0500/terminal-queues.npz
+3493765ab82b625634049e5cd32c22f55d302ee510250acddf8d4261e1c548e8  runs/zero--prefix--reference-t0500/tick-state-hashes.jsonl
+e8952a48cd3ea6a93c811a1183a1f7b79e19646299924e7688e5f393737a9aa2  manifest.json

registry/phase4an-engineering-validation/evidence/logs/static25--chain--light-s00.stdout.log

@@ -0,0 +1 @@
+COMPLETED ENGINEERING ROW static25--chain--light-s00

registry/phase4an-engineering-validation/evidence/logs/static25--chain--light-s01.stdout.log

@@ -0,0 +1 @@
+COMPLETED ENGINEERING ROW static25--chain--light-s01

registry/phase4an-engineering-validation/evidence/logs/static25--chain--light-s02.stdout.log

@@ -0,0 +1 @@
+COMPLETED ENGINEERING ROW static25--chain--light-s02