Audit conditional PN recruitment and graded APL source timing

2026-09-30 10:45:48 +08:00
parent 9437bbff79
commit b2cd81c7b9
283 changed files with 159989 additions and 9 deletions
@@ -4,22 +4,22 @@

 ## 最新结果

-Phase 4AH：**PASS-CONDITIONAL-KC-DRIVE-AUDIT**，已封存。只审计既有轨迹，未运行新脑实验、使用 GPU、调参或训练。
+Phase 4AI：**PASS-CONDITIONAL-PN-APL-SOURCE-AUDIT**，已封存。74 项测试、80 份既有记录的 PN 事件/计数/最终状态重建、8 份小型逐步历史及 12 对重复检查全部通过。无新全脑实验、GPU、调参或训练。

-80 份记录的 KC 放电、计数及最终状态精确重建，8 个小型场景逐步状态一致；12 组重复统计一致。完整 CAL 未保存逐 KC 状态历史，不能把全脑哈希称为逐 KC 历史验证。
+60/60 CAL 中，非设计目标 PN 的首次活动早于首个 KC。已激活非设计 PN 的首发前正增量约 66% 来自 ALLN、28% 来自 ALPN；这是正增量而非净去极化或唯一因果。考虑负项后，两类来源的净时间过滤 V 贡献排名不同。

-关键发现：所有 KC 都收到过兴奋输入；从未放电的 KC 中约 93.35% 收到过 PN 兴奋输入，而且这些静默 KC 没有进入不应期。PN→KC 到达边事件拒绝率仅约 0.037%。约 89.8% 的 ALPN 放电来自当次非设计目标，持续 APL 写入与兴奋输入的累计比值约 3.05，但这不是瞬时 E/I 或已证明的失败原因。
+非设计 PN 贡献了约 74% 的整窗 graded-APL 累计 h；在全网首个 KC 前约为 62%–63%。这些是冻结工程算子的条件来源分账，不是已证实的失败原因。

-原 Phase 4AG **FAIL-FIXED-CAL-REPRESENTATION** 不变：KC 平均活跃比例 1.2713% / 1.2336%，低于固定 3%–9%。没有学习候选，不能进入条件化、游戏/RL/decoder/Web。
+PN 活动具有很强共同背景，但仍有小的气味差异，且指标不一致；matched-energy 的 Euclidean between 未超过 within。不能把高相似性直接解释为零信息。

-原 230,239 项及后续冻结目录 checksum 全部通过。旧五组参考本阶段未重跑，上一轮封存 PASS 记录未变。base CSR、W_syn、sign、旧 APL 参数、eligibility-v2、14,232-edge mask 和既有阶段产物均不改。
+原 Phase 4AG **FAIL-FIXED-CAL-REPRESENTATION** 不变；没有学习候选，不能进入条件化、游戏/RL/decoder/Web。原 230239 项及后续冻结目录校验全部通过。旧五组参考本轮未重跑，上一轮封存 PASS 记录未变。

 ## 下一步

-继续只读审计既有 CAL：重建 ALPN 响应，追踪非设计 PN 再招募的真实时序，并将 PN→APL 输入按设计/非设计来源分账。旧 APL 已明确是每步增量，不是“漏乘 dt”；不同时间算子的假设必须另立单位契约及解析匹配对照，不按 3.05 比值倒推 gain。
+先用既有记录核对最早非设计 PN 群、首个 KC 前窗口及 PN→ALLN 的真实先行边，补足当前尚未证明的动态闭环。再预声明独立 APL 时间算子对照：原 delay=0 与固定 18 步平移；先检验固定序列与末端记录完整性，不扫描最佳值，不调 gain、threshold、eta。18 步是工程对齐，不是文献确定的 MaleCNS 生理延迟。保留正负来源及 never-active 对照，不能把最大正增量来源直接当成最大净因果作用。

-新的因果干预或动力学假设另立协议和目录，不能覆盖现有结果。仍需表征、独立 seed/新气味、信用分配、隔离功能及全脑功能检查后才能进入真正学习验证。
+旧 raw/CSR/W_syn/sign/APL 参数/eligibility-v2/14232-edge mask 与全部冻结产物保持不变。尚未启动上述后续实验；所有新模型假设需独立目录、协议和回归门，不能覆盖本轮结果。

-完整新审计数据约 81.4 MB 存在服务器；Git 发布代码、小报告和校验，不是全量异机备份。
+本轮完整新审计数据约 1.10 GB 在服务器；Git 发布小报告、代码和校验，不是全量异机备份。

-[最新解释](docs/progress/phase4ah-interpretation.md) · [正式报告](docs/progress/phase4ah-kc-drive-audit.md) · [原 CAL 失败解释](docs/progress/phase4ag-interpretation.md) · [封存校验](registry/phase4ah-kc-drive-audit/seal-verification.json)
+[最新解释](docs/progress/phase4ai-interpretation.md) · [正式封存状态](registry/phase4ai-pn-recruitment-audit/evidence/audit/final-status.json) · [下一步假设](docs/progress/phase4ai-next-hypotheses.md) · [封存校验](registry/phase4ai-pn-recruitment-audit/seal-verification.json)
@@ -0,0 +1,89 @@
+# Phase 4AI：PN 再招募与 APL 来源审计
+
+正式状态：`PASS-CONDITIONAL-PN-APL-SOURCE-AUDIT`。这是审计通过，不是表征或学习通过。
+
+## 核验范围
+
+74 项合成测试通过；固定 8 个小场景、60 个 CAL 主记录、12 个技术重复，共 80 份既有 Phase 4AG-r2 记录。PN 的完整放电事件、计数、最终 V/g/ref 逐位一致；8 个小场景的每步 pre/post 状态一致；12 对统计重复一致。CAL 没有独立保存逐 PN 的每步状态，不能把最终状态/事件验证称为完整逐步历史验证。
+
+额外独立复核了每个首发前真实边事件的 source spike、18-step delay、真实 canonical edge、权重位值、到达时刻、接受状态、严格首发前条件。跨批唯一性与从原始 source events 重新推导的逐边期望数量均一致，无漏项或重复。
+
+没有运行新全脑实验、使用 GPU、改参数、改权重、训练或访问 held-out 动态结果。全程只对既有记录做条件重建与非反馈分账；这不是独立全脑 oracle，也不是删掉某条通路的反事实。
+
+## 1. 非设计 PN 的活动先于 KC
+
+“非设计”仅表示该 trial 静态刺激目标集合以外，不等于噪声、错误神经元或污染。
+
+|指标|physiological|matched_energy|
+|---|---:|---:|
+|非设计 PN 首次活动早于首个 KC 的主记录|30/30|30/30|
+|首个非设计 PN tick 范围|40–223|45–216|
+|首个 KC tick 范围|111–322|126–294|
+|首次活动前已有非设计 PN 活动的 active KC neuron-trials|1550/1550|1504/1504|
+|首次活动前已有真实非设计 PN→KC 到达边事件|1539/1550|1496/1504|
+|非设计 PN 放电 / 全部 PN 放电|138679/154514|137431/153049|
+
+tick 是保存记录的整数时间索引，dt=0.1 ms；这里给出的是记录内时间，不是相对每个外部刺激 onset 的延迟。上表多 trial 合计不能当作不同神经元数量。
+
+## 2. 首发前 PN 输入来自哪里
+
+限定对象为已经放电的非设计 PN：14967 / 14939 neuron-trials，两种模式各涉及 547 个不同 PN。
+
+|首发前接受的正权重增量来源|physiological|matched_energy|
+|---|---:|---:|
+|ALLN|65.7040%|65.7683%|
+|ALPN|27.7791%|27.8722%|
+|其他已注释神经元|5.2174%|5.0328%|
+|KC|0.00124%|0.00105%|
+
+ALLN 是 metadata 中精确的 `annotation_class == ALLN`，不是 ALIN；没有根据类型前缀补齐身份。来源表同时保留负权重与零权重。
+
+这些占比是首发前**名义正增量的累计份额**，不是净电流、净去极化或因果贡献。非反馈 V 账本中，ALLN 在首发阈值检查前的平均正/负项约为 +8.93/−5.85 mV（净约 +3.08 mV），而 ALPN 约为 +4.43/−0.11 mV（净约 +4.32 mV）。不能因 ALLN 正增量占比最大就声称其净去极化最大。
+
+这个统计窗口截至每个 PN 自身首发，不是全部截至全网首个 KC，不能拿 66% 直接解释最早一批 PN 的启动。最早非设计 PN 先于首个 KC，排除了此前 KC spikes 启动这一最早群体的解释；之后的再招募与反馈仍可存在。当前只直接覆盖 ALLN→PN 来边，不是 PN→ALLN→PN 动态闭环、必要性或唯一因果路径证明；后续必须保留负项、时间过滤、其他通路和从未激活 PN 对照。
+
+## 3. graded APL 的来源
+
+冻结 APL 输入矩阵是非负 raw-contact 归一化工程映射，不是实际 signed PN→APL LIF 电流，不能称为测得的 dopamine/电导或生理量。
+
+|non-design ALPN 来源份额|physiological|matched_energy|
+|---|---:|---:|
+|整个记录累计 h 写入|73.9038%|73.9797%|
+|每个 active KC 首发严格之前的 h 合计|66.5249%|66.7294%|
+|全网首个 KC 严格之前、全部 KC 的 h 合计|62.8646%|62.4176%|
+
+全网首个 KC 之前的 KC 来源为 0，其余来自 design ALPN。在零初态、由 KC spikes 驱动的算子下，这是结构性结果，不能当成独立证明“KC 反馈无作用”。整窗 KC 来源仍占约 4.72% / 4.64%，每只 active KC 自身首发前占约 7.53% / 7.32%。这些均不证明 PN/APL 是 KC 稀疏度失败的原因。
+
+三组 float64 合计与保存的 float32 drive/state/h 在预先推导的逐 tick 数值误差界内；这是数学来源分账，不是 bitwise CUDA APL replay。累计份额仍是描述统计，未构造累计来源份额的误差区间，不宣称“主导份额经严格误差界证明”。
+
+## 4. 共同活动很强，但不能据此宣布气味信息为零
+
+主比较固定全部 686 个 ALPN 维度；次比较固定六种 CAL 刺激目标并集 76 个 PN 之外的共同 610 维。每模式固定 60 within-seed-pair 与 75 between-odor/same-seed 比较；技术重复不充当新 seed。
+
+|固定 686 维指标：within / between|physiological|matched_energy|
+|---|---:|---:|
+|Cosine distance|0.002812 / 0.003146|0.002936 / 0.003291|
+|Pearson correlation|0.993240 / 0.992438|0.992964 / 0.992107|
+|Active-set Jaccard|0.982743 / 0.980222|0.982590 / 0.979699|
+|Euclidean distance|22.7359 / 26.6852|25.3697 / 25.2796|
+
+共同活动与小的气味差异可以并存。尤其 matched-energy 的 Euclidean between 不高于 within；不同指标并不一致。这不是无信息的统计证明，也不是学习可用性、held-out 泛化、分类器或显著性检验。
+
+## 结论与下一步
+
+原 Phase 4AG `FAIL-FIXED-CAL-REPRESENTATION` 完全不变，未产生学习候选。本轮减少了机制不确定性，没有把“出现差异”当作成功。
+
+下一步先用固定 60 CAL 的已有记录，核对最早非设计 PN 群及首个 KC 前窗口，分开 design/non-design ALPN 与 ALLN 的正负输入，并查 PN→ALLN 方向的真实带时延先行边。不能挑出现所需结论的 cohort，也不能把 shortest path 当动态路径。
+
+再按独立预声明协议检验一个时间算子假设：原 graded APL 当步末写入，与固定平移 18 步的工程对照。不能称为实测生理修正，不能调 gain、threshold 或 eta，不能扫描最佳 delay。先验证固定序列的按位平移与末端样本完整性，再决定是否进入闭环；详细边界见 [下一步假设](phase4ai-next-hypotheses.md)。
+
+## 完整性和保存位置
+
+- 原始登记 230239 个文件及后续 Phase 4AA–4AH 各冻结目录 checksum 全通过。旧五组 reference 本轮未重跑；上一轮封存 PASS 记录按 SHA 校验未变。
+- 新模型目录：`models/male-cns-lif/pn-recruitment-audit-v1/`，16 个 payload 文件，170860 bytes。
+- 新实验目录：`experiments/phase4ai-pn-recruitment-audit/`，734 个 payload 文件，1101594284 bytes，约 1.10 GB。纯 CPU 审计时间合计 726.84 秒，不是脑实时性能 benchmark。
+- 模型 manifest SHA-256：`a53443ac124e9bebc813867a5015d77276c2bd3edf89cd606a57d54756fe0dd7`。
+- 实验 manifest SHA-256：`12c6f2e9929b3f7084e8b39b90c8851185febbc0afbb7031f9eebb4c41d2731d`。
+- Git 仅发布代码、257 份小证据（约 5.85 MB）、文档与校验；完整新事件数据仍在服务器，不是异机全量备份。
+
+解释指标由 `tools/report_phase4ai.py` 从已封存表只读导出，保存于 `registry/phase4ai-pn-recruitment-audit/interpretation-metrics.json` 并附独立 SHA；不修改原封存 manifest 或科学 gate。
@@ -0,0 +1,36 @@
+# Phase 4AI 后的最小时间算子假设（尚未执行）
+
+这是后续独立分支的设计建议，不是已经注册或完成的实验，也不是生理正确性结论。Phase 1–4AI 的代码、数据、参数与结论不因此改变；学习门仍关闭。
+
+先补一项窄范围只读时序检查：在固定 60 CAL 中保留同时首发的全部最早非设计 PN，窗口截至首个 KC，分开 design/non-design PN 与 ALLN 的正负来源；核实 PN→ALLN 方向的真实先行边，必要时仅条件重建 ALLN 的接受状态。Phase 4AI 已验证 ALLN→PN 输入，但未证明动态 PN→ALLN→PN 闭环。此检查不运行新全脑实验，也不用于选择“最佳延迟”。
+
+## 当前可以由代码确认的时间契约
+
+现有 graded APL 组件在 PN/KC 于 tick `s` 放电后，当步更新其状态并在 `s` 末写入 KC 的 `g`。这次写入最早影响 `s+1` 的 threshold。真实直接 PN→KC 边在 `s+18` 的 threshold 之后到达，最早影响 `s+19` 的 threshold。
+
+这是两个算子的调度差异，不足以证明该差异就是失败原因。APL 原参数的单位是每状态每步增量，不是“漏乘 dt”；不能把原数值直接重新解释为 tonic 电位、也不能根据累计抑制/兴奋比反推 gain。
+
+## 唯一建议的最小对照
+
+在新的独立目录和预声明协议中，只比较原 `delay=0` 与固定 `delay=18 steps`：
+
+`h_apply[t] = 0 (t<18), otherwise h_generated[t-18]`。
+
+其余全部保持原样：APL 状态递推、float32 位值、I/O 映射与归一化、gain、fast-APL mask、LIF 参数、connectome、sign、外部请求文件。不扫描“最佳延迟”，不选效果好的 seed，不训练。18 步来自现有解剖事件队列的工程对齐，不是测得的 MaleCNS APL 生理延迟。
+
+注意：整条 `h` 延迟也会延迟 KC→APL 反馈，不是 PN-only 干预。解剖边到达仍受 refractory 保护，APL 写入仍不受该保护；时间对齐不等于两种作用完全等价。
+
+## 两层验证不可混淆
+
+1. 固定现有上游 spike/h 序列：按位平移 h，前补零并显式保留记录末端再延迟的 18 步。验证记录内每一个 h 样本无损、无漏、不循环移位，保持完整已生成序列的累计抑制量；不得把它称为未知未来的完整衰减尾部。
+2. 如继续全脑闭环：只能声明同一请求与同一算子参数。放电变化会改变后续 APL drive/state/h，不能声称两条件实际抑制总量仍相同，更不能事后重新归一化。报告末端状态和未排空事件，保留原固定 CAL 与后续学习门。
+
+先完成零输入、单 PN 脉冲、有限脉冲列、末端脉冲及 reset/refractory 碰撞的 CPU/GPU oracle 检查。`delay=0` 必须重现原记录；任何差异均先停，不进入 CAL。若唯一 delay 改动后完整 CAL 仍失败，则“单独消除这项调度领先足以修复 CAL”的假设不成立；即使通过，也不等于生理正确、泛化通过或学习成功。
+
+## 一手文献边界
+
+- [Shiu et al., Nature 2024](https://www.nature.com/articles/s41586-024-07763-9) 使用固定 1.8 ms 的突触延迟，并讨论统一 spiking LIF 对 non-spiking 生理过程的限制。这不等于解剖上删除 APL，不能写成 MaleCNS/APL 实测值。
+- [Amin et al., eLife 2020](https://elifesciences.org/articles/56954.pdf) 支持 APL 非脉冲活动及局部 KC 抑制；约 5 Hz 成像不足以解析其推测的毫秒级传播，不能据此指定精确 MaleCNS 延迟。
+- [Prisco et al., eLife 2021](https://pmc.ncbi.nlm.nih.gov/articles/PMC8741211/) 支持 calyx 中 PN/APL/KC 的局部关系和响应归一化，不给出这些 MaleCNS 路径的毫秒延迟。
+
+因此 0、1.8、3.6 ms 均不得宣称是由这些文献确定的 MaleCNS APL 生理参数。此建议只用于可证伪、单因素、可回归的工程动力学分支。
@@ -0,0 +1,23 @@
+# Phase 4AI — PN recruitment and graded-APL source audit
+
+Read-only, post-outcome conditional accounting of 80 already sealed Phase 4AG-r2 records. This is not a new whole-brain experiment, a learning trial, an independent brain oracle, or an APL-removal counterfactual.
+
+## Frozen contracts
+
+- Reuse sealed Phase 4AH `replay_core.py` without modification; reconstruct actual ALPN targets (686 in the full graph).
+- Keep the full frozen fast-APL effective-edge zeroing, delay, refractory, reset, threshold, ordering and float64 LIF coefficients. PN graded inhibition is exactly zero because the existing overlay applied only to KC.
+- Separate accepted timed incoming-edge antecedents, non-feedback voltage lineage, and the legacy nonnegative graded-APL input map. The latter is not signed PN-to-APL LIF current.
+- APL source groups: trial design ALPN, other ALPN, KC. Reject unaccounted nonzero input support. Compare summed mathematical float64 traces with stored float32 using prior analytic per-tick bounds, including grouping roundoff. Accumulated source shares remain descriptive; their robust majority is not proven.
+- Strict timing: direct PN arrival at s+18 must precede the KC threshold tick; APL write at s follows the threshold and can affect only later ticks. Never-fired cells remain explicitly censored.
+- Primary odor statistics retain fixed 686 coordinates; secondary statistics retain the fixed complement of six-odor design union. Technical repeats are excluded from odor comparisons.
+
+## Execution
+
+Use the existing CPU environment, Python `-B`, and four-thread OMP/MKL/OpenBLAS/Arrow limits. No Torch import, GPU or parameter changes are needed.
+
+1. `prepare.py`: synthetic tests, source/input hashes, prior integrity, fixed inventory, metadata schema and preregistration.
+2. `run_audit.py`: exact PN conditional replay, event-stream provenance, APL split, twelve repeat checks.
+3. `finalize.py`: independently re-read saved evidence, validate timed edge events, aggregate all fixed records, check prior integrity, seal model and experiment.
+4. `publication.py`: verify both seals, then exclusively publish small evidence to a new registry. Bulk arrays stay on the server; Git is not their off-host backup.
+
+Any failure is preserved. Do not edit a registered source or reuse a populated experiment directory. A new revision requires an explicit separate directory and record. Audit PASS never implies learning PASS, identified unique causality, or permission to tune frozen models.
@@ -0,0 +1,329 @@
+"""Non-feedback float64 attribution of the frozen, recorded graded APL trace.
+
+No files, Torch, GPU, neuronal state, or counterfactual simulation are used.
+The reference is mathematical source accounting, NOT bitwise CUDA replay.
+Full bundle output is generated even for graph fixtures; the caller must not
+interpret inhibition for absent fixture KCs as inhibition actually applied.
+"""
+from __future__ import annotations
+
+import math
+import numpy as np
+
+
+N = 166700
+GROUPS = ("design_ALPN", "non_design_ALPN", "KC")
+DECAY32 = np.float32(math.exp(-.1 / 20.))
+GAIN32 = np.float32(.01)
+
+
+def _require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def _ids(value, name):
+    value = np.asarray(value)
+    _require(value.dtype == np.int32 and value.ndim == 1, name + " must be an int32 vector")
+    _require(np.all((value >= 0) & (value < N)) and np.all(value[1:] > value[:-1]),
+             name + " must contain sorted unique global IDs")
+    return value
+
+
+def _positive_array(value, shape, name):
+    value = np.asarray(value)
+    _require(value.dtype == np.float32 and value.shape == shape, name + " has the wrong shape/dtype")
+    _require(np.isfinite(value).all() and np.all(value >= 0), name + " must be finite and nonnegative")
+    return value
+
+
+def _up(value):
+    return np.nextafter(np.asarray(value, np.float64), np.inf)
+
+
+def _add(a, b):
+    return _up(np.asarray(a, np.float64) + np.asarray(b, np.float64))
+
+
+def _mul(a, b):
+    return _up(np.asarray(a, np.float64) * np.asarray(b, np.float64))
+
+
+def _gamma(count, unit_roundoff):
+    _require(count * unit_roundoff < 1, "Undefined gamma bound")
+    numerator = _mul(count, unit_roundoff)
+    denominator = np.nextafter(1. - numerator, -np.inf)
+    return _up(numerator / denominator)
+
+
+def _sum_upper(values):
+    """Outward-rounded sum on axis zero; inputs are nonnegative."""
+    result = np.zeros(values.shape[1:], np.float64)
+    for value in values:
+        result = _add(result, value)
+    return result
+
+
+def _sum_groups(values):
+    # Explicit separate additions; never rely on a backend reduction over G.
+    return np.add(np.add(values[0], values[1]), values[2])
+
+
+def _positive_dot_upper(state, matrix):
+    result = np.zeros(matrix.shape[1], np.float64)
+    for index in range(len(state)):
+        result = _add(result, _mul(state[index], matrix[index]))
+    return result
+
+
+def _normal(value, tiny):
+    return bool(np.isfinite(value).all() and np.all((value == 0) | (value >= tiny)))
+
+
+def _metric():
+    return dict(elements=0, sum_abs_error=0., max_abs_error=0., max_error_bound=0.,
+                max_bound_utilization=0., bound_violations=0, zero_reference_nonzero_actual=0)
+
+
+def _measure(metric, actual, reference, bound):
+    _require(np.isfinite(reference).all() and np.isfinite(bound).all(), "Nonfinite reference/bound")
+    error = np.abs(actual.astype(np.float64) - reference)
+    upper = np.where(error == 0, 0., _up(error))
+    impossible_zero = (reference == 0) & (actual != 0)
+    bad = (upper > bound) | impossible_zero
+    usage = np.divide(upper, bound, out=np.zeros_like(upper), where=bound > 0)
+    metric['elements'] += error.size
+    metric['sum_abs_error'] += float(error.sum(dtype=np.float64))
+    metric['max_abs_error'] = max(metric['max_abs_error'], float(error.max(initial=0)))
+    metric['max_error_bound'] = max(metric['max_error_bound'], float(bound.max(initial=0)))
+    metric['max_bound_utilization'] = max(metric['max_bound_utilization'], float(usage.max(initial=0)))
+    metric['bound_violations'] += int(bad.sum())
+    metric['zero_reference_nonzero_actual'] += int(impossible_zero.sum())
+
+
+def decompose_apl_sources(I32, O32, pn_globals, kc_globals, design_pn_globals,
+                          event_step, event_node, drive32, state32, h32, *,
+                          decay32, gain32, standard_fp32, chunk_size=512, callback=None,
+                          first_kc_tick=None):
+    """Attribute APL input/output to three exact anatomical source groups.
+
+    I32 is the full (2,166700) normalized float32 input matrix; O32 is (2,K),
+    with columns in sorted kc_globals order. Traces are drive/state float32
+    (T,2), inhibition float32 (T,K), including ALL bundle KC output columns.
+    Actual event vectors are int32 and sorted/unique by tick/global neuron.
+    Design IDs must be a subset of pn_globals; fixtures' design definition is
+    supplied explicitly by the caller, never inferred from response outcome.
+
+    standard_fp32 must be True only after historical metadata verifies TF32 is
+    disabled and matmul precision is 'highest'. This function cannot inspect a
+    GPU environment. d/q must have the exact frozen float32 constant bits.
+
+    Return summary (pure JSON values), tick_rows (T*3*2 JSON dictionaries),
+    first_kc_tick (int32[K], -1 for never fired), and per_kc cumulative arrays.
+    Optional first_kc_tick is checked against actual events, never overrides
+    them. No T*3*K history is retained; source cumulative storage is O(3*K).
+    callback(tick, dict) optionally receives copies of drive/state group arrays
+    (3,2), plus their totals, never a full inhibition history.
+
+    Early means strictly tick < observed first KC spike; same-tick APL output
+    follows threshold and cannot cause that spike. Never-fired KC output and
+    output strictly before the first spike of ANY KC are reported separately.
+    """
+    _require(standard_fp32 is True, "Historical standard FP32 arithmetic must be verified by caller")
+    _require(isinstance(decay32, np.float32) and isinstance(gain32, np.float32) and
+             decay32.view(np.uint32) == DECAY32.view(np.uint32) and
+             gain32.view(np.uint32) == GAIN32.view(np.uint32), "Frozen float32 decay/gain bits changed")
+    _require(isinstance(chunk_size, (int, np.integer)) and not isinstance(chunk_size, (bool, np.bool_)) and
+             chunk_size > 0, "chunk_size must be a positive integer")
+    _require(callback is None or callable(callback), "callback must be callable")
+    pn = _ids(pn_globals, 'pn_globals')
+    kc = _ids(kc_globals, 'kc_globals')
+    design = _ids(design_pn_globals, 'design_pn_globals')
+    _require(len(kc) > 0 and not np.intersect1d(pn, kc).size, "PN/KC identities overlap or KC set is empty")
+    _require(np.isin(design, pn).all(), "Design PN is outside the anatomical PN population")
+    k = len(kc)
+    I = _positive_array(I32, (2, N), 'I32').astype(np.float64)
+    O = _positive_array(O32, (2, k), 'O32').astype(np.float64)
+    state32 = np.asarray(state32)
+    _require(state32.ndim == 2 and len(state32) > 0, "Empty/invalid state trace")
+    steps = len(state32)
+    state32 = _positive_array(state32, (steps, 2), 'state32')
+    drive32 = _positive_array(drive32, (steps, 2), 'drive32')
+    h32 = np.asarray(h32)
+    _require(h32.dtype == np.float32 and h32.shape == (steps, k), "h32 has wrong shape/dtype")
+    # Validate without allocating a dense T*K temporary boolean array.
+    for start in range(0, k, chunk_size):
+        value = h32[:, start:start + chunk_size]
+        _require(np.isfinite(value).all() and np.all(value >= 0), "h32 must be finite and nonnegative")
+    labels = np.full(N, -1, np.int8)
+    labels[pn], labels[design], labels[kc] = 1, 0, 2
+    support = np.any(I != 0, axis=0)
+    unknown = np.flatnonzero(support & (labels < 0))
+    _require(not len(unknown), "Nonzero APL input outside design/non-design PN/KC: " + str(unknown[:10].tolist()))
+    ticks, nodes = np.asarray(event_step), np.asarray(event_node)
+    _require(ticks.dtype == nodes.dtype == np.int32 and ticks.ndim == nodes.ndim == 1 and
+             ticks.shape == nodes.shape, "Actual events must be matching int32 vectors")
+    _require(np.all((ticks >= 0) & (ticks < steps)) and np.all((nodes >= 0) & (nodes < N)), "Event out of range")
+    _require(np.all((ticks[1:] > ticks[:-1]) | ((ticks[1:] == ticks[:-1]) & (nodes[1:] > nodes[:-1]))),
+             "Actual events must be sorted and unique")
+    ptr = np.searchsorted(ticks, np.arange(steps + 1))
+    lookup = np.full(N, -1, np.int32)
+    lookup[kc] = np.arange(k, dtype=np.int32)
+    first = np.full(k, steps, np.int32)
+    is_kc = lookup[nodes] >= 0
+    np.minimum.at(first, lookup[nodes[is_kc]], ticks[is_kc])
+    ever = first < steps
+    first_any = int(first.min()) if ever.any() else None
+    first[~ever] = -1
+    if first_kc_tick is not None:
+        supplied = np.asarray(first_kc_tick)
+        _require(supplied.dtype == np.int32 and supplied.shape == (k,) and np.array_equal(supplied, first),
+                 "Supplied first_kc_tick disagrees with observed actual KC events")
+    d, q = float(decay32), float(gain32)
+    u32, u64 = 2.**-24, 2.**-53
+    gd32, gd64 = _gamma(N - 1, u32), _gamma(N - 1, u64)
+    gs32, gs64 = _gamma(2, u32), _gamma(2, u64)
+    gh32, gh64, gg64 = _gamma(5, u32), _gamma(5, u64), _gamma(2, u64)
+    group_state = np.zeros((3, 2), np.float64)
+    e64 = np.zeros_like(group_state)
+    e32 = np.zeros(2, np.float64)
+    previous32 = np.zeros(2, np.float64)
+    statistics = {name: _metric() for name in ('drive', 'state', 'inhibition')}
+    tiny32, tiny64 = np.finfo(np.float32).tiny, np.finfo(np.float64).tiny
+    normal = _normal(I, tiny32) and _normal(O, tiny32)
+    sums = {name: dict(actual_spikes=0, input_supported_spikes=0, first_actual_spike_tick=None,
+            first_nonzero_drive_tick=None, cumulative_drive_by_apl=np.zeros(2),
+            cumulative_state_by_apl=np.zeros(2), h_sum_mV=0., h_before_first_KC_sum_mV=0.,
+            h_never_fired_KC_sum_mV=0., h_before_first_any_KC_sum_mV=0.) for name in GROUPS}
+    rows = []
+    per_kc = dict(neuron_idx=kc.copy(), first_spike_tick=first.copy(), ever_fired=ever.copy())
+    for name in GROUPS:
+        for suffix in ('pre_first_h_sum_mV', 'never_fired_h_sum_mV', 'h_sum_mV'):
+            per_kc[name + '_' + suffix] = np.zeros(k, np.float64)
+    O_total, O_never = O.sum(axis=1), O[:, ~ever].sum(axis=1)
+    for tick in range(steps):
+        fired = nodes[ptr[tick]:ptr[tick + 1]]
+        group_drive = np.zeros_like(group_state)
+        spike_counts = np.zeros(3, np.int64)
+        for group, name in enumerate(GROUPS):
+            selected = fired[labels[fired] == group]
+            spike_counts[group] = len(selected)
+            group_drive[group] = I[:, selected].sum(axis=1, dtype=np.float64)
+            acc = sums[name]
+            acc['actual_spikes'] += len(selected)
+            acc['input_supported_spikes'] += int(support[selected].sum())
+            if len(selected) and acc['first_actual_spike_tick'] is None:
+                acc['first_actual_spike_tick'] = tick
+            if np.any(group_drive[group] > 0) and acc['first_nonzero_drive_tick'] is None:
+                acc['first_nonzero_drive_tick'] = tick
+        # Each source-group positive reduction independently bounds its exact
+        # real sum. Outward sum across groups bounds the common exact drive.
+        Dupper = _up(group_drive / np.nextafter(1. - gd64, -np.inf))
+        total_Dupper = _sum_upper(Dupper)
+        drive_ref = _sum_groups(group_drive)
+        drive_bound = _add(_mul(gd32, total_Dupper),
+            _add(_sum_upper(_mul(gd64, Dupper)), _mul(gg64, _sum_upper(group_drive))))
+        e32 = _add(_mul(d, e32), _add(_mul(gs32, _add(_mul(d, previous32), total_Dupper)),
+            _mul(1. + u32, _mul(gd32, total_Dupper))))
+        e64 = _add(_mul(d, e64), _add(_mul(gs64, _add(_mul(d, group_state), Dupper)),
+            _mul(1. + u64, _mul(gd64, Dupper))))
+        normal &= _normal(d * previous32, tiny32) and _normal(d * group_state, tiny64)
+        group_state = np.add(np.multiply(d, group_state), group_drive)
+        state_ref = _sum_groups(group_state)
+        state_bound = _add(e32, _add(_sum_upper(e64), _mul(gg64, _sum_upper(group_state))))
+        observed_state = state32[tick].astype(np.float64)
+        normal &= _normal(drive32[tick], tiny32) and _normal(observed_state, tiny32)
+        _measure(statistics['drive'], drive32[tick], drive_ref, drive_bound)
+        _measure(statistics['state'], state32[tick], state_ref, state_bound)
+        for start in range(0, k, chunk_size):
+            stop = min(k, start + chunk_size)
+            matrix = O[:, start:stop]
+            h_group = np.empty((3, stop - start), np.float64)
+            h_error = np.empty_like(h_group)
+            for group in range(3):
+                products = group_state[group, :, None] * matrix
+                dot = np.add(products[0], products[1])
+                h_group[group] = np.multiply(q, dot)
+                normal &= _normal(products, tiny64) and _normal(h_group[group], tiny64)
+                h_error[group] = _add(_mul(q, _positive_dot_upper(e64[group], matrix)),
+                    _mul(gh64, _mul(q, _positive_dot_upper(group_state[group], matrix))))
+                name = GROUPS[group]
+                per_kc[name + '_h_sum_mV'][start:stop] += h_group[group]
+                early_mask = ever[start:stop] & (tick < first[start:stop])
+                per_kc[name + '_pre_first_h_sum_mV'][start:stop] += h_group[group] * early_mask
+                per_kc[name + '_never_fired_h_sum_mV'][start:stop] += h_group[group] * ~ever[start:stop]
+            h_ref = _sum_groups(h_group)
+            h32_error = _add(_mul(q, _positive_dot_upper(e32, matrix)),
+                _mul(gh32, _mul(q, _positive_dot_upper(observed_state, matrix))))
+            bound = _add(h32_error, _add(_sum_upper(h_error), _mul(gg64, _sum_upper(h_group))))
+            actual_products = observed_state[:, None] * matrix
+            actual_dot = np.add(actual_products[0], actual_products[1])
+            normal &= _normal(actual_products, tiny32) and _normal(q * actual_dot, tiny32)
+            normal &= _normal(h32[tick, start:stop], tiny32)
+            _measure(statistics['inhibition'], h32[tick, start:stop], h_ref, bound)
+        # Aggregate output per source and per APL, never T*G*K. This is linear
+        # f64 measurement; grouping/reduction is not claimed bitwise identical.
+        early = ever & (tick < first)
+        O_early = O[:, early].sum(axis=1)
+        before_any = first_any is not None and tick < first_any
+        for group, name in enumerate(GROUPS):
+            acc = sums[name]
+            acc['cumulative_drive_by_apl'] += group_drive[group]
+            acc['cumulative_state_by_apl'] += group_state[group]
+            for apl in range(2):
+                amplitude = q * group_state[group, apl]
+                h_sum = float(amplitude * O_total[apl])
+                h_early = float(amplitude * O_early[apl])
+                h_never = float(amplitude * O_never[apl])
+                h_any = h_sum if before_any else 0.
+                row = dict(tick=tick, group=name, apl_index=apl, source_spikes=int(spike_counts[group]),
+                    drive64=float(group_drive[group, apl]), state64=float(group_state[group, apl]),
+                    h_sum_mV=h_sum, h_before_first_KC_sum_mV=h_early,
+                    h_never_fired_KC_sum_mV=h_never, h_before_first_any_KC_sum_mV=h_any)
+                rows.append(row)
+                for key in ('h_sum_mV', 'h_before_first_KC_sum_mV', 'h_never_fired_KC_sum_mV', 'h_before_first_any_KC_sum_mV'):
+                    acc[key] += row[key]
+        if callback is not None:
+            callback(tick, dict(drive_by_group=group_drive.copy(), state_by_group=group_state.copy(),
+                drive_total=drive_ref.copy(), state_total=state_ref.copy()))
+        previous32 = observed_state
+    total_h = sum(value['h_sum_mV'] for value in sums.values())
+    total_drive = sum(float(value['cumulative_drive_by_apl'].sum()) for value in sums.values())
+    for acc in sums.values():
+        acc['generated_h_fraction'] = None if total_h == 0 else acc['h_sum_mV'] / total_h
+        acc['drive_fraction'] = None if total_drive == 0 else float(acc['cumulative_drive_by_apl'].sum()) / total_drive
+        for key in ('cumulative_drive_by_apl', 'cumulative_state_by_apl'):
+            acc[key] = acc[key].tolist()
+    for metric in statistics.values():
+        metric['mean_abs_error'] = metric.pop('sum_abs_error') / metric['elements']
+    finite_metrics = all(np.isfinite([row[key] for row in rows]).all() for key in
+        ('drive64', 'state64', 'h_sum_mV', 'h_before_first_KC_sum_mV', 'h_never_fired_KC_sum_mV', 'h_before_first_any_KC_sum_mV'))
+    _require(finite_metrics, "Nonfinite aggregate accounting")
+    _require(all(np.isfinite(value).all() for value in per_kc.values()), "Nonfinite per-KC accounting")
+    passed = bool(normal and all(metric['bound_violations'] == 0 for metric in statistics.values()))
+    summary = dict(pass_all=passed, steps=steps, neurons=N, apl=2, bundle_KC=k,
+        actual_events=len(nodes), groups=sums, group_order=list(GROUPS),
+        input_support_partition_exact=True, unknown_nonzero_input_columns=0,
+        source_population_counts={name: int(np.count_nonzero(labels == index)) for index, name in enumerate(GROUPS)},
+        input_supported_population_counts={name: int(np.count_nonzero(support & (labels == index))) for index, name in enumerate(GROUPS)},
+        first_any_KC_spike_tick=first_any, ever_fired_KC=int(ever.sum()), never_fired_KC=int((~ever).sum()),
+        decay_f32_bits=f'{int(decay32.view(np.uint32)):08x}', gain_f32_bits=f'{int(gain32.view(np.uint32)):08x}',
+        comparison=statistics, theoretical_bound=dict(applicable=bool(normal),
+            normal_or_zero_arithmetic=bool(normal), historical_standard_fp32_verified_by_caller=True,
+            gamma_definition='gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded',
+            drive_terms_bound=N-1, state_operation_bound=2, output_operation_bound=5, group_sum_operation_bound=2,
+            state_recurrence='E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper',
+            grouped_f64_bound='Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only',
+            output_bound='q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors',
+            tolerance_fitted_to_observed_error=False,
+            scope='Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions'),
+        early_definition='strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded',
+        value_units=dict(drive64='legacy normalized-contact spike drive', state64='legacy normalized-drive accumulator',
+            h='legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance'),
+        generated_full_bundle_trace=True, fixture_absent_KC_output_is_not_claimed_applied=True,
+        row_source_spikes_repeated_for_each_APL=True, nonfeedback=True, CUDA_float32_bitwise_replay=False,
+        cumulative_and_fraction_metrics_descriptive_float64=True,
+        cumulative_source_fraction_error_bounds_verified=False,
+        source_majority_robustness_proven=False,
+        independent_brain_oracle=False, lesion_or_counterfactual=False, parameters_changed=False)
+    return dict(summary=summary, tick_rows=rows, first_kc_tick=first, per_kc=per_kc)
@@ -0,0 +1,17 @@
+58f2f78b94aa783cc30b4b5e79ab003cc83f8a09b66c195d963bca6ee691e44c  README.md
+61f4c35b464315d19bbffce534cfc037a0111725da0eb07ee53a41db81767fcb  apl_sources.py
+a166da3d964b49ca28a013d3a3cf33df1607c76d4a6a53a8ca8e2d955aa92cb0  context.py
+40e0f8a9e075db42ac63163de8362d808b9110f371e49f6d4088267eecf2eb4c  finalize.py
+0663c1f723f614ebcdb666b46eaa49288aec26125d6aceb18cd237330a705968  pn_observer.py
+9fbef01968c54637c9063bb1e2d7f45fdc97b886b3c25815a6146fc5f219164c  prepare.py
+7a79c499098b74163e7bb16adabcbc54e7069dafa204d0b99c7f4c03d79f8016  publication.py
+a5a7861e8ced4739cd1a1f4314b8af7cff71168499f1ae6ed94ac71b481bcdd8  run_audit.py
+669e91a862efea5f243a054c883bc1a183e96b0bcf02fac5f6972c4a8272a4cb  structure_metrics.py
+a7ac0f38877e0244a4bcc574264c72617ec487544a19dbc705e0c1e26c4be78d  test_apl_sources.py
+c2e66adb18d25264d21bfce16462ef698a3ba09d178908bef1068881d46ac1e7  test_harness.py
+fff3cb9da17d9d638e53a609a265d6531ed82824d10e06fcb3863edfeab7a267  test_pn_observer.py
+a3516aefa6a753f8fca6c5a4c2109ae4d65ce0ab0278e4795d537148f04495ff  test_publication.py
+de1298a4a92facad97339e9a4cdb60ea2b7c30adc1a6f05274bd3be034239717  test_structure_metrics.py
+d687ceb171c7dad77dfe2eb53524091a7ee02ddc04d9bbafb3b4a59b0d1eb66c  test_validate_events.py
+32a33988c5c9619b2ff3553c2d508924a404ade17b526541a2ff113a61df68e4  validate_events.py
+a53443ac124e9bebc813867a5015d77276c2bd3edf89cd606a57d54756fe0dd7  manifest.json
@@ -0,0 +1,86 @@
+"""Phase 4AI: read-only PN/APL accounting of sealed Phase 4AG-r2 records."""
+import hashlib
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path('/data/digital-drosophila')
+MODEL = Path(__file__).resolve().parent
+EXP = ROOT / 'experiments/phase4ai-pn-recruitment-audit'
+AH_MODEL = ROOT / 'models/male-cns-lif/kc-drive-audit-v1'
+AH = ROOT / 'experiments/phase4ah-kc-drive-audit'
+AG_MODEL = ROOT / 'models/male-cns-lif/author-apl-lab-v2'
+AG = ROOT / 'experiments/phase4ag-author-apl-r2'
+META = ROOT / 'datasets/male-cns-v1.0/processed/neuron-only/neuron-index/unified-metadata.parquet'
+COEFF = ROOT / 'experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json'
+GROUPS = ('KC', 'APL', 'ALPN', 'MBON', 'anatomical_DAN', 'dopamine_annotation_only',
+          'ALLN', 'ALIN', 'ALON', 'olfactory_sensory', 'other', 'unclassified')
+
+
+def load_module(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def digest(path):
+    h = hashlib.sha256()
+    with Path(path).open('rb') as f:
+        for b in iter(lambda: f.read(8 << 20), b''):
+            h.update(b)
+    return h.hexdigest()
+
+
+def read(path):
+    return json.loads(Path(path).read_text(encoding='utf-8'))
+
+
+def save(path, value):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open('x', encoding='utf-8') as f:
+        json.dump(value, f, indent=2, ensure_ascii=False, allow_nan=False)
+        f.write('\n')
+
+
+def sources():
+    return {p.name: digest(p) for p in sorted(MODEL.iterdir()) if p.is_file()
+            and p.name not in ('manifest.json', 'checksums.sha256')}
+
+
+def integrity():
+    prior = load_module('sealed_ah_context_ai', AH_MODEL / 'context.py')
+    result = prior.integrity()
+    sys.path.insert(0, str(ROOT / 'models/male-cns-lif/terminal-scope-diagnostic-v1'))
+    from diagnostic import manifest_check
+    for path in (AH_MODEL, AH):
+        result[str(path.relative_to(ROOT))] = manifest_check(path, digest)
+    assert all(row['pass'] for row in result.values())
+    return result
+
+
+def check():
+    record = read(EXP / 'protocol/preregistered.json')
+    assert record['sources'] == sources(), 'Registered source changed'
+    for row in record['inputs']:
+        assert digest(ROOT / row['path']) == row['sha256'], row['path']
+    for row in read(EXP / 'protocol/prepared-hashes.json'):
+        assert digest(EXP / row['path']) == row['sha256'], row['path']
+    return record
+
+
+def seal(root):
+    rows = [dict(path=str(p.relative_to(root)), bytes=p.stat().st_size, sha256=digest(p))
+            for p in sorted(root.rglob('*')) if p.is_file() and '__pycache__' not in p.parts]
+    save(root / 'manifest.json', dict(root=str(root), files=rows))
+    with (root / 'checksums.sha256').open('x') as f:
+        for row in rows:
+            f.write(row['sha256'] + '  ' + row['path'] + '\n')
+        f.write(digest(root / 'manifest.json') + '  manifest.json\n')
+
+
+def bit_equal(a, b):
+    return a.dtype == b.dtype and a.shape == b.shape and a.tobytes() == b.tobytes()
@@ -0,0 +1,258 @@
+"""Independently re-read evidence, aggregate descriptive outcomes, and seal."""
+from collections import Counter
+import numpy as np
+import pandas as pd
+import pyarrow.parquet as pq
+from context import (ROOT, MODEL, EXP, AG, AG_MODEL, GROUPS, read, save, digest, check,
+                     integrity, seal, bit_equal)
+from run_audit import graph_view, first_ticks, temporal_relation
+from structure_metrics import aggregate_structure
+from validate_events import validate_batch
+
+
+def expected_inventory():
+    result = [(n, 0, 'fixture') for n in read(AG_MODEL / 'config.json')['fixtures']]
+    for row in read(AG / 'protocol/calibration-cases.json'):
+        result.append((row['name'], 0, 'calibration'))
+        if row['seed'] == 51101:
+            result.append((row['name'], 1, 'calibration'))
+    return result
+
+
+def verify_trial(item):
+    out = EXP / 'trials' / (item['case'] + '-r' + str(item['repeat']))
+    source = ROOT / item['source']
+    result = read(out / 'summary.json')
+    hashes = read(out / 'output-hashes.json')
+    assert len({r['path'] for r in hashes}) == len(hashes)
+    assert {r['path'] for r in hashes} == {p.name for p in out.iterdir() if p.is_file() and p.name != 'output-hashes.json'}
+    for row in hashes:
+        assert digest(out / row['path']) == row['sha256'] and (out / row['path']).stat().st_size == row['bytes']
+    assert (result['case'], result['repeat'], result['kind']) == (item['case'], item['repeat'], item['kind'])
+    assert result['pass_all'] and all(result['exact'].values()) and result['APL_source_bound_pass']
+    for name, sha in result['input_sha256'].items():
+        assert digest(source / name) == sha
+    spec = read(AG / 'cases' / item['case'] / 'spec.json')
+    assert result['steps'] == spec['steps'] and result['duration_ms'] == spec['duration_ms']
+    for key in ('mode', 'seed', 'odor_id'):
+        assert result[key] == spec.get(key)
+    graph = 'fixtures' if item['kind'] == 'fixture' else 'full'
+    _, incoming, _, codes, targets, positions, _ = graph_view(graph)
+    pn_table = pd.read_parquet(out / 'per-pn.parquet')
+    kc_table = pd.read_parquet(out / 'per-kc-apl-sources.parquet')
+    apl = read(out / 'apl-source-summary.json')
+    assert apl['pass_all'] and apl['theoretical_bound']['applicable']
+    assert all(v['bound_violations'] == 0 for v in apl['comparison'].values())
+    assert not apl['source_majority_robustness_proven']
+    with np.load(source / 'state.npz') as expected, np.load(out / 'replay-final.npz') as actual:
+        assert bit_equal(actual['target_globals'], targets)
+        for key in ('v', 'g', 'ref', 'counts'):
+            assert bit_equal(actual[key], expected[key][positions])
+        selected = np.isin(expected['neuron_idx'], targets)
+        for key in ('step', 'neuron_idx'):
+            assert bit_equal(actual[key], expected[key][selected])
+        assert bit_equal(pn_table.neuron_idx.to_numpy(), targets)
+        assert bit_equal(pn_table.spike_count.to_numpy(), actual['counts'])
+        assert bit_equal(pn_table.first_spike_tick.to_numpy(), actual['first_spike'])
+        assert bit_equal(actual['first_spike'], first_ticks(expected['step'], expected['neuron_idx'], targets))
+        kc = np.load(AG / 'apl-bundle/kc_globals.npy')
+        assert bit_equal(kc_table.neuron_idx.to_numpy(), kc)
+        assert bit_equal(kc_table.first_spike_tick.to_numpy(), first_ticks(expected['step'], expected['neuron_idx'], kc))
+        source_keys = expected['step'].astype(np.int64) * 166700 + expected['neuron_idx']
+        assert np.all(source_keys[1:] > source_keys[:-1])
+        source_time_keys = np.sort(expected['neuron_idx'].astype(np.int64) * spec['steps'] + expected['step'])
+        final_first = actual['first_spike'].copy()
+    assert np.array_equal(pn_table.first_spike_observed, pn_table.first_spike_tick >= 0)
+    for name in pn_table.select_dtypes(include='number'):
+        values = pn_table[name].to_numpy()
+        assert not np.isinf(values).any()
+        if np.isnan(values).any():
+            assert name.startswith('first_') and np.array_equal(np.isnan(values), ~pn_table.first_spike_observed.to_numpy())
+    assert np.isfinite(kc_table.select_dtypes(include='number').to_numpy()).all()
+    design = pn_table.is_design_target.to_numpy()
+    with np.load(AG / 'cases' / item['case'] / 'requests.npz') as req:
+        table = pd.read_csv(source / 'requests.csv')
+        assert np.array_equal(table.neuron_idx, req['neuron_idx']) and np.array_equal(table.tick, req['tick'])
+        requested = np.bincount(req['neuron_idx'], minlength=166700)[targets]
+        accepted = np.bincount(req['neuron_idx'][table.accepted.to_numpy().astype(bool)], minlength=166700)[targets]
+        assert np.array_equal(pn_table.requested, requested) and np.array_equal(pn_table.accepted_requests, accepted)
+    if item['kind'] == 'calibration':
+        with np.load(AG / 'cases' / item['case'] / 'pn-drive.npz') as pdz:
+            assert np.array_equal(design, np.isin(targets, pdz['targets']))
+    totals = np.zeros(len(targets), np.int64)
+    edge_totals = np.zeros(len(incoming.edge_id), np.int64)
+    count = 0
+    last_record_key = -1
+    for batch in pq.ParquetFile(out / 'accepted-prefirst-edge-events.parquet').iter_batches(batch_size=65536):
+        columns = {name: batch.column(name).to_numpy(zero_copy_only=False) for name in batch.schema.names}
+        checked = validate_batch(columns, edge_ids=incoming.edge_id, srcglobals=incoming.src_global,
+            dstglobals=targets[incoming.dst_local], weights=incoming.weights, target_globals=targets,
+            target_first=final_first, source_event_keys=source_keys)
+        totals += checked['per_target_count']
+        count += checked['count']
+        pos = np.searchsorted(incoming.edge_id, columns['edge_id'])
+        keys = columns['arrival_tick'].astype(np.int64) * 25582938 + columns['edge_id']
+        assert np.all(keys[1:] > keys[:-1]) and (not len(keys) or int(keys[0]) > last_record_key)
+        if len(keys):
+            last_record_key = int(keys[-1])
+        np.add.at(edge_totals, pos, 1)
+        assert np.array_equal(columns['incoming_edge_row'], pos)
+        assert np.array_equal(columns['source_group'], np.asarray(GROUPS)[codes[pos]])
+        assert np.array_equal(columns['target_is_design'], design[incoming.dst_local[pos]])
+    assert count == result['observer']['first_arrival_record_count']
+    expected_totals = sum((pn_table[g + '_accepted_nonzero_before_first_edges'].to_numpy() for g in GROUPS), start=np.zeros(len(targets), np.int64))
+    assert np.array_equal(totals, expected_totals)
+    edge_summary = pd.read_parquet(out / 'prefirst-edge-summary.parquet')
+    assert int(edge_summary.accepted_event_count.sum()) == count
+    assert len(edge_summary) == result['observer']['edge_summary_count']
+    selected_edges = np.flatnonzero(edge_totals)
+    assert np.array_equal(edge_summary.edge_id.to_numpy(), incoming.edge_id[selected_edges])
+    assert np.array_equal(edge_summary.accepted_event_count.to_numpy(), edge_totals[selected_edges])
+    # Independent completeness: initially ref=0 and no reset before the first spike.
+    # Every nonzero source event arriving strictly before that boundary must be present.
+    end = np.where(final_first[incoming.dst_local] >= 0, final_first[incoming.dst_local], spec['steps'])
+    source_start = incoming.src_global.astype(np.int64) * spec['steps']
+    source_end = source_start + np.maximum(end - 18, 0)
+    independent_counts = np.searchsorted(source_time_keys, source_end) - np.searchsorted(source_time_keys, source_start)
+    independent_counts[incoming.weights == 0] = 0
+    assert np.array_equal(edge_totals, independent_counts), 'Independent timed antecedent coverage mismatch'
+    # Validate aggregation receipts against per-neuron evidence instead of trusting JSON alone.
+    for stratum, mask in (('all_PN', np.ones(len(targets), bool)), ('design_PN', design),
+                          ('non_design_PN', ~design), ('never_active_PN', final_first < 0)):
+        agg = result['observer']['aggregates'][stratum]
+        assert agg['neurons'] == int(mask.sum()) and agg['spikes'] == int(pn_table.spike_count.to_numpy()[mask].sum())
+        for group, metrics in agg['source_groups'].items():
+            for metric, value in metrics.items():
+                summed = pn_table[group + '_' + metric].to_numpy()[mask].sum(dtype=np.longdouble)
+                if isinstance(value, int):
+                    assert int(summed) == value
+                else:
+                    # Serialization to per-neuron f64 and regrouping changes only final reporting arithmetic.
+                    assert abs(float(summed) - value) <= 64 * np.finfo(np.float64).eps * max(1., abs(value))
+    tick_table = pd.read_parquet(out / 'apl-per-tick.parquet')
+    assert len(tick_table) == spec['steps'] * 6
+    assert not tick_table[['tick', 'group', 'apl_index']].duplicated().any()
+    assert set(tick_table.group.unique()) == {'design_ALPN', 'non_design_ALPN', 'KC'}
+    for group in ('design_ALPN', 'non_design_ALPN', 'KC'):
+        metric = group + '_h_sum_mV'
+        observed = float(kc_table[metric].sum())
+        expected_sum = apl['groups'][group]['h_sum_mV']
+        assert abs(observed - expected_sum) <= 128 * spec['steps'] * np.finfo(np.float64).eps * max(1., abs(expected_sum))
+    return result, pn_table, kc_table, apl
+
+
+def main():
+    check()
+    assert not (EXP / 'audit/failure.json').exists(), 'Cannot promote a preserved failure'
+    inventory = read(EXP / 'protocol/inventory.json')
+    identities = [(r['case'], r['repeat'], r['kind']) for r in inventory]
+    assert identities == expected_inventory() and len(set(identities)) == 80
+    completed = read(EXP / 'audit/completed.json')
+    assert completed['pass_all']
+    ids = [(r['case'], r['repeat']) for r in completed['trials']]
+    assert len(ids) == len(set(ids)) == 80 and set(ids) == {(r[0], r[1]) for r in identities}
+    assert all(r['pass_all'] for r in completed['trials'])
+    repeats = completed['repeat_checks']
+    assert len(repeats) == len({r['case'] for r in repeats}) == 12
+    assert {r['case'] for r in repeats} == {r['case'] for r in inventory if r['repeat'] == 1}
+    assert all(r['pass_all'] and all(r['checks'].values()) for r in repeats)
+    reports, metrics, by_mode = [], [], {}
+    cal_rows = read(AG / 'protocol/calibration-cases.json')
+    odors = list(dict.fromkeys(r['odor_id'] for r in cal_rows))
+    assert len(odors) == 6
+    for item in inventory:
+        report, pn, kc, apl = verify_trial(item)
+        reports.append(report)
+        print('VERIFIED', item['case'], item['repeat'], flush=True)
+        if item['kind'] != 'calibration' or item['repeat'] != 0:
+            continue
+        metrics.append(dict(mode=report['mode'], odor_index=odors.index(report['odor_id']), seed=report['seed'],
+                            counts=pn.spike_count.to_numpy(), design_mask=pn.is_design_target.to_numpy()))
+        by_mode.setdefault(report['mode'], []).append((report, pn, kc, apl))
+    # Independently repeat the stored repeat gate without executing a trajectory.
+    for item in inventory:
+        if item['repeat'] != 1:
+            continue
+        a = EXP / 'trials' / (item['case'] + '-r0')
+        b = EXP / 'trials' / (item['case'] + '-r1')
+        for name in ('per-pn.parquet', 'prefirst-edge-summary.parquet', 'apl-per-tick.parquet', 'per-kc-apl-sources.parquet'):
+            assert pd.read_parquet(a / name).equals(pd.read_parquet(b / name))
+        assert digest(a / 'accepted-prefirst-edge-events.parquet') == digest(b / 'accepted-prefirst-edge-events.parquet')
+        assert read(a / 'apl-source-summary.json') == read(b / 'apl-source-summary.json')
+        with np.load(a / 'replay-final.npz') as aa, np.load(b / 'replay-final.npz') as bb:
+            assert set(aa.files) == set(bb.files) and all(bit_equal(aa[k], bb[k]) for k in aa.files)
+    structure = aggregate_structure(metrics)
+    structure['odor_index_to_id'] = odors
+    structure['ALPN_column_neuron_idx'] = np.load(AG / 'apl-bundle/pn_globals.npy').tolist()
+    save(EXP / 'audit/PN-odor-structure.json', structure)
+    aggregate = {}
+    for mode, trials in by_mode.items():
+        assert len(trials) == 30
+        sources = {}
+        for group in ('design_ALPN', 'non_design_ALPN', 'KC'):
+            sources[group] = {metric: sum(a['groups'][group][metric] for _, _, _, a in trials) for metric in (
+                'h_sum_mV', 'h_before_first_KC_sum_mV', 'h_never_fired_KC_sum_mV', 'h_before_first_any_KC_sum_mV')}
+            sources[group]['drive_sum'] = sum(sum(a['groups'][group]['cumulative_drive_by_apl']) for _, _, _, a in trials)
+        for group in sources:
+            for key in ('h_sum_mV', 'h_before_first_KC_sum_mV', 'h_before_first_any_KC_sum_mV', 'drive_sum'):
+                total = sum(s[key] for s in sources.values())
+                sources[group][key + '_fraction'] = None if total == 0 else sources[group][key] / total
+        source_inputs = {group: {metric: sum(r['observer']['aggregates']['non_design_PN']['source_groups'][group][metric]
+             for r, _, _, _ in trials) for metric in trials[0][0]['observer']['aggregates']['non_design_PN']['source_groups'][group]}
+             for group in GROUPS}
+        allpn = pd.concat([p for _, p, _, _ in trials], ignore_index=True)
+        allkc = pd.concat([k for _, _, k, _ in trials], ignore_index=True)
+        activated = allkc[allkc.first_spike_tick >= 0]
+        first_metrics = [r for r, _, _, _ in trials]
+        aggregate[mode] = dict(trials=30,
+            first_non_design_vs_first_KC=dict(Counter(r['first_non_design_vs_first_KC'] for r in first_metrics)),
+            first_non_design_PN_tick_range=[min(r['first_non_design_PN_tick'] for r in first_metrics), max(r['first_non_design_PN_tick'] for r in first_metrics)],
+            first_any_KC_tick_range=[min(r['first_any_KC_tick'] for r in first_metrics), max(r['first_any_KC_tick'] for r in first_metrics)],
+            each_active_KC_relation=dict(activated.first_non_design_relation.value_counts()),
+            each_active_KC_count=len(activated),
+            each_active_KC_has_strict_pre_first_nondesign_PN_edge=int((activated.non_design_ALPN_strict_pre_first_edge_events > 0).sum()),
+            PN_neuron_trials=len(allpn), PN_active_neuron_trials=int(allpn.first_spike_observed.sum()),
+            PN_spikes=int(allpn.spike_count.sum()), design_PN_spikes=int(allpn.loc[allpn.is_design_target, 'spike_count'].sum()),
+            nondesign_PN_spikes=int(allpn.loc[~allpn.is_design_target, 'spike_count'].sum()),
+            non_design_PN_input_sources=source_inputs, APL_sources=sources,
+            common_non_design_dimensions=structure['design']['common_non_design_count'],
+            counts_are_neuron_trials_not_distinct_neurons=True)
+        aggregate[mode]['each_active_KC_relation'] = {k: int(v) for k, v in aggregate[mode]['each_active_KC_relation'].items()}
+    after = integrity()
+    save(EXP / 'regression/old-integrity-after.json', after)
+    assert read(AG / 'regression/frozen-five.json')['pass_all']
+    result = dict(status='PASS-CONDITIONAL-PN-APL-SOURCE-AUDIT', pass_all=True,
+        exact_PN_trials=80, fixture_dense_pre_post_trials=8, CAL_event_final_trials=72, repeat_accounting_pass=12,
+        modes=aggregate, max_PN_voltage_ledger_residual_SI=max(r['observer']['voltage_decomposition']['maximum_reconstruction_residual_SI'] for r in reports),
+        CPU_audit_wall_seconds=sum(r['CPU_audit_wall_seconds'] for r in reports),
+        old_integrity_pass=all(r['pass'] for r in after.values()),
+        prior_frozen_five_pass=True, frozen_five_reexecuted_this_audit=False,
+        prior_frozen_five_sha256=digest(AG / 'regression/frozen-five.json'),
+        new_brain_simulation=False, GPU_used=False, training=False, heldout_access=False,
+        candidate_generated=False, learning_achieved=False, prior_CAL_failure_unchanged=True,
+        source_fraction_robustness_proven=False, counterfactual_causality_tested=False,
+        limitations=['Logged upstream spikes are conditioning inputs, not an independent whole-brain oracle',
+            'Real timed edges are accepted antecedents, not unique causes or necessity proofs',
+            'APL uses the unchanged nonnegative engineering input map, not signed PN-to-APL LIF drive',
+            'APL summed traces pass prior per-tick error bounds; accumulated shares remain descriptive',
+            'Shared PN activity does not imply absent odor information; no learning gate applied',
+            'No independently saved per-tick PN states for CAL; fixtures have full histories',
+            'Frozen five simulation executions were not repeated; previous sealed PASS checked by hash'])
+    save(EXP / 'audit/final-status.json', result)
+    with (EXP / 'REPORT.md').open('x') as f:
+        f.write('# Phase 4AI — conditional PN recruitment and APL source audit\n\n'
+            'Status: `PASS-CONDITIONAL-PN-APL-SOURCE-AUDIT`.\n\n'
+            '80 existing records; PN events/counts/final states exact; eight fixture histories exact; twelve repeats exact. '
+            'No new brain experiment, tuning, training, GPU, or learning candidate.\n\n'
+            'See audit/final-status.json and audit/PN-odor-structure.json. Accepted edges are timed antecedents, '
+            'not unique causes. Graded-APL cumulative source shares are descriptive, not causal or error-bounded majority claims. '
+            'Prior CAL failure remains unchanged. Frozen integrity passed; five reference simulations were not rerun.\n')
+    check()
+    assert sum(p.stat().st_size for p in EXP.rglob('*') if p.is_file()) < 2 * 1024**3
+    seal(MODEL)
+    seal(EXP)
+    print(result['status'], flush=True)
+
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,85 @@
+{
+  "root": "/data/digital-drosophila/models/male-cns-lif/pn-recruitment-audit-v1",
+  "files": [
+    {
+      "path": "README.md",
+      "bytes": 2504,
+      "sha256": "58f2f78b94aa783cc30b4b5e79ab003cc83f8a09b66c195d963bca6ee691e44c"
+    },
+    {
+      "path": "apl_sources.py",
+      "bytes": 19165,
+      "sha256": "61f4c35b464315d19bbffce534cfc037a0111725da0eb07ee53a41db81767fcb"
+    },
+    {
+      "path": "context.py",
+      "bytes": 3182,
+      "sha256": "a166da3d964b49ca28a013d3a3cf33df1607c76d4a6a53a8ca8e2d955aa92cb0"
+    },
+    {
+      "path": "finalize.py",
+      "bytes": 17774,
+      "sha256": "40e0f8a9e075db42ac63163de8362d808b9110f371e49f6d4088267eecf2eb4c"
+    },
+    {
+      "path": "pn_observer.py",
+      "bytes": 23294,
+      "sha256": "0663c1f723f614ebcdb666b46eaa49288aec26125d6aceb18cd237330a705968"
+    },
+    {
+      "path": "prepare.py",
+      "bytes": 7062,
+      "sha256": "9fbef01968c54637c9063bb1e2d7f45fdc97b886b3c25815a6146fc5f219164c"
+    },
+    {
+      "path": "publication.py",
+      "bytes": 14239,
+      "sha256": "7a79c499098b74163e7bb16adabcbc54e7069dafa204d0b99c7f4c03d79f8016"
+    },
+    {
+      "path": "run_audit.py",
+      "bytes": 16829,
+      "sha256": "a5a7861e8ced4739cd1a1f4314b8af7cff71168499f1ae6ed94ac71b481bcdd8"
+    },
+    {
+      "path": "structure_metrics.py",
+      "bytes": 10327,
+      "sha256": "669e91a862efea5f243a054c883bc1a183e96b0bcf02fac5f6972c4a8272a4cb"
+    },
+    {
+      "path": "test_apl_sources.py",
+      "bytes": 12733,
+      "sha256": "a7ac0f38877e0244a4bcc574264c72617ec487544a19dbc705e0c1e26c4be78d"
+    },
+    {
+      "path": "test_harness.py",
+      "bytes": 1452,
+      "sha256": "c2e66adb18d25264d21bfce16462ef698a3ba09d178908bef1068881d46ac1e7"
+    },
+    {
+      "path": "test_pn_observer.py",
+      "bytes": 8472,
+      "sha256": "fff3cb9da17d9d638e53a609a265d6531ed82824d10e06fcb3863edfeab7a267"
+    },
+    {
+      "path": "test_publication.py",
+      "bytes": 10514,
+      "sha256": "a3516aefa6a753f8fca6c5a4c2109ae4d65ce0ab0278e4795d537148f04495ff"
+    },
+    {
+      "path": "test_structure_metrics.py",
+      "bytes": 10003,
+      "sha256": "de1298a4a92facad97339e9a4cdb60ea2b7c30adc1a6f05274bd3be034239717"
+    },
+    {
+      "path": "test_validate_events.py",
+      "bytes": 6426,
+      "sha256": "d687ceb171c7dad77dfe2eb53524091a7ee02ddc04d9bbafb3b4a59b0d1eb66c"
+    },
+    {
+      "path": "validate_events.py",
+      "bytes": 6884,
+      "sha256": "32a33988c5c9619b2ff3553c2d508924a404ade17b526541a2ff113a61df68e4"
+    }
+  ]
+}
@@ -0,0 +1,315 @@
+"""CPU-only observer for the unchanged Phase 4AH replay_core callback.
+
+All input events are fixed observations, not interventions.  This module writes
+no files and never changes a callback array.  Incoming records are antecedents,
+not a selected cause, shortest path, necessity test, or whole-brain simulation.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+
+DELAY = 18
+COEFF_KEYS = ("gd", "c0", "cg", "cv", "threshold", "reset", "seed_volt")
+FLOAT_KEYS = ("old_v", "old_g", "v_integrated", "g_decayed", "v_threshold",
+              "v_after_reset", "g_after_reset", "v_pre_apl", "g_pre_apl", "delta_si", "v", "g")
+INT_KEYS = ("ref_before", "ref_after_reset", "ref_pre_apl", "ref")
+BOOL_KEYS = ("available", "request", "request_accepted", "request_rejected", "fired")
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def bit_equal(a, b):
+    return 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))
+
+
+class PNObserver:
+    def __init__(self, target_globals, design_target_globals, incoming, edge_groups,
+                 group_names, coeff, steps, *, max_first_event_rows, event_sink=None):
+        targets = np.asarray(target_globals)
+        require(targets.dtype == np.int32 and targets.ndim == 1 and len(targets) > 0 and
+                np.all((targets >= 0) & (targets < 166700)) and np.all(np.diff(targets) > 0),
+                "Targets must be sorted unique global int32 IDs")
+        design = np.asarray(design_target_globals)
+        require(design.dtype == np.int32 and design.ndim == 1 and len(np.unique(design)) == len(design) and
+                np.isin(design, targets).all(), "Design target IDs must be unique int32 subset of observed PNs")
+        require(type(steps) is int and steps > 0, "steps must be a positive integer")
+        require(type(max_first_event_rows) is int and max_first_event_rows > 0, "Explicit positive row budget required")
+        require(event_sink is None or callable(event_sink), "event_sink must be callable or None")
+        names = tuple(group_names)
+        require(names and all(isinstance(name, str) and name for name in names) and len(set(names)) == len(names),
+                "Source group names must be nonempty and unique")
+        codes = np.asarray(edge_groups)
+        e = len(incoming.edge_id)
+        require(codes.ndim == 1 and codes.shape == (e,) and codes.dtype.kind in "iu" and
+                np.all((codes >= 0) & (codes < len(names))), "Invalid source-group code per incoming edge")
+        require(incoming.target_count == len(targets) and incoming.weights.dtype == np.float64 and
+                np.isfinite(incoming.weights).all(), "Incoming index/weights mismatch")
+        require(all(name in coeff and np.isfinite(coeff[name]) for name in COEFF_KEYS), "Missing/nonfinite coefficient")
+        self.targets = targets.copy()
+        self.design = np.isin(targets, design)
+        self.incoming, self.groups, self.names = incoming, codes.astype(np.int64, copy=True), names
+        self.coeff = {name: np.float64(coeff[name]) for name in COEFF_KEYS}
+        self.steps, self.n = steps, len(targets)
+        self.max_rows, self.sink = max_first_event_rows, event_sink
+        self.callback_count, self.record_count = 0, 0
+        self.first_arrival_records = []
+        self.first = np.full(self.n, -1, np.int32)
+        self.first_request = np.full(self.n, -1, np.int32)
+        self.first_accepted_request = np.full(self.n, -1, np.int32)
+        self.first_positive_arrival = np.full(self.n, -1, np.int32)
+        self.counts = np.zeros(self.n, np.int32)
+        self.requested = np.zeros(self.n, np.int64)
+        self.request_accepted = np.zeros(self.n, np.int64)
+        self.request_rejected = np.zeros(self.n, np.int64)
+        self.first_request_coincident = np.zeros(self.n, bool)
+        self.first_state = {name: np.full(self.n, np.nan, np.float64) for name in
+            ("old_v", "old_g", "v_integrated", "v_threshold", "threshold_margin", "ref_before")}
+        shape = (len(names), self.n)
+        self.stats = {name: np.zeros(shape, np.int64) for name in
+            ("due_edges", "accepted_edges", "rejected_edges", "accepted_zero_edges", "rejected_zero_edges",
+             "accepted_positive_edges", "accepted_negative_edges", "rejected_positive_edges", "rejected_negative_edges",
+             "accepted_nonzero_before_first_edges", "accepted_positive_before_first_edges", "accepted_negative_before_first_edges")}
+        self.sums = {name: np.zeros(shape, np.longdouble) for name in
+            ("accepted_positive_V", "accepted_negative_abs_V", "rejected_positive_V", "rejected_negative_abs_V",
+             "accepted_positive_before_first_V", "accepted_negative_before_first_abs_V")}
+        self.edge_prefirst_count = np.zeros(e, np.int64)
+        self.edge_first_arrival = np.full(e, -1, np.int32)
+        self.edge_last_arrival = np.full(e, -1, np.int32)
+        # Non-feedback signed-source decomposition.  Residual corrections are
+        # explicit lanes, never silently assigned to an anatomical population.
+        self.lane_names = [name + "/positive_weight" for name in names] + [name + "/negative_weight" for name in names]
+        self.lane_names += ["initial_and_affine_baseline", "request_or_reset", "roundoff_residual"]
+        self.baseline_lane, self.request_lane, self.round_lane = 2 * len(names), 2 * len(names) + 1, 2 * len(names) + 2
+        self.lv = np.zeros((len(self.lane_names), self.n), np.longdouble)
+        self.lg = np.zeros_like(self.lv)
+        self.first_integrated_lanes = np.full_like(self.lv, np.nan)
+        self.first_threshold_lanes = np.full_like(self.lv, np.nan)
+        self.first_ledger_residual = np.full(self.n, np.nan, np.longdouble)
+        self.integration_roundoff_v = np.zeros(self.n, np.longdouble)
+        self.integration_roundoff_g = np.zeros(self.n, np.longdouble)
+        self.arrival_roundoff_g = np.zeros(self.n, np.longdouble)
+        self.max_ledger_residual = np.longdouble(0)
+        self.previous = None
+        self.finished = False
+
+    def _validate_stage(self, tick, s):
+        require(not self.finished and type(tick) in (int, np.int32, np.int64) and
+                int(tick) == self.callback_count and tick < self.steps, "Missing, duplicate or out-of-order callback tick")
+        for names, dtype in ((FLOAT_KEYS, np.float64), (INT_KEYS, np.int32), (BOOL_KEYS, bool)):
+            for name in names:
+                require(name in s and isinstance(s[name], np.ndarray) and s[name].shape == (self.n,) and
+                        s[name].dtype == dtype, "Missing/wrong callback array: " + name)
+                require(np.isfinite(s[name]).all(), "Nonfinite callback array: " + name)
+        require("h32" in s and s["h32"].dtype == np.float32 and s["h32"].shape == (self.n,) and
+                np.all(s["h32"] == 0) and np.all(s["delta_si"] == 0), "PN observer requires zero graded APL h/delta")
+        require(bit_equal(s["g"], s["g_pre_apl"]) and bit_equal(s["v"], s["v_pre_apl"]) and
+                bit_equal(s["ref"], s["ref_pre_apl"]), "Nonzero or unexpected post-APL PN state change")
+        require(np.all((s["ref_before"] >= 0) & (s["ref_before"] <= 22)) and
+                np.all((s["ref"] >= 0) & (s["ref"] <= 22)), "Refractory range mismatch")
+        require(np.array_equal(s["available"], s["ref_before"] <= 1), "Availability does not match pre-step refractory")
+        require(np.array_equal(s["request_accepted"], s["request"] & s["available"]) and
+                np.array_equal(s["request_rejected"], s["request"] & ~s["available"]), "Request accounting mismatch")
+        require(not np.any(s["request"] & ~self.design), "Observed request outside frozen odor design targets")
+        require(np.array_equal(s["fired"], s["available"] & (s["v_threshold"] > self.coeff["threshold"])),
+                "Callback firing does not match strict threshold")
+        if self.previous is not None:
+            require(all(bit_equal(s[key], self.previous[old]) for key, old in
+                        (("old_v", "v"), ("old_g", "g"), ("ref_before", "ref"))), "Discontinuous callback state")
+        due = s.get("due_edge_indices")
+        require(isinstance(due, np.ndarray) and due.dtype == np.int64 and due.ndim == 1 and
+                np.all((due >= 0) & (due < len(self.incoming.edge_id))) and np.all(np.diff(due) > 0),
+                "Incoming queue must retain unique canonical edge rows")
+        require("due_edge_id" in s and bit_equal(s["due_edge_id"], self.incoming.edge_id[due]), "Incoming edge-ID mismatch")
+        accepted = s.get("arrival_accepted")
+        require(isinstance(accepted, np.ndarray) and accepted.dtype == bool and accepted.shape == due.shape and
+                np.array_equal(accepted, s["ref_after_reset"][self.incoming.dst_local[due]] == 0), "Arrival guard mismatch")
+        require(tick >= DELAY or not len(due), "Incoming event before the fixed 18-step delay")
+        return due, accepted
+
+    def __call__(self, tick, s):
+        due, accepted = self._validate_stage(tick, s)
+        tick = int(tick)
+        dst, weights, groups = self.incoming.dst_local[due], self.incoming.weights[due], self.groups[due]
+        before = self.first < 0
+        first_now = before & s["fired"]
+        # Arrivals happen AFTER this tick's threshold.  Same-tick arrivals are
+        # never antecedents to a first spike, even if malformed data said accepted.
+        strictly_before = before[dst] & ~s["fired"][dst]
+        record_mask = accepted & (weights != 0) & strictly_before
+        new_records = int(np.count_nonzero(record_mask))
+        require(self.record_count + new_records <= self.max_rows,
+                "First-arrival record resource limit exceeded; no truncation or event selection permitted")
+        if self.previous is None:
+            self.lv[self.baseline_lane] = s["old_v"].astype(np.longdouble)
+            self.lg[self.baseline_lane] = s["old_g"].astype(np.longdouble)
+        available = s["available"]
+        # Use old lane-g for V, as in the author update; do NOT use decayed g.
+        self.lv[:, available] = (np.longdouble(self.coeff["cv"]) * self.lv[:, available] +
+                                  np.longdouble(self.coeff["cg"]) * self.lg[:, available])
+        self.lv[self.baseline_lane, available] += np.longdouble(self.coeff["c0"])
+        self.lg[:, available] *= np.longdouble(self.coeff["gd"])
+        rv = s["v_integrated"].astype(np.longdouble) - self.lv.sum(axis=0, dtype=np.longdouble)
+        rg = s["g_decayed"].astype(np.longdouble) - self.lg.sum(axis=0, dtype=np.longdouble)
+        self.integration_roundoff_v += rv
+        self.integration_roundoff_g += rg
+        self.lv[self.round_lane] += rv
+        self.lg[self.round_lane] += rg
+        self.first_integrated_lanes[:, first_now] = self.lv[:, first_now]
+        req = s["request_accepted"]
+        self.lv[:, req] = 0
+        self.lv[self.request_lane, req] = np.longdouble(self.coeff["seed_volt"])
+        self.first_threshold_lanes[:, first_now] = self.lv[:, first_now]
+        vres = s["v_threshold"].astype(np.longdouble) - self.lv.sum(axis=0, dtype=np.longdouble)
+        self.first_ledger_residual[first_now] = vres[first_now]
+        self.max_ledger_residual = max(self.max_ledger_residual, np.max(np.abs(vres), initial=np.longdouble(0)))
+        for name in self.first_state:
+            values = (self.coeff["threshold"] - s["v_threshold"]) if name == "threshold_margin" else s[name]
+            self.first_state[name][first_now] = values[first_now]
+        self.first_request_coincident[first_now] = req[first_now]
+        self.first[first_now] = tick
+        for array, selected in ((self.first_request, s["request"]), (self.first_accepted_request, req)):
+            array[(array < 0) & selected] = tick
+        self.requested += s["request"].astype(np.int64)
+        self.request_accepted += req.astype(np.int64)
+        self.request_rejected += s["request_rejected"].astype(np.int64)
+        self.counts += s["fired"].astype(np.int32)
+        fired = s["fired"]
+        self.lv[:, fired] = 0
+        self.lv[self.request_lane, fired] = np.longdouble(self.coeff["reset"])
+        self.lg[:, fired] = 0
+        positive, negative, zero = weights > 0, weights < 0, weights == 0
+        picks = {"due_edges": np.ones(len(due), bool), "accepted_edges": accepted,
+                 "rejected_edges": ~accepted, "accepted_zero_edges": accepted & zero,
+                 "rejected_zero_edges": ~accepted & zero,
+                 "accepted_positive_edges": accepted & positive, "accepted_negative_edges": accepted & negative,
+                 "rejected_positive_edges": ~accepted & positive, "rejected_negative_edges": ~accepted & negative,
+                 "accepted_nonzero_before_first_edges": record_mask,
+                 "accepted_positive_before_first_edges": record_mask & positive,
+                 "accepted_negative_before_first_edges": record_mask & negative}
+        for name, mask in picks.items():
+            np.add.at(self.stats[name], (groups[mask], dst[mask]), 1)
+        for name, mask, sign in (
+            ("accepted_positive_V", accepted & positive, 1), ("accepted_negative_abs_V", accepted & negative, -1),
+            ("rejected_positive_V", ~accepted & positive, 1), ("rejected_negative_abs_V", ~accepted & negative, -1),
+            ("accepted_positive_before_first_V", record_mask & positive, 1),
+            ("accepted_negative_before_first_abs_V", record_mask & negative, -1)):
+            np.add.at(self.sums[name], (groups[mask], dst[mask]), sign * weights[mask].astype(np.longdouble))
+        for offset, mask in ((0, accepted & positive), (len(self.names), accepted & negative)):
+            np.add.at(self.lg, (groups[mask] + offset, dst[mask]), weights[mask].astype(np.longdouble))
+        ag = s["g_pre_apl"].astype(np.longdouble) - self.lg.sum(axis=0, dtype=np.longdouble)
+        self.arrival_roundoff_g += ag
+        self.lg[self.round_lane] += ag
+        gres = s["g"].astype(np.longdouble) - self.lg.sum(axis=0, dtype=np.longdouble)
+        self.max_ledger_residual = max(self.max_ledger_residual, np.max(np.abs(gres), initial=np.longdouble(0)))
+        require(np.isfinite(self.lv).all() and np.isfinite(self.lg).all(), "Nonfinite non-feedback lineage ledger")
+        positive_targets = np.unique(dst[accepted & positive])
+        self.first_positive_arrival[positive_targets[self.first_positive_arrival[positive_targets] < 0]] = tick
+        selected_rows = due[record_mask]
+        np.add.at(self.edge_prefirst_count, selected_rows, 1)
+        self.edge_first_arrival[selected_rows[self.edge_first_arrival[selected_rows] < 0]] = tick
+        self.edge_last_arrival[selected_rows] = tick
+        rows = []
+        for edge in selected_rows:
+            target = int(self.incoming.dst_local[edge])
+            weight = float(self.incoming.weights[edge])
+            rows.append({"edge_id": int(self.incoming.edge_id[edge]), "incoming_edge_row": int(edge),
+                "source_neuron_idx": int(self.incoming.src_global[edge]), "target_neuron_idx": int(self.targets[target]),
+                "source_group": self.names[int(self.groups[edge])], "source_spike_tick": tick - DELAY,
+                "arrival_tick": tick, "target_is_design": bool(self.design[target]), "accepted": True,
+                "weight_SI": weight, "weight_sign": 1 if weight > 0 else -1,
+                "ref_before": int(s["ref_before"][target]), "ref_at_arrival": int(s["ref_after_reset"][target]),
+                "available_at_integration": bool(s["available"][target]),
+                "old_v_SI": float(s["old_v"][target]), "old_g_SI": float(s["old_g"][target]),
+                "v_integrated_SI": float(s["v_integrated"][target]), "v_prethreshold_SI": float(s["v_threshold"][target]),
+                "threshold_margin_SI": float(self.coeff["threshold"] - s["v_threshold"][target]),
+                "g_before_arrivals_SI": float(s["g_after_reset"][target]),
+                "record_scope": "accepted nonzero input strictly before any observed first spike; join final first_spike_tick"})
+        if rows:
+            if self.sink is None:
+                self.first_arrival_records.extend(rows)
+            else:
+                self.sink(rows)
+        self.record_count += len(rows)
+        self.previous = {name: s[name].copy() for name in ("v", "g", "ref")}
+        self.callback_count += 1
+
+    def edge_summary(self):
+        """All edges with stored pre-first records, including never-active PNs."""
+        selected = np.flatnonzero(self.edge_prefirst_count)
+        dst = self.incoming.dst_local[selected]
+        return {"edge_id": self.incoming.edge_id[selected].copy(),
+                "source_neuron_idx": self.incoming.src_global[selected].copy(), "target_neuron_idx": self.targets[dst].copy(),
+                "source_group": np.asarray(self.names, dtype=str)[self.groups[selected]],
+                "weight_SI": self.incoming.weights[selected].copy(),
+                "accepted_event_count": self.edge_prefirst_count[selected].copy(),
+                "nominal_weight_times_event_count_SI": (self.incoming.weights[selected].astype(np.longdouble) *
+                    self.edge_prefirst_count[selected]).astype(np.float64),
+                "first_arrival_tick": self.edge_first_arrival[selected].copy(),
+                "last_arrival_tick": self.edge_last_arrival[selected].copy(),
+                "target_first_spike_tick": self.first[dst].copy(), "target_is_design": self.design[dst].copy()}
+
+    def finish(self, result):
+        """Return (per-PN arrays, JSON report); caller verifies original events/state.
+
+        first_* floating fields are NaN when first_spike_observed is false.
+        They must not be imputed to zero or interpreted as observed voltages.
+        """
+        require(not self.finished and self.callback_count == self.steps and self.previous is not None, "Observer did not cover every tick")
+        require(bit_equal(result["target_globals"], self.targets) and bit_equal(result["first_spike"], self.first) and
+                bit_equal(result["counts"], self.counts), "Replay result identity/count/first spike differs from observer")
+        require(all(bit_equal(result[name], self.previous[name]) for name in ("v", "g", "ref")), "Replay final state differs from last callback")
+        require(int(self.edge_prefirst_count.sum()) == self.record_count ==
+                int(self.stats["accepted_nonzero_before_first_edges"].sum()), "Pre-first event coverage mismatch")
+        require(np.array_equal(self.stats["due_edges"], self.stats["accepted_edges"] + self.stats["rejected_edges"]),
+                "Due/accepted/rejected coverage mismatch")
+        data = {"neuron_idx": self.targets.copy(), "is_design_target": self.design.copy(),
+                "spike_count": self.counts.copy(), "first_spike_tick": self.first.copy(), "first_spike_observed": self.first >= 0,
+                "first_request_tick": self.first_request.copy(), "first_accepted_request_tick": self.first_accepted_request.copy(),
+                "first_accepted_positive_arrival_tick": self.first_positive_arrival.copy(),
+                "requested": self.requested.copy(), "accepted_requests": self.request_accepted.copy(),
+                "rejected_requests": self.request_rejected.copy(), "first_spike_coincident_with_accepted_request": self.first_request_coincident.copy(),
+                "first_voltage_ledger_residual_SI": self.first_ledger_residual.astype(np.float64),
+                "integration_roundoff_v_SI": self.integration_roundoff_v.astype(np.float64),
+                "integration_roundoff_g_SI": self.integration_roundoff_g.astype(np.float64),
+                "arrival_roundoff_g_SI": self.arrival_roundoff_g.astype(np.float64)}
+        data.update({"first_" + name + ("_SI" if name != "ref_before" else ""): value.copy()
+                     for name, value in self.first_state.items()})
+        for gi, name in enumerate(self.names):
+            for key, value in {**self.stats, **self.sums}.items():
+                data[name + "_" + key] = value[gi].copy() if key in self.stats else value[gi].astype(np.float64)
+        for index, name in enumerate(self.lane_names):
+            data["first_integrated_V_from_" + name] = self.first_integrated_lanes[index].astype(np.float64)
+            data["first_prethreshold_V_from_" + name] = self.first_threshold_lanes[index].astype(np.float64)
+        aggregates = {}
+        for name, mask in (("all_PN", np.ones(self.n, bool)), ("design_PN", self.design),
+                           ("non_design_PN", ~self.design), ("never_active_PN", self.first < 0)):
+            aggregates[name] = {"neurons": int(mask.sum()), "active": int(np.count_nonzero(mask & (self.first >= 0))),
+                "spikes": int(self.counts[mask].sum()), "source_groups": {
+                    group: {**{key: int(value[gi, mask].sum()) for key, value in self.stats.items()},
+                            **{key: float(value[gi, mask].sum(dtype=np.longdouble)) for key, value in self.sums.items()}}
+                    for gi, group in enumerate(self.names)}}
+        report = {"pass_all": True, "scope": "Observer coverage/internal consistency only; caller must verify recorded PN events and final state exactly",
+                  "callback_count": self.callback_count, "steps": self.steps, "PN_count": self.n,
+                  "source_group_names": list(self.names), "first_arrival_record_count": self.record_count,
+                  "first_arrival_record_limit": self.max_rows, "records_truncated": False,
+                  "edge_summary_count": int(np.count_nonzero(self.edge_prefirst_count)), "aggregates": aggregates,
+                  "time_contract": "source_spike_tick=arrival_tick-18; arrivals follow threshold; first-spike tick arrivals excluded",
+                  "record_contract": "Every accepted nonzero edge event strictly before first spike for every PN; never-active PNs retain full-window records with final first=-1",
+                  "sum_contract": "Observer nominal signed weight sums, not the sequentially rounded runtime g; weight-times-count edge summaries are descriptive",
+                  "voltage_decomposition": {"nonfeedback": True, "precision": str(np.dtype(np.longdouble)),
+                      "lanes": list(self.lane_names), "maximum_reconstruction_residual_SI": float(self.max_ledger_residual),
+                      "roundoff_lane_explicit": True, "fitted_tolerance": False,
+                      "reset_clears_prior_lanes": True, "request_override_has_separate_lane": True,
+                      "first_integrated_is_before_request_override": True,
+                      "never_spiked_first_fields_are_NaN": True,
+                      "threshold_crossing_contributions_are_not_necessity_or_unique_cause": True},
+                  "graded_APL_to_PN": "Required h32=0 and delta_si=0 every tick; fast APL weights supplied already frozen-masked by caller",
+                  "new_brain_run": False, "parameter_changes": False, "shortest_path_claim": False,
+                  "unique_cause_claim": False, "whole_brain_intervention_claim": False}
+        self.finished = True
+        return data, report
@@ -0,0 +1,93 @@
+"""Register fixed conditional audit before reading PN contribution results."""
+from datetime import datetime, timezone
+import platform
+import subprocess
+import sys
+import numpy as np
+import pandas as pd
+from context import (ROOT, MODEL, EXP, AH, AH_MODEL, AG, AG_MODEL, META, COEFF,
+                     GROUPS, read, save, digest, sources, integrity, load_module)
+
+
+def main():
+    assert not EXP.exists() or not any(EXP.iterdir()), 'Populated audit directory must not be reused'
+    assert read(AH / 'audit/final-status.json')['status'] == 'PASS-CONDITIONAL-KC-DRIVE-AUDIT'
+    assert read(AG / 'audit/final-status.json')['numerical_gate_pass']
+    for sub in ('protocol', 'regression', 'trials', 'audit', 'logs'):
+        (EXP / sub).mkdir(parents=True, exist_ok=False)
+    test_command = [sys.executable, '-B', '-m', 'unittest', '-v',
+                    'test_pn_observer', 'test_apl_sources', 'test_structure_metrics', 'test_harness',
+                    'test_validate_events', 'test_publication']
+    tested = subprocess.run(test_command, cwd=MODEL, capture_output=True, text=True)
+    with (EXP / 'regression/unit-tests.log').open('x') as f:
+        f.write(tested.stdout + tested.stderr)
+    save(EXP / 'regression/unit-tests.json', dict(command=test_command, exit_code=tested.returncode,
+         pass_all=tested.returncode == 0, sha256=digest(EXP / 'regression/unit-tests.log')))
+    assert tested.returncode == 0
+    paths = [AH / 'manifest.json', AH / 'checksums.sha256', AH_MODEL / 'manifest.json',
+             AH_MODEL / 'checksums.sha256', AH_MODEL / 'replay_core.py', AH_MODEL / 'populations.py',
+             AG / 'manifest.json', AG / 'checksums.sha256', AG_MODEL / 'manifest.json',
+             AG_MODEL / 'checksums.sha256', META, COEFF,
+             ROOT / 'datasets/male-cns-v1.0/processed/neuron-only/gpu/csr-weights.int64.npy']
+    save(EXP / 'protocol/preregistered.json', dict(
+        timestamp_utc=datetime.now(timezone.utc).isoformat(), sources=sources(),
+        inputs=[dict(path=str(p.relative_to(ROOT)), sha256=digest(p)) for p in paths],
+        parent_commit=subprocess.check_output(['git', '-C', str(ROOT), 'rev-parse', 'HEAD'], text=True).strip(),
+        scope='Post-outcome conditional PN/APL source audit; no new whole-brain simulation or learning',
+        previous_KC_outcome_known=True, before_PN_contribution_accounting=True,
+        new_GPU_use=False, max_threads=4, output_budget_bytes=2 * 1024**3,
+        per_trial_first_arrival_row_limit=1000000, truncation_allowed=False,
+        exact_gate='All PN events/counts/final v,g,ref; fixture pre/post histories; 12 deterministic accounting repeats',
+        APL_gate='Source float64 mathematical accounting within prior standard-float32 analytic roundoff bounds; not CUDA bitwise replay',
+        hypotheses={
+            'temporal_precedence': 'For every trial and every KC first spike, non-design PN spike must be strictly earlier; equals/after/absent retained',
+            'direct_PN_KC_arrival': 'PN source tick+18 strictly less than KC first spike; same tick arrival is after threshold',
+            'APL_source_precedence': 'Group h write at tick s affects only KC threshold ticks greater than s',
+            'APL_share': 'Cumulative group shares are descriptive float64; no accumulated source-share error bound or robust-majority claim',
+            'odor_structure': 'Fixed 686-dimensional counts; secondary fixed outside-six-odor-design-union subset; no activity-fraction or learning gate'},
+        attribution_limits=['Accepted edge antecedents are not proof of single-neuron necessity or intervention causality',
+            'Non-design means not in static design targets; does not mean noise or biologically incorrect',
+            'Source-V lanes are non-feedback accounting with initial/constant/request/reset/roundoff lanes',
+            'APL input matrix is legacy nonnegative raw-contact-normalized engineering mapping, not signed LIF current',
+            'No CAL per-tick target state was independently saved; final states and events only',
+            'Fixtures generated h for 4064 KC but applied only to fixture KC'],
+        python=sys.version, numpy=np.__version__, pandas=pd.__version__, machine=platform.machine(),
+        longdouble_mantissa_bits=int(np.finfo(np.longdouble).nmant)))
+    save(EXP / 'regression/old-integrity-before.json', integrity())
+    population = load_module('frozen_population_ai', AH_MODEL / 'populations.py')
+    assert digest(META) == population.METADATA_SHA256
+    meta = pd.read_parquet(META).sort_values('neuron_idx').reset_index(drop=True)
+    labels, report = population.classify(meta)
+    assert report['pass_all']
+    for name, count in (('ALLN', 420), ('ALIN', 24), ('ALON', 14), ('olfactory', 2639)):
+        selected = (meta.annotation_class == name).fillna(False).to_numpy(dtype=bool)
+        assert int(selected.sum()) == count and np.all(labels[selected] == 'other')
+        labels[selected] = 'olfactory_sensory' if name == 'olfactory' else name
+    assert set(np.unique(labels)).issubset(GROUPS)
+    for label, fname, count in (('KC', 'kc_globals.npy', 4064), ('APL', 'apl_globals.npy', 2), ('ALPN', 'pn_globals.npy', 686)):
+        observed = np.flatnonzero(labels == label).astype(np.int32)
+        assert len(observed) == count and np.array_equal(observed, np.load(AG / 'apl-bundle' / fname))
+    report.update(refined_exact_class_counts={label: int((labels == label).sum()) for label in GROUPS},
+        refinement='AH anatomical classifier, then exact ALLN/ALIN/ALON/olfactory classes split only from other; no name-prefix guessing')
+    save(EXP / 'protocol/population-audit.json', report)
+    save(EXP / 'protocol/metadata-schema.json', {c: dict(dtype=str(meta[c].dtype), nulls=int(meta[c].isna().sum())) for c in meta})
+    meta[['neuron_idx', 'body_id', 'annotation_class', 'annotation_type', 'neurotransmitter']].assign(
+        audit_source_group=labels).to_parquet(EXP / 'protocol/neuron-source-groups.parquet', index=False)
+    inventory = [dict(case=name, repeat=0, kind='fixture') for name in read(AG_MODEL / 'config.json')['fixtures']]
+    for row in read(AG / 'protocol/calibration-cases.json'):
+        inventory.append(dict(case=row['name'], repeat=0, kind='calibration'))
+        if row['seed'] == 51101:
+            inventory.append(dict(case=row['name'], repeat=1, kind='calibration'))
+    assert len(inventory) == len({(r['case'], r['repeat']) for r in inventory}) == 80
+    for row in inventory:
+        source = AG / 'gpu' / (row['case'] + '-r' + str(row['repeat']))
+        assert read(source / 'summary.json')['complete']
+        row['source'] = str(source.relative_to(ROOT))
+    save(EXP / 'protocol/inventory.json', inventory)
+    save(EXP / 'protocol/prepared-hashes.json', [dict(path=str(p.relative_to(EXP)), sha256=digest(p))
+         for p in sorted((EXP / 'protocol').iterdir()) if p.is_file() and p.name != 'prepared-hashes.json'])
+    print('REGISTERED fixed 80 existing records; no new brain simulation', flush=True)
+
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,270 @@
+"""Publish small evidence only after independent verification of both seals.
+
+No prior verification helper is imported or executed.  Publishing verifies
+bytes and declared completion; it does not rerun or certify a scientific gate.
+Every destination is exclusive.  An interrupted publication is retained, not
+deleted, overwritten, or silently resumed.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path, PurePosixPath
+import re
+import shutil
+import stat
+
+
+ROOT = Path('/data/digital-drosophila')
+MODEL_RELATIVE = Path('models/male-cns-lif/pn-recruitment-audit-v1')
+EXPERIMENT_RELATIVE = Path('experiments/phase4ai-pn-recruitment-audit')
+REGISTRY_RELATIVE = Path('registry/phase4ai-pn-recruitment-audit')
+FINAL_STATUS = 'PASS-CONDITIONAL-PN-APL-SOURCE-AUDIT'
+MAX_EVIDENCE_BYTES = 4 * 1024 ** 2
+EVIDENCE_SUFFIXES = frozenset(('.json', '.csv', '.md', '.log', '.sha256'))
+CONTROLS = frozenset(('manifest.json', 'checksums.sha256'))
+SHA256 = re.compile(r'^[0-9a-f]{64}$')
+
+
+def _require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def _unique_object(pairs):
+    result = {}
+    for name, value in pairs:
+        _require(name not in result, 'Duplicate JSON object key: ' + name)
+        result[name] = value
+    return result
+
+
+def _bad_constant(value):
+    raise ValueError('Nonfinite JSON constant: ' + value)
+
+
+def _json_bytes(data):
+    return json.loads(data.decode('utf-8'), object_pairs_hook=_unique_object,
+                      parse_constant=_bad_constant)
+
+
+def _digest(path):
+    checksum = hashlib.sha256()
+    with Path(path).open('rb') as handle:
+        for block in iter(lambda: handle.read(8 << 20), b''):
+            checksum.update(block)
+    return checksum.hexdigest()
+
+
+def _write_json(path, value):
+    with Path(path).open('x', encoding='utf-8') as handle:
+        json.dump(value, handle, indent=2, ensure_ascii=False, allow_nan=False)
+        handle.write('\n')
+
+
+def _relative_name(value):
+    _require(isinstance(value, str) and bool(value) and '\\' not in value and
+             '\x00' not in value and '\n' not in value and '\r' not in value,
+             'Invalid manifest/checksum relative 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 or escaping relative path: ' + value)
+    return path
+
+
+def _regular_file(base, relative):
+    rel = _relative_name(relative)
+    target = base
+    for part in rel.parts:
+        target = target / part
+        _require(not target.is_symlink(), 'Symlink not allowed in sealed path: ' + str(target))
+    _require(target.exists() and stat.S_ISREG(target.stat().st_mode),
+             'Missing/nonregular sealed file: ' + str(target))
+    _require(target.resolve().is_relative_to(base), 'Sealed file escapes its root')
+    return target
+
+
+def verify_seal(directory):
+    """Independently verify every listed byte/hash and the checksum inventory.
+
+    Unlisted files fail, apart from __pycache__ files explicitly excluded by
+    the producer's seal contract.  Such caches are counted, never published.
+    The checksum file must describe exactly the manifest payload plus the
+    manifest itself.  Symlinks, duplicate paths and path traversal fail.
+    """
+    supplied = Path(directory)
+    _require(supplied.is_absolute() and supplied.is_dir() and not supplied.is_symlink(),
+             'A sealed root must be an absolute real directory')
+    base = supplied.resolve(strict=True)
+    manifest_path = _regular_file(base, 'manifest.json')
+    checksums_path = _regular_file(base, 'checksums.sha256')
+    manifest_bytes = manifest_path.read_bytes()
+    manifest_sha = hashlib.sha256(manifest_bytes).hexdigest()
+    manifest = _json_bytes(manifest_bytes)
+    _require(isinstance(manifest, dict) and set(manifest) == {'root', 'files'}, 'Unexpected seal manifest schema')
+    _require(isinstance(manifest['root'], str) and Path(manifest['root']).is_absolute() and
+             Path(manifest['root']).resolve(strict=True) == base, 'Manifest names another root')
+    _require(isinstance(manifest['files'], list) and bool(manifest['files']), 'Empty/invalid manifest payload')
+    rows, expected = [], {}
+    for row in manifest['files']:
+        _require(isinstance(row, dict) and set(row) == {'path', 'bytes', 'sha256'}, 'Invalid manifest file row')
+        relative = row['path']
+        parsed = _relative_name(relative)
+        _require(relative not in CONTROLS and '__pycache__' not in parsed.parts,
+                 'Control/cache file incorrectly listed as payload: ' + relative)
+        _require(relative not in expected, 'Duplicate manifest path: ' + relative)
+        _require(type(row['bytes']) is int and row['bytes'] >= 0 and isinstance(row['sha256'], str) and
+                 SHA256.fullmatch(row['sha256']), 'Invalid byte count or SHA-256: ' + relative)
+        path = _regular_file(base, relative)
+        _require(path.stat().st_size == row['bytes'], 'Payload byte count mismatch: ' + relative)
+        _require(_digest(path) == row['sha256'], 'Payload SHA-256 mismatch: ' + relative)
+        _require(path.stat().st_size == row['bytes'], 'Payload changed during verification: ' + relative)
+        expected[relative] = row['sha256']
+        rows.append(dict(row))
+    observed, excluded_caches = set(), 0
+    for path in base.rglob('*'):
+        _require(not path.is_symlink(), 'Symlink found in sealed tree: ' + str(path))
+        if path.is_dir():
+            continue
+        _require(stat.S_ISREG(path.stat().st_mode), 'Nonregular file in sealed tree: ' + str(path))
+        relative = path.relative_to(base).as_posix()
+        if '__pycache__' in path.relative_to(base).parts:
+            excluded_caches += 1
+        else:
+            observed.add(relative)
+    _require(observed == set(expected) | CONTROLS,
+             'Sealed tree has unlisted/missing files: ' + repr(sorted(observed ^ (set(expected) | CONTROLS))))
+    checksums_bytes = checksums_path.read_bytes()
+    checksum_rows = {}
+    for line in checksums_bytes.decode('utf-8').splitlines():
+        _require(len(line) >= 67 and line[64:66] == '  ' and SHA256.fullmatch(line[:64]),
+                 'Malformed checksums.sha256 line')
+        relative = line[66:]
+        _relative_name(relative)
+        _require(relative not in checksum_rows, 'Duplicate checksum path: ' + relative)
+        checksum_rows[relative] = line[:64]
+    _require(checksum_rows == {**expected, 'manifest.json': manifest_sha},
+             'Checksum inventory or manifest self-checksum mismatch')
+    return dict(pass_all=True, root=str(base), payload_file_count=len(rows),
+        payload_bytes=sum(row['bytes'] for row in rows), manifest_sha256=manifest_sha,
+        checksums_sha256=hashlib.sha256(checksums_bytes).hexdigest(),
+        excluded_pycache_files=excluded_caches, files=sorted(rows, key=lambda row: row['path']),
+        verification_scope='All sealed payload bytes/SHA-256, exact checksum inventory, and manifest self-SHA; no scientific gate execution')
+
+
+def _copy_verified(source, destination, byte_count, checksum):
+    _require(source.stat().st_size == byte_count, 'Source size changed before evidence copy')
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    with source.open('rb') as src, destination.open('xb') as dst:
+        shutil.copyfileobj(src, dst, length=1 << 20)
+    _require(destination.stat().st_size == byte_count and _digest(destination) == checksum,
+             'Copied evidence failed its sealed byte/hash check')
+    _require(source.stat().st_size == byte_count and _digest(source) == checksum,
+             'Sealed source changed during evidence copy')
+
+
+def _control_rows(root, verification):
+    return [dict(path='manifest.json', bytes=(root / 'manifest.json').stat().st_size,
+                 sha256=verification['manifest_sha256']),
+            dict(path='checksums.sha256', bytes=(root / 'checksums.sha256').stat().st_size,
+                 sha256=verification['checksums_sha256'])]
+
+
+def publish(root=ROOT):
+    """Create the one new registry exclusively; call only after finalize seals.
+
+    ``root`` exists for isolated synthetic tests.  Production uses the fixed
+    default project root and fixed Phase 4AI relative directories above.
+    """
+    root = Path(root)
+    _require(root.is_absolute() and root.is_dir() and not root.is_symlink(), 'Invalid project root')
+    root = root.resolve(strict=True)
+    model, experiment, registry = (root / part for part in
+                                   (MODEL_RELATIVE, EXPERIMENT_RELATIVE, REGISTRY_RELATIVE))
+    _require(not registry.exists() and not registry.is_symlink(), 'Registry already exists; no overwrite/resume')
+    for path in (model, experiment, registry.parent):
+        current = root
+        for part in path.relative_to(root).parts:
+            current = current / part
+            _require(not current.is_symlink(), 'Symlink in publication root path: ' + str(current))
+    verified = {'model': verify_seal(model), 'experiment': verify_seal(experiment)}
+    experiment_rows = {row['path']: row for row in verified['experiment']['files']}
+    _require('audit/final-status.json' in experiment_rows,
+             'Final status must exist inside the sealed experiment payload')
+    status = _json_bytes((experiment / 'audit/final-status.json').read_bytes())
+    _require(isinstance(status, dict) and status.get('status') == FINAL_STATUS and
+             status.get('pass_all') is True, 'Finalize completion status is missing or unexpected')
+    for flag in ('candidate_generated', 'learning_achieved', 'new_brain_simulation', 'GPU_used'):
+        _require(status.get(flag) is False, 'Unexpected finalized scope flag: ' + flag)
+    plans, omitted = [], []
+    for row in verified['experiment']['files'] + _control_rows(experiment, verified['experiment']):
+        allowed = PurePosixPath(row['path']).suffix.lower() in EVIDENCE_SUFFIXES
+        if allowed and row['bytes'] <= MAX_EVIDENCE_BYTES:
+            plans.append((experiment, row, 'evidence/' + row['path']))
+        else:
+            omitted.append(dict(path=row['path'], bytes=row['bytes'],
+                reason='exceeds_4_MiB' if row['bytes'] > MAX_EVIDENCE_BYTES else 'bulk_or_non_evidence_extension'))
+    for row in _control_rows(model, verified['model']):
+        _require(row['bytes'] <= MAX_EVIDENCE_BYTES, 'Model seal control exceeds small-evidence limit')
+        plans.append((model, row, 'model/' + row['path']))
+    for control in ('manifest.json', 'checksums.sha256'):
+        _require(any(target == 'evidence/' + control for _, _, target in plans),
+                 'Experiment seal control exceeds small-evidence limit')
+    _require(any(target == 'evidence/audit/final-status.json' for _, _, target in plans),
+             'Final status exceeds small-evidence limit')
+    registry.parent.mkdir(parents=True, exist_ok=True)
+    registry.mkdir(exist_ok=False)
+    try:
+        records = []
+        for source_root, row, relative in plans:
+            source = _regular_file(source_root.resolve(), row['path'])
+            target = registry / relative
+            _copy_verified(source, target, row['bytes'], row['sha256'])
+            records.append(dict(source=source.relative_to(root).as_posix(), copy=relative,
+                                bytes=row['bytes'], sha256=row['sha256']))
+        # Revalidate after copying, including payloads deliberately not copied.
+        after = {'model': verify_seal(model), 'experiment': verify_seal(experiment)}
+        _require(after == verified, 'A sealed tree changed during publication')
+        proof = {name: {key: value for key, value in report.items() if key != 'files'}
+                 for name, report in verified.items()}
+        _write_json(registry / 'seal-verification.json', proof)
+        _write_json(registry / 'evidence-index.json', records)
+        receipt_files = []
+        for path in sorted(registry.rglob('*')):
+            if path.is_file():
+                receipt_files.append(dict(path=path.relative_to(registry).as_posix(),
+                                          bytes=path.stat().st_size, sha256=_digest(path)))
+        receipt = dict(publication_complete=True, registry=registry.relative_to(root).as_posix(),
+            project_root=str(root), declared_audit_status=status['status'],
+            model_manifest_sha256=verified['model']['manifest_sha256'],
+            experiment_manifest_sha256=verified['experiment']['manifest_sha256'],
+            copied_evidence_files=len(records), copied_evidence_bytes=sum(row['bytes'] for row in records),
+            files=receipt_files, experiment_payload_not_copied=omitted,
+            model_payload_not_duplicated=True, model_payload_remains_at=MODEL_RELATIVE.as_posix(),
+            bulk_remains_at=EXPERIMENT_RELATIVE.as_posix(),
+            complete_bulk_backup=False, scientific_gate_executed_by_publisher=False,
+            scientific_gate_certified_by_publication=False, candidate_generated=False,
+            learning_achieved=False, existing_files_modified=False,
+            receipt_self_hash='Not self-referential; returned by publish() and printed by main()',
+            limits=dict(max_selected_evidence_file_bytes=MAX_EVIDENCE_BYTES,
+                        selected_suffixes=sorted(EVIDENCE_SUFFIXES)))
+        receipt_path = registry / 'publication-receipt.json'
+        _write_json(receipt_path, receipt)
+        return dict(publication_complete=True, registry=str(registry), copied_evidence_files=len(records),
+                    receipt_sha256=_digest(receipt_path), scientific_gate_executed_by_publisher=False)
+    except Exception as error:
+        failure = registry / 'publication-failure.json'
+        if not failure.exists():
+            _write_json(failure, dict(publication_complete=False, type=type(error).__name__,
+                                     message=str(error), partial_outputs_preserved=True,
+                                     existing_files_modified=False))
+        raise
+
+
+def main():
+    print(json.dumps(publish(), ensure_ascii=False, allow_nan=False), flush=True)
+
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,283 @@
+"""Read existing records and replay PN targets only; no GPU or counterfactual."""
+from functools import lru_cache
+import time
+import traceback
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+from context import (ROOT, EXP, AH_MODEL, AG, COEFF, GROUPS, read, save, digest,
+                     check, bit_equal, load_module)
+from pn_observer import PNObserver
+from apl_sources import decompose_apl_sources
+
+
+def first_ticks(event_tick, event_node, targets):
+    first = np.full(166700, np.iinfo(np.int32).max, np.int32)
+    np.minimum.at(first, event_node, event_tick)
+    first[first == np.iinfo(np.int32).max] = -1
+    return first[targets]
+
+
+def temporal_relation(source_tick, target_tick):
+    if source_tick < 0 or target_tick < 0:
+        return 'unobserved_source' if source_tick < 0 and target_tick >= 0 else (
+            'unobserved_target' if source_tick >= 0 else 'both_unobserved')
+    return 'before' if source_tick < target_tick else ('same_tick' if source_tick == target_tick else 'after')
+
+
+def min_observed(values):
+    values = np.asarray(values)
+    values = values[values >= 0]
+    return int(values.min()) if len(values) else -1
+
+
+class EventSink:
+    """Streaming accepted antecedents, never silently truncate."""
+    def __init__(self, path):
+        ints64 = ('edge_id', 'incoming_edge_row')
+        ints32 = ('source_neuron_idx', 'target_neuron_idx', 'source_spike_tick', 'arrival_tick',
+                  'weight_sign', 'ref_before', 'ref_at_arrival')
+        bools = ('target_is_design', 'accepted', 'available_at_integration')
+        floats = ('weight_SI', 'old_v_SI', 'old_g_SI', 'v_integrated_SI', 'v_prethreshold_SI',
+                  'threshold_margin_SI', 'g_before_arrivals_SI')
+        self.schema = pa.schema([(k, t) for names, t in ((ints64, pa.int64()), (ints32, pa.int32()),
+             (bools, pa.bool_()), (floats, pa.float64()), (('source_group', 'record_scope'), pa.string())) for k in names])
+        assert not path.exists()
+        self.writer = pq.ParquetWriter(path, self.schema, compression='zstd')
+        self.rows = 0
+
+    def __call__(self, rows):
+        self.writer.write_table(pa.Table.from_pylist(rows, schema=self.schema))
+        self.rows += len(rows)
+
+    def close(self):
+        self.writer.close()
+
+
+@lru_cache(maxsize=2)
+def graph_view(graph_name):
+    core = load_module('sealed_ah_replay_ai_' + graph_name, AH_MODEL / 'replay_core.py')
+    folder = AG / 'graphs' / graph_name
+    nodes = np.load(folder / 'nodes.npy', mmap_mode='r')
+    pn = np.load(AG / 'apl-bundle/pn_globals.npy')
+    apl = np.load(AG / 'apl-bundle/apl_globals.npy')
+    targets, positions, _ = np.intersect1d(nodes, pn, assume_unique=True, return_indices=True)
+    assert len(targets) > 0, 'Empty PN fixture subset: stop and report nonapplicable; never fabricate targets'
+    lookup = np.full(len(nodes), -1, np.int32)
+    lookup[positions] = np.arange(len(targets), dtype=np.int32)
+    dst = np.load(folder / 'dst.npy', mmap_mode='r')
+    selected = np.flatnonzero(lookup[dst] >= 0)
+    src = nodes[np.load(folder / 'src.npy', mmap_mode='r')[selected]]
+    ids = np.load(folder / 'edge_id.npy', mmap_mode='r')[selected]
+    weights = np.load(folder / 'weights.npy', mmap_mode='r')[selected].copy()
+    weights[np.isin(src, apl)] = 0.0
+    raw = np.load(ROOT / 'datasets/male-cns-v1.0/processed/neuron-only/gpu/csr-weights.int64.npy', mmap_mode='r')[ids]
+    assert raw.dtype == np.int64 and np.all(raw > 0)
+    incoming = core.IncomingIndex(src, lookup[dst[selected]], ids, weights, len(targets))
+    groups = pd.read_parquet(EXP / 'protocol/neuron-source-groups.parquet').audit_source_group.to_numpy()
+    codes = np.array([GROUPS.index(x) for x in groups], np.int32)[src]
+    audit = dict(graph=graph_name, PN_targets=len(targets), incoming_edges=len(ids), contacts=int(raw.sum()),
+        zeroed_fast_APL_edges=int(np.isin(src, apl).sum()), graded_APL_to_PN=False,
+        groups={g: dict(edges=int((codes == i).sum()), contacts=int(raw[codes == i].sum())) for i, g in enumerate(GROUPS)},
+        source_graph_unchanged=True, effective_fast_APL_zero_mask_preserved=True)
+    return core, incoming, raw, codes, targets, positions, audit
+
+
+@lru_cache(maxsize=2)
+def pn_kc_edges(graph_name):
+    folder = AG / 'graphs' / graph_name
+    nodes = np.load(folder / 'nodes.npy', mmap_mode='r')
+    pn = np.load(AG / 'apl-bundle/pn_globals.npy')
+    kc = np.load(AG / 'apl-bundle/kc_globals.npy')
+    src = nodes[np.load(folder / 'src.npy', mmap_mode='r')]
+    dst = nodes[np.load(folder / 'dst.npy', mmap_mode='r')]
+    picked = np.flatnonzero(np.isin(src, pn) & np.isin(dst, kc))
+    return src[picked], np.searchsorted(kc, dst[picked]), np.load(folder / 'weights.npy', mmap_mode='r')[picked]
+
+
+def pn_kc_before_first(graph_name, state, kc_first, design):
+    """All PN edge arrivals strictly before first KC spike; no refractory yet."""
+    src, dst, weights = pn_kc_edges(graph_name)
+    rows = {'neuron_idx': np.load(AG / 'apl-bundle/kc_globals.npy').copy(), 'first_spike_tick': kc_first.copy()}
+    for name in ('design_ALPN', 'non_design_ALPN'):
+        rows[name + '_strict_pre_first_edge_events'] = np.zeros(len(kc_first), np.int64)
+        rows[name + '_strict_pre_first_positive_V'] = np.zeros(len(kc_first), np.float64)
+        rows[name + '_strict_pre_first_negative_abs_V'] = np.zeros(len(kc_first), np.float64)
+    # Fixed graph edges only. Before the first spike, initially zero ref has never been reset.
+    for source in np.unique(src):
+        edges = np.flatnonzero((src == source) & (kc_first[dst] >= 0))
+        spikes = state['step'][state['neuron_idx'] == source]
+        count = np.searchsorted(spikes, kc_first[dst[edges]] - 18, side='left')
+        label = 'design_ALPN' if source in design else 'non_design_ALPN'
+        np.add.at(rows[label + '_strict_pre_first_edge_events'], dst[edges], count)
+        np.add.at(rows[label + '_strict_pre_first_positive_V'], dst[edges], count * np.maximum(weights[edges], 0))
+        np.add.at(rows[label + '_strict_pre_first_negative_abs_V'], dst[edges], count * np.maximum(-weights[edges], 0))
+    return rows
+
+
+def audit_trial(row, population):
+    start = time.perf_counter()
+    out = EXP / 'trials' / (row['case'] + '-r' + str(row['repeat']))
+    out.mkdir(exist_ok=False)
+    source, case = ROOT / row['source'], AG / 'cases' / row['case']
+    spec = read(case / 'spec.json')
+    graph_name = 'fixtures' if row['kind'] == 'fixture' else 'full'
+    core, incoming, raw, codes, targets, positions, graph_audit = graph_view(graph_name)
+    with np.load(source / 'state.npz', allow_pickle=False) as data:
+        state = {k: data[k].copy() for k in data.files}
+    assert set(state) == {'step', 'neuron_idx', 'counts', 'v', 'g', 'ref'}
+    with np.load(case / 'requests.npz', allow_pickle=False) as data:
+        req = {k: data[k].copy() for k in data.files}
+    rt = pd.read_csv(source / 'requests.csv')
+    assert np.array_equal(req['tick'], rt.tick) and np.array_equal(req['neuron_idx'], rt.neuron_idx)
+    assert (rt.attempted == 1).all() and rt.accepted.isin([0, 1]).all()
+    assert np.array_equal(rt.rejected, 1 - rt.accepted)
+    if row['kind'] == 'calibration':
+        with np.load(case / 'pn-drive.npz', allow_pickle=False) as data:
+            design = np.sort(data['targets'].copy())
+            assert design.dtype == np.int32 and data['rates_hz'].dtype == np.float32
+            assert len(design) == spec['target_count'] and (data['rates_hz'] > 0).all()
+    else:
+        design = np.intersect1d(req['neuron_idx'], targets)
+    assert np.isin(design, targets).all() and len(np.unique(design)) == len(design)
+    expected_mask = np.isin(state['neuron_idx'], targets)
+    expected = {k: state[k][expected_mask] for k in ('step', 'neuron_idx')}
+    initial_v = np.full(len(targets), spec['model']['resting_potential_mv'], np.float64) * np.float64(.001)
+    initial_g = np.zeros(len(targets), np.float64)
+    if (case / 'arrays.npz').exists():
+        with np.load(case / 'arrays.npz', allow_pickle=False) as data:
+            initial_v = data['initial_v_mv'][positions] * np.float64(.001)
+            initial_g = data['initial_g_mv'][positions] * np.float64(.001)
+    histories = {}
+    if row['kind'] == 'fixture':
+        for key, dtype in (('v', 'float64'), ('g', 'float64'), ('ref', 'int32')):
+            histories[key] = np.load(source / f'{key}-history.{dtype}.npy', mmap_mode='r')[:, positions]
+            histories['pre_' + key] = np.load(source / f'preAPL-{key}.{dtype}.npy', mmap_mode='r')[:, positions]
+    sink = EventSink(out / 'accepted-prefirst-edge-events.parquet')
+    observer = PNObserver(targets, design, incoming, codes, GROUPS, read(COEFF), spec['steps'],
+                          max_first_event_rows=1000000, event_sink=sink)
+    request_lookup = np.full(166700, -1, np.int32)
+    request_lookup[targets] = np.arange(len(targets), dtype=np.int32)
+    def callback(tick, stage):
+        for key in ('v', 'g', 'ref'):
+            if histories:
+                assert bit_equal(stage[key], histories[key][tick]), 'Fixture post state mismatch'
+                assert bit_equal(stage[key + '_pre_apl'], histories['pre_' + key][tick]), 'Fixture pre state mismatch'
+        indices = np.flatnonzero((req['tick'] == tick) & np.isin(req['neuron_idx'], targets))
+        if len(indices):
+            local = request_lookup[req['neuron_idx'][indices]]
+            assert np.array_equal(stage['request_accepted'][local], rt.accepted.to_numpy()[indices].astype(bool))
+        observer(tick, stage)
+    try:
+        result = core.replay(initial_v, initial_g, read(COEFF), spec['steps'], targets, req,
+            dict(step=state['step'], neuron_idx=state['neuron_idx']), incoming,
+            np.zeros((spec['steps'], len(targets)), np.float32), callback)
+    finally:
+        sink.close()
+    exact = {k: bit_equal(result[k], state[k][positions]) for k in ('v', 'g', 'ref', 'counts')}
+    exact.update({k: bit_equal(result[k], expected[k]) for k in ('step', 'neuron_idx')})
+    assert all(exact.values()), 'PN replay diverged: ' + str(exact)
+    data, observer_report = observer.finish(result)
+    assert sink.rows == observer_report['first_arrival_record_count']
+    table = pd.DataFrame(data)
+    table.insert(1, 'body_id', population.iloc[targets].body_id.to_numpy())
+    table.insert(2, 'annotation_type', population.iloc[targets].annotation_type.to_numpy())
+    table.to_parquet(out / 'per-pn.parquet', index=False)
+    edges = pd.DataFrame(observer.edge_summary())
+    if len(edges):
+        edge_positions = np.searchsorted(incoming.edge_id, edges.edge_id.to_numpy())
+        assert np.array_equal(incoming.edge_id[edge_positions], edges.edge_id.to_numpy())
+        edges['raw_contact_count'] = raw[edge_positions]
+        for prefix in ('source', 'target'):
+            global_ids = edges[prefix + '_neuron_idx'].to_numpy()
+            edges[prefix + '_body_id'] = population.iloc[global_ids].body_id.to_numpy()
+            edges[prefix + '_type'] = population.iloc[global_ids].annotation_type.to_numpy()
+    edges.to_parquet(out / 'prefirst-edge-summary.parquet', index=False)
+    with (out / 'replay-final.npz').open('xb') as f:
+        np.savez_compressed(f, **result)
+    kc = np.load(AG / 'apl-bundle/kc_globals.npy')
+    pn = np.load(AG / 'apl-bundle/pn_globals.npy')
+    first_kc = first_ticks(state['step'], state['neuron_idx'], kc)
+    first_pn = first_ticks(state['step'], state['neuron_idx'], pn)
+    first_nondesign = min_observed(first_pn[~np.isin(pn, design)])
+    first_anykc = min_observed(first_kc)
+    component = read(source / 'apl-component.json')
+    env = component['environment']
+    assert env['cuda_matmul_allow_tf32'] is False and env['float32_matmul_precision'] == 'highest'
+    d32 = np.array([int(component['decay_f32_bits'], 16)], np.uint32).view(np.float32)[0]
+    q32 = np.array([int(component['gain_f32_bits'], 16)], np.uint32).view(np.float32)[0]
+    apl = decompose_apl_sources(np.load(AG / 'apl-bundle/input_matrix.npy', mmap_mode='r'),
+        np.load(AG / 'apl-bundle/output_matrix.npy', mmap_mode='r'), pn, kc, design,
+        state['step'], state['neuron_idx'], np.load(source / 'apl-drive.float32.npy', mmap_mode='r'),
+        np.load(source / 'apl-state.float32.npy', mmap_mode='r'),
+        np.load(source / 'apl-inhibition.float32.npy', mmap_mode='r'),
+        decay32=d32, gain32=q32, standard_fp32=True, first_kc_tick=first_kc)
+    assert apl['summary']['pass_all']
+    save(out / 'apl-source-summary.json', apl['summary'])
+    pd.DataFrame(apl['tick_rows']).to_parquet(out / 'apl-per-tick.parquet', index=False)
+    per_kc = pd.DataFrame(apl['per_kc'])
+    per_kc.insert(1, 'body_id', population.iloc[kc].body_id.to_numpy())
+    per_kc['KC_present_in_source_graph'] = np.isin(kc, np.load(spec['graph_dir'] + '/nodes.npy'))
+    per_kc['first_non_design_PN_tick'] = first_nondesign
+    per_kc['first_non_design_relation'] = [temporal_relation(first_nondesign, int(t)) for t in first_kc]
+    for key, value in pn_kc_before_first(graph_name, state, first_kc, design).items():
+        if key not in ('neuron_idx', 'first_spike_tick'):
+            per_kc[key] = value
+    per_kc.to_parquet(out / 'per-kc-apl-sources.parquet', index=False)
+    report = dict(case=row['case'], repeat=row['repeat'], kind=row['kind'], pass_all=True, exact=exact,
+        every_tick_fixture_pre_post_exact=bool(histories), CAL_per_tick_independent_state_available=False,
+        steps=spec['steps'], duration_ms=spec['duration_ms'], mode=spec.get('mode'), seed=spec.get('seed'),
+        odor_id=spec.get('odor_id'), graph=graph_audit, observer=observer_report,
+        first_non_design_PN_tick=first_nondesign, first_any_KC_tick=first_anykc,
+        first_non_design_vs_first_KC=temporal_relation(first_nondesign, first_anykc),
+        fixture_design_definition='Unique requested PN IDs for numerical fixture only; not odor design' if histories else None,
+        APL_source_bound_pass=apl['summary']['pass_all'], candidate_generated=False, new_brain_simulation=False,
+        CPU_audit_wall_seconds=time.perf_counter() - start,
+        input_sha256={f: digest(source / f) for f in ('state.npz', 'requests.csv', 'summary.json',
+            'apl-component.json', 'apl-drive.float32.npy', 'apl-state.float32.npy', 'apl-inhibition.float32.npy')})
+    save(out / 'summary.json', report)
+    save(out / 'output-hashes.json', [dict(path=p.name, sha256=digest(p), bytes=p.stat().st_size)
+         for p in sorted(out.iterdir()) if p.is_file()])
+    return report
+
+
+def main():
+    check()
+    population = pd.read_parquet(EXP / 'protocol/neuron-source-groups.parquet')
+    inventory = read(EXP / 'protocol/inventory.json')
+    receipts = []
+    for row in inventory:
+        try:
+            report = audit_trial(row, population)
+            receipts.append(dict(case=row['case'], repeat=row['repeat'], pass_all=report['pass_all']))
+            assert sum(p.stat().st_size for p in EXP.rglob('*') if p.is_file()) < 2 * 1024**3
+            print(row['case'], row['repeat'], 'EXACT PN / APL BOUND PASS',
+                  round(report['CPU_audit_wall_seconds'], 3), 'CPU sec', flush=True)
+        except Exception as error:
+            save(EXP / 'audit/failure.json', dict(case=row, error=type(error).__name__, message=str(error),
+                 traceback=traceback.format_exc(), completed=receipts, new_brain_simulation=False))
+            raise
+    repeats = []
+    for row in inventory:
+        if row['repeat'] != 1:
+            continue
+        a = EXP / 'trials' / (row['case'] + '-r0')
+        b = EXP / 'trials' / (row['case'] + '-r1')
+        checks = {}
+        for f in ('per-pn.parquet', 'prefirst-edge-summary.parquet', 'apl-per-tick.parquet', 'per-kc-apl-sources.parquet'):
+            checks[f] = pd.read_parquet(a / f).equals(pd.read_parquet(b / f))
+        checks['antecedent_events'] = digest(a / 'accepted-prefirst-edge-events.parquet') == digest(b / 'accepted-prefirst-edge-events.parquet')
+        checks['apl-summary'] = read(a / 'apl-source-summary.json') == read(b / 'apl-source-summary.json')
+        with np.load(a / 'replay-final.npz') as aa, np.load(b / 'replay-final.npz') as bb:
+            checks['replay'] = set(aa.files) == set(bb.files) and all(bit_equal(aa[k], bb[k]) for k in aa.files)
+        assert all(checks.values()), 'Repeated accounting differs'
+        repeats.append(dict(case=row['case'], pass_all=True, checks=checks))
+    assert len(receipts) == 80 and len(repeats) == 12
+    save(EXP / 'audit/completed.json', dict(pass_all=True, trials=receipts, repeat_checks=repeats,
+         meaning='Conditional PN exactness and bounded APL attribution only; not a learning or causal gate'))
+    print('PASS 80 conditional audits and 12 repeats', flush=True)
+
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,179 @@
+"""Fixed descriptive ALPN-count comparisons; pure NumPy, no files or tuning.
+
+Column positions refer to the caller's fixed canonical 686-ALPN order.  This
+module cannot assign body IDs or infer anatomical identities.  Repeated runs
+are integrity evidence, never additional independent seeds in these metrics.
+"""
+from __future__ import annotations
+
+import itertools
+
+import numpy as np
+
+
+MODES = ('physiological', 'matched_energy')
+ODORS = tuple(range(6))
+SEEDS = tuple(range(51101, 51106))
+N_ALPN = 686
+FIELDS = frozenset(('mode', 'odor_index', 'seed', 'counts', 'design_mask'))
+METRICS = ('cosine_distance', 'pearson_correlation', 'jaccard', 'euclidean_distance')
+
+
+def _require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def _integer(value, name):
+    _require(isinstance(value, (int, np.integer)) and not isinstance(value, (bool, np.bool_)),
+             name + ' must be an integer, not a Boolean')
+    return int(value)
+
+
+def _array(value, dtype, name):
+    _require(isinstance(value, np.ndarray) and not np.ma.isMaskedArray(value),
+             name + ' must be an unmasked NumPy array')
+    _require(value.dtype == np.dtype(dtype) and value.shape == (N_ALPN,),
+             name + ' must have dtype ' + np.dtype(dtype).name + ' and shape (686,)')
+    return np.array(value, copy=True, order='C')
+
+
+def _pair_metrics(first, second):
+    # Cast BEFORE subtraction/norm so int32 extrema do not overflow.
+    x, y = first.astype(np.float64), second.astype(np.float64)
+    active_x, active_y = first > 0, second > 0
+    intersection = int(np.count_nonzero(active_x & active_y))
+    union = int(np.count_nonzero(active_x | active_y))
+    result = dict(active_a=int(active_x.sum()), active_b=int(active_y.sum()),
+                  active_intersection=intersection, active_union=union)
+    if not len(first):
+        result.update({name: None for name in METRICS})
+        return result
+    norm_x, norm_y = float(np.linalg.norm(x)), float(np.linalg.norm(y))
+    cosine = None if norm_x == 0 or norm_y == 0 else float(np.clip(
+        np.dot(x, y) / (norm_x * norm_y), -1., 1.))
+    # A constant or one-channel vector has undefined Pearson correlation;
+    # equality does not turn it into evidence of shared structure.
+    correlation = None if bool(np.all(x == x[0]) or np.all(y == y[0])) else float(
+        np.clip(np.corrcoef(x, y)[0, 1], -1., 1.))
+    result.update(cosine_distance=None if cosine is None else float(1. - cosine),
+                  pearson_correlation=correlation,
+                  jaccard=None if union == 0 else float(intersection / union),
+                  euclidean_distance=float(np.linalg.norm(x - y)))
+    _require(all(value is None or np.isfinite(value) for value in result.values()),
+             'A structure metric became nonfinite')
+    return result
+
+
+def _summary(rows):
+    result = {}
+    for name in METRICS:
+        values = np.asarray([row[name] for row in rows if row[name] is not None], np.float64)
+        result[name] = dict(mean=None if not len(values) else float(values.mean()),
+            variance_ddof0=None if not len(values) else float(values.var(ddof=0)),
+            valid_comparisons=int(len(values)), undefined_comparisons=int(len(rows) - len(values)))
+    return result
+
+
+def _view(mode, records, positions):
+    arrays = {(odor, seed): records[(mode, odor, seed)]['counts'][positions]
+              for odor in ODORS for seed in SEEDS}
+    within, between, pairs = [], [], []
+    for odor in ODORS:
+        for first_seed, second_seed in itertools.combinations(SEEDS, 2):
+            within.append(dict(odor_index=odor, seed_a=first_seed, seed_b=second_seed,
+                **_pair_metrics(arrays[(odor, first_seed)], arrays[(odor, second_seed)])))
+    for first_odor, second_odor in itertools.combinations(ODORS, 2):
+        pair_between = []
+        for seed in SEEDS:
+            row = dict(odor_index_a=first_odor, odor_index_b=second_odor, seed=seed,
+                **_pair_metrics(arrays[(first_odor, seed)], arrays[(second_odor, seed)]))
+            pair_between.append(row)
+            between.append(row)
+        # Original pair-specific comparison: 10 within-seed pairs for each
+        # member odor, not a baseline pooled across all six odors.
+        pair_within = [row for row in within if row['odor_index'] in (first_odor, second_odor)]
+        within_summary, between_summary = _summary(pair_within), _summary(pair_between)
+        differences = {name: None if (within_summary[name]['mean'] is None or
+                                     between_summary[name]['mean'] is None) else
+                       float(between_summary[name]['mean'] - within_summary[name]['mean'])
+                       for name in METRICS}
+        pairs.append(dict(odor_index_a=first_odor, odor_index_b=second_odor,
+            within_comparison_count=len(pair_within), between_comparison_count=len(pair_between),
+            within=within_summary, between=between_summary,
+            mean_between_minus_within=differences,
+            within_comparisons=pair_within, between_comparisons=pair_between))
+    _require(len(within) == 60 and len(between) == 75 and len(pairs) == 15 and
+             all(row['within_comparison_count'] == 20 and row['between_comparison_count'] == 5
+                 for row in pairs), 'Internal fixed comparison inventory changed')
+    return dict(dimensions=int(len(positions)), applicable=bool(len(positions)),
+        column_positions=[int(value) for value in positions],
+        within_comparison_count=len(within), between_comparison_count=len(between), pair_count=len(pairs),
+        within=_summary(within), between=_summary(between),
+        within_comparisons=within, between_comparisons=between, pairs=pairs)
+
+
+def aggregate_structure(records):
+    """Describe precisely 60 fixed CAL records, without selecting results.
+
+    Each record has exactly mode, odor_index, seed, counts:int32[686] and
+    design_mask:bool[686].  There are two named modes, six odors (0..5), five
+    seeds (51101..51105), and no repeat records.  Every odor's design mask must
+    be identical across seeds AND modes.  No caller-owned array is modified.
+
+    Undefined cosine (zero norm), Pearson (constant vector), or Jaccard (empty
+    active union) is null with explicit valid/undefined counts.  An empty
+    common-nondesign population is nonapplicable, with every metric null.
+    """
+    _require(isinstance(records, list) and len(records) == 60,
+             'Exactly 60 base CAL records are required; technical repeats must be excluded')
+    indexed, masks = {}, {}
+    for position, record in enumerate(records):
+        _require(isinstance(record, dict) and set(record) == FIELDS,
+                 'Record schema must contain exactly ' + ', '.join(sorted(FIELDS)))
+        mode = record['mode']
+        _require(isinstance(mode, str) and mode in MODES, 'Unexpected CAL mode')
+        odor = _integer(record['odor_index'], 'odor_index')
+        seed = _integer(record['seed'], 'seed')
+        _require(odor in ODORS and seed in SEEDS, 'Odor index or seed outside the fixed CAL inventory')
+        key = mode, odor, seed
+        _require(key not in indexed, 'Duplicate CAL identity: ' + str(key))
+        counts = _array(record['counts'], np.int32, 'counts')
+        design = _array(record['design_mask'], np.bool_, 'design_mask')
+        _require(bool(np.all(counts >= 0)), 'Spike counts must be nonnegative')
+        if odor in masks:
+            _require(np.array_equal(design, masks[odor]),
+                     'An odor design mask changed across seed or mode: ' + str(odor))
+        else:
+            masks[odor] = design.copy()
+        indexed[key] = dict(counts=counts, design_mask=design)
+    expected = set(itertools.product(MODES, ODORS, SEEDS))
+    _require(set(indexed) == expected, 'Incomplete fixed CAL identity set')
+    union = np.logical_or.reduce([masks[odor] for odor in ODORS])
+    primary = np.arange(N_ALPN, dtype=np.int32)
+    common = np.flatnonzero(~union).astype(np.int32)
+    return dict(schema='phase4ai-alpn-structure-v1', record_count=60, ALPN_dimensions=N_ALPN,
+        design=dict(identical_across_seeds_and_modes=True,
+            design_neuron_count_by_odor={str(odor): int(masks[odor].sum()) for odor in ODORS},
+            design_union_count=int(union.sum()), common_non_design_count=int(len(common)),
+            common_non_design_column_positions=[int(value) for value in common],
+            common_non_design_definition='Fixed complement of the union of all six CAL odor design masks; same columns in all modes/seeds'),
+        modes={mode: dict(trials=30, fixed_686=_view(mode, indexed, primary),
+                         common_non_design=_view(mode, indexed, common)) for mode in MODES},
+        protocol=dict(odor_indices=list(ODORS), seeds=list(SEEDS), variance_ddof=0,
+            within='All 10 distinct seed pairs within each of six odors: 60 comparisons per mode',
+            between='Same-seed pairs for each of 15 odor pairs: 75 comparisons per mode',
+            pair_baseline='Only each odor pair: 10+10 within comparisons and five same-seed between comparisons',
+            counts='Original nonnegative int32 spike counts; no normalization, fitting or resampling',
+            undefined_cosine='null if either vector has zero norm',
+            undefined_Pearson='null if either vector is constant, including dimension one',
+            undefined_Jaccard='null if active union is empty',
+            empty_population='All metrics null, applicable=false; no fabricated zero distance',
+            clipping='Only cosine/correlation numerical roundoff is clipped to their mathematical [-1,1] range',
+            technical_repeats_included=False, population_columns='Caller-supplied fixed canonical ALPN order; positions are not neuron_idx'),
+        decision_gate_applied=False, learning_claimed=False, absence_of_encoding_claimed=False,
+        limitations=['Descriptive CAL structure only, not a held-out or learning result',
+            'Shared activity can coexist with odor-specific information',
+            'Active-set Jaccard can saturate even when spike-count patterns differ',
+            'Valid metric counts vary when a metric is undefined; null is not zero similarity',
+            'No KC sparsity gate is transferred to the ALPN population'])
@@ -0,0 +1,242 @@
+"""Synthetic CPU-only tests. No real records, files, Torch, GPU, or model runs."""
+import json
+import sys
+import unittest
+
+import numpy as np
+
+from apl_sources import N, GROUPS, DECAY32, GAIN32, decompose_apl_sources
+
+
+def fixture(events=((0, 1), (1, 4), (2, 10), (4, 20)), steps=6):
+    I = np.zeros((2, N), np.float32)
+    I[:, 1] = [1., .3]
+    I[:, 4] = [.5, 2.]
+    I[:, 10] = [1.1, .2]
+    I[:, 20] = [.7, 1.5]
+    O = np.array([[1., .7, .2, 0.], [.3, .5, 1., 2.]], np.float32)
+    pairs = np.asarray(events, np.int32).reshape(-1, 2)
+    tick, node = pairs[:, 0], pairs[:, 1]
+    # This is merely one legal ordinary f32 reduction implementation for
+    # exercising the mathematical bound, not a CUDA-equality oracle.
+    state = np.zeros(2, np.float32)
+    drive_log, state_log, h_log = [], [], []
+    for t in range(steps):
+        drive = I[:, node[tick == t]].sum(axis=1, dtype=np.float32)
+        state = np.add(np.multiply(DECAY32, state), drive)
+        h = np.multiply(np.matmul(state, O), GAIN32)
+        drive_log.append(drive)
+        state_log.append(state.copy())
+        h_log.append(h)
+    return dict(I32=I, O32=O, pn_globals=np.array([1, 4, 6], np.int32),
+        kc_globals=np.array([10, 20, 30, 40], np.int32), design_pn_globals=np.array([1], np.int32),
+        event_step=tick, event_node=node, drive32=np.asarray(drive_log),
+        state32=np.asarray(state_log), h32=np.asarray(h_log),
+        decay32=DECAY32, gain32=GAIN32, standard_fp32=True)
+
+
+class AttributionTests(unittest.TestCase):
+    def test_three_groups_cover_drive_and_pass_prior_bound(self):
+        f = fixture()
+        calls = []
+        out = decompose_apl_sources(**f, callback=lambda t, s: calls.append(s))
+        summary = out['summary']
+        self.assertTrue(summary['pass_all'])
+        self.assertTrue(summary['input_support_partition_exact'])
+        np.testing.assert_array_equal(out['first_kc_tick'], [2, 4, -1, -1])
+        self.assertEqual(len(out['tick_rows']), 6 * 3 * 2)
+        self.assertEqual([summary['groups'][g]['actual_spikes'] for g in GROUPS], [1, 1, 2])
+        for s in calls:
+            np.testing.assert_array_equal(s['drive_total'], (s['drive_by_group'][0] + s['drive_by_group'][1]) + s['drive_by_group'][2])
+            np.testing.assert_array_equal(s['state_total'], (s['state_by_group'][0] + s['state_by_group'][1]) + s['state_by_group'][2])
+        self.assertFalse(summary['CUDA_float32_bitwise_replay'])
+        self.assertFalse(summary['independent_brain_oracle'])
+        self.assertFalse(summary['theoretical_bound']['tolerance_fitted_to_observed_error'])
+        self.assertFalse(summary['cumulative_source_fraction_error_bounds_verified'])
+        self.assertFalse(summary['source_majority_robustness_proven'])
+        json.dumps(summary, allow_nan=False)
+        json.dumps(out['tick_rows'], allow_nan=False)
+
+    def test_early_excludes_same_tick_and_never_fired_columns(self):
+        f = fixture(events=((0, 1), (2, 10)))
+        out = decompose_apl_sources(**f)
+        rows = [r for r in out['tick_rows'] if r['group'] == 'design_ALPN' and r['apl_index'] == 0]
+        d, q = float(DECAY32), float(GAIN32)
+        self.assertAlmostEqual(rows[0]['h_before_first_KC_sum_mV'], q * 1.)
+        self.assertAlmostEqual(rows[1]['h_before_first_KC_sum_mV'], q * d)
+        self.assertEqual(rows[2]['h_before_first_KC_sum_mV'], 0.)
+        self.assertGreater(rows[2]['h_never_fired_KC_sum_mV'], 0.)
+        self.assertGreater(rows[1]['h_before_first_any_KC_sum_mV'], 0.)
+        self.assertEqual(rows[2]['h_before_first_any_KC_sum_mV'], 0.)
+
+    def test_first_kc_at_zero_has_no_early_output(self):
+        out = decompose_apl_sources(**fixture(events=((0, 1), (0, 10))))
+        self.assertEqual(out['summary']['first_any_KC_spike_tick'], 0)
+        self.assertTrue(all(r['h_before_first_any_KC_sum_mV'] == 0 for r in out['tick_rows']))
+        self.assertTrue(all(r['h_before_first_KC_sum_mV'] == 0 for r in out['tick_rows']))
+
+    def test_no_kc_spikes_keep_never_output_separate(self):
+        out = decompose_apl_sources(**fixture(events=((0, 1),)))
+        self.assertIsNone(out['summary']['first_any_KC_spike_tick'])
+        np.testing.assert_array_equal(out['first_kc_tick'], [-1] * 4)
+        for row in out['tick_rows']:
+            self.assertEqual(row['h_sum_mV'], row['h_never_fired_KC_sum_mV'])
+            self.assertEqual(row['h_before_first_KC_sum_mV'], 0.)
+            self.assertEqual(row['h_before_first_any_KC_sum_mV'], 0.)
+
+    def test_zero_input_exact_zeros_and_undefined_fractions(self):
+        out = decompose_apl_sources(**fixture(events=()))
+        self.assertTrue(out['summary']['pass_all'])
+        for group in out['summary']['groups'].values():
+            self.assertEqual(group['h_sum_mV'], 0.)
+            self.assertIsNone(group['generated_h_fraction'])
+            self.assertIsNone(group['drive_fraction'])
+
+    def test_source_first_spike_is_not_first_nonzero_drive(self):
+        out = decompose_apl_sources(**fixture(events=((0, 6), (2, 4), (3, 100))))
+        group = out['summary']['groups']['non_design_ALPN']
+        self.assertEqual(group['actual_spikes'], 2)
+        self.assertEqual(group['input_supported_spikes'], 1)
+        self.assertEqual(group['first_actual_spike_tick'], 0)
+        self.assertEqual(group['first_nonzero_drive_tick'], 2)
+        self.assertEqual(out['summary']['actual_events'], 3)
+        self.assertTrue(out['summary']['pass_all'])
+
+    def test_empty_design_set_reclassifies_pn_not_drops_them(self):
+        f = fixture()
+        f['design_pn_globals'] = np.empty(0, np.int32)
+        out = decompose_apl_sources(**f)
+        self.assertTrue(out['summary']['pass_all'])
+        self.assertEqual(out['summary']['groups']['design_ALPN']['actual_spikes'], 0)
+        self.assertEqual(out['summary']['groups']['non_design_ALPN']['actual_spikes'], 2)
+
+    def test_chunk_size_does_not_change_source_accounting(self):
+        f = fixture()
+        a = decompose_apl_sources(**f, chunk_size=1)
+        b = decompose_apl_sources(**f, chunk_size=7)
+        self.assertTrue(a['summary']['pass_all'] and b['summary']['pass_all'])
+        self.assertEqual(a['tick_rows'], b['tick_rows'])
+        self.assertEqual(a['summary']['groups'], b['summary']['groups'])
+        for name in ('drive', 'state', 'inhibition'):
+            for key in ('max_abs_error', 'max_error_bound', 'max_bound_utilization', 'bound_violations', 'elements'):
+                self.assertEqual(a['summary']['comparison'][name][key], b['summary']['comparison'][name][key])
+
+    def test_callback_and_core_never_modify_inputs_or_running_state(self):
+        f = fixture()
+        inputs = {k: v.copy() for k, v in f.items() if isinstance(v, np.ndarray)}
+        expected = decompose_apl_sources(**f)
+        def mutate(t, s):
+            for value in s.values():
+                value[:] = 100.
+        actual = decompose_apl_sources(**f, callback=mutate)
+        self.assertEqual(actual['summary'], expected['summary'])
+        self.assertEqual(actual['tick_rows'], expected['tick_rows'])
+        for name, before in inputs.items():
+            np.testing.assert_array_equal(np.ascontiguousarray(f[name]).view(np.uint8),
+                                          np.ascontiguousarray(before).view(np.uint8))
+
+    def test_per_kc_strict_pre_first_and_never_sums(self):
+        f = fixture(events=((0, 1), (2, 10)))
+        out = decompose_apl_sources(**f, first_kc_tick=np.array([2, -1, -1, -1], np.int32))
+        per = out['per_kc']
+        d, q = float(DECAY32), float(GAIN32)
+        first_two = q * (1. + d) * (float(f['I32'][0, 1]) * float(f['O32'][0, 0]) +
+                                   float(f['I32'][1, 1]) * float(f['O32'][1, 0]))
+        self.assertAlmostEqual(per['design_ALPN_pre_first_h_sum_mV'][0], first_two)
+        np.testing.assert_array_equal(per['design_ALPN_pre_first_h_sum_mV'][1:], [0., 0., 0.])
+        self.assertEqual(per['design_ALPN_never_fired_h_sum_mV'][0], 0.)
+        np.testing.assert_array_equal(per['design_ALPN_never_fired_h_sum_mV'][1:], per['design_ALPN_h_sum_mV'][1:])
+        self.assertEqual(per['KC_pre_first_h_sum_mV'][0], 0.)
+        self.assertTrue(out['summary']['fixture_absent_KC_output_is_not_claimed_applied'])
+
+    def test_supplied_first_times_must_match_actual_logs(self):
+        for first in (np.array([3, 4, -1, -1], np.int32), np.array([2, 4, -1, -1], np.int64)):
+            with self.subTest(first=first), self.assertRaises(ValueError):
+                decompose_apl_sources(**fixture(), first_kc_tick=first)
+
+    def test_corrupted_positive_trace_violates_unfitted_bound(self):
+        for field in ('drive32', 'state32', 'h32'):
+            with self.subTest(field=field):
+                f = fixture()
+                f[field][1, 0] += np.float32(100.)
+                out = decompose_apl_sources(**f)
+                self.assertFalse(out['summary']['pass_all'])
+                target = {'drive32': 'drive', 'state32': 'state', 'h32': 'inhibition'}[field]
+                self.assertGreater(out['summary']['comparison'][target]['bound_violations'], 0)
+
+    def test_zero_reference_cannot_accept_nonzero_actual(self):
+        f = fixture(events=())
+        f['h32'][0, 0] = np.finfo(np.float32).tiny
+        out = decompose_apl_sources(**f)
+        self.assertFalse(out['summary']['pass_all'])
+        self.assertEqual(out['summary']['comparison']['inhibition']['zero_reference_nonzero_actual'], 1)
+
+    def test_subnormal_disables_theoretical_pass(self):
+        f = fixture(events=())
+        f['I32'][0, 1] = np.float32(np.finfo(np.float32).tiny / 2)
+        out = decompose_apl_sources(**f)
+        self.assertFalse(out['summary']['pass_all'])
+        self.assertFalse(out['summary']['theoretical_bound']['applicable'])
+
+
+class ValidationTests(unittest.TestCase):
+    def test_nonzero_unknown_source_is_rejected(self):
+        f = fixture()
+        f['I32'][0, 100] = 1.
+        with self.assertRaisesRegex(ValueError, 'outside design/non-design'):
+            decompose_apl_sources(**f)
+
+    def test_bad_identity_and_nonpartition_are_rejected(self):
+        for key, value in [('design_pn_globals', np.array([10], np.int32)),
+                           ('design_pn_globals', np.array([1, 1], np.int32)),
+                           ('pn_globals', np.array([1, 4, 10], np.int32)),
+                           ('kc_globals', np.array([10, 20, 40, 30], np.int32)),
+                           ('pn_globals', np.array([1, 4, 6], np.int64))]:
+            with self.subTest(key=key):
+                f = fixture()
+                f[key] = value
+                with self.assertRaises(ValueError):
+                    decompose_apl_sources(**f)
+
+    def test_invalid_events_dtype_order_duplicate_range(self):
+        changes = [('event_step', np.array([0, 1, 2, 4], np.int64)),
+                   ('event_step', np.array([1, 0, 2, 4], np.int32)),
+                   ('event_step', np.array([0, 1, 2, 6], np.int32)),
+                   ('event_node', np.array([1, 4, 10, N], np.int32))]
+        for key, value in changes:
+            with self.subTest(key=key):
+                f = fixture()
+                f[key] = value
+                with self.assertRaises(ValueError):
+                    decompose_apl_sources(**f)
+        f = fixture(events=((0, 1), (0, 1)))
+        with self.assertRaises(ValueError):
+            decompose_apl_sources(**f)
+
+    def test_invalid_trace_matrix_precision_constants_or_environment(self):
+        variants = [dict(standard_fp32=False), dict(standard_fp32=1), dict(chunk_size=0),
+            dict(decay32=float(DECAY32)), dict(gain32=np.nextafter(GAIN32, np.float32(np.inf))),
+            dict(callback=3)]
+        for change in variants:
+            with self.subTest(change=change), self.assertRaises(ValueError):
+                decompose_apl_sources(**(fixture() | change))
+        for name in ('I32', 'O32', 'drive32', 'state32', 'h32'):
+            for bad in ('dtype', 'negative', 'nonfinite'):
+                with self.subTest(name=name, bad=bad):
+                    f = fixture()
+                    if bad == 'dtype':
+                        f[name] = f[name].astype(np.float64)
+                    else:
+                        f[name].flat[0] = -1. if bad == 'negative' else np.nan
+                    with self.assertRaises(ValueError):
+                        decompose_apl_sources(**f)
+
+    def test_no_dense_source_history_or_scientific_runtime(self):
+        out = decompose_apl_sources(**fixture())
+        self.assertEqual(set(out), {'summary', 'tick_rows', 'first_kc_tick', 'per_kc'})
+        self.assertNotIn('torch', sys.modules)
+        self.assertNotIn('brian2', sys.modules)
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)
@@ -0,0 +1,36 @@
+import tempfile
+import unittest
+from pathlib import Path
+import numpy as np
+import pyarrow.parquet as pq
+from run_audit import first_ticks, temporal_relation, min_observed, EventSink
+
+
+class HarnessTests(unittest.TestCase):
+    def test_first_tick_uses_minimum_not_order(self):
+        self.assertEqual(first_ticks(np.array([4, 2, 3], np.int32), np.array([7, 7, 8], np.int32),
+                                    np.array([7, 8, 9], np.int32)).tolist(), [2, 3, -1])
+
+    def test_strict_temporal_boundary(self):
+        self.assertEqual(temporal_relation(17, 18), 'before')
+        self.assertEqual(temporal_relation(18, 18), 'same_tick')
+        self.assertEqual(temporal_relation(19, 18), 'after')
+        self.assertEqual(temporal_relation(-1, 18), 'unobserved_source')
+        self.assertEqual(temporal_relation(18, -1), 'unobserved_target')
+        self.assertEqual(temporal_relation(-1, -1), 'both_unobserved')
+
+    def test_min_observed(self):
+        self.assertEqual(min_observed([-1, 0, 3]), 0)
+        self.assertEqual(min_observed([-1, -1]), -1)
+
+    def test_empty_event_sink_has_schema(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / 'events.parquet'
+            sink = EventSink(path)
+            sink.close()
+            self.assertEqual(pq.read_table(path).num_rows, 0)
+            self.assertIn('source_spike_tick', pq.read_schema(path).names)
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,152 @@
+"""Synthetic CPU-only tests, including the untouched sibling AH callback."""
+import importlib.util
+from pathlib import Path
+import unittest
+
+import numpy as np
+
+from pn_observer import PNObserver
+
+
+path = Path(__file__).resolve().parent.parent / "kc-drive-audit-v1/replay_core.py"
+spec = importlib.util.spec_from_file_location("frozen_ah_observer_test_core", path)
+core = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(core)
+
+
+def event(rows=()):
+    values = np.array(rows, np.int32).reshape(-1, 2)
+    return {"step": values[:, 0], "neuron_idx": values[:, 1]}
+
+
+def run(*, edges=(), events=(), requests=(), n=1, design=(), steps=25, coeff=None,
+        initial_v=None, initial_g=None, sink=None, cap=1000, h=None, hook=None):
+    targets = np.arange(100, 100 + n, dtype=np.int32)
+    constants = dict(gd=1., c0=0., cg=1., cv=1., threshold=1., reset=0., seed_volt=2.)
+    if coeff: constants.update(coeff)
+    arrays = np.asarray(edges).reshape(-1, 4)
+    incoming = core.IncomingIndex(arrays[:, 0].astype(np.int32), arrays[:, 1].astype(np.int32),
+        np.arange(len(arrays), dtype=np.int64) + 81, arrays[:, 2].astype(np.float64), n)
+    groups = arrays[:, 3].astype(np.int16)
+    observer = PNObserver(targets, np.array(design, np.int32), incoming, groups, ("ALPN", "other"), constants,
+                          steps, max_first_event_rows=cap, event_sink=sink)
+    def callback(tick, state):
+        if hook: hook(tick, state, observer)
+        observer(tick, state)
+    result = core.replay(np.zeros(n, np.float64) if initial_v is None else np.array(initial_v, np.float64),
+        np.zeros(n, np.float64) if initial_g is None else np.array(initial_g, np.float64), constants, steps, targets,
+        event(requests), event(events), incoming, np.zeros((steps, n), np.float32) if h is None else h, callback)
+    data, report = observer.finish(result)
+    return observer, result, data, report
+
+
+class PNObserverTests(unittest.TestCase):
+    def test_18_step_arrival_then_19_step_first_spike(self):
+        observer, result, data, report = run(edges=[(10, 0, 2., 0)], events=[(0, 10)])
+        self.assertEqual(data["first_spike_tick"].tolist(), [19])
+        self.assertEqual(len(observer.first_arrival_records), 1)
+        row = observer.first_arrival_records[0]
+        self.assertEqual((row["source_spike_tick"], row["arrival_tick"]), (0, 18))
+        self.assertEqual(row["v_prethreshold_SI"], 0.)
+        self.assertEqual(row["threshold_margin_SI"], 1.)
+        self.assertEqual(data["first_integrated_V_from_ALPN/positive_weight"].tolist(), [2.])
+        self.assertEqual(observer.edge_summary()["target_first_spike_tick"].tolist(), [19])
+        self.assertTrue(report["pass_all"])
+
+    def test_same_tick_first_spike_arrival_is_rejected_not_antecedent(self):
+        observer, _, data, _ = run(edges=[(10, 0, 2., 0)], events=[(0, 10)], requests=[(18, 100)], design=[100])
+        self.assertEqual(data["first_spike_tick"].tolist(), [18])
+        self.assertEqual(observer.first_arrival_records, [])
+        self.assertEqual(data["ALPN_rejected_positive_edges"].tolist(), [1])
+        self.assertEqual(data["ALPN_accepted_positive_before_first_edges"].tolist(), [0])
+        self.assertEqual(data["first_prethreshold_V_from_request_or_reset"].tolist(), [2.])
+
+    def test_all_positive_and_inhibitory_events_are_retained(self):
+        observer, _, data, _ = run(edges=[(10, 0, 2., 0), (11, 0, -.5, 1), (12, 0, 0., 1)],
+                                    events=[(0, 10), (0, 11), (0, 12)])
+        self.assertEqual([r["weight_sign"] for r in observer.first_arrival_records], [1, -1])
+        self.assertEqual(data["first_spike_tick"].tolist(), [19])
+        self.assertEqual(data["other_accepted_zero_edges"].tolist(), [1])
+        self.assertEqual(data["other_accepted_negative_before_first_abs_V"].tolist(), [.5])
+        self.assertEqual(data["first_integrated_V_from_other/negative_weight"].tolist(), [-.5])
+
+    def test_never_active_targets_retain_all_prefirst_records(self):
+        observer, _, data, report = run(edges=[(10, 0, .25, 0)], events=[(0, 10), (1, 10)],
+                                       coeff={"cg": 0.})
+        self.assertEqual(data["first_spike_tick"].tolist(), [-1])
+        self.assertTrue(np.isnan(data["first_v_threshold_SI"][0]))
+        self.assertEqual(observer.edge_summary()["accepted_event_count"].tolist(), [2])
+        self.assertEqual(observer.edge_summary()["target_first_spike_tick"].tolist(), [-1])
+        self.assertEqual(report["first_arrival_record_count"], 2)
+
+    def test_multiple_targets_independent_first_times_and_design(self):
+        observer, _, data, _ = run(n=2, edges=[(10, 0, 2., 0), (10, 1, .25, 0)],
+                                  events=[(0, 10)], requests=[(23, 101)], design=[101])
+        self.assertEqual(data["first_spike_tick"].tolist(), [19, 23])
+        self.assertEqual([r["target_is_design"] for r in observer.first_arrival_records], [False, True])
+        self.assertEqual(data["first_spike_coincident_with_accepted_request"].tolist(), [False, True])
+
+    def test_old_g_not_decayed_g_used_for_first_voltage(self):
+        _, _, data, _ = run(edges=[(10, 0, 4., 0)], events=[(0, 10)],
+                            coeff={"gd": .1, "cg": .5, "cv": 0.})
+        self.assertEqual(data["first_integrated_V_from_ALPN/positive_weight"].tolist(), [2.])
+        self.assertEqual(data["first_spike_tick"].tolist(), [19])
+
+    def test_initial_state_is_not_assigned_to_source_class(self):
+        _, _, data, _ = run(initial_g=[2.])
+        self.assertEqual(data["first_spike_tick"].tolist(), [0])
+        self.assertEqual(data["first_integrated_V_from_initial_and_affine_baseline"].tolist(), [2.])
+        self.assertEqual(data["first_integrated_V_from_ALPN/positive_weight"].tolist(), [0.])
+
+    def test_streaming_sink_and_row_budget_fail_closed(self):
+        received = []
+        observer, _, _, report = run(edges=[(10, 0, .2, 0)], events=[(0, 10)],
+                                     sink=lambda rows: received.extend(rows))
+        self.assertEqual(observer.first_arrival_records, [])
+        self.assertEqual(len(received), report["first_arrival_record_count"])
+        with self.assertRaisesRegex(ValueError, "resource limit"):
+            run(edges=[(10, 0, .2, 0), (11, 0, .2, 1)], events=[(0, 10), (0, 11)], cap=1)
+
+    def test_nonzero_PN_APL_and_non_design_request_are_rejected(self):
+        h = np.zeros((25, 1), np.float32); h[0, 0] = 1
+        with self.assertRaisesRegex(ValueError, "zero graded APL"):
+            run(h=h)
+        with self.assertRaisesRegex(ValueError, "outside frozen odor design"):
+            run(requests=[(0, 100)])
+
+    def test_callback_arrays_not_modified(self):
+        snapshots = []
+        def hook(tick, state, observer):
+            if tick == 0:
+                before = {key: value.copy() for key, value in state.items() if isinstance(value, np.ndarray)}
+                observer(tick, state)
+                for key, value in before.items():
+                    self.assertEqual(state[key].tobytes(), value.tobytes())
+                snapshots.append(True)
+                # Already consumed this tick; stop this synthetic test directly.
+                raise RuntimeError("checked immutability")
+        with self.assertRaisesRegex(RuntimeError, "checked immutability"):
+            run(hook=hook)
+        self.assertEqual(snapshots, [True])
+
+    def test_bad_queue_guard_and_tick_fail_closed(self):
+        def wrong_guard(tick, state, observer):
+            if tick == 18: state["arrival_accepted"][:] = False
+        with self.assertRaisesRegex(ValueError, "Arrival guard"):
+            run(edges=[(10, 0, 2., 0)], events=[(0, 10)], hook=wrong_guard)
+        def wrong_tick(tick, state, observer):
+            observer(tick + 1, state)
+        with self.assertRaisesRegex(ValueError, "out-of-order"):
+            run(hook=wrong_tick)
+
+    def test_sequential_arrival_roundoff_has_own_lane(self):
+        _, _, data, report = run(edges=[(10, 0, 1e16, 0), (11, 0, 1., 0), (12, 0, -1e16, 1)],
+                                 events=[(0, 10), (0, 11), (0, 12)], coeff={"cg": 0.})
+        if np.finfo(np.longdouble).nmant > np.finfo(np.float64).nmant:
+            self.assertEqual(data["arrival_roundoff_g_SI"].tolist(), [-1.])
+        self.assertTrue(report["voltage_decomposition"]["roundoff_lane_explicit"])
+        self.assertFalse(report["unique_cause_claim"])
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,205 @@
+"""Only temporary synthetic seals are used; production publication is never run."""
+import hashlib
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from unittest import mock
+
+import publication
+
+
+def _sha(path):
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def _write(path, value):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value), encoding='utf-8')
+
+
+def _seal(root):
+    rows = [dict(path=path.relative_to(root).as_posix(), bytes=path.stat().st_size, sha256=_sha(path))
+            for path in sorted(root.rglob('*')) if path.is_file() and
+            path.name not in ('manifest.json', 'checksums.sha256') and '__pycache__' not in path.parts]
+    _write(root / 'manifest.json', dict(root=str(root), files=rows))
+    lines = [row['sha256'] + '  ' + row['path'] for row in rows]
+    lines.append(_sha(root / 'manifest.json') + '  manifest.json')
+    (root / 'checksums.sha256').write_text('\n'.join(lines) + '\n', encoding='utf-8')
+
+
+class PublicationTests(unittest.TestCase):
+    def setUp(self):
+        self.temporary = tempfile.TemporaryDirectory(prefix='phase4ai-publication-unit-')
+        self.addCleanup(self.temporary.cleanup)
+        self.root = Path(self.temporary.name).resolve()
+        self.model = self.root / publication.MODEL_RELATIVE
+        self.experiment = self.root / publication.EXPERIMENT_RELATIVE
+        self.registry = self.root / publication.REGISTRY_RELATIVE
+        self.model.mkdir(parents=True)
+        self.experiment.mkdir(parents=True)
+        (self.model / 'module.py').write_text('# synthetic\n', encoding='utf-8')
+        status = dict(status=publication.FINAL_STATUS, pass_all=True, candidate_generated=False,
+                      learning_achieved=False, new_brain_simulation=False, GPU_used=False)
+        _write(self.experiment / 'audit/final-status.json', status)
+        _write(self.experiment / 'trials/example/summary.json', dict(synthetic=True))
+        _write(self.experiment / 'trials/example/apl-summary.json', dict(synthetic=True))
+        (self.experiment / 'REPORT.md').write_text('Synthetic evidence.\n', encoding='utf-8')
+        (self.experiment / 'unit-tests.log').write_text('Synthetic tests passed.\n', encoding='utf-8')
+        (self.experiment / 'counts.npy').write_bytes(b'not-a-real-array')
+        _seal(self.model)
+        _seal(self.experiment)
+
+    def test_all_payload_and_checksum_self_hash_are_verified(self):
+        result = publication.verify_seal(self.experiment)
+        self.assertTrue(result['pass_all'])
+        self.assertEqual(result['payload_file_count'], 6)
+        self.assertEqual(result['manifest_sha256'], _sha(self.experiment / 'manifest.json'))
+
+    def test_publication_only_copies_small_evidence_and_leaves_sources_unchanged(self):
+        before = {str(path): _sha(path) for base in (self.model, self.experiment)
+                  for path in base.rglob('*') if path.is_file()}
+        outcome = publication.publish(self.root)
+        self.assertTrue(outcome['publication_complete'])
+        self.assertFalse(outcome['scientific_gate_executed_by_publisher'])
+        self.assertTrue((self.registry / 'evidence/trials/example/apl-summary.json').is_file())
+        self.assertTrue((self.registry / 'evidence/unit-tests.log').is_file())
+        self.assertFalse((self.registry / 'evidence/counts.npy').exists())
+        self.assertFalse((self.registry / 'model/module.py').exists())
+        self.assertTrue((self.registry / 'model/manifest.json').is_file())
+        receipt = json.loads((self.registry / 'publication-receipt.json').read_text())
+        self.assertFalse(receipt['complete_bulk_backup'])
+        self.assertFalse(receipt['scientific_gate_certified_by_publication'])
+        for row in receipt['files']:
+            path = self.registry / row['path']
+            self.assertEqual(path.stat().st_size, row['bytes'])
+            self.assertEqual(_sha(path), row['sha256'])
+        for name, checksum in before.items():
+            self.assertEqual(_sha(Path(name)), checksum)
+
+    def test_existing_registry_is_never_overwritten_or_resumed(self):
+        self.registry.mkdir(parents=True)
+        sentinel = self.registry / 'keep.txt'
+        sentinel.write_text('keep', encoding='utf-8')
+        with self.assertRaisesRegex(ValueError, 'Registry already exists'):
+            publication.publish(self.root)
+        self.assertEqual(sentinel.read_text(), 'keep')
+        self.assertEqual(list(self.registry.iterdir()), [sentinel])
+
+    def test_bulk_payload_corruption_blocks_before_registry_creation(self):
+        (self.experiment / 'counts.npy').write_bytes(b'corrupt')
+        with self.assertRaisesRegex(ValueError, 'Payload byte count mismatch'):
+            publication.publish(self.root)
+        self.assertFalse(self.registry.exists())
+
+    def test_same_size_payload_hash_corruption_is_detected(self):
+        path = self.experiment / 'counts.npy'
+        path.write_bytes(b'x' * path.stat().st_size)
+        with self.assertRaisesRegex(ValueError, 'Payload SHA-256 mismatch'):
+            publication.verify_seal(self.experiment)
+
+    def test_missing_payload_or_unlisted_file_is_detected(self):
+        (self.experiment / 'extra.txt').write_text('unlisted', encoding='utf-8')
+        with self.assertRaisesRegex(ValueError, 'unlisted/missing'):
+            publication.verify_seal(self.experiment)
+
+    def test_wrong_manifest_self_checksum_is_detected(self):
+        path = self.experiment / 'checksums.sha256'
+        lines = path.read_text().splitlines()
+        lines[-1] = '0' * 64 + '  manifest.json'
+        path.write_text('\n'.join(lines) + '\n')
+        with self.assertRaisesRegex(ValueError, 'manifest self-checksum'):
+            publication.verify_seal(self.experiment)
+
+    def test_duplicate_checksum_path_is_detected(self):
+        path = self.experiment / 'checksums.sha256'
+        text = path.read_text()
+        path.write_text(text + text.splitlines()[0] + '\n')
+        with self.assertRaisesRegex(ValueError, 'Duplicate checksum'):
+            publication.verify_seal(self.experiment)
+
+    def test_manifest_root_mismatch_is_detected(self):
+        path = self.experiment / 'manifest.json'
+        value = json.loads(path.read_text())
+        value['root'] = str(self.model)
+        _write(path, value)
+        with self.assertRaisesRegex(ValueError, 'another root'):
+            publication.verify_seal(self.experiment)
+
+    def test_manifest_duplicate_path_and_traversal_are_rejected(self):
+        manifest = self.experiment / 'manifest.json'
+        original = json.loads(manifest.read_text())
+        for bad_path in ('../escape.txt', '/absolute', 'a/../escape', 'a\\escape', 'C:/escape'):
+            with self.subTest(path=bad_path):
+                value = json.loads(json.dumps(original))
+                value['files'][0]['path'] = bad_path
+                _write(manifest, value)
+                with self.assertRaises(ValueError):
+                    publication.verify_seal(self.experiment)
+        original['files'].append(original['files'][0].copy())
+        _write(manifest, original)
+        with self.assertRaisesRegex(ValueError, 'Duplicate manifest path'):
+            publication.verify_seal(self.experiment)
+
+    def test_explicitly_excluded_pycache_is_not_published(self):
+        cache = self.experiment / '__pycache__/unused.pyc'
+        cache.parent.mkdir()
+        cache.write_bytes(b'cache')
+        self.assertEqual(publication.verify_seal(self.experiment)['excluded_pycache_files'], 1)
+        publication.publish(self.root)
+        self.assertFalse((self.registry / 'evidence/__pycache__').exists())
+
+    def test_file_size_limit_skips_large_json_without_omitting_verification(self):
+        huge = self.experiment / 'huge.json'
+        huge.write_bytes(b' ' * (publication.MAX_EVIDENCE_BYTES + 1))
+        _seal(self.experiment)
+        publication.publish(self.root)
+        self.assertFalse((self.registry / 'evidence/huge.json').exists())
+        receipt = json.loads((self.registry / 'publication-receipt.json').read_text())
+        omitted = {row['path']: row for row in receipt['experiment_payload_not_copied']}
+        self.assertEqual(omitted['huge.json']['reason'], 'exceeds_4_MiB')
+
+    def test_unexpected_final_status_or_scope_flag_blocks_publication(self):
+        path = self.experiment / 'audit/final-status.json'
+        original = json.loads(path.read_text())
+        for field, value in [('status', 'OTHER-PASS'), ('pass_all', False), ('learning_achieved', True),
+                             ('GPU_used', True), ('new_brain_simulation', True), ('candidate_generated', True)]:
+            with self.subTest(field=field):
+                bad = dict(original)
+                bad[field] = value
+                _write(path, bad)
+                _seal(self.experiment)
+                with self.assertRaises(ValueError):
+                    publication.publish(self.root)
+                self.assertFalse(self.registry.exists())
+
+    def test_copy_failure_is_retained_without_success_receipt(self):
+        with mock.patch.object(publication, '_copy_verified', side_effect=OSError('synthetic interruption')):
+            with self.assertRaisesRegex(OSError, 'synthetic interruption'):
+                publication.publish(self.root)
+        self.assertTrue(self.registry.is_dir())
+        self.assertTrue((self.registry / 'publication-failure.json').is_file())
+        self.assertFalse((self.registry / 'publication-receipt.json').exists())
+        with self.assertRaisesRegex(ValueError, 'Registry already exists'):
+            publication.publish(self.root)
+
+    def test_source_change_during_copy_prevents_success(self):
+        original = publication._copy_verified
+        changed = False
+
+        def copy_then_modify(source, target, byte_count, checksum):
+            nonlocal changed
+            original(source, target, byte_count, checksum)
+            if not changed:
+                changed = True
+                (self.experiment / 'counts.npy').write_bytes(b'deliberately-changed-after-initial-verification')
+
+        with mock.patch.object(publication, '_copy_verified', side_effect=copy_then_modify):
+            with self.assertRaisesRegex(ValueError, 'Payload byte count mismatch'):
+                publication.publish(self.root)
+        self.assertFalse((self.registry / 'publication-receipt.json').exists())
+        self.assertTrue((self.registry / 'publication-failure.json').exists())
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,204 @@
+"""Synthetic tests only; no saved scientific results are accessed."""
+import copy
+import json
+import unittest
+
+import numpy as np
+
+from structure_metrics import aggregate_structure, MODES, SEEDS, METRICS
+
+
+def records():
+    rows = []
+    for mode in MODES:
+        for odor in range(6):
+            design = np.zeros(686, bool)
+            design[odor] = True
+            for seed in SEEDS:
+                count = np.zeros(686, np.int32)
+                count[odor] = 10
+                count[10] = seed - SEEDS[0]
+                count[11] = odor
+                rows.append(dict(mode=mode, odor_index=odor, seed=seed,
+                                 counts=count, design_mask=design.copy()))
+    return rows
+
+
+class StructureMetricsTests(unittest.TestCase):
+    def test_fixed_complete_inventory_and_pair_specific_baseline(self):
+        result = aggregate_structure(records())
+        self.assertEqual(result['record_count'], 60)
+        self.assertEqual(result['design']['design_union_count'], 6)
+        self.assertEqual(result['design']['common_non_design_count'], 680)
+        self.assertEqual(result['design']['common_non_design_column_positions'], list(range(6, 686)))
+        for mode in MODES:
+            self.assertEqual(result['modes'][mode]['trials'], 30)
+            for view_name in ('fixed_686', 'common_non_design'):
+                view = result['modes'][mode][view_name]
+                self.assertEqual(len(view['within_comparisons']), 60)
+                self.assertEqual(len(view['between_comparisons']), 75)
+                self.assertEqual(len(view['pairs']), 15)
+                for pair in view['pairs']:
+                    self.assertEqual(len(pair['within_comparisons']), 20)
+                    self.assertEqual(len(pair['between_comparisons']), 5)
+                    self.assertEqual({row['odor_index'] for row in pair['within_comparisons']},
+                                     {pair['odor_index_a'], pair['odor_index_b']})
+                    self.assertEqual([row['seed'] for row in pair['between_comparisons']], list(SEEDS))
+        json.dumps(result, allow_nan=False)
+
+    def test_primary_retains_design_columns_and_common_view_is_fixed(self):
+        result = aggregate_structure(records())['modes'][MODES[0]]
+        pair = result['fixed_686']['pairs'][0]
+        common_pair = result['common_non_design']['pairs'][0]
+        # Odors zero and one differ by two ten-count design axes plus one
+        # shared-coordinate count; same-seed variability cancels between.
+        self.assertEqual(pair['between']['euclidean_distance']['mean'], np.sqrt(201.))
+        self.assertEqual(common_pair['between']['euclidean_distance']['mean'], 1.)
+        self.assertEqual(pair['within']['euclidean_distance']['mean'], 2.)
+        self.assertEqual(common_pair['within']['euclidean_distance']['mean'], 2.)
+
+    def test_input_order_does_not_change_result(self):
+        rows = records()
+        expected = aggregate_structure(rows)
+        actual = aggregate_structure(list(reversed(rows)))
+        self.assertEqual(expected, actual)
+
+    def test_inputs_unchanged_and_readonly_arrays_accepted(self):
+        rows = records()
+        before = copy.deepcopy(rows)
+        for row in rows:
+            row['counts'].setflags(write=False)
+            row['design_mask'].setflags(write=False)
+        aggregate_structure(rows)
+        for old, new in zip(before, rows):
+            np.testing.assert_array_equal(old['counts'], new['counts'])
+            np.testing.assert_array_equal(old['design_mask'], new['design_mask'])
+            self.assertFalse(new['counts'].flags.writeable)
+
+    def test_zero_vectors_do_not_become_similarity_evidence(self):
+        rows = records()
+        for row in rows:
+            row['counts'].fill(0)
+        result = aggregate_structure(rows)
+        for mode in MODES:
+            for name in ('fixed_686', 'common_non_design'):
+                view = result['modes'][mode][name]
+                for metric in ('cosine_distance', 'pearson_correlation', 'jaccard'):
+                    self.assertIsNone(view['within'][metric]['mean'])
+                    self.assertEqual(view['within'][metric]['valid_comparisons'], 0)
+                    self.assertEqual(view['between'][metric]['undefined_comparisons'], 75)
+                self.assertEqual(view['between']['euclidean_distance']['mean'], 0.)
+        json.dumps(result, allow_nan=False)
+
+    def test_constant_nonzero_vectors_have_undefined_pearson(self):
+        rows = records()
+        for row in rows:
+            row['counts'].fill(1)
+        view = aggregate_structure(rows)['modes'][MODES[0]]['fixed_686']
+        self.assertIsNone(view['within']['pearson_correlation']['mean'])
+        self.assertEqual(view['within']['jaccard']['mean'], 1.)
+        self.assertAlmostEqual(view['within']['cosine_distance']['mean'], 0., places=14)
+
+    def test_empty_common_population_is_nonapplicable(self):
+        rows = records()
+        for row in rows:
+            row['design_mask'].fill(True)
+        result = aggregate_structure(rows)
+        self.assertEqual(result['design']['common_non_design_count'], 0)
+        for mode in MODES:
+            view = result['modes'][mode]['common_non_design']
+            self.assertFalse(view['applicable'])
+            self.assertEqual(view['dimensions'], 0)
+            for metric in METRICS:
+                self.assertIsNone(view['between'][metric]['mean'])
+                self.assertEqual(view['within'][metric]['undefined_comparisons'], 60)
+
+    def test_int32_extrema_are_promoted_before_subtraction_and_norm(self):
+        rows = records()
+        maximum = np.iinfo(np.int32).max
+        for row in rows:
+            row['counts'].fill(0)
+            row['counts'][row['odor_index']] = maximum
+        result = aggregate_structure(rows)['modes'][MODES[0]]['fixed_686']
+        distance = result['pairs'][0]['between']['euclidean_distance']['mean']
+        self.assertAlmostEqual(distance / float(maximum), np.sqrt(2.))
+        self.assertEqual(result['between']['cosine_distance']['mean'], 1.)
+        json.dumps(result, allow_nan=False)
+
+    def test_missing_record_or_extra_repeat_rejected(self):
+        rows = records()
+        for bad in (rows[:-1], rows + [copy.deepcopy(rows[0])]):
+            with self.assertRaisesRegex(ValueError, 'Exactly 60'):
+                aggregate_structure(bad)
+
+    def test_duplicate_identity_rejected_even_with_sixty_rows(self):
+        rows = records()
+        rows[-1] = copy.deepcopy(rows[0])
+        with self.assertRaisesRegex(ValueError, 'Duplicate CAL identity'):
+            aggregate_structure(rows)
+
+    def test_mask_change_across_seed_rejected(self):
+        rows = records()
+        rows[1]['design_mask'][100] = True
+        with self.assertRaisesRegex(ValueError, 'mask changed across seed or mode'):
+            aggregate_structure(rows)
+
+    def test_mask_change_across_mode_rejected(self):
+        rows = records()
+        for row in rows:
+            if row['mode'] == MODES[1] and row['odor_index'] == 0:
+                row['design_mask'][100] = True
+        with self.assertRaisesRegex(ValueError, 'mask changed across seed or mode'):
+            aggregate_structure(rows)
+
+    def test_negative_counts_and_incorrect_dtype_or_shape_rejected(self):
+        changes = [('negative', lambda row: row['counts'].__setitem__(0, -1)),
+                   ('counts64', lambda row: row.update(counts=row['counts'].astype(np.int64))),
+                   ('counts_float', lambda row: row.update(counts=row['counts'].astype(np.float64))),
+                   ('shape', lambda row: row.update(counts=np.zeros(685, np.int32))),
+                   ('mask_dtype', lambda row: row.update(design_mask=row['design_mask'].astype(np.uint8))),
+                   ('mask_shape', lambda row: row.update(design_mask=np.zeros(685, bool)))]
+        for label, change in changes:
+            with self.subTest(label=label):
+                rows = records()
+                change(rows[0])
+                with self.assertRaises(ValueError):
+                    aggregate_structure(rows)
+
+    def test_strict_record_schema_and_id_ranges(self):
+        changes = [lambda row: row.update(extra=1), lambda row: row.pop('counts'),
+                   lambda row: row.update(mode='new_mode'), lambda row: row.update(odor_index=6),
+                   lambda row: row.update(odor_index=True), lambda row: row.update(seed=51106),
+                   lambda row: row.update(seed=float(SEEDS[0]))]
+        for change in changes:
+            rows = records()
+            change(rows[0])
+            with self.assertRaises(ValueError):
+                aggregate_structure(rows)
+
+    def test_partial_undefined_metrics_report_counts_without_imputation(self):
+        rows = records()
+        # One zero-count record per mode. Four of the 60 within comparisons
+        # and five of the 75 between comparisons then have undefined cosine.
+        for row in rows:
+            if row['odor_index'] == 0 and row['seed'] == SEEDS[0]:
+                row['counts'].fill(0)
+        view = aggregate_structure(rows)['modes'][MODES[0]]['fixed_686']
+        self.assertEqual(view['within']['cosine_distance']['undefined_comparisons'], 4)
+        self.assertEqual(view['between']['cosine_distance']['undefined_comparisons'], 5)
+        self.assertEqual(view['within']['cosine_distance']['valid_comparisons'], 56)
+        self.assertEqual(view['between']['cosine_distance']['valid_comparisons'], 70)
+
+    def test_one_common_channel_pearson_is_undefined(self):
+        rows = records()
+        for row in rows:
+            row['design_mask'][:685] = True
+            row['counts'][685] = row['odor_index'] + 1
+        view = aggregate_structure(rows)['modes'][MODES[0]]['common_non_design']
+        self.assertEqual(view['dimensions'], 1)
+        self.assertIsNone(view['between']['pearson_correlation']['mean'])
+        self.assertEqual(view['between']['cosine_distance']['mean'], 0.)
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,134 @@
+"""Pure synthetic checks for stateless pre-first event validation."""
+import unittest
+
+import numpy as np
+
+from validate_events import COLUMN_DTYPES, N_GLOBAL, validate_batch
+
+
+def fixture():
+    reference = dict(edge_ids=np.array([7, 20, 99], np.int64),
+        srcglobals=np.array([3, 4, 3], np.int32), dstglobals=np.array([10, 10, 20], np.int32),
+        weights=np.array([.001, -.002, .003], np.float64),
+        target_globals=np.array([10, 20, 30], np.int32), target_first=np.array([30, -1, 0], np.int32),
+        source_event_keys=np.array([3, 4, 4 * N_GLOBAL + 3], np.int64))
+    # Arbitrary order, repeated edge at a later tick, negative and positive.
+    values = dict(edge_id=[99, 20, 7, 99], source_neuron_idx=[3, 4, 3, 3],
+        target_neuron_idx=[20, 10, 10, 20], source_spike_tick=[4, 0, 0, 0],
+        arrival_tick=[22, 18, 18, 18], weight_sign=[1, -1, 1, 1],
+        ref_at_arrival=[0] * 4, weight_SI=[.003, -.002, .001, .003], accepted=[True] * 4)
+    columns = {name: np.array(values[name], dtype) for name, dtype in COLUMN_DTYPES.items()}
+    return columns, reference
+
+
+class EventValidationTests(unittest.TestCase):
+    def test_unordered_rows_real_edges_signed_weights_and_never_first(self):
+        columns, ref = fixture()
+        original = {k: v.copy() for k, v in columns.items()}
+        result = validate_batch(columns, **ref)
+        self.assertEqual(result['count'], 4)
+        np.testing.assert_array_equal(result['per_target_count'], [2, 2, 0])
+        self.assertEqual(result['per_target_count'].dtype, np.int64)
+        self.assertFalse(result['unique_cause_claim'])
+        self.assertFalse(result['cross_batch_completeness_checked'])
+        for key in columns:
+            np.testing.assert_array_equal(columns[key], original[key])
+
+    def test_empty_valid_but_missing_wrong_dtype_or_shape_still_rejected(self):
+        columns, ref = fixture()
+        empty = {name: value[:0] for name, value in columns.items()}
+        result = validate_batch(empty, **ref)
+        self.assertEqual(result['count'], 0)
+        np.testing.assert_array_equal(result['per_target_count'], [0, 0, 0])
+        bad = empty.copy()
+        bad['arrival_tick'] = np.empty(0, np.int64)
+        with self.assertRaises(ValueError):
+            validate_batch(bad, **ref)
+        bad = empty.copy()
+        del bad['accepted']
+        with self.assertRaises(ValueError):
+            validate_batch(bad, **ref)
+        bad = empty.copy()
+        bad['weight_sign'] = np.empty((0, 1), np.int32)
+        with self.assertRaises(ValueError):
+            validate_batch(bad, **ref)
+
+    def test_every_edge_field_and_weight_bit_is_checked(self):
+        for field, value in [('edge_id', 8), ('source_neuron_idx', 4), ('target_neuron_idx', 10),
+                             ('weight_sign', -1), ('weight_SI', np.nextafter(.003, np.inf))]:
+            with self.subTest(field=field):
+                columns, ref = fixture()
+                columns[field][0] = value
+                with self.assertRaises(ValueError):
+                    validate_batch(columns, **ref)
+        columns, ref = fixture()
+        ref['weights'][2] = 0.
+        columns['weight_SI'][[0, 3]] = -0.
+        with self.assertRaisesRegex(ValueError, 'bits mismatch'):
+            validate_batch(columns, **ref)
+        columns['weight_SI'][[0, 3]] = 0.
+        with self.assertRaisesRegex(ValueError, 'zero-weight'):
+            validate_batch(columns, **ref)
+
+    def test_guard_strict_prefirst_and_source_delay(self):
+        changes = [('accepted', False), ('ref_at_arrival', 1), ('source_spike_tick', -1),
+                   ('source_spike_tick', 3), ('arrival_tick', 21)]
+        for field, value in changes:
+            with self.subTest(field=field):
+                columns, ref = fixture()
+                columns[field][0] = value
+                with self.assertRaises(ValueError):
+                    validate_batch(columns, **ref)
+        for first in (22, 21):
+            columns, ref = fixture()
+            ref['target_first'][1] = first
+            with self.assertRaisesRegex(ValueError, 'strictly before'):
+                validate_batch(columns, **ref)
+
+    def test_source_event_membership_and_target_population(self):
+        columns, ref = fixture()
+        ref['source_event_keys'] = ref['source_event_keys'][:2]
+        with self.assertRaisesRegex(ValueError, 'source spike'):
+            validate_batch(columns, **ref)
+        columns, ref = fixture()
+        ref['target_globals'] = np.array([10, 30], np.int32)
+        ref['target_first'] = np.array([30, 0], np.int32)
+        with self.assertRaisesRegex(ValueError, 'target global'):
+            validate_batch(columns, **ref)
+
+    def test_duplicate_rows_rejected_without_sort_assumption(self):
+        columns, ref = fixture()
+        for value in columns.values():
+            value[0] = value[3]
+        with self.assertRaisesRegex(ValueError, 'Duplicate edge event'):
+            validate_batch(columns, **ref)
+
+    def test_invalid_reference_schema_order_duplicate_range_nonfinite(self):
+        variants = [dict(edge_ids=np.array([7, 20, 99], np.int32)),
+            dict(edge_ids=np.array([7, 99, 20], np.int64)),
+            dict(edge_ids=np.array([7, 20, 20], np.int64)),
+            dict(srcglobals=np.array([3, 4, N_GLOBAL], np.int32)),
+            dict(weights=np.array([.001, -.002, np.inf])),
+            dict(target_first=np.array([30, -2, 0], np.int32)),
+            dict(source_event_keys=np.array([3, 3, 4], np.int64)),
+            dict(source_event_keys=np.array([4, 3], np.int64)),
+            dict(source_event_keys=np.array([-1, 3], np.int64))]
+        for change in variants:
+            with self.subTest(change=change):
+                columns, ref = fixture()
+                with self.assertRaises(ValueError):
+                    validate_batch(columns, **(ref | change))
+
+    def test_optional_design_and_local_row_fields_are_not_assumed(self):
+        columns, ref = fixture()
+        columns['incoming_edge_row'] = np.array([1000, 2, 1, 1000], np.int64)
+        columns['target_is_design'] = np.array([True, False, True, False])
+        self.assertEqual(validate_batch(columns, **ref)['count'], 4)
+        bad = columns.copy()
+        bad['accepted'] = columns['accepted'].astype(np.uint8)
+        with self.assertRaises(ValueError):
+            validate_batch(bad, **ref)
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)
@@ -0,0 +1,123 @@
+"""Stateless independent checks for accepted pre-first anatomical event rows.
+
+Pure NumPy: no files or brain execution. Passing establishes row consistency
+with the supplied graph and recorded source events, not necessity/unique cause.
+The caller owns provenance, design labels, trial bounds, cross-batch duplicate
+detection, expected totals, and completeness of the full record collection.
+"""
+from collections.abc import Mapping
+
+import numpy as np
+
+
+N_GLOBAL = 166700
+DELAY_STEPS = 18
+COLUMN_DTYPES = {
+    'edge_id': np.int64,
+    'source_neuron_idx': np.int32,
+    'target_neuron_idx': np.int32,
+    'source_spike_tick': np.int32,
+    'arrival_tick': np.int32,
+    'weight_sign': np.int32,
+    'ref_at_arrival': np.int32,
+    'weight_SI': np.float64,
+    'accepted': np.bool_,
+}
+
+
+def _require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def _vector(value, dtype, name, length=None):
+    _require(isinstance(value, np.ndarray), name + ' must be a NumPy array')
+    _require(value.dtype == np.dtype(dtype) and value.ndim == 1, name + ' has the wrong dtype/shape')
+    _require(length is None or len(value) == length, name + ' has the wrong length')
+    return value
+
+
+def _globals(value, name, length=None, sorted_unique=False):
+    value = _vector(value, np.int32, name, length)
+    _require(np.all((value >= 0) & (value < N_GLOBAL)), name + ' contains an out-of-range global ID')
+    if sorted_unique:
+        _require(np.all(value[1:] > value[:-1]), name + ' must be sorted and unique')
+    return value
+
+
+def _lookup(sorted_reference, wanted, name):
+    positions = np.searchsorted(sorted_reference, wanted)
+    _require(np.all(positions < len(sorted_reference)), name + ' is absent from the reference')
+    _require(np.array_equal(sorted_reference[positions], wanted), name + ' is absent from the reference')
+    return positions
+
+
+def validate_batch(columns, *, edge_ids, srcglobals, dstglobals, weights,
+                   target_globals, target_first, source_event_keys):
+    """Validate arbitrary-order rows; return count and target-indexed int64 counts.
+
+    Required columns and exact dtypes are COLUMN_DTYPES. Additional columns are
+    intentionally not interpreted: in particular incoming_edge_row has a
+    caller-specific coordinate system, and design/source labels are separate.
+    References: sorted unique nonnegative edge_ids:int64[E]; source/destination
+    globals:int32[E]; finite effective SI weights:float64[E]; sorted unique
+    target_globals:int32[K]; target_first:int32[K] (-1 means never fired);
+    source_event_keys:int64 sorted unique, encoding tick*166700+global ID.
+
+    Every row must reference a real nonzero edge, its exact weight bits/sign,
+    accepted=True/ref_at_arrival=0, a recorded source event exactly 18 ticks
+    earlier, and arrival strictly before the target's first spike, if any.
+    Duplicate (arrival_tick,edge_id) rows within this batch are rejected without
+    assuming any input row ordering. Cross-batch duplicates require caller state.
+    Empty batches still require valid complete schema/references and return zero.
+    No supplied array is modified or sorted in place.
+    """
+    _require(isinstance(columns, Mapping), 'columns must be a mapping')
+    _require(set(COLUMN_DTYPES).issubset(columns), 'Missing required event columns')
+    ids = _vector(edge_ids, np.int64, 'edge_ids')
+    e = len(ids)
+    _require(np.all(ids >= 0) and np.all(ids[1:] > ids[:-1]), 'edge_ids must be sorted unique nonnegative IDs')
+    sources = _globals(srcglobals, 'srcglobals', e)
+    destinations = _globals(dstglobals, 'dstglobals', e)
+    weight = _vector(weights, np.float64, 'weights', e)
+    _require(np.isfinite(weight).all(), 'Nonfinite reference weight')
+    targets = _globals(target_globals, 'target_globals', sorted_unique=True)
+    first = _vector(target_first, np.int32, 'target_first', len(targets))
+    _require(np.all(first >= -1), 'target_first must be -1 or a nonnegative tick')
+    keys = _vector(source_event_keys, np.int64, 'source_event_keys')
+    largest_key = int(np.iinfo(np.int32).max) * N_GLOBAL + N_GLOBAL - 1
+    _require(np.all((keys >= 0) & (keys <= largest_key)) and np.all(keys[1:] > keys[:-1]),
+             'source_event_keys must be sorted unique valid int32-tick/global encodings')
+    count = len(_vector(columns['edge_id'], np.int64, 'columns.edge_id'))
+    data = {name: _vector(columns[name], dtype, 'columns.' + name, count)
+            for name, dtype in COLUMN_DTYPES.items()}
+    _require(np.isfinite(data['weight_SI']).all(), 'Nonfinite recorded weight')
+    _require(np.all(data['accepted']) and np.all(data['ref_at_arrival'] == 0),
+             'Recorded arrival was not accepted at ref=0')
+    row_edge = _lookup(ids, data['edge_id'], 'Recorded edge ID')
+    _require(np.array_equal(data['source_neuron_idx'], sources[row_edge]), 'Recorded edge source mismatch')
+    _require(np.array_equal(data['target_neuron_idx'], destinations[row_edge]), 'Recorded edge target mismatch')
+    actual_weight = weight[row_edge]
+    _require(np.array_equal(np.ascontiguousarray(data['weight_SI']).view(np.uint64),
+                            np.ascontiguousarray(actual_weight).view(np.uint64)), 'Recorded weight bits mismatch')
+    _require(np.all(actual_weight != 0), 'Pre-first nonzero-event table contains a zero-weight edge')
+    _require(np.array_equal(data['weight_sign'], np.sign(actual_weight).astype(np.int32)), 'Recorded weight sign mismatch')
+    local_targets = _lookup(targets, data['target_neuron_idx'], 'Recorded target global')
+    arrival = data['arrival_tick'].astype(np.int64)
+    source_tick = data['source_spike_tick'].astype(np.int64)
+    _require(np.all(source_tick >= 0) and np.array_equal(source_tick, arrival - DELAY_STEPS),
+             'Source/arrival delay is not exactly 18 nonnegative ticks')
+    wanted_keys = source_tick * np.int64(N_GLOBAL) + data['source_neuron_idx'].astype(np.int64)
+    _lookup(keys, wanted_keys, 'Recorded source spike')
+    target_first_rows = first[local_targets].astype(np.int64)
+    _require(np.all((target_first_rows == -1) | (arrival < target_first_rows)),
+             'Arrival is not strictly before the observed first target spike')
+    if count > 1:
+        order = np.lexsort((data['edge_id'], arrival))
+        sorted_arrival, sorted_edge = arrival[order], data['edge_id'][order]
+        _require(not np.any((sorted_arrival[1:] == sorted_arrival[:-1]) &
+                            (sorted_edge[1:] == sorted_edge[:-1])), 'Duplicate edge event within batch')
+    per_target = np.bincount(local_targets, minlength=len(targets)).astype(np.int64, copy=False)
+    _require(int(per_target.sum()) == count, 'Target counts do not cover the batch')
+    return dict(pass_all=True, count=count, per_target_count=per_target,
+                unique_cause_claim=False, cross_batch_completeness_checked=False)
@@ -0,0 +1,7 @@
+# Phase 4AI — conditional PN recruitment and APL source audit
+
+Status: `PASS-CONDITIONAL-PN-APL-SOURCE-AUDIT`.
+
+80 existing records; PN events/counts/final states exact; eight fixture histories exact; twelve repeats exact. No new brain experiment, tuning, training, GPU, or learning candidate.
+
+See audit/final-status.json and audit/PN-odor-structure.json. Accepted edges are timed antecedents, not unique causes. Graded-APL cumulative source shares are descriptive, not causal or error-bounded majority claims. Prior CAL failure remains unchanged. Frozen integrity passed; five reference simulations were not rerun.
@@ -0,0 +1,564 @@
+{
+  "pass_all": true,
+  "trials": [
+    {
+      "case": "zero",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "pn_pulse",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "kc_ref_boundary",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "two_sources",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "arrival_collision",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "natural_request",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "apl_only",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "high_fanin",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-00-s51101",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-00-s51101",
+      "repeat": 1,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-00-s51102",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-00-s51103",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-00-s51104",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-00-s51105",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-01-s51101",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-01-s51101",
+      "repeat": 1,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-01-s51102",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-01-s51103",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-01-s51104",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-01-s51105",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-02-s51101",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-02-s51101",
+      "repeat": 1,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-02-s51102",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-02-s51103",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-02-s51104",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-02-s51105",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-03-s51101",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-03-s51101",
+      "repeat": 1,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-03-s51102",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-03-s51103",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-03-s51104",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-03-s51105",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-04-s51101",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-04-s51101",
+      "repeat": 1,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-04-s51102",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-04-s51103",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-04-s51104",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-04-s51105",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-05-s51101",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-05-s51101",
+      "repeat": 1,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-05-s51102",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-05-s51103",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-05-s51104",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-physiological-05-s51105",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-00-s51101",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-00-s51101",
+      "repeat": 1,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-00-s51102",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-00-s51103",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-00-s51104",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-00-s51105",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-01-s51101",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-01-s51101",
+      "repeat": 1,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-01-s51102",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-01-s51103",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-01-s51104",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-01-s51105",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-02-s51101",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-02-s51101",
+      "repeat": 1,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-02-s51102",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-02-s51103",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-02-s51104",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-02-s51105",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-03-s51101",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-03-s51101",
+      "repeat": 1,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-03-s51102",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-03-s51103",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-03-s51104",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-03-s51105",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-04-s51101",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-04-s51101",
+      "repeat": 1,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-04-s51102",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-04-s51103",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-04-s51104",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-04-s51105",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-05-s51101",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-05-s51101",
+      "repeat": 1,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-05-s51102",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-05-s51103",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-05-s51104",
+      "repeat": 0,
+      "pass_all": true
+    },
+    {
+      "case": "cal-matched_energy-05-s51105",
+      "repeat": 0,
+      "pass_all": true
+    }
+  ],
+  "repeat_checks": [
+    {
+      "case": "cal-physiological-00-s51101",
+      "pass_all": true,
+      "checks": {
+        "per-pn.parquet": true,
+        "prefirst-edge-summary.parquet": true,
+        "apl-per-tick.parquet": true,
+        "per-kc-apl-sources.parquet": true,
+        "antecedent_events": true,
+        "apl-summary": true,
+        "replay": true
+      }
+    },
+    {
+      "case": "cal-physiological-01-s51101",
+      "pass_all": true,
+      "checks": {
+        "per-pn.parquet": true,
+        "prefirst-edge-summary.parquet": true,
+        "apl-per-tick.parquet": true,
+        "per-kc-apl-sources.parquet": true,
+        "antecedent_events": true,
+        "apl-summary": true,
+        "replay": true
+      }
+    },
+    {
+      "case": "cal-physiological-02-s51101",
+      "pass_all": true,
+      "checks": {
+        "per-pn.parquet": true,
+        "prefirst-edge-summary.parquet": true,
+        "apl-per-tick.parquet": true,
+        "per-kc-apl-sources.parquet": true,
+        "antecedent_events": true,
+        "apl-summary": true,
+        "replay": true
+      }
+    },
+    {
+      "case": "cal-physiological-03-s51101",
+      "pass_all": true,
+      "checks": {
+        "per-pn.parquet": true,
+        "prefirst-edge-summary.parquet": true,
+        "apl-per-tick.parquet": true,
+        "per-kc-apl-sources.parquet": true,
+        "antecedent_events": true,
+        "apl-summary": true,
+        "replay": true
+      }
+    },
+    {
+      "case": "cal-physiological-04-s51101",
+      "pass_all": true,
+      "checks": {
+        "per-pn.parquet": true,
+        "prefirst-edge-summary.parquet": true,
+        "apl-per-tick.parquet": true,
+        "per-kc-apl-sources.parquet": true,
+        "antecedent_events": true,
+        "apl-summary": true,
+        "replay": true
+      }
+    },
+    {
+      "case": "cal-physiological-05-s51101",
+      "pass_all": true,
+      "checks": {
+        "per-pn.parquet": true,
+        "prefirst-edge-summary.parquet": true,
+        "apl-per-tick.parquet": true,
+        "per-kc-apl-sources.parquet": true,
+        "antecedent_events": true,
+        "apl-summary": true,
+        "replay": true
+      }
+    },
+    {
+      "case": "cal-matched_energy-00-s51101",
+      "pass_all": true,
+      "checks": {
+        "per-pn.parquet": true,
+        "prefirst-edge-summary.parquet": true,
+        "apl-per-tick.parquet": true,
+        "per-kc-apl-sources.parquet": true,
+        "antecedent_events": true,
+        "apl-summary": true,
+        "replay": true
+      }
+    },
+    {
+      "case": "cal-matched_energy-01-s51101",
+      "pass_all": true,
+      "checks": {
+        "per-pn.parquet": true,
+        "prefirst-edge-summary.parquet": true,
+        "apl-per-tick.parquet": true,
+        "per-kc-apl-sources.parquet": true,
+        "antecedent_events": true,
+        "apl-summary": true,
+        "replay": true
+      }
+    },
+    {
+      "case": "cal-matched_energy-02-s51101",
+      "pass_all": true,
+      "checks": {
+        "per-pn.parquet": true,
+        "prefirst-edge-summary.parquet": true,
+        "apl-per-tick.parquet": true,
+        "per-kc-apl-sources.parquet": true,
+        "antecedent_events": true,
+        "apl-summary": true,
+        "replay": true
+      }
+    },
+    {
+      "case": "cal-matched_energy-03-s51101",
+      "pass_all": true,
+      "checks": {
+        "per-pn.parquet": true,
+        "prefirst-edge-summary.parquet": true,
+        "apl-per-tick.parquet": true,
+        "per-kc-apl-sources.parquet": true,
+        "antecedent_events": true,
+        "apl-summary": true,
+        "replay": true
+      }
+    },
+    {
+      "case": "cal-matched_energy-04-s51101",
+      "pass_all": true,
+      "checks": {
+        "per-pn.parquet": true,
+        "prefirst-edge-summary.parquet": true,
+        "apl-per-tick.parquet": true,
+        "per-kc-apl-sources.parquet": true,
+        "antecedent_events": true,
+        "apl-summary": true,
+        "replay": true
+      }
+    },
+    {
+      "case": "cal-matched_energy-05-s51101",
+      "pass_all": true,
+      "checks": {
+        "per-pn.parquet": true,
+        "prefirst-edge-summary.parquet": true,
+        "apl-per-tick.parquet": true,
+        "per-kc-apl-sources.parquet": true,
+        "antecedent_events": true,
+        "apl-summary": true,
+        "replay": true
+      }
+    }
+  ],
+  "meaning": "Conditional PN exactness and bounded APL attribution only; not a learning or causal gate"
+}
@@ -0,0 +1,640 @@
+{
+  "status": "PASS-CONDITIONAL-PN-APL-SOURCE-AUDIT",
+  "pass_all": true,
+  "exact_PN_trials": 80,
+  "fixture_dense_pre_post_trials": 8,
+  "CAL_event_final_trials": 72,
+  "repeat_accounting_pass": 12,
+  "modes": {
+    "physiological": {
+      "trials": 30,
+      "first_non_design_vs_first_KC": {
+        "before": 30
+      },
+      "first_non_design_PN_tick_range": [
+        40,
+        223
+      ],
+      "first_any_KC_tick_range": [
+        111,
+        322
+      ],
+      "each_active_KC_relation": {
+        "before": 1550
+      },
+      "each_active_KC_count": 1550,
+      "each_active_KC_has_strict_pre_first_nondesign_PN_edge": 1539,
+      "PN_neuron_trials": 20580,
+      "PN_active_neuron_trials": 16311,
+      "PN_spikes": 154514,
+      "design_PN_spikes": 15835,
+      "nondesign_PN_spikes": 138679,
+      "non_design_PN_input_sources": {
+        "KC": {
+          "due_edges": 2071,
+          "accepted_edges": 1316,
+          "rejected_edges": 755,
+          "accepted_zero_edges": 0,
+          "rejected_zero_edges": 0,
+          "accepted_positive_edges": 1316,
+          "accepted_negative_edges": 0,
+          "rejected_positive_edges": 755,
+          "rejected_negative_edges": 0,
+          "accepted_nonzero_before_first_edges": 283,
+          "accepted_positive_before_first_edges": 283,
+          "accepted_negative_before_first_edges": 0,
+          "accepted_positive_V": 0.4400000000000001,
+          "accepted_negative_abs_V": 0.0,
+          "rejected_positive_V": 0.24750000000000005,
+          "rejected_negative_abs_V": 0.0,
+          "accepted_positive_before_first_V": 0.10780000000000002,
+          "accepted_negative_before_first_abs_V": 0.0
+        },
+        "APL": {
+          "due_edges": 150474,
+          "accepted_edges": 105868,
+          "rejected_edges": 44606,
+          "accepted_zero_edges": 105868,
+          "rejected_zero_edges": 44606,
+          "accepted_positive_edges": 0,
+          "accepted_negative_edges": 0,
+          "rejected_positive_edges": 0,
+          "rejected_negative_edges": 0,
+          "accepted_nonzero_before_first_edges": 0,
+          "accepted_positive_before_first_edges": 0,
+          "accepted_negative_before_first_edges": 0,
+          "accepted_positive_V": 0.0,
+          "accepted_negative_abs_V": 0.0,
+          "rejected_positive_V": 0.0,
+          "rejected_negative_abs_V": 0.0,
+          "accepted_positive_before_first_V": 0.0,
+          "accepted_negative_before_first_abs_V": 0.0
+        },
+        "ALPN": {
+          "due_edges": 6412899,
+          "accepted_edges": 4835492,
+          "rejected_edges": 1577407,
+          "accepted_zero_edges": 0,
+          "rejected_zero_edges": 0,
+          "accepted_positive_edges": 4458134,
+          "accepted_negative_edges": 377358,
+          "rejected_positive_edges": 1448863,
+          "rejected_negative_edges": 128544,
+          "accepted_nonzero_before_first_edges": 1381961,
+          "accepted_positive_before_first_edges": 1270361,
+          "accepted_negative_before_first_edges": 111600,
+          "accepted_positive_V": 8907.84785,
+          "accepted_negative_abs_V": 296.8944000000001,
+          "rejected_positive_V": 3159.213475,
+          "rejected_negative_abs_V": 151.61025,
+          "accepted_positive_before_first_V": 2166.2817000000005,
+          "accepted_negative_before_first_abs_V": 100.84717500000001
+        },
+        "MBON": {
+          "due_edges": 20002,
+          "accepted_edges": 16836,
+          "rejected_edges": 3166,
+          "accepted_zero_edges": 0,
+          "rejected_zero_edges": 0,
+          "accepted_positive_edges": 13338,
+          "accepted_negative_edges": 3498,
+          "rejected_positive_edges": 2798,
+          "rejected_negative_edges": 368,
+          "accepted_nonzero_before_first_edges": 7158,
+          "accepted_positive_before_first_edges": 5254,
+          "accepted_negative_before_first_edges": 1904,
+          "accepted_positive_V": 30.284925,
+          "accepted_negative_abs_V": 2.446949999999999,
+          "rejected_positive_V": 10.2927,
+          "rejected_negative_abs_V": 0.4045249999999999,
+          "accepted_positive_before_first_V": 9.71025,
+          "accepted_negative_before_first_abs_V": 1.2856249999999998
+        },
+        "anatomical_DAN": {
+          "due_edges": 102093,
+          "accepted_edges": 75247,
+          "rejected_edges": 26846,
+          "accepted_zero_edges": 8583,
+          "rejected_zero_edges": 2780,
+          "accepted_positive_edges": 66664,
+          "accepted_negative_edges": 0,
+          "rejected_positive_edges": 24066,
+          "rejected_negative_edges": 0,
+          "accepted_nonzero_before_first_edges": 19016,
+          "accepted_positive_before_first_edges": 19016,
+          "accepted_negative_before_first_edges": 0,
+          "accepted_positive_V": 63.956475000000005,
+          "accepted_negative_abs_V": 0.0,
+          "rejected_positive_V": 32.133475,
+          "rejected_negative_abs_V": 0.0,
+          "accepted_positive_before_first_V": 10.072699999999998,
+          "accepted_negative_before_first_abs_V": 0.0
+        },
+        "dopamine_annotation_only": {
+          "due_edges": 10133,
+          "accepted_edges": 7216,
+          "rejected_edges": 2917,
+          "accepted_zero_edges": 0,
+          "rejected_zero_edges": 0,
+          "accepted_positive_edges": 7216,
+          "accepted_negative_edges": 0,
+          "rejected_positive_edges": 2917,
+          "rejected_negative_edges": 0,
+          "accepted_nonzero_before_first_edges": 1905,
+          "accepted_positive_before_first_edges": 1905,
+          "accepted_negative_before_first_edges": 0,
+          "accepted_positive_V": 3.3907500000000006,
+          "accepted_negative_abs_V": 0.0,
+          "rejected_positive_V": 1.47785,
+          "rejected_negative_abs_V": 0.0,
+          "accepted_positive_before_first_V": 0.720225,
+          "accepted_negative_before_first_abs_V": 0.0
+        },
+        "ALLN": {
+          "due_edges": 22665855,
+          "accepted_edges": 17224492,
+          "rejected_edges": 5441363,
+          "accepted_zero_edges": 2117146,
+          "rejected_zero_edges": 641726,
+          "accepted_positive_edges": 9682545,
+          "accepted_negative_edges": 5424801,
+          "rejected_positive_edges": 3108130,
+          "rejected_negative_edges": 1691507,
+          "accepted_nonzero_before_first_edges": 4603287,
+          "accepted_positive_before_first_edges": 2827157,
+          "accepted_negative_before_first_edges": 1776130,
+          "accepted_positive_V": 22630.828275,
+          "accepted_negative_abs_V": 15889.297050000005,
+          "rejected_positive_V": 12808.797099999998,
+          "rejected_negative_abs_V": 5691.117025000002,
+          "accepted_positive_before_first_V": 3781.1674999999996,
+          "accepted_negative_before_first_abs_V": 5524.98155
+        },
+        "ALIN": {
+          "due_edges": 296795,
+          "accepted_edges": 222311,
+          "rejected_edges": 74484,
+          "accepted_zero_edges": 0,
+          "rejected_zero_edges": 0,
+          "accepted_positive_edges": 138337,
+          "accepted_negative_edges": 83974,
+          "rejected_positive_edges": 49976,
+          "rejected_negative_edges": 24508,
+          "accepted_nonzero_before_first_edges": 66282,
+          "accepted_positive_before_first_edges": 37980,
+          "accepted_negative_before_first_edges": 28302,
+          "accepted_positive_V": 139.28640000000001,
+          "accepted_negative_abs_V": 292.3756000000001,
+          "rejected_positive_V": 63.451025,
+          "rejected_negative_abs_V": 86.122575,
+          "accepted_positive_before_first_V": 28.98115000000001,
+          "accepted_negative_before_first_abs_V": 107.00002500000001
+        },
+        "ALON": {
+          "due_edges": 217376,
+          "accepted_edges": 167813,
+          "rejected_edges": 49563,
+          "accepted_zero_edges": 0,
+          "rejected_zero_edges": 0,
+          "accepted_positive_edges": 66214,
+          "accepted_negative_edges": 101599,
+          "rejected_positive_edges": 21764,
+          "rejected_negative_edges": 27799,
+          "accepted_nonzero_before_first_edges": 62049,
+          "accepted_positive_before_first_edges": 21938,
+          "accepted_negative_before_first_edges": 40111,
+          "accepted_positive_V": 129.708975,
+          "accepted_negative_abs_V": 259.9476,
+          "rejected_positive_V": 24.702975000000002,
+          "rejected_negative_abs_V": 45.086800000000004,
+          "accepted_positive_before_first_V": 43.279775,
+          "accepted_negative_before_first_abs_V": 130.11047499999998
+        },
+        "olfactory_sensory": {
+          "due_edges": 24114,
+          "accepted_edges": 17457,
+          "rejected_edges": 6657,
+          "accepted_zero_edges": 0,
+          "rejected_zero_edges": 0,
+          "accepted_positive_edges": 17457,
+          "accepted_negative_edges": 0,
+          "rejected_positive_edges": 6657,
+          "rejected_negative_edges": 0,
+          "accepted_nonzero_before_first_edges": 4398,
+          "accepted_positive_before_first_edges": 4398,
+          "accepted_negative_before_first_edges": 0,
+          "accepted_positive_V": 62.863625,
+          "accepted_negative_abs_V": 0.0,
+          "rejected_positive_V": 32.930425,
+          "rejected_negative_abs_V": 0.0,
+          "accepted_positive_before_first_V": 5.814050000000003,
+          "accepted_negative_before_first_abs_V": 0.0
+        },
+        "other": {
+          "due_edges": 4757427,
+          "accepted_edges": 3465052,
+          "rejected_edges": 1292375,
+          "accepted_zero_edges": 189840,
+          "rejected_zero_edges": 68143,
+          "accepted_positive_edges": 951633,
+          "accepted_negative_edges": 2323579,
+          "rejected_positive_edges": 308418,
+          "rejected_negative_edges": 915814,
+          "accepted_nonzero_before_first_edges": 839252,
+          "accepted_positive_before_first_edges": 276466,
+          "accepted_negative_before_first_edges": 562786,
+          "accepted_positive_V": 1643.72065,
+          "accepted_negative_abs_V": 3503.0349749999996,
+          "rejected_positive_V": 757.28015,
+          "rejected_negative_abs_V": 1881.5106750000002,
+          "accepted_positive_before_first_V": 353.16050000000007,
+          "accepted_negative_before_first_abs_V": 673.2217250000001
+        },
+        "unclassified": {
+          "due_edges": 78924,
+          "accepted_edges": 60973,
+          "rejected_edges": 17951,
+          "accepted_zero_edges": 2072,
+          "rejected_zero_edges": 784,
+          "accepted_positive_edges": 15504,
+          "accepted_negative_edges": 43397,
+          "rejected_positive_edges": 4292,
+          "rejected_negative_edges": 12875,
+          "accepted_nonzero_before_first_edges": 14141,
+          "accepted_positive_before_first_edges": 4247,
+          "accepted_negative_before_first_edges": 9894,
+          "accepted_positive_V": 9.852150000000002,
+          "accepted_negative_abs_V": 42.12312500000001,
+          "rejected_positive_V": 2.1029250000000004,
+          "rejected_negative_abs_V": 20.430025000000004,
+          "accepted_positive_before_first_V": 3.1528750000000003,
+          "accepted_negative_before_first_abs_V": 5.785175
+        }
+      },
+      "APL_sources": {
+        "design_ALPN": {
+          "h_sum_mV": 33930928.05712421,
+          "h_before_first_KC_sum_mV": 17377.491899006312,
+          "h_never_fired_KC_sum_mV": 33568137.563492276,
+          "h_before_first_any_KC_sum_mV": 802839.8771653378,
+          "drive_sum": 9333.30871398747,
+          "h_sum_mV_fraction": 0.21375800841248854,
+          "h_before_first_KC_sum_mV_fraction": 0.2594529050911962,
+          "h_before_first_any_KC_sum_mV_fraction": 0.3713544005001501,
+          "drive_sum_fraction": 0.21390673846769892
+        },
+        "non_design_ALPN": {
+          "h_sum_mV": 117311355.02550764,
+          "h_before_first_KC_sum_mV": 44556.65791527906,
+          "h_never_fired_KC_sum_mV": 116010919.08425687,
+          "h_before_first_any_KC_sum_mV": 1359083.8164385387,
+          "drive_sum": 32629.246017321944,
+          "h_sum_mV_fraction": 0.739037894047753,
+          "h_before_first_KC_sum_mV_fraction": 0.6652487254466706,
+          "h_before_first_any_KC_sum_mV_fraction": 0.6286455994998499,
+          "drive_sum_fraction": 0.7478179291086141
+        },
+        "KC": {
+          "h_sum_mV": 7492953.595133901,
+          "h_before_first_KC_sum_mV": 5043.29217233731,
+          "h_never_fired_KC_sum_mV": 7395753.445729335,
+          "h_before_first_any_KC_sum_mV": 0.0,
+          "drive_sum": 1670.0525481328368,
+          "h_sum_mV_fraction": 0.04720409753975847,
+          "h_before_first_KC_sum_mV_fraction": 0.07529836946213324,
+          "h_before_first_any_KC_sum_mV_fraction": 0.0,
+          "drive_sum_fraction": 0.038275332423686984
+        }
+      },
+      "common_non_design_dimensions": 610,
+      "counts_are_neuron_trials_not_distinct_neurons": true
+    },
+    "matched_energy": {
+      "trials": 30,
+      "first_non_design_vs_first_KC": {
+        "before": 30
+      },
+      "first_non_design_PN_tick_range": [
+        45,
+        216
+      ],
+      "first_any_KC_tick_range": [
+        126,
+        294
+      ],
+      "each_active_KC_relation": {
+        "before": 1504
+      },
+      "each_active_KC_count": 1504,
+      "each_active_KC_has_strict_pre_first_nondesign_PN_edge": 1496,
+      "PN_neuron_trials": 20580,
+      "PN_active_neuron_trials": 16283,
+      "PN_spikes": 153049,
+      "design_PN_spikes": 15618,
+      "nondesign_PN_spikes": 137431,
+      "non_design_PN_input_sources": {
+        "KC": {
+          "due_edges": 2070,
+          "accepted_edges": 1295,
+          "rejected_edges": 775,
+          "accepted_zero_edges": 0,
+          "rejected_zero_edges": 0,
+          "accepted_positive_edges": 1295,
+          "accepted_negative_edges": 0,
+          "rejected_positive_edges": 775,
+          "rejected_negative_edges": 0,
+          "accepted_nonzero_before_first_edges": 305,
+          "accepted_positive_before_first_edges": 305,
+          "accepted_negative_before_first_edges": 0,
+          "accepted_positive_V": 0.434775,
+          "accepted_negative_abs_V": 0.0,
+          "rejected_positive_V": 0.2552,
+          "rejected_negative_abs_V": 0.0,
+          "accepted_positive_before_first_V": 0.11714999999999999,
+          "accepted_negative_before_first_abs_V": 0.0
+        },
+        "APL": {
+          "due_edges": 148331,
+          "accepted_edges": 104414,
+          "rejected_edges": 43917,
+          "accepted_zero_edges": 104414,
+          "rejected_zero_edges": 43917,
+          "accepted_positive_edges": 0,
+          "accepted_negative_edges": 0,
+          "rejected_positive_edges": 0,
+          "rejected_negative_edges": 0,
+          "accepted_nonzero_before_first_edges": 0,
+          "accepted_positive_before_first_edges": 0,
+          "accepted_negative_before_first_edges": 0,
+          "accepted_positive_V": 0.0,
+          "accepted_negative_abs_V": 0.0,
+          "rejected_positive_V": 0.0,
+          "rejected_negative_abs_V": 0.0,
+          "accepted_positive_before_first_V": 0.0,
+          "accepted_negative_before_first_abs_V": 0.0
+        },
+        "ALPN": {
+          "due_edges": 6352352,
+          "accepted_edges": 4792039,
+          "rejected_edges": 1560313,
+          "accepted_zero_edges": 0,
+          "rejected_zero_edges": 0,
+          "accepted_positive_edges": 4418770,
+          "accepted_negative_edges": 373269,
+          "rejected_positive_edges": 1433212,
+          "rejected_negative_edges": 127101,
+          "accepted_nonzero_before_first_edges": 1383638,
+          "accepted_positive_before_first_edges": 1272477,
+          "accepted_negative_before_first_edges": 111161,
+          "accepted_positive_V": 8819.086925000001,
+          "accepted_negative_abs_V": 295.654425,
+          "rejected_positive_V": 3142.3196750000006,
+          "rejected_negative_abs_V": 147.71267500000002,
+          "accepted_positive_before_first_V": 2225.3222749999995,
+          "accepted_negative_before_first_abs_V": 100.61837499999999
+        },
+        "MBON": {
+          "due_edges": 19535,
+          "accepted_edges": 16470,
+          "rejected_edges": 3065,
+          "accepted_zero_edges": 0,
+          "rejected_zero_edges": 0,
+          "accepted_positive_edges": 13079,
+          "accepted_negative_edges": 3391,
+          "rejected_positive_edges": 2716,
+          "rejected_negative_edges": 349,
+          "accepted_nonzero_before_first_edges": 7210,
+          "accepted_positive_before_first_edges": 5353,
+          "accepted_negative_before_first_edges": 1857,
+          "accepted_positive_V": 29.559199999999997,
+          "accepted_negative_abs_V": 2.3771000000000004,
+          "rejected_positive_V": 10.326800000000002,
+          "rejected_negative_abs_V": 0.37455000000000005,
+          "accepted_positive_before_first_V": 10.683475,
+          "accepted_negative_before_first_abs_V": 1.265275
+        },
+        "anatomical_DAN": {
+          "due_edges": 100648,
+          "accepted_edges": 74500,
+          "rejected_edges": 26148,
+          "accepted_zero_edges": 8586,
+          "rejected_zero_edges": 2754,
+          "accepted_positive_edges": 65914,
+          "accepted_negative_edges": 0,
+          "rejected_positive_edges": 23394,
+          "rejected_negative_edges": 0,
+          "accepted_nonzero_before_first_edges": 18967,
+          "accepted_positive_before_first_edges": 18967,
+          "accepted_negative_before_first_edges": 0,
+          "accepted_positive_V": 63.44882500000002,
+          "accepted_negative_abs_V": 0.0,
+          "rejected_positive_V": 31.133300000000006,
+          "rejected_negative_abs_V": 0.0,
+          "accepted_positive_before_first_V": 10.068300000000004,
+          "accepted_negative_before_first_abs_V": 0.0
+        },
+        "dopamine_annotation_only": {
+          "due_edges": 10228,
+          "accepted_edges": 7290,
+          "rejected_edges": 2938,
+          "accepted_zero_edges": 0,
+          "rejected_zero_edges": 0,
+          "accepted_positive_edges": 7290,
+          "accepted_negative_edges": 0,
+          "rejected_positive_edges": 2938,
+          "rejected_negative_edges": 0,
+          "accepted_nonzero_before_first_edges": 1953,
+          "accepted_positive_before_first_edges": 1953,
+          "accepted_negative_before_first_edges": 0,
+          "accepted_positive_V": 3.46665,
+          "accepted_negative_abs_V": 0.0,
+          "rejected_positive_V": 1.4646499999999998,
+          "rejected_negative_abs_V": 0.0,
+          "accepted_positive_before_first_V": 0.7254500000000002,
+          "accepted_negative_before_first_abs_V": 0.0
+        },
+        "ALLN": {
+          "due_edges": 22454950,
+          "accepted_edges": 17072621,
+          "rejected_edges": 5382329,
+          "accepted_zero_edges": 2100382,
+          "rejected_zero_edges": 636169,
+          "accepted_positive_edges": 9600659,
+          "accepted_negative_edges": 5371580,
+          "rejected_positive_edges": 3076911,
+          "rejected_negative_edges": 1669249,
+          "accepted_nonzero_before_first_edges": 4589451,
+          "accepted_positive_before_first_edges": 2819703,
+          "accepted_negative_before_first_edges": 1769748,
+          "accepted_positive_V": 22435.618150000002,
+          "accepted_negative_abs_V": 15733.762000000004,
+          "rejected_positive_V": 12681.204800000001,
+          "rejected_negative_abs_V": 5617.566899999999,
+          "accepted_positive_before_first_V": 3783.3614499999994,
+          "accepted_negative_before_first_abs_V": 5598.491800000001
+        },
+        "ALIN": {
+          "due_edges": 291743,
+          "accepted_edges": 218617,
+          "rejected_edges": 73126,
+          "accepted_zero_edges": 0,
+          "rejected_zero_edges": 0,
+          "accepted_positive_edges": 136041,
+          "accepted_negative_edges": 82576,
+          "rejected_positive_edges": 49171,
+          "rejected_negative_edges": 23955,
+          "accepted_nonzero_before_first_edges": 65515,
+          "accepted_positive_before_first_edges": 37642,
+          "accepted_negative_before_first_edges": 27873,
+          "accepted_positive_V": 136.84935000000004,
+          "accepted_negative_abs_V": 288.62487500000003,
+          "rejected_positive_V": 62.70962500000002,
+          "rejected_negative_abs_V": 83.38192500000002,
+          "accepted_positive_before_first_V": 28.834850000000003,
+          "accepted_negative_before_first_abs_V": 105.02332500000001
+        },
+        "ALON": {
+          "due_edges": 215776,
+          "accepted_edges": 166887,
+          "rejected_edges": 48889,
+          "accepted_zero_edges": 0,
+          "rejected_zero_edges": 0,
+          "accepted_positive_edges": 65915,
+          "accepted_negative_edges": 100972,
+          "rejected_positive_edges": 21378,
+          "rejected_negative_edges": 27511,
+          "accepted_nonzero_before_first_edges": 62085,
+          "accepted_positive_before_first_edges": 22046,
+          "accepted_negative_before_first_edges": 40039,
+          "accepted_positive_V": 128.25917500000003,
+          "accepted_negative_abs_V": 259.10775,
+          "rejected_positive_V": 24.277275000000003,
+          "rejected_negative_abs_V": 43.74700000000001,
+          "accepted_positive_before_first_V": 42.07610000000001,
+          "accepted_negative_before_first_abs_V": 130.35660000000001
+        },
+        "olfactory_sensory": {
+          "due_edges": 23994,
+          "accepted_edges": 17401,
+          "rejected_edges": 6593,
+          "accepted_zero_edges": 0,
+          "rejected_zero_edges": 0,
+          "accepted_positive_edges": 17401,
+          "accepted_negative_edges": 0,
+          "rejected_positive_edges": 6593,
+          "rejected_negative_edges": 0,
+          "accepted_nonzero_before_first_edges": 4479,
+          "accepted_positive_before_first_edges": 4479,
+          "accepted_negative_before_first_edges": 0,
+          "accepted_positive_V": 62.307025,
+          "accepted_negative_abs_V": 0.0,
+          "rejected_positive_V": 32.84765,
+          "rejected_negative_abs_V": 0.0,
+          "accepted_positive_before_first_V": 5.9642,
+          "accepted_negative_before_first_abs_V": 0.0
+        },
+        "other": {
+          "due_edges": 4712124,
+          "accepted_edges": 3435149,
+          "rejected_edges": 1276975,
+          "accepted_zero_edges": 188816,
+          "rejected_zero_edges": 67249,
+          "accepted_positive_edges": 942593,
+          "accepted_negative_edges": 2303740,
+          "rejected_positive_edges": 304706,
+          "rejected_negative_edges": 905020,
+          "accepted_nonzero_before_first_edges": 834864,
+          "accepted_positive_before_first_edges": 274639,
+          "accepted_negative_before_first_edges": 560225,
+          "accepted_positive_V": 1630.3936000000003,
+          "accepted_negative_abs_V": 3475.134025,
+          "rejected_positive_V": 745.1102999999999,
+          "rejected_negative_abs_V": 1860.7902500000002,
+          "accepted_positive_before_first_V": 351.507475,
+          "accepted_negative_before_first_abs_V": 672.5455
+        },
+        "unclassified": {
+          "due_edges": 78114,
+          "accepted_edges": 60604,
+          "rejected_edges": 17510,
+          "accepted_zero_edges": 2081,
+          "rejected_zero_edges": 787,
+          "accepted_positive_edges": 15391,
+          "accepted_negative_edges": 43132,
+          "rejected_positive_edges": 4185,
+          "rejected_negative_edges": 12538,
+          "accepted_nonzero_before_first_edges": 14101,
+          "accepted_positive_before_first_edges": 4254,
+          "accepted_negative_before_first_edges": 9847,
+          "accepted_positive_V": 9.733625,
+          "accepted_negative_abs_V": 41.988375,
+          "rejected_positive_V": 2.0759749999999997,
+          "rejected_negative_abs_V": 19.933375,
+          "accepted_positive_before_first_V": 3.1426999999999996,
+          "accepted_negative_before_first_abs_V": 5.763175
+        }
+      },
+      "APL_sources": {
+        "design_ALPN": {
+          "h_sum_mV": 33537629.665002033,
+          "h_before_first_KC_sum_mV": 17484.840584900314,
+          "h_never_fired_KC_sum_mV": 33187421.10364814,
+          "h_before_first_any_KC_sum_mV": 784478.4870301877,
+          "drive_sum": 9238.824171174318,
+          "h_sum_mV_fraction": 0.21380658101749994,
+          "h_before_first_KC_sum_mV_fraction": 0.2594614047757469,
+          "h_before_first_any_KC_sum_mV_fraction": 0.3758237357610822,
+          "drive_sum_fraction": 0.21378575280007192
+        },
+        "non_design_ALPN": {
+          "h_sum_mV": 116044322.34059998,
+          "h_before_first_KC_sum_mV": 44968.29391546448,
+          "h_never_fired_KC_sum_mV": 114783374.24335937,
+          "h_before_first_any_KC_sum_mV": 1302878.9957044702,
+          "drive_sum": 32351.732915855944,
+          "h_sum_mV_fraction": 0.7397970594215179,
+          "h_before_first_KC_sum_mV_fraction": 0.6672944287379448,
+          "h_before_first_any_KC_sum_mV_fraction": 0.6241762642389178,
+          "drive_sum_fraction": 0.7486168637544289
+        },
+        "KC": {
+          "h_sum_mV": 7277717.633177725,
+          "h_before_first_KC_sum_mV": 4935.850000094925,
+          "h_never_fired_KC_sum_mV": 7184544.346125161,
+          "h_before_first_any_KC_sum_mV": 0.0,
+          "drive_sum": 1624.7837397940457,
+          "h_sum_mV_fraction": 0.046396359560982314,
+          "h_before_first_KC_sum_mV_fraction": 0.07324416648630837,
+          "h_before_first_any_KC_sum_mV_fraction": 0.0,
+          "drive_sum_fraction": 0.0375973834454991
+        }
+      },
+      "common_non_design_dimensions": 610,
+      "counts_are_neuron_trials_not_distinct_neurons": true
+    }
+  },
+  "max_PN_voltage_ledger_residual_SI": 0.0,
+  "CPU_audit_wall_seconds": 726.8410196360037,
+  "old_integrity_pass": true,
+  "prior_frozen_five_pass": true,
+  "frozen_five_reexecuted_this_audit": false,
+  "prior_frozen_five_sha256": "9057437695a0c2bd565de3600d1185e6351cbeb8128198fe2d8686437d8117ae",
+  "new_brain_simulation": false,
+  "GPU_used": false,
+  "training": false,
+  "heldout_access": false,
+  "candidate_generated": false,
+  "learning_achieved": false,
+  "prior_CAL_failure_unchanged": true,
+  "source_fraction_robustness_proven": false,
+  "counterfactual_causality_tested": false,
+  "limitations": [
+    "Logged upstream spikes are conditioning inputs, not an independent whole-brain oracle",
+    "Real timed edges are accepted antecedents, not unique causes or necessity proofs",
+    "APL uses the unchanged nonnegative engineering input map, not signed PN-to-APL LIF drive",
+    "APL summed traces pass prior per-tick error bounds; accumulated shares remain descriptive",
+    "Shared PN activity does not imply absent odor information; no learning gate applied",
+    "No independently saved per-tick PN states for CAL; fixtures have full histories",
+    "Frozen five simulation executions were not repeated; previous sealed PASS checked by hash"
+  ]
+}
@@ -0,0 +1,735 @@
+8275119bbd142b3c51a4d25682238ef53be9b8de1f11e2b3c5d8b655fee651d5  REPORT.md
+3e3130064b41383129fa97ee7c2c690fca95ea943afa02f2f4526ccbbcae8ba9  audit/PN-odor-structure.json
+70f48d5c4b105b406d4534a3f47629ff7862976406a6e08c252978d85b167aa8  audit/completed.json
+0c47ff18aba80cb7d9cc6e3d1108dc048e573f6affc044663c6fe8bdad23aca8  audit/final-status.json
+7b5c136fac6b644ca704fc39d53582ccd7892100e77fa446efdc8440d32ead04  protocol/inventory.json
+14db34a21e6cb4b43b9a8bc2873455d70001c231383fc9930ff5bea1b7b8a5d0  protocol/metadata-schema.json
+8aac9e262ba4666ba2a4fd69ee3c51c3e94c694971cdba186b0c7ce242a7b974  protocol/neuron-source-groups.parquet
+6cea0246657b781d64e3fa46cb7602d9271aa8821da45a644514c64757f3bc8b  protocol/population-audit.json
+eaa79a8d9ee7fbf2418ab6cacbd0bdbfab6bdcf81039b981a8ee938495433a35  protocol/prepared-hashes.json
+6da758d88c775a97453d0ddac72eea39aea1a01a824e71da7e85ae34b0f9e25a  protocol/preregistered.json
+e5d4435c52089de9019d032266dab8bbf4710c5466c4955f5833efaab744e8c1  regression/old-integrity-after.json
+e5d4435c52089de9019d032266dab8bbf4710c5466c4955f5833efaab744e8c1  regression/old-integrity-before.json
+df2f154898b259ed583d7cc7299007e66777967de9214ef5ab8399d0bb6f4049  regression/unit-tests.json
+c3fa21aa9b3dd8e82c1f6daee6c8bdfe3ad5750daf62c57d45634fc609a170f3  regression/unit-tests.log
+f280887885ac42602eed3797664549a47ee920c18703894296a21ca9104d2e7c  trials/apl_only-r0/accepted-prefirst-edge-events.parquet
+7b656cbab6a3d669d697e1bbe1f0f292d9605efad2de3f052c60cfed09ff4756  trials/apl_only-r0/apl-per-tick.parquet
+78fa84027da85d2025f1e34c3e8c8afe64d835c73ca130d2df47e8763b0423be  trials/apl_only-r0/apl-source-summary.json
+a1c79b1dfd8c436950fb4c24049526a070b69fabffe4dce3d8d4f6a6c69719f6  trials/apl_only-r0/output-hashes.json
+7048f979b2bdde63845476c0b1675bd501071e2a5ec121e37b7c88fb71c49c94  trials/apl_only-r0/per-kc-apl-sources.parquet
+4033991453ba40920b385c1052af42e45b5618d942a8eb63a2b0b70a4a420ac0  trials/apl_only-r0/per-pn.parquet
+1fa7444c3453560ead9aea031934ddc46fd75a3f8c73de0f8779703ab00c6798  trials/apl_only-r0/prefirst-edge-summary.parquet
+b2a3ea4ccb556229cf6f3587628e1f5d89cf30daf4732737baa5a94a0ea2bc1c  trials/apl_only-r0/replay-final.npz
+21271a27c433a7da433c07720e53d02b60017ee02099a37834314202acc88978  trials/apl_only-r0/summary.json
+d4b9e846fc0584305bdb660e67102987dbc877f03ae2ba29c023f76985a9e1a1  trials/arrival_collision-r0/accepted-prefirst-edge-events.parquet
+1f8b2383a954ed28851bdc383a8a6d30491feb5866eaa10e397b405b9127b905  trials/arrival_collision-r0/apl-per-tick.parquet
+a78c866c8f5d4c578a84d11efdf9f789106ab3be9b396a74e93f899fa27448a1  trials/arrival_collision-r0/apl-source-summary.json
+6f4ad84dabf331caefecf8ed48d1c411a35c9666be73358e2da02e148e07948a  trials/arrival_collision-r0/output-hashes.json
+02bcc5bb8befb1b30e66b2c07d3293c65c7db6fb73c85f4e28c96aa18d5f7fe7  trials/arrival_collision-r0/per-kc-apl-sources.parquet
+167537a93b0a7853e83e46da93d56b274a1ddd9cf74ef42483fcd4539b05bcbc  trials/arrival_collision-r0/per-pn.parquet
+10134725dbbe001e865c050bf9d978bef6d4db71f82f41cad10633915e44d455  trials/arrival_collision-r0/prefirst-edge-summary.parquet
+f98f6f286ae6bfb90ca89363911939dc4a26f6a0e06b613f02584a5b31cb5cd0  trials/arrival_collision-r0/replay-final.npz
+ab5634cf8444d0d732657c1500986042667639d2060804a72ab77c28819347f5  trials/arrival_collision-r0/summary.json
+a14e7d2cfaf2fc442fcdface1f8914b0ee6d6ac849759117d86be236df1e3c99  trials/cal-matched_energy-00-s51101-r0/accepted-prefirst-edge-events.parquet
+e216536d6bbddcaaab011975271dbc3fea8149a95cce8105ce1a3fe8b03260d8  trials/cal-matched_energy-00-s51101-r0/apl-per-tick.parquet
+3308a515eef6e6f2351ece8ca97970a21ef812608f5d5c8325c4ccf42bb1b24f  trials/cal-matched_energy-00-s51101-r0/apl-source-summary.json
+42796b259f11647b21d20a55d4b841989e5a21895a5768425cc329eeb4f8612a  trials/cal-matched_energy-00-s51101-r0/output-hashes.json
+18881c686d2aae8ad7c50aa8fa2b029f95a155297446e0114e93bfefc8f57ba8  trials/cal-matched_energy-00-s51101-r0/per-kc-apl-sources.parquet
+11fb20837a3adf71aef1000a5f068c1c3d0ae942d7c9ae89f3198efeaafa9159  trials/cal-matched_energy-00-s51101-r0/per-pn.parquet
+1e5908472d06a33f536dd6effe5b70d97ef706dc9049fc9d97a16ab16400375d  trials/cal-matched_energy-00-s51101-r0/prefirst-edge-summary.parquet
+c949ce9bf7da4d8c19e8c713c0655344cf3e2225f4ade56780e826b4b6fd6ebf  trials/cal-matched_energy-00-s51101-r0/replay-final.npz
+d7c022d057848421870529103a0a2617456d7171ddfc26dbbc0b4fc116c8f825  trials/cal-matched_energy-00-s51101-r0/summary.json
+a14e7d2cfaf2fc442fcdface1f8914b0ee6d6ac849759117d86be236df1e3c99  trials/cal-matched_energy-00-s51101-r1/accepted-prefirst-edge-events.parquet
+e216536d6bbddcaaab011975271dbc3fea8149a95cce8105ce1a3fe8b03260d8  trials/cal-matched_energy-00-s51101-r1/apl-per-tick.parquet
+3308a515eef6e6f2351ece8ca97970a21ef812608f5d5c8325c4ccf42bb1b24f  trials/cal-matched_energy-00-s51101-r1/apl-source-summary.json
+d00279c092adddeb7d193865864fcce796e93292070e732789852258f222c76d  trials/cal-matched_energy-00-s51101-r1/output-hashes.json
+18881c686d2aae8ad7c50aa8fa2b029f95a155297446e0114e93bfefc8f57ba8  trials/cal-matched_energy-00-s51101-r1/per-kc-apl-sources.parquet
+11fb20837a3adf71aef1000a5f068c1c3d0ae942d7c9ae89f3198efeaafa9159  trials/cal-matched_energy-00-s51101-r1/per-pn.parquet
+1e5908472d06a33f536dd6effe5b70d97ef706dc9049fc9d97a16ab16400375d  trials/cal-matched_energy-00-s51101-r1/prefirst-edge-summary.parquet
+c949ce9bf7da4d8c19e8c713c0655344cf3e2225f4ade56780e826b4b6fd6ebf  trials/cal-matched_energy-00-s51101-r1/replay-final.npz
+b98b20611027e2521eed3b9bd7a8bd4e73628ea2260e065b3a49fe8566bd60e0  trials/cal-matched_energy-00-s51101-r1/summary.json
+2e0ce386ca3d37d079cf00cbb6d628ba7a3fc073460b1ded5ec0ee5427def6e6  trials/cal-matched_energy-00-s51102-r0/accepted-prefirst-edge-events.parquet
+105198550cbf836833d0b756313bdcbf5d30bd29161709f7cd4a7da3f798732a  trials/cal-matched_energy-00-s51102-r0/apl-per-tick.parquet
+19eb0801e91adce536ef4b99f4958e55c0221425f55d910f7b9fe5cf39c52d6a  trials/cal-matched_energy-00-s51102-r0/apl-source-summary.json
+a118ff3b30e2e9f86c1f76c50910fc9d18a36b9cff78f3b648c1d09ac6d2ecb8  trials/cal-matched_energy-00-s51102-r0/output-hashes.json
+ed581eb14fc0772d192650c2bc3817c26386cf8f0a8fbd3979537126cea3ef91  trials/cal-matched_energy-00-s51102-r0/per-kc-apl-sources.parquet
+cdb21f860aa026931546cc0b2e097f5832e8ae026f9b030a2fc68332b94a4878  trials/cal-matched_energy-00-s51102-r0/per-pn.parquet
+8ac8fa43e2b3a4493ef24332e969dc24ea4afd1a3acea4fcdd98ab50e6d7eb1a  trials/cal-matched_energy-00-s51102-r0/prefirst-edge-summary.parquet
+0bfceca8078b394a25c019015c133eb0fe5958f1951d242b5c1102633761c36f  trials/cal-matched_energy-00-s51102-r0/replay-final.npz
+79a13b59b9b69c2df1cc77b855cf5e6cb9d19e5003e7f9891585140249e3eb2e  trials/cal-matched_energy-00-s51102-r0/summary.json
+0f3c31f0fd7dab7f988e89c1ba452ff3aa612318b07a6f8194653ad4ba9dc1c1  trials/cal-matched_energy-00-s51103-r0/accepted-prefirst-edge-events.parquet
+e5ef632f8e2abfdca09f78b6cdb248851d9d1c35e0ead451bfdd90a85c7ac4d0  trials/cal-matched_energy-00-s51103-r0/apl-per-tick.parquet
+73a0e18c3ddf422b33ca41900cfe91f558f07f685d592dd6e39eceed406ba40a  trials/cal-matched_energy-00-s51103-r0/apl-source-summary.json
+f5700a4a26417b4db73edd7f418f9b712503619130ad70229d3689a57af3eddf  trials/cal-matched_energy-00-s51103-r0/output-hashes.json
+e045ebce8a7c5d1d104a3d9639d35160f7941bcb1bf74cbf729f2cb12498e5ac  trials/cal-matched_energy-00-s51103-r0/per-kc-apl-sources.parquet
+180217811d07c36cf07e5a5ec570d2535ee2dc9639b40ec363a5ecf12b02b8ab  trials/cal-matched_energy-00-s51103-r0/per-pn.parquet
+e04b43f1fadcd4e7be45bd2dd7d9e51b2ecfd75c1088ba72658b405e8d2b9668  trials/cal-matched_energy-00-s51103-r0/prefirst-edge-summary.parquet
+80acc8773d345f6698f02c9db77395a9d10647c376f9e4455541e07047488156  trials/cal-matched_energy-00-s51103-r0/replay-final.npz
+8c1ebb56482b7cf63b9f5a89c20c39b12078a8bb80dc347f8ececf776bfca8fc  trials/cal-matched_energy-00-s51103-r0/summary.json
+3ad4d95634927d35c967d252d6f24ee869bcee2ff389a850548ad42bd6e0d127  trials/cal-matched_energy-00-s51104-r0/accepted-prefirst-edge-events.parquet
+e1e34ea0dad07a8033617bc4b29404feb39e683e394ebbfd4d92e98aa33816d3  trials/cal-matched_energy-00-s51104-r0/apl-per-tick.parquet
+4846b3bd9ef68e21f9f44fc00ce2daad53ae9139e710d583d4c63402b7f14c94  trials/cal-matched_energy-00-s51104-r0/apl-source-summary.json
+0d02d9773fe7e7a9df872227f73c12c9f9cfa673d90a1e1a1d7d86e09d42a947  trials/cal-matched_energy-00-s51104-r0/output-hashes.json
+b422d8f2bcc8673c21bd7ca1095c58fb8436fcff4e1d4f8d71135346465d3ce1  trials/cal-matched_energy-00-s51104-r0/per-kc-apl-sources.parquet
+59b439bf5048121b48ce996a9f994561907738d6584dbc7a3f14c9157bde371d  trials/cal-matched_energy-00-s51104-r0/per-pn.parquet
+d36c36b6f57be7a9b617b56c2fb18c441f36e6f8ff22c716419cfe882a446065  trials/cal-matched_energy-00-s51104-r0/prefirst-edge-summary.parquet
+bbff421b5341927544a192ca14d1dba884dc3f71db3f72dddf64ff2945c093a4  trials/cal-matched_energy-00-s51104-r0/replay-final.npz
+e5906aa7606b3321f1dfcf9ac406119ef86507805ebd700829f219e286e56f9e  trials/cal-matched_energy-00-s51104-r0/summary.json
+e5c52c727dce96b2a2688301e2e8e1fb639de2e2e0c76153d2c71df7c35f3c92  trials/cal-matched_energy-00-s51105-r0/accepted-prefirst-edge-events.parquet
+937fdbfdd2f5a2896a9275de22a03385345711743b3f950a7494f49c4a8e6934  trials/cal-matched_energy-00-s51105-r0/apl-per-tick.parquet
+1e572f9f22d8b4c81d164a53ac6958b5997240de328474dcdd3285fcf9dbbb9a  trials/cal-matched_energy-00-s51105-r0/apl-source-summary.json
+c8788dd75fc6d6f4f227787322dfc98414c773c0fd91b7ed78d9bdb957a4d92a  trials/cal-matched_energy-00-s51105-r0/output-hashes.json
+e96b088612fdeee7d59047fe453de0c5ead54fd615411d21d3b4edf51827b398  trials/cal-matched_energy-00-s51105-r0/per-kc-apl-sources.parquet
+963676e149322d565e3defeb81df63a5d45700222b6864bb24da985ac52eb0f0  trials/cal-matched_energy-00-s51105-r0/per-pn.parquet
+79a6e0cfb41d67d733ee5b6bcf62f2c408f3591a38c7b9de1dfeb6c8cd05d596  trials/cal-matched_energy-00-s51105-r0/prefirst-edge-summary.parquet
+a238ef341fb3ad92b50c79471fa2c3edafab9a64f239217ff650ad6dca7d7da1  trials/cal-matched_energy-00-s51105-r0/replay-final.npz
+4875c9966343a7d3bb86d75ff4c039b64df3369db4ff58bcfcf0b97900cbc0bc  trials/cal-matched_energy-00-s51105-r0/summary.json
+b00ce578b9e2296b984fed0fb176e897145c32f1b52fe1c3a7a1fbc5da5a8c72  trials/cal-matched_energy-01-s51101-r0/accepted-prefirst-edge-events.parquet
+804599256e2be45ef2bda027f5dd40af2cb6106f8b9ed38dd5bec71e943a5df8  trials/cal-matched_energy-01-s51101-r0/apl-per-tick.parquet
+918dfb60b4e26182d0474563a96f741ff9b4fcb2494430c3d7fa9299ff583952  trials/cal-matched_energy-01-s51101-r0/apl-source-summary.json
+8a8b15235cbabc0978556577105c5e41f8e19836dd736fde1304c50c1849fe4c  trials/cal-matched_energy-01-s51101-r0/output-hashes.json
+5761b9285a390b1f183e7458ed64a9035ac465526943d36c296797dba84a2b68  trials/cal-matched_energy-01-s51101-r0/per-kc-apl-sources.parquet
+121d245c089b0ac186425fae93c276eea82009387c292b7b013aaa8551803b7e  trials/cal-matched_energy-01-s51101-r0/per-pn.parquet
+7492d791e9eff33e21c6910dfcb92cf64b37566fc7529475747d63704020af37  trials/cal-matched_energy-01-s51101-r0/prefirst-edge-summary.parquet
+217d74b25dcec13b31f1eb0cf72ee1651c7813acc8e20ae9e84732dd7fa67e4c  trials/cal-matched_energy-01-s51101-r0/replay-final.npz
+7b5edc6bcdf7fe861c5e61714659dcefc419bf0fa6f9c263f59142a7a307d2dc  trials/cal-matched_energy-01-s51101-r0/summary.json
+b00ce578b9e2296b984fed0fb176e897145c32f1b52fe1c3a7a1fbc5da5a8c72  trials/cal-matched_energy-01-s51101-r1/accepted-prefirst-edge-events.parquet
+804599256e2be45ef2bda027f5dd40af2cb6106f8b9ed38dd5bec71e943a5df8  trials/cal-matched_energy-01-s51101-r1/apl-per-tick.parquet
+918dfb60b4e26182d0474563a96f741ff9b4fcb2494430c3d7fa9299ff583952  trials/cal-matched_energy-01-s51101-r1/apl-source-summary.json
+192eac3d30fec65d2884b0233fe70a346a1a54c534c4772404bef16850a6599f  trials/cal-matched_energy-01-s51101-r1/output-hashes.json
+5761b9285a390b1f183e7458ed64a9035ac465526943d36c296797dba84a2b68  trials/cal-matched_energy-01-s51101-r1/per-kc-apl-sources.parquet
+121d245c089b0ac186425fae93c276eea82009387c292b7b013aaa8551803b7e  trials/cal-matched_energy-01-s51101-r1/per-pn.parquet
+7492d791e9eff33e21c6910dfcb92cf64b37566fc7529475747d63704020af37  trials/cal-matched_energy-01-s51101-r1/prefirst-edge-summary.parquet
+217d74b25dcec13b31f1eb0cf72ee1651c7813acc8e20ae9e84732dd7fa67e4c  trials/cal-matched_energy-01-s51101-r1/replay-final.npz
+32827808d88d5381fb0c0a958a3246583c32de32afc7d81d152b6e3ffe468cee  trials/cal-matched_energy-01-s51101-r1/summary.json
+8e811e81b324390da65c29635422522a713c0895dcfd99eba716dc81ec109b92  trials/cal-matched_energy-01-s51102-r0/accepted-prefirst-edge-events.parquet
+c25592bfb99b2951844bada381f67cc413dadccdeeebbc87bea0f4855c3e6719  trials/cal-matched_energy-01-s51102-r0/apl-per-tick.parquet
+42a43f8a20ba9fd3b84882d7ad8258a9cf158b41e3fb6843bbb3bbbf1507e8da  trials/cal-matched_energy-01-s51102-r0/apl-source-summary.json
+07cd96e08b5e29993139acd8fafb0816e29949b74e4ae856298cee2183fe5da9  trials/cal-matched_energy-01-s51102-r0/output-hashes.json
+5561b7b84d94a1e5249b1e0038097f3c1ab0c7c33604827dee1f71fc55153175  trials/cal-matched_energy-01-s51102-r0/per-kc-apl-sources.parquet
+e1bbe166c8140717b5c9a8d1e35464ff5f5f66634b843412913ee33bbc4bde7f  trials/cal-matched_energy-01-s51102-r0/per-pn.parquet
+265226bdde49cb5522e32c60a3d361e6a2991014187aadb9188d3b5f8c85fd8f  trials/cal-matched_energy-01-s51102-r0/prefirst-edge-summary.parquet
+3af7773dc6bee3032e495c178e3013f1234f3b25561e7800f64ebf44a41d32ef  trials/cal-matched_energy-01-s51102-r0/replay-final.npz
+4ffadbf7168a33f973bc1d51ee0ca5590ba122de903f85972232848f23a37c29  trials/cal-matched_energy-01-s51102-r0/summary.json
+052020f10e372b4f75caf353d648252c44e77b716accdd13006537f912fd27c5  trials/cal-matched_energy-01-s51103-r0/accepted-prefirst-edge-events.parquet
+eddcdb7ecaf55d8c40b7a60185e1fdbba467a3da4d228b8657cba8ae62b3226b  trials/cal-matched_energy-01-s51103-r0/apl-per-tick.parquet
+3a58bb681648b7afcc48a0332e13dd9627fe40737716d9bc081719048b0dcbd7  trials/cal-matched_energy-01-s51103-r0/apl-source-summary.json
+ba9df67c4dfa34ae236b5d125d58aebcceac0d7a7f4b80e57df145a6cb401430  trials/cal-matched_energy-01-s51103-r0/output-hashes.json
+8a91366b3688db920754dcbf49fbc9c036a14e1c33e5d75a00cbabef56dffa5b  trials/cal-matched_energy-01-s51103-r0/per-kc-apl-sources.parquet
+2d6c8806ee6b360350739323abe8836f27cb7faa5cca0221fbd8fec2c9ef3655  trials/cal-matched_energy-01-s51103-r0/per-pn.parquet
+d029b3d1f735ad957c331f3151e800064b78ba2e9e16531516fd1f84b1c6bbde  trials/cal-matched_energy-01-s51103-r0/prefirst-edge-summary.parquet
+7cf143280c9637f258ac17109dd90cafa422f07cc160e4e2f828f818dbc50d3d  trials/cal-matched_energy-01-s51103-r0/replay-final.npz
+412b5425dab8e9f0b77883981de300a5be76d470b6543128080cb53085c0db86  trials/cal-matched_energy-01-s51103-r0/summary.json
+66ac749366009d3525c1d4c75df3bef00e4ef715541fce88fd9a53b7dcbfcec7  trials/cal-matched_energy-01-s51104-r0/accepted-prefirst-edge-events.parquet
+249944d0a40b1c121128bc9a2b1b1a3b57054d678b265829d8045997d523934b  trials/cal-matched_energy-01-s51104-r0/apl-per-tick.parquet
+0cd5427ca9379b669f55e4f4aab2682092d692dccb0265fbc9f326ecaeca8612  trials/cal-matched_energy-01-s51104-r0/apl-source-summary.json
+d916fa5353babbb46df4c3dc491561048dd2e5a6913f61ca389763e2e01812f2  trials/cal-matched_energy-01-s51104-r0/output-hashes.json
+29d951ac7575983300c5a54754bc486831363cde2c09b65319fd6b1f0fda56cc  trials/cal-matched_energy-01-s51104-r0/per-kc-apl-sources.parquet
+4f425c46dfa2421b6c4910af2dd235ad721574899752a3a2a1ec72b45c27a60b  trials/cal-matched_energy-01-s51104-r0/per-pn.parquet
+a8fd0ed632202d7596b9429b2c460575dfe7c563b35f4597a50f0e751b16ceac  trials/cal-matched_energy-01-s51104-r0/prefirst-edge-summary.parquet
+bbc8470d6cbbb8dff4fdd95ee2119c8b29a5438fe67dcdaefe2acb0cae2f2342  trials/cal-matched_energy-01-s51104-r0/replay-final.npz
+79335ab1e6c646a6a1e8fc38cc76184e175fce11d9dd7076c96a219ee315295d  trials/cal-matched_energy-01-s51104-r0/summary.json
+061d2ea0bd11dc76867972d83f4e5a5d30a167a491358f31b33ea1a95648251e  trials/cal-matched_energy-01-s51105-r0/accepted-prefirst-edge-events.parquet
+188a913d451089affab376343e18c2578732c6d8ccfbccf00b0e52ba52be6fd6  trials/cal-matched_energy-01-s51105-r0/apl-per-tick.parquet
+880d69ccbbdaab0b1c98343e5f0cc1136b15414b1d50d8f6cb5fa84a2d8baab0  trials/cal-matched_energy-01-s51105-r0/apl-source-summary.json
+b18ff4c1ce036e0b003a7cc20350e90359eed928c81c5ff23f19ec33d4e78be3  trials/cal-matched_energy-01-s51105-r0/output-hashes.json
+4ca31e93ac03a1c245aa2d29adf3d0d2c57550affd8e3f1e84f2fbcd6f487893  trials/cal-matched_energy-01-s51105-r0/per-kc-apl-sources.parquet
+a1766cf80dd3c501c1021fd1b19e0964063ee303ec97aaebeb004e3075c94da8  trials/cal-matched_energy-01-s51105-r0/per-pn.parquet
+b7b48ecb4158fe00c478b55985cce157d00116926d12617fec81fb3d4400c08f  trials/cal-matched_energy-01-s51105-r0/prefirst-edge-summary.parquet
+7a27864fb761fe3970bbb830b9c95be93279231ec64bfce1b1496fd23af940d1  trials/cal-matched_energy-01-s51105-r0/replay-final.npz
+8efccb0b1e6f14e0fc7b480a8a7a78f84fde06c9aa65513595fd577f7e9fde51  trials/cal-matched_energy-01-s51105-r0/summary.json
+be50536d41d98c8f9eda084908e9f302d830987fc7f4a4744c2a55bfc2f5e845  trials/cal-matched_energy-02-s51101-r0/accepted-prefirst-edge-events.parquet
+fd09cbc093b0a886a57a625dd65bccce5188ead916bf40a1d9c9f9f6860c70f8  trials/cal-matched_energy-02-s51101-r0/apl-per-tick.parquet
+8ff4d114aeed9bb7ffc2aa0c852e0c08931079d0b78f5c40d313af95461cd3d5  trials/cal-matched_energy-02-s51101-r0/apl-source-summary.json
+825c3b7493c1eb5384678e185771328fdbf997ab77a76cb88b8f61167f7a9f2f  trials/cal-matched_energy-02-s51101-r0/output-hashes.json
+af3b75cfc647626b98645cf71d29efa09ed5af95628c0ec7ed4c92a811969c99  trials/cal-matched_energy-02-s51101-r0/per-kc-apl-sources.parquet
+62cc4ea1ca9000407d91ddd3c4569bc4aa10ee90e454cd61d075a633fd1e678b  trials/cal-matched_energy-02-s51101-r0/per-pn.parquet
+2f5c4baf6cab67cf6877ebf8a0db55fc3b09a7b2c2886fb7133d62df160bd01a  trials/cal-matched_energy-02-s51101-r0/prefirst-edge-summary.parquet
+bee035da95f7e393948666e945c2da70b6fe2df710ffea84f321adc84f5f1489  trials/cal-matched_energy-02-s51101-r0/replay-final.npz
+b8eb40e0314bd369195a35ad45a9c31624675f7de3b0e5afdb728e1b5a558b90  trials/cal-matched_energy-02-s51101-r0/summary.json
+be50536d41d98c8f9eda084908e9f302d830987fc7f4a4744c2a55bfc2f5e845  trials/cal-matched_energy-02-s51101-r1/accepted-prefirst-edge-events.parquet
+fd09cbc093b0a886a57a625dd65bccce5188ead916bf40a1d9c9f9f6860c70f8  trials/cal-matched_energy-02-s51101-r1/apl-per-tick.parquet
+8ff4d114aeed9bb7ffc2aa0c852e0c08931079d0b78f5c40d313af95461cd3d5  trials/cal-matched_energy-02-s51101-r1/apl-source-summary.json
+a9124267042a0d0988dc84abb6c9e0aa7e91c9b2b3df36b5fdf4b734a9bd2b3c  trials/cal-matched_energy-02-s51101-r1/output-hashes.json
+af3b75cfc647626b98645cf71d29efa09ed5af95628c0ec7ed4c92a811969c99  trials/cal-matched_energy-02-s51101-r1/per-kc-apl-sources.parquet
+62cc4ea1ca9000407d91ddd3c4569bc4aa10ee90e454cd61d075a633fd1e678b  trials/cal-matched_energy-02-s51101-r1/per-pn.parquet
+2f5c4baf6cab67cf6877ebf8a0db55fc3b09a7b2c2886fb7133d62df160bd01a  trials/cal-matched_energy-02-s51101-r1/prefirst-edge-summary.parquet
+bee035da95f7e393948666e945c2da70b6fe2df710ffea84f321adc84f5f1489  trials/cal-matched_energy-02-s51101-r1/replay-final.npz
+092f4d74c4db93b94890c3c6dd9431deacf76625e088781a1775a00f53e64005  trials/cal-matched_energy-02-s51101-r1/summary.json
+9ea7ecf704a7c9ae65bab8fc51ebe963ee11a9c23b08c8693cd1721acd79c5d3  trials/cal-matched_energy-02-s51102-r0/accepted-prefirst-edge-events.parquet
+09e0d99f92f4f6f0e478a93e52ade5dc2012a6fd4579ea05e4405e7365c14746  trials/cal-matched_energy-02-s51102-r0/apl-per-tick.parquet
+68965a694af73a874409bf226502b36cafc1bcd3d8c25f57cf789491279416fb  trials/cal-matched_energy-02-s51102-r0/apl-source-summary.json
+3c82b0ab18f83e1693608676207fed33d983b2a0b5900e4d1ec78e71becd9b27  trials/cal-matched_energy-02-s51102-r0/output-hashes.json
+cbc972f8433fc1df9306cead29075778e8c8d02fff5221a2369184bbfa310930  trials/cal-matched_energy-02-s51102-r0/per-kc-apl-sources.parquet
+bd7150f67570820470fe5abc1df0c6c7dbfa58e68a870b59ed4e8c8a84b9174e  trials/cal-matched_energy-02-s51102-r0/per-pn.parquet
+a20c90946ae6fa881c41624f85b5ff6cc190fdebcd7700e04b82046b52b8258b  trials/cal-matched_energy-02-s51102-r0/prefirst-edge-summary.parquet
+56d0efdc6c5554f6a1ac637284d2c7fcb009dd5bb48667085f4a2bbac4d9c464  trials/cal-matched_energy-02-s51102-r0/replay-final.npz
+689bec79517789754291cc78c015a53a0155c9b0e2e6968fe10a03165670725a  trials/cal-matched_energy-02-s51102-r0/summary.json
+d74f03f28213ff842de01bd0c39c562677cddcd330eda6ddb24834cced4d6088  trials/cal-matched_energy-02-s51103-r0/accepted-prefirst-edge-events.parquet
+b9280e3bd3cac9d5c4fb38882adb532db8610c0c4076402b48006cc6ad554d82  trials/cal-matched_energy-02-s51103-r0/apl-per-tick.parquet
+a6b6f7f39fae9f521ecfde83a9e4e65f17a1a02773c1796ebd46a9193bcea106  trials/cal-matched_energy-02-s51103-r0/apl-source-summary.json
+4b810b83cb2a9b70c9a7be1cc257edbb2463402c7a2a49e0c169ecdbf384bd52  trials/cal-matched_energy-02-s51103-r0/output-hashes.json
+6749efc843522b699e277cfc973d9554ca3c4ad44b98b40c3c8f308e309aff3a  trials/cal-matched_energy-02-s51103-r0/per-kc-apl-sources.parquet
+103a4241a0af3f2d8c653b4dbb7ab1e12e7dc5778c1a9acb8e3fa060fc664d92  trials/cal-matched_energy-02-s51103-r0/per-pn.parquet
+ed5509b4aae6a0d2a97ae42e947c4cca8f0be84c0655b7e6247bd22f5ebda202  trials/cal-matched_energy-02-s51103-r0/prefirst-edge-summary.parquet
+1afdb16cb2e5990a916176430d7cffc7485a4157ef368a45e0dd65f7268c543d  trials/cal-matched_energy-02-s51103-r0/replay-final.npz
+0c766c6e33857f7b47426b2dd1d88bad7237b32f7c20e3342f8d356628b84fc9  trials/cal-matched_energy-02-s51103-r0/summary.json
+e11714c8303fab203ad936d8a2a57dede3d45a36eccd5ec8433225a46af6e87c  trials/cal-matched_energy-02-s51104-r0/accepted-prefirst-edge-events.parquet
+17af86eec5cb3e736ef9608d0aad291fe5f8e81b72f0a0155f3c308daf7a72c9  trials/cal-matched_energy-02-s51104-r0/apl-per-tick.parquet
+7138acb697bb9d0a8ceb06ac374fcd7cd3c1b4e35f46a48e3b038ed49eebc68b  trials/cal-matched_energy-02-s51104-r0/apl-source-summary.json
+6cb94d6e4b54a4b592d02da82a6c6e88c76d9d1ef1bcba89ce72487d0e1c69cf  trials/cal-matched_energy-02-s51104-r0/output-hashes.json
+f51d252ade1e58e85daf2f3a26462f156deb20171894cc1f7ec402899a2361ff  trials/cal-matched_energy-02-s51104-r0/per-kc-apl-sources.parquet
+7d07e478c67fc444c2dc5a32dab6b9d35b50c76bb491475202ccb7cef8994010  trials/cal-matched_energy-02-s51104-r0/per-pn.parquet
+40abcae883b058e667da283ebc0a0f7256ccbba4dc29af5181ec338324b22142  trials/cal-matched_energy-02-s51104-r0/prefirst-edge-summary.parquet
+cf9efaf0a40878ce2b9233a64903b4a90872454b24e403f38ac4b3fe30dd26f7  trials/cal-matched_energy-02-s51104-r0/replay-final.npz
+21fa105a946c4f996360fc24de68b8d81724ae39a9a744def402aa8d5362c658  trials/cal-matched_energy-02-s51104-r0/summary.json
+d35fcd607930571fd30ac222680a08b5225fab1d8f989e7632a0c61bc967623e  trials/cal-matched_energy-02-s51105-r0/accepted-prefirst-edge-events.parquet
+953d7de18bd0c691521154a5f88cb375ba10eec7e179cbee9eb890296b5727d8  trials/cal-matched_energy-02-s51105-r0/apl-per-tick.parquet
+e0c0c0a30966507d0dba0ac5cff471b87c4eddce4797f78cf49480a8ee210d62  trials/cal-matched_energy-02-s51105-r0/apl-source-summary.json
+3a200b7ba84461ab04ee558a42ebbf9fb7fdc8605bcd0d87b08f4f569eacb068  trials/cal-matched_energy-02-s51105-r0/output-hashes.json
+f1e63ebc9c6d4895cf8033d5bed75bdf0c9751d22a48e4655b31a3d16b564f4f  trials/cal-matched_energy-02-s51105-r0/per-kc-apl-sources.parquet
+c96b33d91ddeba904b929cd979f9d57fe34823c4dec5ba7b45b55ab38f1f0dce  trials/cal-matched_energy-02-s51105-r0/per-pn.parquet
+b257e539df1fbaeb88cb994660ed7b3866388a8dde0b0371bda6c7b6c8953134  trials/cal-matched_energy-02-s51105-r0/prefirst-edge-summary.parquet
+0f9a400791f1cea36a3e3d29be68cf9fb49aeb79677f985976dea6ef1f227435  trials/cal-matched_energy-02-s51105-r0/replay-final.npz
+a0a7968d5e12198a9990317c2448a5b8de42053afa45037d697b6da140b42fca  trials/cal-matched_energy-02-s51105-r0/summary.json
+d113735ea826fec1da6db1200d71b514dd2532ac41b83b9d9ebd1df78b712cd9  trials/cal-matched_energy-03-s51101-r0/accepted-prefirst-edge-events.parquet
+354a3f50e7cf71489f6b9d42c15632561da339537ae6c30a386f8aa2dc9e99bc  trials/cal-matched_energy-03-s51101-r0/apl-per-tick.parquet
+cfea1561fbc398b8a63437b0bada60d956ced986673e06ce0e331da5b1fb14b5  trials/cal-matched_energy-03-s51101-r0/apl-source-summary.json
+fa02ea67ea4d3db5f9b851c42931de50f25c7fb37cfe5e957b5bb84324928309  trials/cal-matched_energy-03-s51101-r0/output-hashes.json
+f068aca8cb7bdbb6c7151997774aca539cb6151f787a860b85e356025c094ef1  trials/cal-matched_energy-03-s51101-r0/per-kc-apl-sources.parquet
+2af3e52b9345544af22665f5ba728a451e6b77c811a4ce48fcd56005854d219f  trials/cal-matched_energy-03-s51101-r0/per-pn.parquet
+e3f0b79a312daa4a5d8edec2185eb4a82ee6deef979564d37e3a21cb9c1daae8  trials/cal-matched_energy-03-s51101-r0/prefirst-edge-summary.parquet
+7469c6335422ac373658d34fc5853dba53d60ee5bdac1067a4e10037418c6a7c  trials/cal-matched_energy-03-s51101-r0/replay-final.npz
+967d0f9cfbd66d1fcf35f9d03da4799b8a23327972723be74aebc0961129c1aa  trials/cal-matched_energy-03-s51101-r0/summary.json
+d113735ea826fec1da6db1200d71b514dd2532ac41b83b9d9ebd1df78b712cd9  trials/cal-matched_energy-03-s51101-r1/accepted-prefirst-edge-events.parquet
+354a3f50e7cf71489f6b9d42c15632561da339537ae6c30a386f8aa2dc9e99bc  trials/cal-matched_energy-03-s51101-r1/apl-per-tick.parquet
+cfea1561fbc398b8a63437b0bada60d956ced986673e06ce0e331da5b1fb14b5  trials/cal-matched_energy-03-s51101-r1/apl-source-summary.json
+0e4a3e833f84abae8cf03ae2ac57ccb42a47e457bc761a34bd1f83e308ea0041  trials/cal-matched_energy-03-s51101-r1/output-hashes.json
+f068aca8cb7bdbb6c7151997774aca539cb6151f787a860b85e356025c094ef1  trials/cal-matched_energy-03-s51101-r1/per-kc-apl-sources.parquet
+2af3e52b9345544af22665f5ba728a451e6b77c811a4ce48fcd56005854d219f  trials/cal-matched_energy-03-s51101-r1/per-pn.parquet
+e3f0b79a312daa4a5d8edec2185eb4a82ee6deef979564d37e3a21cb9c1daae8  trials/cal-matched_energy-03-s51101-r1/prefirst-edge-summary.parquet
+7469c6335422ac373658d34fc5853dba53d60ee5bdac1067a4e10037418c6a7c  trials/cal-matched_energy-03-s51101-r1/replay-final.npz
+298c53501421901fbbc4b00f91294a2ba14d5a933960175c4373ebccc9583d6d  trials/cal-matched_energy-03-s51101-r1/summary.json
+4cffb30a05fe41c3d484e1eec8380dc280a0474835e3511bf2328eecba85c07c  trials/cal-matched_energy-03-s51102-r0/accepted-prefirst-edge-events.parquet
+ca47862cd6fbf5516c66003f1f0017d981c6f0bf6598ee97af349d4a765e272b  trials/cal-matched_energy-03-s51102-r0/apl-per-tick.parquet
+db57298b5adba280df87356c4a423e73153288a622f187670f96f940c2f415ac  trials/cal-matched_energy-03-s51102-r0/apl-source-summary.json
+f7f8e04fa1e8c24a82d4a1f68b75591c0c0aed385351eea3fe65ba87fbeb0747  trials/cal-matched_energy-03-s51102-r0/output-hashes.json
+f2a3713a66d27479b1f0a8fe4b86772a363215082a0c421c164eff7e13430de1  trials/cal-matched_energy-03-s51102-r0/per-kc-apl-sources.parquet
+d70b199ea4fe6dce369e8d39d377e55d8461c024dc6efaf22ce353189609976a  trials/cal-matched_energy-03-s51102-r0/per-pn.parquet
+b64e3684986a230b537abebdfa647fd22e7191602146a22dc65becb516ea6450  trials/cal-matched_energy-03-s51102-r0/prefirst-edge-summary.parquet
+9ada9d321baf39daae2a84bc11fb4334e1a34f26ed32e8c137ea718881c78ef8  trials/cal-matched_energy-03-s51102-r0/replay-final.npz
+9d885ee3e7a7404f74c0ebee274501d60e09e0afae3d957d7002ead3403fbe8e  trials/cal-matched_energy-03-s51102-r0/summary.json
+26bd7ae1649825660a01de0493a26e28c4599c14a70c0192b31170ef422e6b59  trials/cal-matched_energy-03-s51103-r0/accepted-prefirst-edge-events.parquet
+8229daea7c98c94951f4b44a00618289386b36b44fbf4c8632b38bcc54a6090d  trials/cal-matched_energy-03-s51103-r0/apl-per-tick.parquet
+52b5954dd47845369a696d4fa3c957e219d4b418e1c242c9960d684bb964570c  trials/cal-matched_energy-03-s51103-r0/apl-source-summary.json
+f09aba40b647921dadbef0ac2ce6c1b575843fded6468ed5fd5a0e931d5db157  trials/cal-matched_energy-03-s51103-r0/output-hashes.json
+7923a0dcca36f5e38af37b5643858e8c8dc9997de162b80554af3a1e99ec4665  trials/cal-matched_energy-03-s51103-r0/per-kc-apl-sources.parquet
+4a552cfd145894b0d48246f9d027db2d59d527fba8a9c8e53573a52afc45e240  trials/cal-matched_energy-03-s51103-r0/per-pn.parquet
+516c3af29758bbeaf960007fc5beacfcf3bbbf514902d2ef69edc564ce0bd13a  trials/cal-matched_energy-03-s51103-r0/prefirst-edge-summary.parquet
+2d09bfaf8e47101101c5020fa72db2513e84cd08eba94e9f3e59feaa05035b21  trials/cal-matched_energy-03-s51103-r0/replay-final.npz
+a75ee74723dc0704046b91c048cc2425bd051ef50c11a90b3557dc786d2ff045  trials/cal-matched_energy-03-s51103-r0/summary.json
+a18344f41eb226cd53eee7c08e2e0246906bb81f78204ba6e4149a9ea8f9088b  trials/cal-matched_energy-03-s51104-r0/accepted-prefirst-edge-events.parquet
+10c3a7752f9bad1b973ac5c7a2d8376e74ae8bc26c780813b6912ed30edb4180  trials/cal-matched_energy-03-s51104-r0/apl-per-tick.parquet
+906464e814bf3ff343c37c094ea24930d3273f4c949a3d1b2f4581b092ca29eb  trials/cal-matched_energy-03-s51104-r0/apl-source-summary.json
+446d77a7172b37df31ff0e2cb92e787d6bcedf996c6186a4dc3b30d586cae340  trials/cal-matched_energy-03-s51104-r0/output-hashes.json
+a0f870a8fe753a915adf70a10ff8ad0cb23c424a5624b233ffcc657b215ded16  trials/cal-matched_energy-03-s51104-r0/per-kc-apl-sources.parquet
+a42b44a1067655c85dca357701a758525db645279dc760ca1ed2b006cff25e11  trials/cal-matched_energy-03-s51104-r0/per-pn.parquet
+dca626343df2758d96f45d61abc33a5459e6e92740a99cc5f3337ff6f687f8f0  trials/cal-matched_energy-03-s51104-r0/prefirst-edge-summary.parquet
+ba52efdd752080b849d332909816f7eeb4f4fc7ae9088c3c151f7605353467fb  trials/cal-matched_energy-03-s51104-r0/replay-final.npz
+71b318e0d033e431485c0e5ac122d75189973a6c1662c31e7f50a003a24a7393  trials/cal-matched_energy-03-s51104-r0/summary.json
+c8a3a98acf764ae94fa13a98ec43660970281e7991aa13f3602ec43b4463b0e9  trials/cal-matched_energy-03-s51105-r0/accepted-prefirst-edge-events.parquet
+af52a88908149aa28e8d2d010d83e74a215d3755b9a718787a209df42bf85b6f  trials/cal-matched_energy-03-s51105-r0/apl-per-tick.parquet
+80b1ff061560de8a559e33643cd540ff6697698f6292a521c10e9f3591e8e9a7  trials/cal-matched_energy-03-s51105-r0/apl-source-summary.json
+12b044a777cc4ba8f56a8cbcd12bbdf9d6fd55ed08b4c28fb20b40e20dabc0b7  trials/cal-matched_energy-03-s51105-r0/output-hashes.json
+6a116e7a12ea0677bd7b585ca72cba2ee643ee22ee7790fef6fb431e8149741a  trials/cal-matched_energy-03-s51105-r0/per-kc-apl-sources.parquet
+0f3f76c54b881f67ad1c912b9f6a1e3610b576133e5295799772196ffe88014c  trials/cal-matched_energy-03-s51105-r0/per-pn.parquet
+0a39326ef61d5144bf6e50610699ed125bdf789f1a12c5a2ff46a7564000f4ab  trials/cal-matched_energy-03-s51105-r0/prefirst-edge-summary.parquet
+b5627fd54746c08600caa7b6571f5f2b704a96e5bd509637f45b7e81772aed1c  trials/cal-matched_energy-03-s51105-r0/replay-final.npz
+d2f876446806fa2d2b624f998244bc45311df160846fef307ac1e6a6ae6d9853  trials/cal-matched_energy-03-s51105-r0/summary.json
+33d70d035b8916dbdf9f15515c94cbeb3a2036ab1bb826ffd4ac53506d1cb1d6  trials/cal-matched_energy-04-s51101-r0/accepted-prefirst-edge-events.parquet
+59633e9b0cb89109f902ab9c7d8c33471ec19d313300ac8672220762fbac7a53  trials/cal-matched_energy-04-s51101-r0/apl-per-tick.parquet
+fb0b8520649af96558376a6e2430026936451ead051d27237be7f66f3c9f2d2b  trials/cal-matched_energy-04-s51101-r0/apl-source-summary.json
+468e2a34460f358aba32f9c49db0bd96471f2fe0a2b42cdce6284598e2dc07e3  trials/cal-matched_energy-04-s51101-r0/output-hashes.json
+6d2aa1d193790aa6882b05534f97b6ab937666a1874e07332a003222765486af  trials/cal-matched_energy-04-s51101-r0/per-kc-apl-sources.parquet
+2f191270bf8c504efd2af9c041bc7a35bfffcc508710d63c451dd9dfd054cb97  trials/cal-matched_energy-04-s51101-r0/per-pn.parquet
+d846c4361def05e19aad3eb3150739a121e9c60a0da281cb72f629065a517da0  trials/cal-matched_energy-04-s51101-r0/prefirst-edge-summary.parquet
+052d8d9e127ed52b0d3477fb48e960a851441cc3261a21a74af5801e71847748  trials/cal-matched_energy-04-s51101-r0/replay-final.npz
+d41d6cb860b11f8ee731855ce9f997ffd68999c0d9949db5bdb212c93cfe997d  trials/cal-matched_energy-04-s51101-r0/summary.json
+33d70d035b8916dbdf9f15515c94cbeb3a2036ab1bb826ffd4ac53506d1cb1d6  trials/cal-matched_energy-04-s51101-r1/accepted-prefirst-edge-events.parquet
+59633e9b0cb89109f902ab9c7d8c33471ec19d313300ac8672220762fbac7a53  trials/cal-matched_energy-04-s51101-r1/apl-per-tick.parquet
+fb0b8520649af96558376a6e2430026936451ead051d27237be7f66f3c9f2d2b  trials/cal-matched_energy-04-s51101-r1/apl-source-summary.json
+8d48ee68e147457d1bfb9b65fbdc7ab80c9d9b1c64348fb95dc5ab04fcdaa1e4  trials/cal-matched_energy-04-s51101-r1/output-hashes.json
+6d2aa1d193790aa6882b05534f97b6ab937666a1874e07332a003222765486af  trials/cal-matched_energy-04-s51101-r1/per-kc-apl-sources.parquet
+2f191270bf8c504efd2af9c041bc7a35bfffcc508710d63c451dd9dfd054cb97  trials/cal-matched_energy-04-s51101-r1/per-pn.parquet
+d846c4361def05e19aad3eb3150739a121e9c60a0da281cb72f629065a517da0  trials/cal-matched_energy-04-s51101-r1/prefirst-edge-summary.parquet
+052d8d9e127ed52b0d3477fb48e960a851441cc3261a21a74af5801e71847748  trials/cal-matched_energy-04-s51101-r1/replay-final.npz
+b1b76942ba635f3c71b627887bb71106a703bd19ad2f799e0b456cbabbf5517c  trials/cal-matched_energy-04-s51101-r1/summary.json
+084eb98d1f52c6cb40b2b3aebe156381c9df89b2ad00b15580d9a99a4cdd6fdf  trials/cal-matched_energy-04-s51102-r0/accepted-prefirst-edge-events.parquet
+77cc495a2148e8b2a59256fac78ce874a87dd246f3e5e2e44241a18f2df6d8a2  trials/cal-matched_energy-04-s51102-r0/apl-per-tick.parquet
+772a0a11a255d5e19f439a2239bedbd2f2b8e42ce794f3b2a846eadb3cfef6bf  trials/cal-matched_energy-04-s51102-r0/apl-source-summary.json
+ae20088734d134cb1f2abda081745295ef39e3ef93ffab0d2b55faa76c67ed3c  trials/cal-matched_energy-04-s51102-r0/output-hashes.json
+29488f36fa3d119b4333d60a62b61d76fea469e4d4e6ad6ad339104580692e50  trials/cal-matched_energy-04-s51102-r0/per-kc-apl-sources.parquet
+7a61243f70698eda56c304a71d83018495c3c11820c7ae4b1167ea9a568a1393  trials/cal-matched_energy-04-s51102-r0/per-pn.parquet
+2e5eb0aa8745878d9ecd473705d07576a60b5b489e5fc1dc321b90aa44ca9c4f  trials/cal-matched_energy-04-s51102-r0/prefirst-edge-summary.parquet
+474fbf498d09b2b8dc4b37d6cf6b439f58513b444d76f4da8ac68c56de01526b  trials/cal-matched_energy-04-s51102-r0/replay-final.npz
+9eb7cdbd52692007bc9ffa393d381d333604668bf78d89cb2626e7186cbd2777  trials/cal-matched_energy-04-s51102-r0/summary.json
+361069834ce72404a4a866fcddea1a2f3fb54206c0cf9a0974706ad93017cd2b  trials/cal-matched_energy-04-s51103-r0/accepted-prefirst-edge-events.parquet
+a5dc2efd65fcbcf53cc06553d24905225550c5ef8f4c501cb8c31794a8b6889c  trials/cal-matched_energy-04-s51103-r0/apl-per-tick.parquet
+4a7d8c8da6bee30e21f3f24aaf60ced3e90a217c9d58eb1cae9fb584f3ce16f5  trials/cal-matched_energy-04-s51103-r0/apl-source-summary.json
+83131914d3cb33ee951b49f5851ba5308e1d9816fb3eff7ab73cf75fb6a0e576  trials/cal-matched_energy-04-s51103-r0/output-hashes.json
+065d5d875d9a5bb8823e8125e73ab7470c6d7a913bca6ee880757fde61c84f45  trials/cal-matched_energy-04-s51103-r0/per-kc-apl-sources.parquet
+391dd6929510bf47a07f368f7d7ec35107e451b934945ecb4fbab1eaed593835  trials/cal-matched_energy-04-s51103-r0/per-pn.parquet
+4cd6bcd2bbec78273d256de0167a9cd5777d49ea2ca0b12cd25829e20d4d308c  trials/cal-matched_energy-04-s51103-r0/prefirst-edge-summary.parquet
+76df0c2d65ba4da7db2b2d01047faf66fc9f1f09e59d7b01fc3e961ccbd65052  trials/cal-matched_energy-04-s51103-r0/replay-final.npz
+8732671bb9c313ad6a1704b06ed33d30985542ff94b3603478eab2579b540b0b  trials/cal-matched_energy-04-s51103-r0/summary.json
+0e59a45747ca1d349bc0c94557ad6d108d4d87bdac11089c736fb21b6a0a10b5  trials/cal-matched_energy-04-s51104-r0/accepted-prefirst-edge-events.parquet
+84eb0ccc357071ea3fff330695c02c9ee6bbe439e6f5cb3f45d8f45d30f1dac0  trials/cal-matched_energy-04-s51104-r0/apl-per-tick.parquet
+f76ca0dd9b7b1a541c9c69f3f1fcdade1edf670b93d5ebe4555c3236f063b4d4  trials/cal-matched_energy-04-s51104-r0/apl-source-summary.json
+8a9d44b66f326f85960dee2323866503f5a21ac0601dac3d5a33bcdc5f2c7e1a  trials/cal-matched_energy-04-s51104-r0/output-hashes.json
+e4b6ba5c833cfe6f8c4e3b1fa7da73a6bada0645e31a0128463a102928dbe7b8  trials/cal-matched_energy-04-s51104-r0/per-kc-apl-sources.parquet
+767da5ab15a7196bae26a7ba5cf6c475b5bea835345efadef5b8c07499a2dc6d  trials/cal-matched_energy-04-s51104-r0/per-pn.parquet
+613e03ec33f087183f976d1c81d9939f895455a526a43eb9b583ed69a84be117  trials/cal-matched_energy-04-s51104-r0/prefirst-edge-summary.parquet
+685fde61fda1ae0c5f62d2109016ced54002b30fb244dae7c42851977c08c295  trials/cal-matched_energy-04-s51104-r0/replay-final.npz
+27da7f130af1edd15b596d10799c62d644397699b321142e47a0be96b7686d52  trials/cal-matched_energy-04-s51104-r0/summary.json
+42f3407f7bf6956d399376ae28143d63480547ddc074119b560bae39d3760ffa  trials/cal-matched_energy-04-s51105-r0/accepted-prefirst-edge-events.parquet
+eb0ae622a212d68035bdd0e75ffe46f1418d3f68cb7d1bbc5171560f7f598086  trials/cal-matched_energy-04-s51105-r0/apl-per-tick.parquet
+884ea6f49aac1283aae3c1eb51b9e99b72352bf93df619bbba0483f90ed84b78  trials/cal-matched_energy-04-s51105-r0/apl-source-summary.json
+56d095fbdf2a1403d50eca15bd9e4a12644d4871a4aea2b0ed04a5f58ae3afc5  trials/cal-matched_energy-04-s51105-r0/output-hashes.json
+7d235c9d1f2104671d4a3412ee0d951bb34421c57edd2c44b8bdcca9370801b4  trials/cal-matched_energy-04-s51105-r0/per-kc-apl-sources.parquet
+73c0da8e8986063ccc0d66f07d157093bce112358fddd85d5a789e968f2e6cb6  trials/cal-matched_energy-04-s51105-r0/per-pn.parquet
+674c52b89645e14b5cc80ecd6f21e879f5ebb05c13ce4a096125a3b2a432145e  trials/cal-matched_energy-04-s51105-r0/prefirst-edge-summary.parquet
+fb97788d077193232922aae0ef92aca512e7a6040b29a0a1e431cd276f6bcb25  trials/cal-matched_energy-04-s51105-r0/replay-final.npz
+1fdfd4e00cf5c5d63f0bbc6b259c3a9974235f9b8f5d845152f9d6f6cc0e5392  trials/cal-matched_energy-04-s51105-r0/summary.json
+fb4bebae360dcd89a6ee2cb78b72cc1bb1b860e0a435f4420754c7efc7668f69  trials/cal-matched_energy-05-s51101-r0/accepted-prefirst-edge-events.parquet
+1e1cd0c56610ea8b4eb90f8908a3bcd0e548953add58708cd0e6fee28b74b8b6  trials/cal-matched_energy-05-s51101-r0/apl-per-tick.parquet
+f9f3e10dec28f87c8a80f07390f230ddddf41ac9d98835b0b7c1f7690f882809  trials/cal-matched_energy-05-s51101-r0/apl-source-summary.json
+ed1d20b1bd477e168d079cd4a52357cf75b9a2ae343db198aeb3fa4cc3b21a79  trials/cal-matched_energy-05-s51101-r0/output-hashes.json
+0698af2f2c7ea4ddc192688683b0f4ba12efbdb328bb1b20d7a8661f9c7aff51  trials/cal-matched_energy-05-s51101-r0/per-kc-apl-sources.parquet
+887641c0c48f025ea3653a187226b9cd92056355993b6b704006d276f8b527ac  trials/cal-matched_energy-05-s51101-r0/per-pn.parquet
+2f9b037ccd6ada77c7cfe6f3e193ac749fb3817c973d1c2b866a0a1185278b0e  trials/cal-matched_energy-05-s51101-r0/prefirst-edge-summary.parquet
+f523763609e8a8fe0681795bb8a5a742cba4b27f9a6a3994b684d57707e81f02  trials/cal-matched_energy-05-s51101-r0/replay-final.npz
+829d7175542244a60de2924eacec396ad98d11b9a520e5fa09923094082add62  trials/cal-matched_energy-05-s51101-r0/summary.json
+fb4bebae360dcd89a6ee2cb78b72cc1bb1b860e0a435f4420754c7efc7668f69  trials/cal-matched_energy-05-s51101-r1/accepted-prefirst-edge-events.parquet
+1e1cd0c56610ea8b4eb90f8908a3bcd0e548953add58708cd0e6fee28b74b8b6  trials/cal-matched_energy-05-s51101-r1/apl-per-tick.parquet
+f9f3e10dec28f87c8a80f07390f230ddddf41ac9d98835b0b7c1f7690f882809  trials/cal-matched_energy-05-s51101-r1/apl-source-summary.json
+2c483acde3a538b00e429f79319d94796b89a322f84af74eaa3ccea93acce4a7  trials/cal-matched_energy-05-s51101-r1/output-hashes.json
+0698af2f2c7ea4ddc192688683b0f4ba12efbdb328bb1b20d7a8661f9c7aff51  trials/cal-matched_energy-05-s51101-r1/per-kc-apl-sources.parquet
+887641c0c48f025ea3653a187226b9cd92056355993b6b704006d276f8b527ac  trials/cal-matched_energy-05-s51101-r1/per-pn.parquet
+2f9b037ccd6ada77c7cfe6f3e193ac749fb3817c973d1c2b866a0a1185278b0e  trials/cal-matched_energy-05-s51101-r1/prefirst-edge-summary.parquet
+f523763609e8a8fe0681795bb8a5a742cba4b27f9a6a3994b684d57707e81f02  trials/cal-matched_energy-05-s51101-r1/replay-final.npz
+f16d50e0c5069f7f42e7cadb95cd2034b71fd41f5bb6799b5026ffbdb14e52bc  trials/cal-matched_energy-05-s51101-r1/summary.json
+f355d6fe69a09a92eaf5271fc5d5ed912d635184e2e37d74e8ba191755ee134b  trials/cal-matched_energy-05-s51102-r0/accepted-prefirst-edge-events.parquet
+62307fb6e28323dd95229774e90c3e88f2fd4f6efb654658f5fcf6bf4509f2e0  trials/cal-matched_energy-05-s51102-r0/apl-per-tick.parquet
+a22f3688a566324eb1d1e0d491b251c6525cd43dbe93a5f616e6e58e7a69c6f2  trials/cal-matched_energy-05-s51102-r0/apl-source-summary.json
+367713552a041e7007cddc67ebec26132b2432b16ba502585dc0c8b56c916d09  trials/cal-matched_energy-05-s51102-r0/output-hashes.json
+1c8443de6589afbf55ba35e82da4cfbaad60dc1d825c7f380e89f7c512a5e48e  trials/cal-matched_energy-05-s51102-r0/per-kc-apl-sources.parquet
+d97b4c503fcb7b2170ba5e5efa3f6ac0fa569be9dc59c73264733ce2e7d4b18a  trials/cal-matched_energy-05-s51102-r0/per-pn.parquet
+54caab584102ab7d659fadae46f579b0ec6a8e9a2da7a6bb9e5ddb55612cde36  trials/cal-matched_energy-05-s51102-r0/prefirst-edge-summary.parquet
+5d4bd111c11a5f4aab8e30de38508eb451918c429d7aefc191c97f2b899e2e96  trials/cal-matched_energy-05-s51102-r0/replay-final.npz
+cb2ae4d62749ab9c5ae87a5ef09a9ab1595e25994d67956a1fadf7e64d6e0f4e  trials/cal-matched_energy-05-s51102-r0/summary.json
+9353c88714209eade28f2f5bf527e8dcd00d70cfab17031553cc793b0de12872  trials/cal-matched_energy-05-s51103-r0/accepted-prefirst-edge-events.parquet
+1afbc890661c0094b58df4eea9ca3477f9513c208572d8a11370bb134c2a402e  trials/cal-matched_energy-05-s51103-r0/apl-per-tick.parquet
+e93beb659d32d389bfa84dc37d83417584340054be550ada8e4a0640f0d486e1  trials/cal-matched_energy-05-s51103-r0/apl-source-summary.json
+8cf25e4dd7c4ded3777aded52ca024b5fec77231ca0d415471846c93a03fe810  trials/cal-matched_energy-05-s51103-r0/output-hashes.json
+802fc5d98f6055ae16dafbfd46f31c239692f386f6057fc415a989d1166bcc25  trials/cal-matched_energy-05-s51103-r0/per-kc-apl-sources.parquet
+5a72fc611eeb214cd539a31f64816e345e1bace5e99f9b77992c52643eac2822  trials/cal-matched_energy-05-s51103-r0/per-pn.parquet
+83e02643f8e0a014fb5353311aa6a5bce5ecd605efc1424148efbdb8c7b732be  trials/cal-matched_energy-05-s51103-r0/prefirst-edge-summary.parquet
+dae46ee3018212fcef622733afcc3fec8b70cdecbc70c96ddc85f522796f20ac  trials/cal-matched_energy-05-s51103-r0/replay-final.npz
+0f568d7103e06c4c4b039dee525a3937b4edfb47c025001aa812f97a5ad617a0  trials/cal-matched_energy-05-s51103-r0/summary.json
+5cabe55186eb16f1cc34f82085bbe7e562588473369b3f10b8997e36ff57f06d  trials/cal-matched_energy-05-s51104-r0/accepted-prefirst-edge-events.parquet
+54d55e400456c57026ad053240824e5c1c94569ffe0ab2a0bf7d1417f3436235  trials/cal-matched_energy-05-s51104-r0/apl-per-tick.parquet
+fa5c9fea1ca5c116b428902cc8ec600e038a4e3c9747f24854372e6a69bf373a  trials/cal-matched_energy-05-s51104-r0/apl-source-summary.json
+de632d07fc40d5f28816989a32a757ccfc7793498a2b93b41a6e54758f7ec3ba  trials/cal-matched_energy-05-s51104-r0/output-hashes.json
+a8ff0a41c0ce34991bce30f7b167c531ed3e245012aa5104ab215abf4399aea1  trials/cal-matched_energy-05-s51104-r0/per-kc-apl-sources.parquet
+8b0abe42214cca3aa567efbe58e0557ef72697a8c290cd8c4ed3d96f480cb7d0  trials/cal-matched_energy-05-s51104-r0/per-pn.parquet
+1b57a1eb1b1d837a629324fd983e8a74dfc5085a04517557b119eb83d087cdda  trials/cal-matched_energy-05-s51104-r0/prefirst-edge-summary.parquet
+aa756dc6e9c310b6e71b7c476d6ff8d89c72cd21241d305a7b0969102a40cbe4  trials/cal-matched_energy-05-s51104-r0/replay-final.npz
+a1703a4c1ce0c86bf4b84b2d283a79e754f31b5bb7a01e57e9d35f04dd7bb79e  trials/cal-matched_energy-05-s51104-r0/summary.json
+6dfa7139b5c28fa8e5b15eeaa557ffdb273b5a0b7b2560123f3d01a7cd72771d  trials/cal-matched_energy-05-s51105-r0/accepted-prefirst-edge-events.parquet
+6713172da92b1593a1b5e2b230915579df78819578376843d9dba1d7194e9668  trials/cal-matched_energy-05-s51105-r0/apl-per-tick.parquet
+5359cb78181ebf664ecb8ed69e28d70f6b7d5591431238d2d43f0d7e5dba5a0d  trials/cal-matched_energy-05-s51105-r0/apl-source-summary.json
+2a9fd18f91aab0c16a7d62880c9edd384dea0560ac4843cc0db5e54ba20c2813  trials/cal-matched_energy-05-s51105-r0/output-hashes.json
+88de040fcff56fdd1dd139e632572b342a4f109dc00bb2c2fb0ffb5cc452ba47  trials/cal-matched_energy-05-s51105-r0/per-kc-apl-sources.parquet
+dc04227cca53ea2f3ee13c975ac226ebc1a89e290bc1aca461bdf8c6070c75e3  trials/cal-matched_energy-05-s51105-r0/per-pn.parquet
+33d68d2cdbfba7f70db8636b7928aeb8f2f0be5f84ddc674c6ab22a922658ba6  trials/cal-matched_energy-05-s51105-r0/prefirst-edge-summary.parquet
+6558238e3be5a83676bb3b0d734484026da7f83d1ff297b41687d07a0fa9f9a4  trials/cal-matched_energy-05-s51105-r0/replay-final.npz
+a0b7832f08e2116bde0ee0ee7cec470e53db0d070c3b42573da34be61b5fbc06  trials/cal-matched_energy-05-s51105-r0/summary.json
+60ddd3f6a841a8e3a5f71587c83c006b460e2734493cc10003bd09a95ae11727  trials/cal-physiological-00-s51101-r0/accepted-prefirst-edge-events.parquet
+f76c4f3a6e161cf2200471cc511605ca1805ab2effffd83491daa6b7de67b634  trials/cal-physiological-00-s51101-r0/apl-per-tick.parquet
+14e222415a62bc54186809c1af9496e1ba36a963ae671d42a26e6efd8f065801  trials/cal-physiological-00-s51101-r0/apl-source-summary.json
+5973c74ce88d241b602d1aec2900cafe6d40fa5964cde6e53c89d3c3b9df20e0  trials/cal-physiological-00-s51101-r0/output-hashes.json
+d8c4778486e14b66b3bf9bd35cfaaef0ff3dd5267b04709fb05b4c6e3dd7a9e8  trials/cal-physiological-00-s51101-r0/per-kc-apl-sources.parquet
+517337f157757478a9625836d9b16bda66f36130dbac12eb93cae6bd19bb1c8c  trials/cal-physiological-00-s51101-r0/per-pn.parquet
+b8acc9eb216e21d291a7659d40400e244f170155f020b4abd6ff1f8d028bc853  trials/cal-physiological-00-s51101-r0/prefirst-edge-summary.parquet
+044be3e3a5de3a69f2a0f047f85fb1f58ec9b47cdfcee227a3ff67c91c652d65  trials/cal-physiological-00-s51101-r0/replay-final.npz
+85416e683e6e1bb18c4bd9b05e073cd695722fa25a919595744b8f25fcb62f1b  trials/cal-physiological-00-s51101-r0/summary.json
+60ddd3f6a841a8e3a5f71587c83c006b460e2734493cc10003bd09a95ae11727  trials/cal-physiological-00-s51101-r1/accepted-prefirst-edge-events.parquet
+f76c4f3a6e161cf2200471cc511605ca1805ab2effffd83491daa6b7de67b634  trials/cal-physiological-00-s51101-r1/apl-per-tick.parquet
+14e222415a62bc54186809c1af9496e1ba36a963ae671d42a26e6efd8f065801  trials/cal-physiological-00-s51101-r1/apl-source-summary.json
+1132f66f28d30f8e9add81a68aec62912e69d3ff03a98c16d9c58f4cd8f95d4b  trials/cal-physiological-00-s51101-r1/output-hashes.json
+d8c4778486e14b66b3bf9bd35cfaaef0ff3dd5267b04709fb05b4c6e3dd7a9e8  trials/cal-physiological-00-s51101-r1/per-kc-apl-sources.parquet
+517337f157757478a9625836d9b16bda66f36130dbac12eb93cae6bd19bb1c8c  trials/cal-physiological-00-s51101-r1/per-pn.parquet
+b8acc9eb216e21d291a7659d40400e244f170155f020b4abd6ff1f8d028bc853  trials/cal-physiological-00-s51101-r1/prefirst-edge-summary.parquet
+044be3e3a5de3a69f2a0f047f85fb1f58ec9b47cdfcee227a3ff67c91c652d65  trials/cal-physiological-00-s51101-r1/replay-final.npz
+1809696cabd5c494481ef7abf32bb855fac48dfeb8e64349c7b766a7945791c4  trials/cal-physiological-00-s51101-r1/summary.json
+089b1c235fa0822ada78e8112731ece027a0ef73d129f95c06159ed003ef90aa  trials/cal-physiological-00-s51102-r0/accepted-prefirst-edge-events.parquet
+cdbef43f7bf2d8d3ef55b643a1c7fb8621097ce28e48a02e3ca30971b44900f7  trials/cal-physiological-00-s51102-r0/apl-per-tick.parquet
+5238bade275642fc9eac427d1718382825674f6d5ffc0563dcd62a16946baa6f  trials/cal-physiological-00-s51102-r0/apl-source-summary.json
+cf2faec97478f0598d83d1d0f33573b13eae607ebcf654bce23440a10a842ce5  trials/cal-physiological-00-s51102-r0/output-hashes.json
+e9cb67e2978ed191b7ca9242993f6bae4698c2619917c388fd00877fbc02de06  trials/cal-physiological-00-s51102-r0/per-kc-apl-sources.parquet
+8d1534b2591a24160ba38c30071db1e6379d85bf47252f60b396674d6bd595cf  trials/cal-physiological-00-s51102-r0/per-pn.parquet
+b20c64f8cf96ff3d5f8db4ab1fca91ab9859e5551e94a7b6a95dd1fae88bcc08  trials/cal-physiological-00-s51102-r0/prefirst-edge-summary.parquet
+b388fb13902e56504fd6704cc581c315158a12ac6d362cb18c8bcdebb761e279  trials/cal-physiological-00-s51102-r0/replay-final.npz
+8e00836bc558f9a48bcc010b2b242489977ec99d2f5b423e9900e224fd2543ca  trials/cal-physiological-00-s51102-r0/summary.json
+8f419ad5603a1e006d10b0cd99bf0d6fc0e061b7b201277d2e3c0ae7453b8be9  trials/cal-physiological-00-s51103-r0/accepted-prefirst-edge-events.parquet
+0036724570f9120f48007259e6b197da256b05afab777d5a19e0c2d84b23bd88  trials/cal-physiological-00-s51103-r0/apl-per-tick.parquet
+41048b5222c46164fd5752be459c530e0d515c8df37e8774a3fe419414680811  trials/cal-physiological-00-s51103-r0/apl-source-summary.json
+db7de5d55a514e83ae436316bcc82253f6dbf4027c26f9d2be02341e4261a37d  trials/cal-physiological-00-s51103-r0/output-hashes.json
+51f13dd61de320b9567c010fa0e4875074ed73ff439e07b28ecf0fab4b37308c  trials/cal-physiological-00-s51103-r0/per-kc-apl-sources.parquet
+e0e9ff15c8e5830dfb5c6945176de73b9d7269924f68cad06d93c90468342697  trials/cal-physiological-00-s51103-r0/per-pn.parquet
+fa4fae6880da75223e945623bae76427574ee39005989a9c7703b576ddf3d1cb  trials/cal-physiological-00-s51103-r0/prefirst-edge-summary.parquet
+d18e96b338b7c7cb881af3c61108c06e1cfee386cb44e6c5cc5b487fb58fad3c  trials/cal-physiological-00-s51103-r0/replay-final.npz
+01c20118551b89966714898d4c5ac3609af99e01bd7b746c46eea2a78cdc330a  trials/cal-physiological-00-s51103-r0/summary.json
+936e71bbeebbc2f6dc1451892d341a29a12051f54db14592684f6f663be93aa1  trials/cal-physiological-00-s51104-r0/accepted-prefirst-edge-events.parquet
+8beac4ec787f9a0c2e125290b199b2a755fcb5aea4cf2db30b55f1e594c0d35d  trials/cal-physiological-00-s51104-r0/apl-per-tick.parquet
+766e9a90ee62f6b75e144ca76517292dda1f860616a6a6baa94156d81d3060b4  trials/cal-physiological-00-s51104-r0/apl-source-summary.json
+3b026c7515fa8742952ebefb85431461f06a541f420d54411862103fcdefa84f  trials/cal-physiological-00-s51104-r0/output-hashes.json
+b29b1a305a126f494d05bc91ad180b83ac37ad0a87c0061765967657a4d854ac  trials/cal-physiological-00-s51104-r0/per-kc-apl-sources.parquet
+21bfb7f17da4c2b80cfcbbf59e6742421b20c70317e8a5b33f67f1593331f5cd  trials/cal-physiological-00-s51104-r0/per-pn.parquet
+5d8fb51297060b15b1429c46802ef4ea2c72497fc0369dc2d2dc206e738dabb5  trials/cal-physiological-00-s51104-r0/prefirst-edge-summary.parquet
+c0376da077011d41979b7e0689d96930eaa7a22de9771fa3f8bff67ad82ae42c  trials/cal-physiological-00-s51104-r0/replay-final.npz
+009c7f6a356663afad338fe0a15c8f6fa1975e5b614011cb411cee434ac1ac31  trials/cal-physiological-00-s51104-r0/summary.json
+eec0b9f95e244b46df13aec16fa5425f8aaf65af1fd3ed23bc3a86676494d725  trials/cal-physiological-00-s51105-r0/accepted-prefirst-edge-events.parquet
+6ceba2fb19bec86b2e718ce1194c0d338b405d61278c19b278384251a1318d14  trials/cal-physiological-00-s51105-r0/apl-per-tick.parquet
+7ee5e00f5436b4e59c512aeea3400294f8b15f2d1fc7d1cada108a8953d47cf4  trials/cal-physiological-00-s51105-r0/apl-source-summary.json
+1e6fd89ba7946b03a046941816a8de3bbd18693deed881e1e038d3ac7322dae9  trials/cal-physiological-00-s51105-r0/output-hashes.json
+097776f68225e84e91dfde88a5022d75139ae70a1b07d56b9532ac9d1281e056  trials/cal-physiological-00-s51105-r0/per-kc-apl-sources.parquet
+95df3def519d348f899c8d9fdf5151b1e868d7dac1079ac2a5538b805e5798c6  trials/cal-physiological-00-s51105-r0/per-pn.parquet
+b3dfadeca11b6ffd403d3226ee3f873b43a723e8990eb6e4db5588c8b6d5660d  trials/cal-physiological-00-s51105-r0/prefirst-edge-summary.parquet
+c8e48d9f062130323a6ed5633707387db004635018e20fa1bcf0705e91fe70ac  trials/cal-physiological-00-s51105-r0/replay-final.npz
+0dca1b6187325d734cd1628d62cbfc654b00427c79a32122529352686488dde9  trials/cal-physiological-00-s51105-r0/summary.json
+b884da4b2c4808f6d729bc3665d4d3d06e2f4417c909e2532b4b56b94542921c  trials/cal-physiological-01-s51101-r0/accepted-prefirst-edge-events.parquet
+fb053cbd98cfbc1c7f08e300cc5213c25a1365871b9a6ed2a3ae93655b575c47  trials/cal-physiological-01-s51101-r0/apl-per-tick.parquet
+7c1e3a9067dd7d0ead7bd0a93ffa8ac0bc480c4ad830692ba7d6ff198ba3211c  trials/cal-physiological-01-s51101-r0/apl-source-summary.json
+f11e6a7688fcb02dcdc64fae296e47656376dd2ce0298490b43aa96e442e1195  trials/cal-physiological-01-s51101-r0/output-hashes.json
+5957ec8579a88d54be81fa79b059a9439f097598f48ff7877551efe9982d5dd2  trials/cal-physiological-01-s51101-r0/per-kc-apl-sources.parquet
+52d222ed3f68c7bbcd0ca8cb1be489f59f928504569ce02501694c1b025aa8d0  trials/cal-physiological-01-s51101-r0/per-pn.parquet
+0bbc640222c722f0f2cc18ea5cdee4a2413016d2d345a747834445a6519281bd  trials/cal-physiological-01-s51101-r0/prefirst-edge-summary.parquet
+68d9b8d9ca3965edd1ddc21f670f8acb4066f82e380f3c4c022c9ea7090bbcd4  trials/cal-physiological-01-s51101-r0/replay-final.npz
+6690112447b741f55a35021fc60c1938e940bb0d6e294ebd06e848457076a1cc  trials/cal-physiological-01-s51101-r0/summary.json
+b884da4b2c4808f6d729bc3665d4d3d06e2f4417c909e2532b4b56b94542921c  trials/cal-physiological-01-s51101-r1/accepted-prefirst-edge-events.parquet
+fb053cbd98cfbc1c7f08e300cc5213c25a1365871b9a6ed2a3ae93655b575c47  trials/cal-physiological-01-s51101-r1/apl-per-tick.parquet
+7c1e3a9067dd7d0ead7bd0a93ffa8ac0bc480c4ad830692ba7d6ff198ba3211c  trials/cal-physiological-01-s51101-r1/apl-source-summary.json
+b554bed14112033750878e343bf87ea5ac9905d0c6f72f66cdc4a2245732ccd9  trials/cal-physiological-01-s51101-r1/output-hashes.json
+5957ec8579a88d54be81fa79b059a9439f097598f48ff7877551efe9982d5dd2  trials/cal-physiological-01-s51101-r1/per-kc-apl-sources.parquet
+52d222ed3f68c7bbcd0ca8cb1be489f59f928504569ce02501694c1b025aa8d0  trials/cal-physiological-01-s51101-r1/per-pn.parquet
+0bbc640222c722f0f2cc18ea5cdee4a2413016d2d345a747834445a6519281bd  trials/cal-physiological-01-s51101-r1/prefirst-edge-summary.parquet
+68d9b8d9ca3965edd1ddc21f670f8acb4066f82e380f3c4c022c9ea7090bbcd4  trials/cal-physiological-01-s51101-r1/replay-final.npz
+3a496cdbdfe7e2f658645d6504d4f84031ae2f1594fc17adff5bca33a8192a8a  trials/cal-physiological-01-s51101-r1/summary.json
+fe66b591dcc3e98619478ff8c81d6344987a6dd6c7b0f2f7b753ea5e98a44b07  trials/cal-physiological-01-s51102-r0/accepted-prefirst-edge-events.parquet
+a5a72adc51da67653aaa9d867cb0560ab75f105b88daf84938ea659e5d00eaf4  trials/cal-physiological-01-s51102-r0/apl-per-tick.parquet
+27a92a9e0b3eaed49545b0377ba6ccfa62f57ea04145d13fd2cae2073cfa74c6  trials/cal-physiological-01-s51102-r0/apl-source-summary.json
+9f87873b654674135e3e1fe47b4e435d28be8e291440c66b9759629e49569f0e  trials/cal-physiological-01-s51102-r0/output-hashes.json
+82512942ffa8f6ba7ad79c0a97044347c88dbf19a9c9cadd584474386e98da84  trials/cal-physiological-01-s51102-r0/per-kc-apl-sources.parquet
+a34fafe769be6bb1118d8c3ba885021be5fdedcad2a6ae8799b379274a29d48e  trials/cal-physiological-01-s51102-r0/per-pn.parquet
+55e1a5d56b1191edf047b0876dafa1768efb9aed988614911f25a82833a87d38  trials/cal-physiological-01-s51102-r0/prefirst-edge-summary.parquet
+4bc83dea4e28754a7d0f6bb1ed7a82fee1fbd2cd17bf304bb1dc1c51375260d5  trials/cal-physiological-01-s51102-r0/replay-final.npz
+fec03735d5d0530444a1ec4a280aeef1ef4d5814a4e69c50932699499a1f9632  trials/cal-physiological-01-s51102-r0/summary.json
+9bd00ccefd05c2704a2c8ca9c3f7193ebd51a7195f4aefa363005d78b730708e  trials/cal-physiological-01-s51103-r0/accepted-prefirst-edge-events.parquet
+7d2e11585ef6379e413d9ab74fdc6302f68ee29ed14dbb732af6dea64c6a491e  trials/cal-physiological-01-s51103-r0/apl-per-tick.parquet
+4f7f15e5cc06673f9aa65f4d2b1ecef702e1e1797dbd547946fd65070b7c019d  trials/cal-physiological-01-s51103-r0/apl-source-summary.json
+f09569f3bb1d221e795a6af4422f3a4f2c94a5b093a3bd28515de0a5cde6b117  trials/cal-physiological-01-s51103-r0/output-hashes.json
+f727a25a3752aae31225899398b0f6ab1826f081f3a2aaa51dfd9b4904da2636  trials/cal-physiological-01-s51103-r0/per-kc-apl-sources.parquet
+dfe5d224e94f02a18fd732d8ce73dcd8c3b5c39a5cd3053548be180c36b91afb  trials/cal-physiological-01-s51103-r0/per-pn.parquet
+0a97aa31f2f225b378d02bd692baa9ad3f10fa9585a3a97652cbb157814ac564  trials/cal-physiological-01-s51103-r0/prefirst-edge-summary.parquet
+2b2b1b5285fe84082219283e6b6fc6094f4ee9fe542a5dc4dd484a34651bfd14  trials/cal-physiological-01-s51103-r0/replay-final.npz
+8ead3771b33a5d3cc92fd9b252985bb83361ee7b63298bce3d1026a7c664cdde  trials/cal-physiological-01-s51103-r0/summary.json
+808a6a0d276d3487aae380b4df41458b321bad167770ccd983a6b733de04f0ad  trials/cal-physiological-01-s51104-r0/accepted-prefirst-edge-events.parquet
+709822b83572c58e120effedd634515aead40ec2f8b48688ee83ffbef3c5dcaa  trials/cal-physiological-01-s51104-r0/apl-per-tick.parquet
+ddc9f90c8bbfabf418c60abb9f58b69dec5a0b9493634da4de1788b3b98c1a19  trials/cal-physiological-01-s51104-r0/apl-source-summary.json
+7bec19d49283f92d9a37bfdba802a15307dbd2fbe1e6317d1b8703995243eb29  trials/cal-physiological-01-s51104-r0/output-hashes.json
+b40f720d92fb462e5c8748565e7f40a52a279ec28b3095f48517dbbe93f421fe  trials/cal-physiological-01-s51104-r0/per-kc-apl-sources.parquet
+a0309ecf0324de1a322371311b6d44aef76ecaa69dfb0e0ab286afcdaf6be144  trials/cal-physiological-01-s51104-r0/per-pn.parquet
+f344cd04bbf66e664dcd166a15fd7dc0269c603b9c17c9dffc9f3fc9f75f50f5  trials/cal-physiological-01-s51104-r0/prefirst-edge-summary.parquet
+b105e90eb73a492b83b159f05b517eeffcc7ba6fc2008a56b683f301a1ec2221  trials/cal-physiological-01-s51104-r0/replay-final.npz
+d6cde44319c7cefacc711d6912cc493f294ac0adbb31e28b277f30df18f9e0a3  trials/cal-physiological-01-s51104-r0/summary.json
+7ea6e7597e422fca04400c237f1442e097fa49e05ab7cf278f0b4b5319bc0fea  trials/cal-physiological-01-s51105-r0/accepted-prefirst-edge-events.parquet
+c63718a8d21750361beb18830582ff866853da04a0cc5f875fc221db24b3c0f9  trials/cal-physiological-01-s51105-r0/apl-per-tick.parquet
+7efe0abdd1830a1ab725cd07a7d3d510df78aaa4bd1a0a3c3fe22971ffd6d7ac  trials/cal-physiological-01-s51105-r0/apl-source-summary.json
+6f9b9228a9d3ce14a236f278dcf288a0697557a2b2664b66f06259e54af86761  trials/cal-physiological-01-s51105-r0/output-hashes.json
+a6fef3b2f996e85aeff1f2269b73776726d4afa4b6fe86c59402546d315814ff  trials/cal-physiological-01-s51105-r0/per-kc-apl-sources.parquet
+35e43092f4c3bc875b92182207ff34b2d4defe30042467ca3a2cd373694bc0f4  trials/cal-physiological-01-s51105-r0/per-pn.parquet
+3ef83ccb80301893fc594af4581989f45efcf4751f282a58c9951b9e698ad93f  trials/cal-physiological-01-s51105-r0/prefirst-edge-summary.parquet
+f1bfc282121aa44fcebb2406b2c77db70a6aee077fb22792c8622c327b55d0e0  trials/cal-physiological-01-s51105-r0/replay-final.npz
+b85423892db7d23bce627ee00a3b2071710962e70bc42f4ed669608779e89a8e  trials/cal-physiological-01-s51105-r0/summary.json
+be50536d41d98c8f9eda084908e9f302d830987fc7f4a4744c2a55bfc2f5e845  trials/cal-physiological-02-s51101-r0/accepted-prefirst-edge-events.parquet
+fd09cbc093b0a886a57a625dd65bccce5188ead916bf40a1d9c9f9f6860c70f8  trials/cal-physiological-02-s51101-r0/apl-per-tick.parquet
+8ff4d114aeed9bb7ffc2aa0c852e0c08931079d0b78f5c40d313af95461cd3d5  trials/cal-physiological-02-s51101-r0/apl-source-summary.json
+622ee7f4876d074470194bd5da4db60c6e617ec4f5d30372c798826332ffc3ff  trials/cal-physiological-02-s51101-r0/output-hashes.json
+af3b75cfc647626b98645cf71d29efa09ed5af95628c0ec7ed4c92a811969c99  trials/cal-physiological-02-s51101-r0/per-kc-apl-sources.parquet
+62cc4ea1ca9000407d91ddd3c4569bc4aa10ee90e454cd61d075a633fd1e678b  trials/cal-physiological-02-s51101-r0/per-pn.parquet
+2f5c4baf6cab67cf6877ebf8a0db55fc3b09a7b2c2886fb7133d62df160bd01a  trials/cal-physiological-02-s51101-r0/prefirst-edge-summary.parquet
+bee035da95f7e393948666e945c2da70b6fe2df710ffea84f321adc84f5f1489  trials/cal-physiological-02-s51101-r0/replay-final.npz
+81bc6b49d39477f8c3ba4ca8125d4538d6dd6aac4e576f1af17a8afe745a86f2  trials/cal-physiological-02-s51101-r0/summary.json
+be50536d41d98c8f9eda084908e9f302d830987fc7f4a4744c2a55bfc2f5e845  trials/cal-physiological-02-s51101-r1/accepted-prefirst-edge-events.parquet
+fd09cbc093b0a886a57a625dd65bccce5188ead916bf40a1d9c9f9f6860c70f8  trials/cal-physiological-02-s51101-r1/apl-per-tick.parquet
+8ff4d114aeed9bb7ffc2aa0c852e0c08931079d0b78f5c40d313af95461cd3d5  trials/cal-physiological-02-s51101-r1/apl-source-summary.json
+435696f70d48c752aaaebf4b3503019905cc6a99dfa96455cc4a140f792bf86d  trials/cal-physiological-02-s51101-r1/output-hashes.json
+af3b75cfc647626b98645cf71d29efa09ed5af95628c0ec7ed4c92a811969c99  trials/cal-physiological-02-s51101-r1/per-kc-apl-sources.parquet
+62cc4ea1ca9000407d91ddd3c4569bc4aa10ee90e454cd61d075a633fd1e678b  trials/cal-physiological-02-s51101-r1/per-pn.parquet
+2f5c4baf6cab67cf6877ebf8a0db55fc3b09a7b2c2886fb7133d62df160bd01a  trials/cal-physiological-02-s51101-r1/prefirst-edge-summary.parquet
+bee035da95f7e393948666e945c2da70b6fe2df710ffea84f321adc84f5f1489  trials/cal-physiological-02-s51101-r1/replay-final.npz
+8f0b8470d1474b3e002922a15a37b79e10a78bcdb86acdeba695f76a56625392  trials/cal-physiological-02-s51101-r1/summary.json
+9ea7ecf704a7c9ae65bab8fc51ebe963ee11a9c23b08c8693cd1721acd79c5d3  trials/cal-physiological-02-s51102-r0/accepted-prefirst-edge-events.parquet
+09e0d99f92f4f6f0e478a93e52ade5dc2012a6fd4579ea05e4405e7365c14746  trials/cal-physiological-02-s51102-r0/apl-per-tick.parquet
+68965a694af73a874409bf226502b36cafc1bcd3d8c25f57cf789491279416fb  trials/cal-physiological-02-s51102-r0/apl-source-summary.json
+1aaa2ea1774622337af0ff2deb08333ccac710da1ca19488e28a11c31d556846  trials/cal-physiological-02-s51102-r0/output-hashes.json
+cbc972f8433fc1df9306cead29075778e8c8d02fff5221a2369184bbfa310930  trials/cal-physiological-02-s51102-r0/per-kc-apl-sources.parquet
+bd7150f67570820470fe5abc1df0c6c7dbfa58e68a870b59ed4e8c8a84b9174e  trials/cal-physiological-02-s51102-r0/per-pn.parquet
+a20c90946ae6fa881c41624f85b5ff6cc190fdebcd7700e04b82046b52b8258b  trials/cal-physiological-02-s51102-r0/prefirst-edge-summary.parquet
+56d0efdc6c5554f6a1ac637284d2c7fcb009dd5bb48667085f4a2bbac4d9c464  trials/cal-physiological-02-s51102-r0/replay-final.npz
+9592c26f74a618856eb3e5142cd14fc1960a6e878418900051bd216a880628ec  trials/cal-physiological-02-s51102-r0/summary.json
+85702984077c958a4907d01a5aadc24a31043acf3862f2d0ccd56950ba5baf16  trials/cal-physiological-02-s51103-r0/accepted-prefirst-edge-events.parquet
+20f1172462ff17f5a7be48c4a3528bf8b71395281c1c1c7c7ec239b5dc9b4297  trials/cal-physiological-02-s51103-r0/apl-per-tick.parquet
+63a955f58ca5824bfc42249c5d746416dae5f5612c32e8590fa2b622b2fdb357  trials/cal-physiological-02-s51103-r0/apl-source-summary.json
+44fa11983d9ac5790b544d442656dc9090d0cd5224942848fbb33ce6185d4e51  trials/cal-physiological-02-s51103-r0/output-hashes.json
+155daeae3a60c3a38e0d61833208c5868f618da24fe9fde10112094ea5b2109f  trials/cal-physiological-02-s51103-r0/per-kc-apl-sources.parquet
+3ab399e467ed0a7c64987dbfe8c9ae2355318c5101af5baf17ae85925c2db01f  trials/cal-physiological-02-s51103-r0/per-pn.parquet
+b8d29c158556d20189459cb44f7957b1b852b7235a4130d167a3721d1be616e7  trials/cal-physiological-02-s51103-r0/prefirst-edge-summary.parquet
+d42b8c4ed2badc2f4c515de4f60e009616ccb2f2fa0b3d2557549b8892d419aa  trials/cal-physiological-02-s51103-r0/replay-final.npz
+093da5c0306055132fc354b4b08e75073d01aeddbf77d838fdca9ecd57a3db1d  trials/cal-physiological-02-s51103-r0/summary.json
+e11714c8303fab203ad936d8a2a57dede3d45a36eccd5ec8433225a46af6e87c  trials/cal-physiological-02-s51104-r0/accepted-prefirst-edge-events.parquet
+17af86eec5cb3e736ef9608d0aad291fe5f8e81b72f0a0155f3c308daf7a72c9  trials/cal-physiological-02-s51104-r0/apl-per-tick.parquet
+7138acb697bb9d0a8ceb06ac374fcd7cd3c1b4e35f46a48e3b038ed49eebc68b  trials/cal-physiological-02-s51104-r0/apl-source-summary.json
+2d725be237217cd014795c7383d9c95f75cc166a6361e78e550f08abc061fb36  trials/cal-physiological-02-s51104-r0/output-hashes.json
+f51d252ade1e58e85daf2f3a26462f156deb20171894cc1f7ec402899a2361ff  trials/cal-physiological-02-s51104-r0/per-kc-apl-sources.parquet
+6c88ebeede942c8f6ca8050656169f86bc822eb6ebdb02147ca3de9085b6655d  trials/cal-physiological-02-s51104-r0/per-pn.parquet
+40abcae883b058e667da283ebc0a0f7256ccbba4dc29af5181ec338324b22142  trials/cal-physiological-02-s51104-r0/prefirst-edge-summary.parquet
+cf9efaf0a40878ce2b9233a64903b4a90872454b24e403f38ac4b3fe30dd26f7  trials/cal-physiological-02-s51104-r0/replay-final.npz
+8d640e200c67e46b7c2265cb2456cfde8a343f81580df8035d63f2291e13be05  trials/cal-physiological-02-s51104-r0/summary.json
+2341039df18e3680371fdedc792a389aee50338600f8eb5d341a2f8443d734f8  trials/cal-physiological-02-s51105-r0/accepted-prefirst-edge-events.parquet
+d25b2d4ff68d4a0a22b504ff867dfd89b3ebc6c3e96a476489f82f17f4812c15  trials/cal-physiological-02-s51105-r0/apl-per-tick.parquet
+ad3214378c690669b50b6ec04d1b69bb135cc0b60d86b574bb82b49523af93fe  trials/cal-physiological-02-s51105-r0/apl-source-summary.json
+cef884c400970a4f636f75a10866cfdcd0f070e5966a851f5ecc54dab865e417  trials/cal-physiological-02-s51105-r0/output-hashes.json
+0d5c0eac728a0db0e5383840ccb0ef939ffbae1dd438eb751c1b87c0fe7d32df  trials/cal-physiological-02-s51105-r0/per-kc-apl-sources.parquet
+6b9960b5d776c4cc09f73c353186a9a6ce4b8a288380941d7d7d78a6b9e68127  trials/cal-physiological-02-s51105-r0/per-pn.parquet
+cb6a76a102528ba55aa771cd35be7e8785e5d2ef4904c785f8b3f6ab97e62e9a  trials/cal-physiological-02-s51105-r0/prefirst-edge-summary.parquet
+5d00f3cc1beba87c9c63d46a62e1d02acde804f44a530dd6f7cdc2552f9ef9c1  trials/cal-physiological-02-s51105-r0/replay-final.npz
+0e4b67ce85ac81a426d5921d5b1ce1bcd3726bb93d9ff12d519984b88c959dc0  trials/cal-physiological-02-s51105-r0/summary.json
+d40ec449d22776dd54640a62ccbac38e21505089f3f0e0254ca22413cc09673f  trials/cal-physiological-03-s51101-r0/accepted-prefirst-edge-events.parquet
+26a86cf23393dc94184ff04f1f835ef9a408f852d469dab3332cffffea802fa8  trials/cal-physiological-03-s51101-r0/apl-per-tick.parquet
+91ff7a7f0506f97ebefeedeb20d7736a12bf75fc3038a1456df7049131b6fc50  trials/cal-physiological-03-s51101-r0/apl-source-summary.json
+1b07de442ee083923f87cbe84279858afef5fd4c931883398979a6c3944e7db0  trials/cal-physiological-03-s51101-r0/output-hashes.json
+a4d516821793393c5d18a37d2d711583ca471bb5d44b9afe107285f4b6995bc5  trials/cal-physiological-03-s51101-r0/per-kc-apl-sources.parquet
+acf7c9ef25aed37c6a847973d2700e4ad3509f5c4650eb57aa190c0b93c4974e  trials/cal-physiological-03-s51101-r0/per-pn.parquet
+bdec452c66441aa731c039435451d1280c71f64a3f59fd6c6bf6a7677fca75ca  trials/cal-physiological-03-s51101-r0/prefirst-edge-summary.parquet
+e9ba4e8dc35e7fd053b4e1a6723fa82a304329766f73aab1e3190ac94c40103e  trials/cal-physiological-03-s51101-r0/replay-final.npz
+83db8fb93223a2718067d0059a6fc33ed66b16f3ea65b1dc4fefe5c1aa6605e4  trials/cal-physiological-03-s51101-r0/summary.json
+d40ec449d22776dd54640a62ccbac38e21505089f3f0e0254ca22413cc09673f  trials/cal-physiological-03-s51101-r1/accepted-prefirst-edge-events.parquet
+26a86cf23393dc94184ff04f1f835ef9a408f852d469dab3332cffffea802fa8  trials/cal-physiological-03-s51101-r1/apl-per-tick.parquet
+91ff7a7f0506f97ebefeedeb20d7736a12bf75fc3038a1456df7049131b6fc50  trials/cal-physiological-03-s51101-r1/apl-source-summary.json
+1247f855bc66c54887b1737219681df4e17ccba9d7959a977657aa0e2649994d  trials/cal-physiological-03-s51101-r1/output-hashes.json
+a4d516821793393c5d18a37d2d711583ca471bb5d44b9afe107285f4b6995bc5  trials/cal-physiological-03-s51101-r1/per-kc-apl-sources.parquet
+acf7c9ef25aed37c6a847973d2700e4ad3509f5c4650eb57aa190c0b93c4974e  trials/cal-physiological-03-s51101-r1/per-pn.parquet
+bdec452c66441aa731c039435451d1280c71f64a3f59fd6c6bf6a7677fca75ca  trials/cal-physiological-03-s51101-r1/prefirst-edge-summary.parquet
+e9ba4e8dc35e7fd053b4e1a6723fa82a304329766f73aab1e3190ac94c40103e  trials/cal-physiological-03-s51101-r1/replay-final.npz
+f2fa33697fb1906b576cb6e6cddedbdb45012a0e511cdcf0f8ae2160bf7e118b  trials/cal-physiological-03-s51101-r1/summary.json
+d428a4e812ab0b07a5933b9e66155009ae63c75196ba2fc49ed4a41bf464f551  trials/cal-physiological-03-s51102-r0/accepted-prefirst-edge-events.parquet
+51740794bb70a17dd9f32653197f95592e4f9e601ecb7abd7c3ba5254c8e6017  trials/cal-physiological-03-s51102-r0/apl-per-tick.parquet
+706fc086ac6cf7b0ed95083b6a082d2943f38eb656c011b0c6a54a923bfc448a  trials/cal-physiological-03-s51102-r0/apl-source-summary.json
+26ebc592752b5168e3e367a98792b1c2161923328d213eca6a0d890872b7ca23  trials/cal-physiological-03-s51102-r0/output-hashes.json
+0f568a5a716a34c0151da5e21296aca496a2ac21bef51a8ca24e414fc53d6056  trials/cal-physiological-03-s51102-r0/per-kc-apl-sources.parquet
+38f289033c4ea430b7ced26f7edac93da38b3379f5cb349311012e6f2eac1d86  trials/cal-physiological-03-s51102-r0/per-pn.parquet
+4692499442927c9db1e3b7ea6f4c6a50424838f4122de2d8fb34bdaab8b02138  trials/cal-physiological-03-s51102-r0/prefirst-edge-summary.parquet
+6d3546af32197657994637ff405637d1d09746a33036f9765cc0b2e96a4248ff  trials/cal-physiological-03-s51102-r0/replay-final.npz
+5259dd9381e45757d8be3ca5028d9f983beba904e15e080361767c9d17668022  trials/cal-physiological-03-s51102-r0/summary.json
+17c1913b425b356d5cfb923b5c96b39a601c763c27da6e1efbb0aaa42326a84f  trials/cal-physiological-03-s51103-r0/accepted-prefirst-edge-events.parquet
+87ab18d10da4382b6f06cb03a6c945318d6113b42f0bfa81dd7569babdf1a573  trials/cal-physiological-03-s51103-r0/apl-per-tick.parquet
+a4de55a6cb5e87c272788362a05c0199c8d15c581033bb0c33a34199a801ba5b  trials/cal-physiological-03-s51103-r0/apl-source-summary.json
+0c02acf4a4f8a3727f85e18c7b1a93e9759760cedfc5b367c80819c7ff535c2e  trials/cal-physiological-03-s51103-r0/output-hashes.json
+fd486321edf6e0cb72c7821afa1129f51bbf5ce163b73e2968315c5a3bc36a52  trials/cal-physiological-03-s51103-r0/per-kc-apl-sources.parquet
+bb9a9cfe9061fdf6fc3ee36e5056bd4f4d6d0530dd68bfc4e1dccd7f7a5f1911  trials/cal-physiological-03-s51103-r0/per-pn.parquet
+aaf9664c0bff04ff518124cb758ff312e025d1a10ad4e7d6b4122923980d4e57  trials/cal-physiological-03-s51103-r0/prefirst-edge-summary.parquet
+e6208d922e5fb0b835df8f9963922bfdf896bdd3d718709f4a22970a40a2e9ee  trials/cal-physiological-03-s51103-r0/replay-final.npz
+e4c13fc0e9c0bb3d7c1146f1878bbbf9e321dca4ea95d08520adfc84952eb95e  trials/cal-physiological-03-s51103-r0/summary.json
+0d6d4abf1d208411b3d01f297ccd550d29c5b573ae1b664556949da9b52d5934  trials/cal-physiological-03-s51104-r0/accepted-prefirst-edge-events.parquet
+f02f117d76a3f99a30d1cc920c03e7ae68e887668ed939bcded85057314bf51f  trials/cal-physiological-03-s51104-r0/apl-per-tick.parquet
+5be700d3fd5e45ec4d9f55980425f9ca1b57400ace38ab187171858dbe0219c8  trials/cal-physiological-03-s51104-r0/apl-source-summary.json
+9a8e49ebbc48b395f692b0a29c3cc7ac2a71adcfc861a191a6b8a154111efb15  trials/cal-physiological-03-s51104-r0/output-hashes.json
+facf04ea1da1968928575b7d100c7d965dfd5171c4753ac0a350ea70a2277ece  trials/cal-physiological-03-s51104-r0/per-kc-apl-sources.parquet
+67766588582590a9d17545f651f97d9534cf5ab48b2aad8be31a41b0259eb79b  trials/cal-physiological-03-s51104-r0/per-pn.parquet
+1d16d02007a4ba311482d2d05c671f6e2008b213044e38a1445a281b494bb26b  trials/cal-physiological-03-s51104-r0/prefirst-edge-summary.parquet
+b1ea8267b81ac3d86dab4cd220e04699b4fad79e78ecde3c7294ffb0640b23c7  trials/cal-physiological-03-s51104-r0/replay-final.npz
+878c1abb3547067c63b3b6be21570275f4ff900db0ff3de7407f19b79a6bc352  trials/cal-physiological-03-s51104-r0/summary.json
+13261f9074450d7626760448d0cb3ef784e949c584068f8d90c4f54534d02218  trials/cal-physiological-03-s51105-r0/accepted-prefirst-edge-events.parquet
+3c1a367f77a317375ed898757179e75f96d1a41afa700e72443d6af7686cdaed  trials/cal-physiological-03-s51105-r0/apl-per-tick.parquet
+1fb11b6cc8aaf8298403e6df61efb7b3bc3184d8a44c5c45d86ce7e669b6dd80  trials/cal-physiological-03-s51105-r0/apl-source-summary.json
+702807d4c56a414878c10ae7f922fb46e0dab62bdc63b5e083c31bae16f3f6de  trials/cal-physiological-03-s51105-r0/output-hashes.json
+ce289bbcf9ca13ab1db574463f90cd4a57b95b0b83324ce205b3828de0f59e99  trials/cal-physiological-03-s51105-r0/per-kc-apl-sources.parquet
+75ad49f90d6df50c4f288aa5630e157bfd150b0b94404d1681a409b03f8a98da  trials/cal-physiological-03-s51105-r0/per-pn.parquet
+bd9a043fe5f8931b585fb43d385f01790c401be580bb405a6389243653e27b73  trials/cal-physiological-03-s51105-r0/prefirst-edge-summary.parquet
+bc1ef22fe490c0cc6d59e38ded4029d69b414995e88199cabc01d6bbad9bf8f6  trials/cal-physiological-03-s51105-r0/replay-final.npz
+d5b17738717502e8a69527ab8d380b88b8c9bbf9fad5997cb2dbd776dcd14a3b  trials/cal-physiological-03-s51105-r0/summary.json
+da0481a7f86bb966c18d9bfbf4af485aa6459d41a2d81a408e804fd0532b00f5  trials/cal-physiological-04-s51101-r0/accepted-prefirst-edge-events.parquet
+fcf0f02545baf2c7e2a920e5b8cbfe4f72f6dc1eab5b59c7bb9be8fe00956cdf  trials/cal-physiological-04-s51101-r0/apl-per-tick.parquet
+fa4028e2ad1afbd756bce2b67e244a382b04b2f75f5c9d9809a6538351204cf4  trials/cal-physiological-04-s51101-r0/apl-source-summary.json
+01c679e14c3a372734f5b9165f7ad6a0e6ac30858e883c1e31b38eabd3157c66  trials/cal-physiological-04-s51101-r0/output-hashes.json
+64caa7ab3067e2e5c0a87af49e08622cdbb5bffdc898a09936db1aac7d98e694  trials/cal-physiological-04-s51101-r0/per-kc-apl-sources.parquet
+924ff4aab4b00265dd287c46e2f39fa8b9fe8c9b8f6ad45339828d0b9786b508  trials/cal-physiological-04-s51101-r0/per-pn.parquet
+9892dfa5f43344c9cc3a958b282c90396115fc4016dd2aad6dcf90cbe2d9c1cc  trials/cal-physiological-04-s51101-r0/prefirst-edge-summary.parquet
+981430673f2764babfdb69c892a4c5acf3afeda77ad7ff53818ad4ce74919abd  trials/cal-physiological-04-s51101-r0/replay-final.npz
+093ed38dd2014cd79f00df76bc193abb8f07e22e98516fa5064f29971a146f28  trials/cal-physiological-04-s51101-r0/summary.json
+da0481a7f86bb966c18d9bfbf4af485aa6459d41a2d81a408e804fd0532b00f5  trials/cal-physiological-04-s51101-r1/accepted-prefirst-edge-events.parquet
+fcf0f02545baf2c7e2a920e5b8cbfe4f72f6dc1eab5b59c7bb9be8fe00956cdf  trials/cal-physiological-04-s51101-r1/apl-per-tick.parquet
+fa4028e2ad1afbd756bce2b67e244a382b04b2f75f5c9d9809a6538351204cf4  trials/cal-physiological-04-s51101-r1/apl-source-summary.json
+1b5af8c1be8f4b429a8ea31ad46fd8f9ab602d67df29c5eabe8f5eb2e0090259  trials/cal-physiological-04-s51101-r1/output-hashes.json
+64caa7ab3067e2e5c0a87af49e08622cdbb5bffdc898a09936db1aac7d98e694  trials/cal-physiological-04-s51101-r1/per-kc-apl-sources.parquet
+924ff4aab4b00265dd287c46e2f39fa8b9fe8c9b8f6ad45339828d0b9786b508  trials/cal-physiological-04-s51101-r1/per-pn.parquet
+9892dfa5f43344c9cc3a958b282c90396115fc4016dd2aad6dcf90cbe2d9c1cc  trials/cal-physiological-04-s51101-r1/prefirst-edge-summary.parquet
+981430673f2764babfdb69c892a4c5acf3afeda77ad7ff53818ad4ce74919abd  trials/cal-physiological-04-s51101-r1/replay-final.npz
+5c6d36e2f078b49b606ec017aec8b6fbd197bc6b044d8b53099587249f0fb10a  trials/cal-physiological-04-s51101-r1/summary.json
+f6b482f103f8e71241d29ceb8f3d57c4c7ed18289966d9602b7650f724aba31f  trials/cal-physiological-04-s51102-r0/accepted-prefirst-edge-events.parquet
+7bae4336f31cd085fb629c88435e0f7dfe71692e71ecfb1c966c883ef9c7c232  trials/cal-physiological-04-s51102-r0/apl-per-tick.parquet
+3366e05617b6922600a0e40e740761ab2f4fa51ecfb9dc9bb0431b8aaa1bc9d6  trials/cal-physiological-04-s51102-r0/apl-source-summary.json
+60c52eb1cbfc13a73944f2d60d34882e88b0ccb4ba43a1b0e5a71858e1ae6276  trials/cal-physiological-04-s51102-r0/output-hashes.json
+aec96f77c38cbfa1e709cc35775acaf66d99a9e858a8188c72ceaf4c84b8dab1  trials/cal-physiological-04-s51102-r0/per-kc-apl-sources.parquet
+aed78fbc7cf9558752b4524eb6dbc71dea36293ebdf0f6924a5495303d3a269c  trials/cal-physiological-04-s51102-r0/per-pn.parquet
+d88659cd9c738fb5b98d44935309939c697c6942732155454b4f012fb6a72fb9  trials/cal-physiological-04-s51102-r0/prefirst-edge-summary.parquet
+482ab997bf73e4dd518e0589d080dfc9c41e9e89b8be817a573f2e75be0ac171  trials/cal-physiological-04-s51102-r0/replay-final.npz
+35a41c1daedbc2b9f03cf4ffab8e903f9140fb58b24fc5d469d3b4aeff539ce8  trials/cal-physiological-04-s51102-r0/summary.json
+69a10cebc6e6879cd0f5baace3e3188d0decb6edc292043991cd4b63b6faf579  trials/cal-physiological-04-s51103-r0/accepted-prefirst-edge-events.parquet
+7ee117353920d69b9e1a8810526c7b886d00fa440af3f740d02253b0d8885117  trials/cal-physiological-04-s51103-r0/apl-per-tick.parquet
+572600b47fa371aacbe5dee817a6179bdfe1abbac06b82590805123413cdc388  trials/cal-physiological-04-s51103-r0/apl-source-summary.json
+67f86396975744fb24e6968bca0ef74ac7177536db5f59ef496bb658eea78ea9  trials/cal-physiological-04-s51103-r0/output-hashes.json
+37760f93aad5309a49b184394efc52de43d79ad47af537183d3355ee6a171956  trials/cal-physiological-04-s51103-r0/per-kc-apl-sources.parquet
+11e57faa348cfc97204c2e448b509def4b6262863fcda25393f2599df74e356a  trials/cal-physiological-04-s51103-r0/per-pn.parquet
+0cc2764b389843d93c1e36f029cf6b7742c648e21f00395b9ac8c0e9bf14131f  trials/cal-physiological-04-s51103-r0/prefirst-edge-summary.parquet
+a44379d0fa5d901985b743d95ec5aa5c5cb6159d1b8f2917664905e838fa2c48  trials/cal-physiological-04-s51103-r0/replay-final.npz
+7ef72a29579437f181f7f47544d07200bc5c893d239a77a809c24300ef5dd5c8  trials/cal-physiological-04-s51103-r0/summary.json
+ea9ec492e271d79210cd73152c1802ec6776b8335e21230509b0b990e44c6515  trials/cal-physiological-04-s51104-r0/accepted-prefirst-edge-events.parquet
+a27dbccac13505838dae95f623f3bf589af80a4e443e1dfc6c3621bcb09cc643  trials/cal-physiological-04-s51104-r0/apl-per-tick.parquet
+67e26e5234c375e52664c6fda195bbf23f9f384ab6565b628d5f2312c1dd393b  trials/cal-physiological-04-s51104-r0/apl-source-summary.json
+43ccdc01df512411ba3496bd4d61b1392bc07321d7b1909c5ab46aa6feffeb05  trials/cal-physiological-04-s51104-r0/output-hashes.json
+e2b45d74526a1e1b48b2243fdedc661598c078f00a73c92e9039e6640eb89299  trials/cal-physiological-04-s51104-r0/per-kc-apl-sources.parquet
+339d7857767815e56908bf94c100faebc5eca73cc9b38382e5e826cab6d474f7  trials/cal-physiological-04-s51104-r0/per-pn.parquet
+2c7a19493855a72355e36d85307193a64add5575d43b604420d50f198264a5e0  trials/cal-physiological-04-s51104-r0/prefirst-edge-summary.parquet
+b31a1c93a1b7a0efa4e1457fbf831d8d5a073cfa862ec56042f6440448aa853d  trials/cal-physiological-04-s51104-r0/replay-final.npz
+5b9c806b855522390d87986ea0e686b99cc3ac0f23e1b7fd7bf20584fa5c811e  trials/cal-physiological-04-s51104-r0/summary.json
+3863ffe141d0bf393a1b782f47acb66495962cf1ccfd6c7d30dd75f52d13e0fd  trials/cal-physiological-04-s51105-r0/accepted-prefirst-edge-events.parquet
+7a4c849a77b2cfb4a999b1ac9b0223c2100d8217336b5590be22081dfc2e50e7  trials/cal-physiological-04-s51105-r0/apl-per-tick.parquet
+4f3d0ca3c87948c487b886daff4d9294d07aded9e2ae6fdd7be76b383ff96e9f  trials/cal-physiological-04-s51105-r0/apl-source-summary.json
+acc129698e2bd2ec84d36dbf5c8f2e92ec4f0645f00e3668be909ab55f1b7973  trials/cal-physiological-04-s51105-r0/output-hashes.json
+52e82420528bb1802344927846d5789ba7561bdc3407a425180b6a5e380df7d8  trials/cal-physiological-04-s51105-r0/per-kc-apl-sources.parquet
+815e58cdd608e7cbb6bf3f86a76e80a85ac864495322d1554b56093b64a4e198  trials/cal-physiological-04-s51105-r0/per-pn.parquet
+e7c46cc8a7f2f516f3d8e1d3f02b694aeb2883b42c870b1ebb497433183bb9f5  trials/cal-physiological-04-s51105-r0/prefirst-edge-summary.parquet
+55cd18dc81820f9d06931e0030d537f33b67546f3b6edcdb944a7642677bfa33  trials/cal-physiological-04-s51105-r0/replay-final.npz
+eae1af2fd2827439c91c0a9f90610dfbecf955333fd61dda827a0d3cd5121d47  trials/cal-physiological-04-s51105-r0/summary.json
+3d59560778a58ca35f7db11d675e282ab220b2900efb38afaea6b96148ea1108  trials/cal-physiological-05-s51101-r0/accepted-prefirst-edge-events.parquet
+171a144e97651474bf4763e75ee40fbccd55d1d9f3bad0ac387b6e12a1ad1adb  trials/cal-physiological-05-s51101-r0/apl-per-tick.parquet
+688cbca4e200f630eff7a522235f1e3907389d28970e5e3b3a46c6f43c05677f  trials/cal-physiological-05-s51101-r0/apl-source-summary.json
+54bbebe5f210a9108ea31d999bf0ee25c4d881a5c014823ace68783b2b039aba  trials/cal-physiological-05-s51101-r0/output-hashes.json
+734b5c20ee074d872f64dba7c65d90ec80d3d2c599bdf410d7790474fa70f325  trials/cal-physiological-05-s51101-r0/per-kc-apl-sources.parquet
+2893f9b956d58a81c8dfe2bec338d975fbefa0a406e0264a86970058a8c8d99f  trials/cal-physiological-05-s51101-r0/per-pn.parquet
+a4f59a4b4b1e5f9e2c9a769f43866ab3c5ef6ac220de777959bedb1bc6ad7e62  trials/cal-physiological-05-s51101-r0/prefirst-edge-summary.parquet
+512fee95334107c4675493a4a182e744ddd29615276032fb9e2416830b07e8f1  trials/cal-physiological-05-s51101-r0/replay-final.npz
+7a3e6c4541b7225d9791faf47584564a84b3bdaa1bd64bbcd32ed4f8bb7b7e31  trials/cal-physiological-05-s51101-r0/summary.json
+3d59560778a58ca35f7db11d675e282ab220b2900efb38afaea6b96148ea1108  trials/cal-physiological-05-s51101-r1/accepted-prefirst-edge-events.parquet
+171a144e97651474bf4763e75ee40fbccd55d1d9f3bad0ac387b6e12a1ad1adb  trials/cal-physiological-05-s51101-r1/apl-per-tick.parquet
+688cbca4e200f630eff7a522235f1e3907389d28970e5e3b3a46c6f43c05677f  trials/cal-physiological-05-s51101-r1/apl-source-summary.json
+adbd4879df899e7646dd79941406f472139f2c62e0eee89083b6b6ab24db9f92  trials/cal-physiological-05-s51101-r1/output-hashes.json
+734b5c20ee074d872f64dba7c65d90ec80d3d2c599bdf410d7790474fa70f325  trials/cal-physiological-05-s51101-r1/per-kc-apl-sources.parquet
+2893f9b956d58a81c8dfe2bec338d975fbefa0a406e0264a86970058a8c8d99f  trials/cal-physiological-05-s51101-r1/per-pn.parquet
+a4f59a4b4b1e5f9e2c9a769f43866ab3c5ef6ac220de777959bedb1bc6ad7e62  trials/cal-physiological-05-s51101-r1/prefirst-edge-summary.parquet
+512fee95334107c4675493a4a182e744ddd29615276032fb9e2416830b07e8f1  trials/cal-physiological-05-s51101-r1/replay-final.npz
+089a35b1e7251ddcbc22315374e754efbd89ab4c60b9c0a987a05ffe641380fd  trials/cal-physiological-05-s51101-r1/summary.json
+11a081c1dcbff19054aa47270d126088a0b26a3a85590b2b0cfce272998af196  trials/cal-physiological-05-s51102-r0/accepted-prefirst-edge-events.parquet
+5849fedbeceab9268240e5c79d4704d950ec99db1c4dd2fd56fc8c96fd6a408f  trials/cal-physiological-05-s51102-r0/apl-per-tick.parquet
+db2f321a3b7921187a15436706f45f354c2b40611ca6b58ac36f51b0c77819de  trials/cal-physiological-05-s51102-r0/apl-source-summary.json
+bf5f9d95553cb78bd4250791658194deff7c0b5001b22c964bf81ce12ca088c0  trials/cal-physiological-05-s51102-r0/output-hashes.json
+b99809629d5ae62fd81e1fdb50f6f433dc714732b8cbb4f860f5d6262cf6712f  trials/cal-physiological-05-s51102-r0/per-kc-apl-sources.parquet
+7863c5c189c6c8e409d129025778cfab12e7519b53e7cb139b9d532c06ae4523  trials/cal-physiological-05-s51102-r0/per-pn.parquet
+75be485a49e44a61ac0b32c094598ab276acf304d3a8e1566f2799f29b4be8df  trials/cal-physiological-05-s51102-r0/prefirst-edge-summary.parquet
+88c5f219dce85511f32841e381a6bf6677051d20825e2beccf709baa0d041409  trials/cal-physiological-05-s51102-r0/replay-final.npz
+e66c3b7e46a3381301b6f489752d3d21bee825582916d7940d448b544a96a783  trials/cal-physiological-05-s51102-r0/summary.json
+51c5e14d7dbc814d3e0d398106ef84a5e0a6ccbfb8a3a6001d235b8aa3d980e0  trials/cal-physiological-05-s51103-r0/accepted-prefirst-edge-events.parquet
+59dd7ffec297b788684f88aef67737611c4302499d137b04f602199978c67a0d  trials/cal-physiological-05-s51103-r0/apl-per-tick.parquet
+5a5395a34bb57177d45ac053719247a2e5125bdfe2ce2a551bdddc812f75a0a1  trials/cal-physiological-05-s51103-r0/apl-source-summary.json
+e10faed8a1f3070b8599fbb97b0188c0531da0a0fc564f0a945d8373e611955d  trials/cal-physiological-05-s51103-r0/output-hashes.json
+c545e3a14379e52fb339e52c2d608ab68e8626a2f1cfdc48851566eb6e52b43c  trials/cal-physiological-05-s51103-r0/per-kc-apl-sources.parquet
+bb34084bb876334f5cb01533936466a1c0734f784d13642b01b34305d869f45d  trials/cal-physiological-05-s51103-r0/per-pn.parquet
+a0fc186c47b9f51ac7e61ff9c1485cd0bacc58d0450db88f57a0feb6ebd43ee7  trials/cal-physiological-05-s51103-r0/prefirst-edge-summary.parquet
+d71133cad2a24337a80f69de37804d35ee44d7ae594fd90b32ad715d0fb4722a  trials/cal-physiological-05-s51103-r0/replay-final.npz
+54e0e9395f91813e5995dea0357b311e7f8598bd1dac8d50a03794264e5dfe2e  trials/cal-physiological-05-s51103-r0/summary.json
+4eacc1c83c6d07d661328c4795dada4a7a4afe057c1591600e31e57f374b67a3  trials/cal-physiological-05-s51104-r0/accepted-prefirst-edge-events.parquet
+4c75d6703dbbcc80316dbaff43779be4723bf6629f1c871e4e442b1aeb9e655b  trials/cal-physiological-05-s51104-r0/apl-per-tick.parquet
+8a70c648f666a416ab60c479714d0869c48dbc2eb1d97a24e5419852a18e61c3  trials/cal-physiological-05-s51104-r0/apl-source-summary.json
+0cdd8545e71041699f9b49710e59cc076d3c6b0165f8435e6f311af3e4eb8020  trials/cal-physiological-05-s51104-r0/output-hashes.json
+d23bbad651ff27fdabde351333f93a9b65059c18a34c85ef4ca40f041525fbbc  trials/cal-physiological-05-s51104-r0/per-kc-apl-sources.parquet
+9215243560060298ff591dee8624351f7302ae498deb9aa4ce934a66172806fa  trials/cal-physiological-05-s51104-r0/per-pn.parquet
+c4d391b87dda430b3cf979fe268cefff762437fbb96dcd0819ecd581800f09cb  trials/cal-physiological-05-s51104-r0/prefirst-edge-summary.parquet
+4e60741d12f595acbb630b643c801fece16f4c2c43581a350749f48d2ce42269  trials/cal-physiological-05-s51104-r0/replay-final.npz
+55441f5064ff695aaede72042ad0e8df16c82d0a3d483613c9d4208ce100d814  trials/cal-physiological-05-s51104-r0/summary.json
+789a72b941a99ed4d5ce2a6de704473ef507c21a699c9f0dcb583c1e7b7beb91  trials/cal-physiological-05-s51105-r0/accepted-prefirst-edge-events.parquet
+35c53fdab5e71d034007b1651625491dea6f5339b132c541d7e401336cdf70c3  trials/cal-physiological-05-s51105-r0/apl-per-tick.parquet
+001ec5a86fdecfc532dc2efb1e670155dd95cf20c01a5258e5f7293d4eb481d9  trials/cal-physiological-05-s51105-r0/apl-source-summary.json
+558f0401184acf05e00c533c7eb0479593c7c1454024ecd74fdb74f064fc0464  trials/cal-physiological-05-s51105-r0/output-hashes.json
+72c1be5cec337b4308c5e2e06dfb2cc7038eced5567897ed7b82e247d32c1223  trials/cal-physiological-05-s51105-r0/per-kc-apl-sources.parquet
+92e3febc64f789009c4ab356050508c8f0bca5147625f0bee63f1fa8ca6814e3  trials/cal-physiological-05-s51105-r0/per-pn.parquet
+74aa073a8cac2fed922e0ed3a1f62c6b09b8a2bec0f3f072b9b5b42756d9cd2e  trials/cal-physiological-05-s51105-r0/prefirst-edge-summary.parquet
+a0336fc3993831dd67c43a78f01abb06c70674a50f0f951ec891edc936704e90  trials/cal-physiological-05-s51105-r0/replay-final.npz
+9d5586fc39caae591d94aee9277b85ad64570dd588dd7958cd26d7df319f1046  trials/cal-physiological-05-s51105-r0/summary.json
+f280887885ac42602eed3797664549a47ee920c18703894296a21ca9104d2e7c  trials/high_fanin-r0/accepted-prefirst-edge-events.parquet
+98f8f0121b16c1159f062623f0ebd3dbb04f78d4d26cfe96e912e0503ba40ae6  trials/high_fanin-r0/apl-per-tick.parquet
+f8c4dbd54d78f5ef54c8bbb5d184d58381b4a0796d834d733dea391ddbdcbd2f  trials/high_fanin-r0/apl-source-summary.json
+e0f6c281b54e603803dfa4d01519e5a4dff4cf8b969831c704e1eb025678e800  trials/high_fanin-r0/output-hashes.json
+0bb881dd587d5632fb9aadef78ab00a9f8403576772c8746d6bbe1f25e6b2177  trials/high_fanin-r0/per-kc-apl-sources.parquet
+c9492df4f2ae42c9ac5ed5980793db0c5b96293560c4f31b8c9bbd9cd7ce82ae  trials/high_fanin-r0/per-pn.parquet
+1fa7444c3453560ead9aea031934ddc46fd75a3f8c73de0f8779703ab00c6798  trials/high_fanin-r0/prefirst-edge-summary.parquet
+b72c605fa73f990d6b56ee2ac28ef16ae9180b2afea59af1cb3efd6dca3a8cf6  trials/high_fanin-r0/replay-final.npz
+b87b3858dab608c9d45c14b05273e8e89be229fc4123688947e6859da95027a2  trials/high_fanin-r0/summary.json
+f280887885ac42602eed3797664549a47ee920c18703894296a21ca9104d2e7c  trials/kc_ref_boundary-r0/accepted-prefirst-edge-events.parquet
+b45d904b6614c4376634564900afbdcf5aa15f4922c470e026a7e904197b46eb  trials/kc_ref_boundary-r0/apl-per-tick.parquet
+152582714ed550d7e9b86a788c1566887b342fe96ba11625628af84c70ea1e65  trials/kc_ref_boundary-r0/apl-source-summary.json
+61ab5ec7f5dae9f109a56d8e8fc96d02fa0701663ea8e4c8c98a1f135f13ffbb  trials/kc_ref_boundary-r0/output-hashes.json
+d1ba884d6700b30418acec5945a275a636a95548ec601ef0ddfba5ef4d80fd33  trials/kc_ref_boundary-r0/per-kc-apl-sources.parquet
+f87adf8c149b4245a10877c0a0ada0697984e54c3b4bec38368e3042dec2a324  trials/kc_ref_boundary-r0/per-pn.parquet
+1fa7444c3453560ead9aea031934ddc46fd75a3f8c73de0f8779703ab00c6798  trials/kc_ref_boundary-r0/prefirst-edge-summary.parquet
+b2a3ea4ccb556229cf6f3587628e1f5d89cf30daf4732737baa5a94a0ea2bc1c  trials/kc_ref_boundary-r0/replay-final.npz
+6dd03e2c39f6fa654108347430b9bf73730d8b81218ccef999e630dd8a44fae8  trials/kc_ref_boundary-r0/summary.json
+f280887885ac42602eed3797664549a47ee920c18703894296a21ca9104d2e7c  trials/natural_request-r0/accepted-prefirst-edge-events.parquet
+74c00365f2f8a471c53f288916f1481fa25f9665f88951540cbb58b81a37db49  trials/natural_request-r0/apl-per-tick.parquet
+dc0d825fb00eda3956b438a65113de64b4ea160af899dc10da48535b7034e874  trials/natural_request-r0/apl-source-summary.json
+ec40744e7b3b7ce7f50f8b8bd3a0efddf201d2ad51813975dc96fdf76b972bc5  trials/natural_request-r0/output-hashes.json
+df3fb1339fc5a8379f579bcadf6669a9bf8a5da9cd1154dd7948d27327f4939a  trials/natural_request-r0/per-kc-apl-sources.parquet
+f87adf8c149b4245a10877c0a0ada0697984e54c3b4bec38368e3042dec2a324  trials/natural_request-r0/per-pn.parquet
+1fa7444c3453560ead9aea031934ddc46fd75a3f8c73de0f8779703ab00c6798  trials/natural_request-r0/prefirst-edge-summary.parquet
+b2a3ea4ccb556229cf6f3587628e1f5d89cf30daf4732737baa5a94a0ea2bc1c  trials/natural_request-r0/replay-final.npz
+34e9ba9ee86ba1f88d9dcf4a0fed3fb9fea306a6a42972e584b668fc10bded4f  trials/natural_request-r0/summary.json
+3db0664e23d5862608ca51964947b28deda926971c6a34f0261560827b9d95b7  trials/pn_pulse-r0/accepted-prefirst-edge-events.parquet
+f306f9d101cff67812e7a4928949fb589ccd582146d801e1e10c17c8931a4269  trials/pn_pulse-r0/apl-per-tick.parquet
+ebed0d4264581011d7caa3c1a12ff9040e8dd0c228192a6f5cee5f3b0932bc70  trials/pn_pulse-r0/apl-source-summary.json
+e418e472584c5f0e8143b1daa687082559bc81f4f2882a329876c508d98455d9  trials/pn_pulse-r0/output-hashes.json
+33b10526604870fa0017a045929e1bd995c358919afe7d9e518ed617549572ca  trials/pn_pulse-r0/per-kc-apl-sources.parquet
+274b046fc80d5c403c5f7c4f7f469ca657f07ae324c108a8d31171ad522ba0f1  trials/pn_pulse-r0/per-pn.parquet
+da5e070f1fff5b1d04d78404a9aeea1d02aa74cb8a3e48115d081a239599c7e8  trials/pn_pulse-r0/prefirst-edge-summary.parquet
+3ac12307214c87dd4a9a55288567389c890a5e2cee7c9243602ab24b85426c20  trials/pn_pulse-r0/replay-final.npz
+d65ff6144a9d653e501e3d23f1fa2fc57b91a2773a83f6f25e74383c3ddb5eb8  trials/pn_pulse-r0/summary.json
+9f336236f47b06f68b0de0554affaef82877e54174b65cc18caa6ecb2d6bfa93  trials/two_sources-r0/accepted-prefirst-edge-events.parquet
+5887638344eef13b2fff0028358a73a3d99419f73aab2fd79ec4151f30571cc2  trials/two_sources-r0/apl-per-tick.parquet
+c312fa58d8149747ffe2c69628772e77ec76405f07fa88836342c2df31a3fe92  trials/two_sources-r0/apl-source-summary.json
+200083750677d71b4811f8a39faa915abb0e3a1793f6d4b4d790e663bed35b42  trials/two_sources-r0/output-hashes.json
+a7316d87db16223b1c1ac9b97a692543ef6f962a8bdc34692d5206e11915b861  trials/two_sources-r0/per-kc-apl-sources.parquet
+e953e7c4a2eed9c36d3434e68c1a019134a93d3405063e638e832db2c2024939  trials/two_sources-r0/per-pn.parquet
+e4f10cf84fef400e16f213c2769222f391ba88823d69943ea8d84b6cc5e18197  trials/two_sources-r0/prefirst-edge-summary.parquet
+7c4b92a2f786c85bc267986f861bb69a7ad4610f21f356e82e1abb76c95ce69d  trials/two_sources-r0/replay-final.npz
+663c0c2e800a74dd29318b0d6beb2053ca3cccd3ce62ffcb6fea321e78df7ca0  trials/two_sources-r0/summary.json
+f280887885ac42602eed3797664549a47ee920c18703894296a21ca9104d2e7c  trials/zero-r0/accepted-prefirst-edge-events.parquet
+7b656cbab6a3d669d697e1bbe1f0f292d9605efad2de3f052c60cfed09ff4756  trials/zero-r0/apl-per-tick.parquet
+47d022760b58ee6fcd07e7608b69e16f29ec6c5ca96ff8437421bd2df9fdfe98  trials/zero-r0/apl-source-summary.json
+986ef849bab4d6e74266e1eba9007ca0e27c82733762c3b0f34abcc2cdb19471  trials/zero-r0/output-hashes.json
+7048f979b2bdde63845476c0b1675bd501071e2a5ec121e37b7c88fb71c49c94  trials/zero-r0/per-kc-apl-sources.parquet
+974f18df83470bf5708e787afed3a7973efe7f71c06420660351902640844560  trials/zero-r0/per-pn.parquet
+1fa7444c3453560ead9aea031934ddc46fd75a3f8c73de0f8779703ab00c6798  trials/zero-r0/prefirst-edge-summary.parquet
+b2a3ea4ccb556229cf6f3587628e1f5d89cf30daf4732737baa5a94a0ea2bc1c  trials/zero-r0/replay-final.npz
+bfa26cfc59592049b79b0fa08e07b61de61afa9638ffd596532a6aeea293e7ca  trials/zero-r0/summary.json
+12c6f2e9929b3f7084e8b39b90c8851185febbc0afbb7031f9eebb4c41d2731d  manifest.json
@@ -0,0 +1,482 @@
+[
+  {
+    "case": "zero",
+    "repeat": 0,
+    "kind": "fixture",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/zero-r0"
+  },
+  {
+    "case": "pn_pulse",
+    "repeat": 0,
+    "kind": "fixture",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/pn_pulse-r0"
+  },
+  {
+    "case": "kc_ref_boundary",
+    "repeat": 0,
+    "kind": "fixture",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/kc_ref_boundary-r0"
+  },
+  {
+    "case": "two_sources",
+    "repeat": 0,
+    "kind": "fixture",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/two_sources-r0"
+  },
+  {
+    "case": "arrival_collision",
+    "repeat": 0,
+    "kind": "fixture",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/arrival_collision-r0"
+  },
+  {
+    "case": "natural_request",
+    "repeat": 0,
+    "kind": "fixture",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/natural_request-r0"
+  },
+  {
+    "case": "apl_only",
+    "repeat": 0,
+    "kind": "fixture",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/apl_only-r0"
+  },
+  {
+    "case": "high_fanin",
+    "repeat": 0,
+    "kind": "fixture",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/high_fanin-r0"
+  },
+  {
+    "case": "cal-physiological-00-s51101",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-00-s51101-r0"
+  },
+  {
+    "case": "cal-physiological-00-s51101",
+    "repeat": 1,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-00-s51101-r1"
+  },
+  {
+    "case": "cal-physiological-00-s51102",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-00-s51102-r0"
+  },
+  {
+    "case": "cal-physiological-00-s51103",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-00-s51103-r0"
+  },
+  {
+    "case": "cal-physiological-00-s51104",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-00-s51104-r0"
+  },
+  {
+    "case": "cal-physiological-00-s51105",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-00-s51105-r0"
+  },
+  {
+    "case": "cal-physiological-01-s51101",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-01-s51101-r0"
+  },
+  {
+    "case": "cal-physiological-01-s51101",
+    "repeat": 1,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-01-s51101-r1"
+  },
+  {
+    "case": "cal-physiological-01-s51102",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-01-s51102-r0"
+  },
+  {
+    "case": "cal-physiological-01-s51103",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-01-s51103-r0"
+  },
+  {
+    "case": "cal-physiological-01-s51104",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-01-s51104-r0"
+  },
+  {
+    "case": "cal-physiological-01-s51105",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-01-s51105-r0"
+  },
+  {
+    "case": "cal-physiological-02-s51101",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-02-s51101-r0"
+  },
+  {
+    "case": "cal-physiological-02-s51101",
+    "repeat": 1,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-02-s51101-r1"
+  },
+  {
+    "case": "cal-physiological-02-s51102",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-02-s51102-r0"
+  },
+  {
+    "case": "cal-physiological-02-s51103",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-02-s51103-r0"
+  },
+  {
+    "case": "cal-physiological-02-s51104",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-02-s51104-r0"
+  },
+  {
+    "case": "cal-physiological-02-s51105",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-02-s51105-r0"
+  },
+  {
+    "case": "cal-physiological-03-s51101",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-03-s51101-r0"
+  },
+  {
+    "case": "cal-physiological-03-s51101",
+    "repeat": 1,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-03-s51101-r1"
+  },
+  {
+    "case": "cal-physiological-03-s51102",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-03-s51102-r0"
+  },
+  {
+    "case": "cal-physiological-03-s51103",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-03-s51103-r0"
+  },
+  {
+    "case": "cal-physiological-03-s51104",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-03-s51104-r0"
+  },
+  {
+    "case": "cal-physiological-03-s51105",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-03-s51105-r0"
+  },
+  {
+    "case": "cal-physiological-04-s51101",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-04-s51101-r0"
+  },
+  {
+    "case": "cal-physiological-04-s51101",
+    "repeat": 1,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-04-s51101-r1"
+  },
+  {
+    "case": "cal-physiological-04-s51102",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-04-s51102-r0"
+  },
+  {
+    "case": "cal-physiological-04-s51103",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-04-s51103-r0"
+  },
+  {
+    "case": "cal-physiological-04-s51104",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-04-s51104-r0"
+  },
+  {
+    "case": "cal-physiological-04-s51105",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-04-s51105-r0"
+  },
+  {
+    "case": "cal-physiological-05-s51101",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-05-s51101-r0"
+  },
+  {
+    "case": "cal-physiological-05-s51101",
+    "repeat": 1,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-05-s51101-r1"
+  },
+  {
+    "case": "cal-physiological-05-s51102",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-05-s51102-r0"
+  },
+  {
+    "case": "cal-physiological-05-s51103",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-05-s51103-r0"
+  },
+  {
+    "case": "cal-physiological-05-s51104",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-05-s51104-r0"
+  },
+  {
+    "case": "cal-physiological-05-s51105",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-physiological-05-s51105-r0"
+  },
+  {
+    "case": "cal-matched_energy-00-s51101",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-00-s51101-r0"
+  },
+  {
+    "case": "cal-matched_energy-00-s51101",
+    "repeat": 1,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-00-s51101-r1"
+  },
+  {
+    "case": "cal-matched_energy-00-s51102",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-00-s51102-r0"
+  },
+  {
+    "case": "cal-matched_energy-00-s51103",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-00-s51103-r0"
+  },
+  {
+    "case": "cal-matched_energy-00-s51104",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-00-s51104-r0"
+  },
+  {
+    "case": "cal-matched_energy-00-s51105",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-00-s51105-r0"
+  },
+  {
+    "case": "cal-matched_energy-01-s51101",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-01-s51101-r0"
+  },
+  {
+    "case": "cal-matched_energy-01-s51101",
+    "repeat": 1,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-01-s51101-r1"
+  },
+  {
+    "case": "cal-matched_energy-01-s51102",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-01-s51102-r0"
+  },
+  {
+    "case": "cal-matched_energy-01-s51103",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-01-s51103-r0"
+  },
+  {
+    "case": "cal-matched_energy-01-s51104",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-01-s51104-r0"
+  },
+  {
+    "case": "cal-matched_energy-01-s51105",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-01-s51105-r0"
+  },
+  {
+    "case": "cal-matched_energy-02-s51101",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-02-s51101-r0"
+  },
+  {
+    "case": "cal-matched_energy-02-s51101",
+    "repeat": 1,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-02-s51101-r1"
+  },
+  {
+    "case": "cal-matched_energy-02-s51102",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-02-s51102-r0"
+  },
+  {
+    "case": "cal-matched_energy-02-s51103",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-02-s51103-r0"
+  },
+  {
+    "case": "cal-matched_energy-02-s51104",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-02-s51104-r0"
+  },
+  {
+    "case": "cal-matched_energy-02-s51105",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-02-s51105-r0"
+  },
+  {
+    "case": "cal-matched_energy-03-s51101",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-03-s51101-r0"
+  },
+  {
+    "case": "cal-matched_energy-03-s51101",
+    "repeat": 1,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-03-s51101-r1"
+  },
+  {
+    "case": "cal-matched_energy-03-s51102",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-03-s51102-r0"
+  },
+  {
+    "case": "cal-matched_energy-03-s51103",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-03-s51103-r0"
+  },
+  {
+    "case": "cal-matched_energy-03-s51104",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-03-s51104-r0"
+  },
+  {
+    "case": "cal-matched_energy-03-s51105",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-03-s51105-r0"
+  },
+  {
+    "case": "cal-matched_energy-04-s51101",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-04-s51101-r0"
+  },
+  {
+    "case": "cal-matched_energy-04-s51101",
+    "repeat": 1,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-04-s51101-r1"
+  },
+  {
+    "case": "cal-matched_energy-04-s51102",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-04-s51102-r0"
+  },
+  {
+    "case": "cal-matched_energy-04-s51103",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-04-s51103-r0"
+  },
+  {
+    "case": "cal-matched_energy-04-s51104",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-04-s51104-r0"
+  },
+  {
+    "case": "cal-matched_energy-04-s51105",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-04-s51105-r0"
+  },
+  {
+    "case": "cal-matched_energy-05-s51101",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-05-s51101-r0"
+  },
+  {
+    "case": "cal-matched_energy-05-s51101",
+    "repeat": 1,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-05-s51101-r1"
+  },
+  {
+    "case": "cal-matched_energy-05-s51102",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-05-s51102-r0"
+  },
+  {
+    "case": "cal-matched_energy-05-s51103",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-05-s51103-r0"
+  },
+  {
+    "case": "cal-matched_energy-05-s51104",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-05-s51104-r0"
+  },
+  {
+    "case": "cal-matched_energy-05-s51105",
+    "repeat": 0,
+    "kind": "calibration",
+    "source": "experiments/phase4ag-author-apl-r2/gpu/cal-matched_energy-05-s51105-r0"
+  }
+]
@@ -0,0 +1,218 @@
+{
+  "neuron_idx": {
+    "dtype": "int32",
+    "nulls": 0
+  },
+  "body_id": {
+    "dtype": "uint64",
+    "nulls": 0
+  },
+  "neuron_type": {
+    "dtype": "object",
+    "nulls": 2194
+  },
+  "neuron_class": {
+    "dtype": "object",
+    "nulls": 140187
+  },
+  "side": {
+    "dtype": "object",
+    "nulls": 18003
+  },
+  "neurotransmitter": {
+    "dtype": "object",
+    "nulls": 178
+  },
+  "has_swc": {
+    "dtype": "bool",
+    "nulls": 0
+  },
+  "swc_path": {
+    "dtype": "object",
+    "nulls": 0
+  },
+  "annotation_assignedOlHex1": {
+    "dtype": "float64",
+    "nulls": 142980
+  },
+  "annotation_assignedOlHex2": {
+    "dtype": "float64",
+    "nulls": 142980
+  },
+  "annotation_bodyId": {
+    "dtype": "int64",
+    "nulls": 0
+  },
+  "annotation_flywireType": {
+    "dtype": "object",
+    "nulls": 23546
+  },
+  "annotation_group": {
+    "dtype": "float64",
+    "nulls": 19188
+  },
+  "annotation_instance": {
+    "dtype": "object",
+    "nulls": 6639
+  },
+  "annotation_somaSide": {
+    "dtype": "object",
+    "nulls": 18003
+  },
+  "annotation_statusLabel": {
+    "dtype": "category",
+    "nulls": 11
+  },
+  "annotation_superclass": {
+    "dtype": "object",
+    "nulls": 0
+  },
+  "annotation_type": {
+    "dtype": "object",
+    "nulls": 2194
+  },
+  "annotation_vfbId": {
+    "dtype": "object",
+    "nulls": 16
+  },
+  "annotation_hemibrainType": {
+    "dtype": "object",
+    "nulls": 133781
+  },
+  "annotation_itoleeHl": {
+    "dtype": "object",
+    "nulls": 128955
+  },
+  "annotation_supertype": {
+    "dtype": "object",
+    "nulls": 132604
+  },
+  "annotation_birthtime": {
+    "dtype": "object",
+    "nulls": 158797
+  },
+  "annotation_mancBodyid": {
+    "dtype": "float64",
+    "nulls": 148128
+  },
+  "annotation_mancGroup": {
+    "dtype": "float64",
+    "nulls": 152146
+  },
+  "annotation_mancType": {
+    "dtype": "object",
+    "nulls": 143956
+  },
+  "annotation_subclass": {
+    "dtype": "object",
+    "nulls": 144771
+  },
+  "annotation_synonyms": {
+    "dtype": "object",
+    "nulls": 162746
+  },
+  "annotation_class": {
+    "dtype": "object",
+    "nulls": 140187
+  },
+  "annotation_rootSide": {
+    "dtype": "object",
+    "nulls": 148794
+  },
+  "annotation_somaNeuromere": {
+    "dtype": "object",
+    "nulls": 144901
+  },
+  "annotation_trumanHl": {
+    "dtype": "object",
+    "nulls": 146967
+  },
+  "annotation_dimorphism": {
+    "dtype": "object",
+    "nulls": 164332
+  },
+  "annotation_matchingNotes": {
+    "dtype": "object",
+    "nulls": 163280
+  },
+  "annotation_entryNerve": {
+    "dtype": "object",
+    "nulls": 154894
+  },
+  "annotation_mancSerial": {
+    "dtype": "float64",
+    "nulls": 161278
+  },
+  "annotation_mcnsSerial": {
+    "dtype": "float64",
+    "nulls": 162755
+  },
+  "annotation_serialMotif": {
+    "dtype": "object",
+    "nulls": 165798
+  },
+  "annotation_fruDsx": {
+    "dtype": "object",
+    "nulls": 161688
+  },
+  "annotation_exitNerve": {
+    "dtype": "object",
+    "nulls": 165695
+  },
+  "annotation_receptorType": {
+    "dtype": "object",
+    "nulls": 165948
+  },
+  "annotation_somaLocation": {
+    "dtype": "object",
+    "nulls": 27038
+  },
+  "annotation_tosomaLocation": {
+    "dtype": "object",
+    "nulls": 165705
+  },
+  "annotation_status": {
+    "dtype": "object",
+    "nulls": 2002
+  },
+  "nt_body": {
+    "dtype": "float64",
+    "nulls": 178
+  },
+  "nt_cell_type": {
+    "dtype": "object",
+    "nulls": 2254
+  },
+  "nt_total_nt_predictions": {
+    "dtype": "float64",
+    "nulls": 178
+  },
+  "nt_predicted_nt_confidence": {
+    "dtype": "float64",
+    "nulls": 1035
+  },
+  "nt_predicted_nt": {
+    "dtype": "object",
+    "nulls": 178
+  },
+  "nt_ground_truth": {
+    "dtype": "object",
+    "nulls": 81216
+  },
+  "nt_celltype_total_nt_predictions": {
+    "dtype": "float64",
+    "nulls": 178
+  },
+  "nt_celltype_predicted_nt": {
+    "dtype": "object",
+    "nulls": 178
+  },
+  "nt_celltype_predicted_nt_confidence": {
+    "dtype": "float64",
+    "nulls": 2255
+  },
+  "nt_consensus_nt": {
+    "dtype": "object",
+    "nulls": 178
+  }
+}
@@ -0,0 +1,202 @@
+{
+  "neurons": 166700,
+  "groups": {
+    "KC": 4064,
+    "APL": 2,
+    "ALPN": 686,
+    "MBON": 97,
+    "anatomical_DAN": 340,
+    "dopamine_annotation_only": 52,
+    "other": 160143,
+    "unclassified": 1316
+  },
+  "group_order": [
+    "KC",
+    "APL",
+    "ALPN",
+    "MBON",
+    "anatomical_DAN",
+    "dopamine_annotation_only",
+    "other",
+    "unclassified"
+  ],
+  "all_neurons_assigned_once": true,
+  "labels_index": "global neuron_idx, identical to canonical row index",
+  "identity_conflicts_present": false,
+  "pass_all": true,
+  "pass_all_scope": "schema, complete disjoint accounting and no conflicting exact identities; not biological validation",
+  "flags": {
+    "annotation_DPM": 2,
+    "metadata_dopamine": 392,
+    "annotation_DAN": 340,
+    "identity_conflict": 0,
+    "multiple_exact_group_hits": 0,
+    "no_anatomical_annotation": 1316,
+    "DAN_name_prefix_without_DAN_class": 0,
+    "metadata_dopamine_not_annotation_DAN": 54,
+    "annotation_DAN_not_metadata_dopamine": 2,
+    "has_raw_ground_truth": 85484
+  },
+  "flag_counts_by_group": {
+    "annotation_DPM": {
+      "KC": 0,
+      "APL": 0,
+      "ALPN": 0,
+      "MBON": 0,
+      "anatomical_DAN": 0,
+      "dopamine_annotation_only": 0,
+      "other": 2,
+      "unclassified": 0
+    },
+    "metadata_dopamine": {
+      "KC": 0,
+      "APL": 0,
+      "ALPN": 0,
+      "MBON": 0,
+      "anatomical_DAN": 338,
+      "dopamine_annotation_only": 52,
+      "other": 2,
+      "unclassified": 0
+    },
+    "annotation_DAN": {
+      "KC": 0,
+      "APL": 0,
+      "ALPN": 0,
+      "MBON": 0,
+      "anatomical_DAN": 340,
+      "dopamine_annotation_only": 0,
+      "other": 0,
+      "unclassified": 0
+    },
+    "identity_conflict": {
+      "KC": 0,
+      "APL": 0,
+      "ALPN": 0,
+      "MBON": 0,
+      "anatomical_DAN": 0,
+      "dopamine_annotation_only": 0,
+      "other": 0,
+      "unclassified": 0
+    },
+    "multiple_exact_group_hits": {
+      "KC": 0,
+      "APL": 0,
+      "ALPN": 0,
+      "MBON": 0,
+      "anatomical_DAN": 0,
+      "dopamine_annotation_only": 0,
+      "other": 0,
+      "unclassified": 0
+    },
+    "no_anatomical_annotation": {
+      "KC": 0,
+      "APL": 0,
+      "ALPN": 0,
+      "MBON": 0,
+      "anatomical_DAN": 0,
+      "dopamine_annotation_only": 0,
+      "other": 0,
+      "unclassified": 1316
+    },
+    "DAN_name_prefix_without_DAN_class": {
+      "KC": 0,
+      "APL": 0,
+      "ALPN": 0,
+      "MBON": 0,
+      "anatomical_DAN": 0,
+      "dopamine_annotation_only": 0,
+      "other": 0,
+      "unclassified": 0
+    },
+    "metadata_dopamine_not_annotation_DAN": {
+      "KC": 0,
+      "APL": 0,
+      "ALPN": 0,
+      "MBON": 0,
+      "anatomical_DAN": 0,
+      "dopamine_annotation_only": 52,
+      "other": 2,
+      "unclassified": 0
+    },
+    "annotation_DAN_not_metadata_dopamine": {
+      "KC": 0,
+      "APL": 0,
+      "ALPN": 0,
+      "MBON": 0,
+      "anatomical_DAN": 2,
+      "dopamine_annotation_only": 0,
+      "other": 0,
+      "unclassified": 0
+    },
+    "has_raw_ground_truth": {
+      "KC": 0,
+      "APL": 2,
+      "ALPN": 573,
+      "MBON": 65,
+      "anatomical_DAN": 338,
+      "dopamine_annotation_only": 42,
+      "other": 84464,
+      "unclassified": 0
+    }
+  },
+  "DPM_neuron_idx": [
+    1618,
+    2403
+  ],
+  "identity_conflict_neuron_idx": [],
+  "uncertain_DAN_prefix_neuron_idx": [],
+  "definitions": {
+    "KC": "annotation_class exactly Kenyon_Cell",
+    "APL": "annotation_type exactly APL",
+    "ALPN": "annotation_class exactly ALPN; annotation_class olfactory is NOT included",
+    "MBON": "annotation_class exactly MBON",
+    "anatomical_DAN": "annotation_class exactly DAN, no exact identity conflict; not inferred from NT or PAM/PPL1 prefix",
+    "dopamine_annotation_only": "normalized neurotransmitter=dopamine, no named exact group, no DPM; transmitter-evidence diagnostic, NOT DAN",
+    "other": "remaining annotated neurons, explicitly including non-conflicting annotation_type DPM",
+    "unclassified": "conflicting exact identity, no anatomical class/type evidence, or only uncertain DAN-name hint without class/NT evidence"
+  },
+  "uncertainty_policy": {
+    "explicit_unknown_tokens_casefolded": [
+      "",
+      "unknown",
+      "unclear",
+      "unclassified"
+    ],
+    "PAM_PPL1_DAN_prefix_never_assigns_identity": true,
+    "transmitter_role_and_anatomical_identity_are_separate": true,
+    "DPM_retained_as_other_with_explicit_flag": true,
+    "missing_ground_truth_is_not_filled_or_guessed": true,
+    "other_does_not_mean_known_function": true
+  },
+  "provenance": {
+    "metadata_path_contract": "context.META; caller must verify its preregistered SHA-256 before loading",
+    "metadata_expected_sha256_from_AG_r2": "922af16846a065c3dbfca7c11146b83ca217fcbd7392edc745f444a04eae8c63",
+    "frozen_rules_path": "/data/digital-drosophila/models/male-cns-lif/transmitter-audit-v1/transmitter_roles_v1.py",
+    "frozen_rules_sha256": "76ba0cae6c5db417ec030456797f7935216c6877bd339d5e435133a0061e3930",
+    "frozen_sidecar_path": "/data/digital-drosophila/experiments/phase4x-transmitter-provenance/roles/neuron-evidence-axes.parquet",
+    "frozen_sidecar_sha256": "8b51d12d84d66cdca66aeb7d052a24e520b9c28f462bd6bf87f37dda85c33284",
+    "frozen_MB_DAN_mapping_path": "/data/digital-drosophila/experiments/phase4h-dopamine-plasticity/mappings/dan-to-mbon-confirmed.parquet",
+    "frozen_MB_DAN_mapping_used_to_assign_identity": false,
+    "file_hash_verified_by_this_pure_function": false,
+    "differences_from_4X_reporting": "ALPN separated from broader olfactory class; DPM grouped other with flag; absent/conflicting identity explicitly unclassified"
+  },
+  "source_graph_changed": false,
+  "simulation_executed": false,
+  "heldout_dynamic_access": false,
+  "reward_or_valence_inferred": false,
+  "refined_exact_class_counts": {
+    "KC": 4064,
+    "APL": 2,
+    "ALPN": 686,
+    "MBON": 97,
+    "anatomical_DAN": 340,
+    "dopamine_annotation_only": 52,
+    "ALLN": 420,
+    "ALIN": 24,
+    "ALON": 14,
+    "olfactory_sensory": 2639,
+    "other": 157046,
+    "unclassified": 1316
+  },
+  "refinement": "AH anatomical classifier, then exact ALLN/ALIN/ALON/olfactory classes split only from other; no name-prefix guessing"
+}
@@ -0,0 +1,22 @@
+[
+  {
+    "path": "protocol/inventory.json",
+    "sha256": "7b5c136fac6b644ca704fc39d53582ccd7892100e77fa446efdc8440d32ead04"
+  },
+  {
+    "path": "protocol/metadata-schema.json",
+    "sha256": "14db34a21e6cb4b43b9a8bc2873455d70001c231383fc9930ff5bea1b7b8a5d0"
+  },
+  {
+    "path": "protocol/neuron-source-groups.parquet",
+    "sha256": "8aac9e262ba4666ba2a4fd69ee3c51c3e94c694971cdba186b0c7ce242a7b974"
+  },
+  {
+    "path": "protocol/population-audit.json",
+    "sha256": "6cea0246657b781d64e3fa46cb7602d9271aa8821da45a644514c64757f3bc8b"
+  },
+  {
+    "path": "protocol/preregistered.json",
+    "sha256": "6da758d88c775a97453d0ddac72eea39aea1a01a824e71da7e85ae34b0f9e25a"
+  }
+]
@@ -0,0 +1,106 @@
+{
+  "timestamp_utc": "2026-09-30T02:23:43.612283+00:00",
+  "sources": {
+    "README.md": "58f2f78b94aa783cc30b4b5e79ab003cc83f8a09b66c195d963bca6ee691e44c",
+    "apl_sources.py": "61f4c35b464315d19bbffce534cfc037a0111725da0eb07ee53a41db81767fcb",
+    "context.py": "a166da3d964b49ca28a013d3a3cf33df1607c76d4a6a53a8ca8e2d955aa92cb0",
+    "finalize.py": "40e0f8a9e075db42ac63163de8362d808b9110f371e49f6d4088267eecf2eb4c",
+    "pn_observer.py": "0663c1f723f614ebcdb666b46eaa49288aec26125d6aceb18cd237330a705968",
+    "prepare.py": "9fbef01968c54637c9063bb1e2d7f45fdc97b886b3c25815a6146fc5f219164c",
+    "publication.py": "7a79c499098b74163e7bb16adabcbc54e7069dafa204d0b99c7f4c03d79f8016",
+    "run_audit.py": "a5a7861e8ced4739cd1a1f4314b8af7cff71168499f1ae6ed94ac71b481bcdd8",
+    "structure_metrics.py": "669e91a862efea5f243a054c883bc1a183e96b0bcf02fac5f6972c4a8272a4cb",
+    "test_apl_sources.py": "a7ac0f38877e0244a4bcc574264c72617ec487544a19dbc705e0c1e26c4be78d",
+    "test_harness.py": "c2e66adb18d25264d21bfce16462ef698a3ba09d178908bef1068881d46ac1e7",
+    "test_pn_observer.py": "fff3cb9da17d9d638e53a609a265d6531ed82824d10e06fcb3863edfeab7a267",
+    "test_publication.py": "a3516aefa6a753f8fca6c5a4c2109ae4d65ce0ab0278e4795d537148f04495ff",
+    "test_structure_metrics.py": "de1298a4a92facad97339e9a4cdb60ea2b7c30adc1a6f05274bd3be034239717",
+    "test_validate_events.py": "d687ceb171c7dad77dfe2eb53524091a7ee02ddc04d9bbafb3b4a59b0d1eb66c",
+    "validate_events.py": "32a33988c5c9619b2ff3553c2d508924a404ade17b526541a2ff113a61df68e4"
+  },
+  "inputs": [
+    {
+      "path": "experiments/phase4ah-kc-drive-audit/manifest.json",
+      "sha256": "fb30ca09068d5d8dc1dc9972e00f674c5dc3aa49c7117d630607b5d9067927db"
+    },
+    {
+      "path": "experiments/phase4ah-kc-drive-audit/checksums.sha256",
+      "sha256": "567a3eb5758763c86146235835984a352dd860bf69489d1cf2b048d93fba05c9"
+    },
+    {
+      "path": "models/male-cns-lif/kc-drive-audit-v1/manifest.json",
+      "sha256": "fa89cb0a6e2dc77462057b672ffbcfabbe74b893d8f70e4b41d8b5202de15530"
+    },
+    {
+      "path": "models/male-cns-lif/kc-drive-audit-v1/checksums.sha256",
+      "sha256": "ed082e56978ac841c1fd92810eb611b63d6c2238d0406c92c281bb5023bc9f70"
+    },
+    {
+      "path": "models/male-cns-lif/kc-drive-audit-v1/replay_core.py",
+      "sha256": "aa3187cb23712c09ab603e27e60424294db92de8086d60a95cf7a629d0521fdc"
+    },
+    {
+      "path": "models/male-cns-lif/kc-drive-audit-v1/populations.py",
+      "sha256": "8504b38219bac952b07a67e7dc37a520f0a68238cb0b0dd56f4b4b7948c5233b"
+    },
+    {
+      "path": "experiments/phase4ag-author-apl-r2/manifest.json",
+      "sha256": "21593297c40bee58516d4d7fd16e9d8d20ffdea5f8e0652fa5dd4e903b4d96ee"
+    },
+    {
+      "path": "experiments/phase4ag-author-apl-r2/checksums.sha256",
+      "sha256": "dcc61d2251cb1b425196f180e3ec3816d1fa5eb91aefda7940f9d821aae82d19"
+    },
+    {
+      "path": "models/male-cns-lif/author-apl-lab-v2/manifest.json",
+      "sha256": "208c00961b9d895d14ac050bc23fbc18db49d0df1fcf5c20d4c3eaa8e15ff7ff"
+    },
+    {
+      "path": "models/male-cns-lif/author-apl-lab-v2/checksums.sha256",
+      "sha256": "effb9ef2cbd08ec973a01c2b9b2a9047fc0a42732601a734e733d56b93029ff1"
+    },
+    {
+      "path": "datasets/male-cns-v1.0/processed/neuron-only/neuron-index/unified-metadata.parquet",
+      "sha256": "922af16846a065c3dbfca7c11146b83ca217fcbd7392edc745f444a04eae8c63"
+    },
+    {
+      "path": "experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+      "sha256": "bde79d95ef0097b827d5faf4d5658eafc009d8e9fcef1fddd645c953823e3f64"
+    },
+    {
+      "path": "datasets/male-cns-v1.0/processed/neuron-only/gpu/csr-weights.int64.npy",
+      "sha256": "c7ae101451dd19c47fd976bcfacbc52d67193a68ffa04c5b4d2e911cfd52d99b"
+    }
+  ],
+  "parent_commit": "9437bbff79de448cff0bb438bc53a1fbab482938",
+  "scope": "Post-outcome conditional PN/APL source audit; no new whole-brain simulation or learning",
+  "previous_KC_outcome_known": true,
+  "before_PN_contribution_accounting": true,
+  "new_GPU_use": false,
+  "max_threads": 4,
+  "output_budget_bytes": 2147483648,
+  "per_trial_first_arrival_row_limit": 1000000,
+  "truncation_allowed": false,
+  "exact_gate": "All PN events/counts/final v,g,ref; fixture pre/post histories; 12 deterministic accounting repeats",
+  "APL_gate": "Source float64 mathematical accounting within prior standard-float32 analytic roundoff bounds; not CUDA bitwise replay",
+  "hypotheses": {
+    "temporal_precedence": "For every trial and every KC first spike, non-design PN spike must be strictly earlier; equals/after/absent retained",
+    "direct_PN_KC_arrival": "PN source tick+18 strictly less than KC first spike; same tick arrival is after threshold",
+    "APL_source_precedence": "Group h write at tick s affects only KC threshold ticks greater than s",
+    "APL_share": "Cumulative group shares are descriptive float64; no accumulated source-share error bound or robust-majority claim",
+    "odor_structure": "Fixed 686-dimensional counts; secondary fixed outside-six-odor-design-union subset; no activity-fraction or learning gate"
+  },
+  "attribution_limits": [
+    "Accepted edge antecedents are not proof of single-neuron necessity or intervention causality",
+    "Non-design means not in static design targets; does not mean noise or biologically incorrect",
+    "Source-V lanes are non-feedback accounting with initial/constant/request/reset/roundoff lanes",
+    "APL input matrix is legacy nonnegative raw-contact-normalized engineering mapping, not signed LIF current",
+    "No CAL per-tick target state was independently saved; final states and events only",
+    "Fixtures generated h for 4064 KC but applied only to fixture KC"
+  ],
+  "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]",
+  "numpy": "2.2.6",
+  "pandas": "2.3.3",
+  "machine": "x86_64",
+  "longdouble_mantissa_bits": 63
+}
@@ -0,0 +1,153 @@
+{
+  "original": {
+    "pass": true,
+    "checked": 230239,
+    "mismatches": [],
+    "reference_sha256": "6f186112e6102f2f7969de7442fa7ee4432200a3678586cfc4e10c490b31bca4",
+    "exclusions": [
+      ".cache",
+      ".git",
+      ".mypy_cache",
+      ".pytest_cache",
+      ".venv",
+      "__pycache__",
+      "node_modules",
+      "venv"
+    ],
+    "new_stage_additions_allowed": true,
+    "meaning": "All original listed bytes checked; only newly named stage outputs are additions."
+  },
+  "models/male-cns-lif/apl-pn-scope-audit-v1": {
+    "pass": true,
+    "checked": 12,
+    "mismatches": [],
+    "manifest_sha256": "9120685eb02dc2bd3b38d42b2ade1f38f6bbc2a1ec269fd4d555cead2d628277",
+    "checksums_sha256": "55dc418f2d62be04601af33cbd8789578447e6a2289d3a581dc713cbb7466a25"
+  },
+  "experiments/phase4aa-apl-pn-scope": {
+    "pass": true,
+    "checked": 68,
+    "mismatches": [],
+    "manifest_sha256": "6d75567af2a6c0993d4fc08e272814910c19fa9602811cfacd1ebc4ba76bc737",
+    "checksums_sha256": "a69b2511689207b0d9ddbe2fabce3be71908f457bb898e3b685a213a796a272a"
+  },
+  "models/male-cns-lif/terminal-scope-diagnostic-v1": {
+    "pass": true,
+    "checked": 11,
+    "mismatches": [],
+    "manifest_sha256": "5cea0035a95345825b73385c6e3056244c2a614d10a6fa6742487a331d8f0f3e",
+    "checksums_sha256": "92a03195cb41863027fd0397ad3811248354a5d3f2e91ffa2c297eba62dc2821"
+  },
+  "experiments/phase4ab-terminal-scope": {
+    "pass": true,
+    "checked": 199,
+    "mismatches": [],
+    "manifest_sha256": "cb3723f9dae29d4889489ae39f40293c927f4f9e532551e2c4d5214bf0a70140",
+    "checksums_sha256": "d83926a3055d9f9ca471ceba328076d7ceba883f267468750914080733e95e31"
+  },
+  "models/male-cns-lif/lif-semantics-audit-v1": {
+    "pass": true,
+    "checked": 7,
+    "mismatches": [],
+    "manifest_sha256": "53e53d51bba86ec11a02e920f2c2653db4c138dd9562e8416dd001780635070c",
+    "checksums_sha256": "15b7b7828492387beed2c885ad9d22af682cff1dc38198c0770ab7175759c69d"
+  },
+  "experiments/phase4ac-lif-semantics": {
+    "pass": true,
+    "checked": 57,
+    "mismatches": [],
+    "manifest_sha256": "4e7d1606e107fe72f5dad935952705260577edaba6f811d65b4105ce07abd72c",
+    "checksums_sha256": "81bb3a86454147f1562bc3592438b6a6d0091dbe1d2a777e802882ecf1d0db35"
+  },
+  "registry/feedback-context-review-20260930": {
+    "pass": true,
+    "checked": 8,
+    "mismatches": [],
+    "manifest_sha256": "8fda8506cae9b5b258fe371c8938a15e613114f4234c969fdf742d1f5133c64b",
+    "checksums_sha256": "9390c04cf4d0bcd2ed89bb4efd1db01cb2faf7dc4f23e8cb411b2ed782ba083d"
+  },
+  "models/male-cns-lif/author-semantics-lab-v1": {
+    "pass": true,
+    "checked": 11,
+    "mismatches": [],
+    "manifest_sha256": "07a22bade4892adca3a4585656aa3ecce5219790b0dc8a851a12bfd7248d3769",
+    "checksums_sha256": "a632c04e62d8072caacfa680e0da7ad785a1d0db604cf5900853fd0b01c70ee7"
+  },
+  "experiments/phase4ad-author-semantics": {
+    "pass": true,
+    "checked": 565,
+    "mismatches": [],
+    "manifest_sha256": "c939d3977a1883e86108c1e3edd25619118cec61e5c7712ae4dfa2893a73c0ca",
+    "checksums_sha256": "89ca0f11877dadb901bd2bd5d469d7bd145de980fc6b203b79daeec640a1b72c"
+  },
+  "models/male-cns-lif/author-runtime-lab-v1": {
+    "pass": true,
+    "checked": 11,
+    "mismatches": [],
+    "manifest_sha256": "7e8b0ac4adcd48eceabca7c9cc4f2c42a8746ebc673aee4490bae5a4746bbe12",
+    "checksums_sha256": "bf8eaad5963e6a6cf6bada6024ba37a36a0acb064bfc0beacd9c69dfd074b5c8"
+  },
+  "experiments/phase4ae-author-runtime": {
+    "pass": true,
+    "checked": 916,
+    "mismatches": [],
+    "manifest_sha256": "a86caca4ecbd96c2b7cf24371b28f80f37170fa8769cdd9a31c822434be1eef5",
+    "checksums_sha256": "7bd84b8365953964b24684830e1fd97fca04bef8f8c051dcad3ff95633a1ae82"
+  },
+  "models/male-cns-lif/author-fullgraph-lab-v1": {
+    "pass": true,
+    "checked": 11,
+    "mismatches": [],
+    "manifest_sha256": "ead78ed89d0daebee5281ef285bbfe9d79c69b5034830609414f7b130d3c5827",
+    "checksums_sha256": "6fd184043777b190006ce344861477b91df908eac5351f74efeb3fd1151011a0"
+  },
+  "experiments/phase4af-author-fullgraph": {
+    "pass": true,
+    "checked": 129,
+    "mismatches": [],
+    "manifest_sha256": "0646b5fc232ee44912f1c3a60d600355f5a6d97dff7cf59fccea612d822fb899",
+    "checksums_sha256": "f4d502c32ce80c70ff5271a686f09d9f72e1dc277863df1d0135ddeb09475736"
+  },
+  "models/male-cns-lif/author-apl-lab-v1": {
+    "pass": true,
+    "checked": 16,
+    "mismatches": [],
+    "manifest_sha256": "6aa01a937f1f3c6504ee92e847cf7b3a884e88aa4ef37a68b0b7d4e7deed4bf2",
+    "checksums_sha256": "8768d1cf1a4ae4de595aa5623b27c77b84b620767d202c74db5a69e7617f42b3"
+  },
+  "experiments/phase4ag-author-apl": {
+    "pass": true,
+    "checked": 333,
+    "mismatches": [],
+    "manifest_sha256": "4920e331efb7d0db6366ef1ef727c180a179c298834e45a9c06eb8e5bfc489d6",
+    "checksums_sha256": "06e0cc917ee3bf194384262d34c0762641e0403468ec556cd09866572fb87cde"
+  },
+  "models/male-cns-lif/author-apl-lab-v2": {
+    "pass": true,
+    "checked": 17,
+    "mismatches": [],
+    "manifest_sha256": "208c00961b9d895d14ac050bc23fbc18db49d0df1fcf5c20d4c3eaa8e15ff7ff",
+    "checksums_sha256": "effb9ef2cbd08ec973a01c2b9b2a9047fc0a42732601a734e733d56b93029ff1"
+  },
+  "experiments/phase4ag-author-apl-r2": {
+    "pass": true,
+    "checked": 1718,
+    "mismatches": [],
+    "manifest_sha256": "21593297c40bee58516d4d7fd16e9d8d20ffdea5f8e0652fa5dd4e903b4d96ee",
+    "checksums_sha256": "dcc61d2251cb1b425196f180e3ec3816d1fa5eb91aefda7940f9d821aae82d19"
+  },
+  "models/male-cns-lif/kc-drive-audit-v1": {
+    "pass": true,
+    "checked": 11,
+    "mismatches": [],
+    "manifest_sha256": "fa89cb0a6e2dc77462057b672ffbcfabbe74b893d8f70e4b41d8b5202de15530",
+    "checksums_sha256": "ed082e56978ac841c1fd92810eb611b63d6c2238d0406c92c281bb5023bc9f70"
+  },
+  "experiments/phase4ah-kc-drive-audit": {
+    "pass": true,
+    "checked": 415,
+    "mismatches": [],
+    "manifest_sha256": "fb30ca09068d5d8dc1dc9972e00f674c5dc3aa49c7117d630607b5d9067927db",
+    "checksums_sha256": "567a3eb5758763c86146235835984a352dd860bf69489d1cf2b048d93fba05c9"
+  }
+}
@@ -0,0 +1,153 @@
+{
+  "original": {
+    "pass": true,
+    "checked": 230239,
+    "mismatches": [],
+    "reference_sha256": "6f186112e6102f2f7969de7442fa7ee4432200a3678586cfc4e10c490b31bca4",
+    "exclusions": [
+      ".cache",
+      ".git",
+      ".mypy_cache",
+      ".pytest_cache",
+      ".venv",
+      "__pycache__",
+      "node_modules",
+      "venv"
+    ],
+    "new_stage_additions_allowed": true,
+    "meaning": "All original listed bytes checked; only newly named stage outputs are additions."
+  },
+  "models/male-cns-lif/apl-pn-scope-audit-v1": {
+    "pass": true,
+    "checked": 12,
+    "mismatches": [],
+    "manifest_sha256": "9120685eb02dc2bd3b38d42b2ade1f38f6bbc2a1ec269fd4d555cead2d628277",
+    "checksums_sha256": "55dc418f2d62be04601af33cbd8789578447e6a2289d3a581dc713cbb7466a25"
+  },
+  "experiments/phase4aa-apl-pn-scope": {
+    "pass": true,
+    "checked": 68,
+    "mismatches": [],
+    "manifest_sha256": "6d75567af2a6c0993d4fc08e272814910c19fa9602811cfacd1ebc4ba76bc737",
+    "checksums_sha256": "a69b2511689207b0d9ddbe2fabce3be71908f457bb898e3b685a213a796a272a"
+  },
+  "models/male-cns-lif/terminal-scope-diagnostic-v1": {
+    "pass": true,
+    "checked": 11,
+    "mismatches": [],
+    "manifest_sha256": "5cea0035a95345825b73385c6e3056244c2a614d10a6fa6742487a331d8f0f3e",
+    "checksums_sha256": "92a03195cb41863027fd0397ad3811248354a5d3f2e91ffa2c297eba62dc2821"
+  },
+  "experiments/phase4ab-terminal-scope": {
+    "pass": true,
+    "checked": 199,
+    "mismatches": [],
+    "manifest_sha256": "cb3723f9dae29d4889489ae39f40293c927f4f9e532551e2c4d5214bf0a70140",
+    "checksums_sha256": "d83926a3055d9f9ca471ceba328076d7ceba883f267468750914080733e95e31"
+  },
+  "models/male-cns-lif/lif-semantics-audit-v1": {
+    "pass": true,
+    "checked": 7,
+    "mismatches": [],
+    "manifest_sha256": "53e53d51bba86ec11a02e920f2c2653db4c138dd9562e8416dd001780635070c",
+    "checksums_sha256": "15b7b7828492387beed2c885ad9d22af682cff1dc38198c0770ab7175759c69d"
+  },
+  "experiments/phase4ac-lif-semantics": {
+    "pass": true,
+    "checked": 57,
+    "mismatches": [],
+    "manifest_sha256": "4e7d1606e107fe72f5dad935952705260577edaba6f811d65b4105ce07abd72c",
+    "checksums_sha256": "81bb3a86454147f1562bc3592438b6a6d0091dbe1d2a777e802882ecf1d0db35"
+  },
+  "registry/feedback-context-review-20260930": {
+    "pass": true,
+    "checked": 8,
+    "mismatches": [],
+    "manifest_sha256": "8fda8506cae9b5b258fe371c8938a15e613114f4234c969fdf742d1f5133c64b",
+    "checksums_sha256": "9390c04cf4d0bcd2ed89bb4efd1db01cb2faf7dc4f23e8cb411b2ed782ba083d"
+  },
+  "models/male-cns-lif/author-semantics-lab-v1": {
+    "pass": true,
+    "checked": 11,
+    "mismatches": [],
+    "manifest_sha256": "07a22bade4892adca3a4585656aa3ecce5219790b0dc8a851a12bfd7248d3769",
+    "checksums_sha256": "a632c04e62d8072caacfa680e0da7ad785a1d0db604cf5900853fd0b01c70ee7"
+  },
+  "experiments/phase4ad-author-semantics": {
+    "pass": true,
+    "checked": 565,
+    "mismatches": [],
+    "manifest_sha256": "c939d3977a1883e86108c1e3edd25619118cec61e5c7712ae4dfa2893a73c0ca",
+    "checksums_sha256": "89ca0f11877dadb901bd2bd5d469d7bd145de980fc6b203b79daeec640a1b72c"
+  },
+  "models/male-cns-lif/author-runtime-lab-v1": {
+    "pass": true,
+    "checked": 11,
+    "mismatches": [],
+    "manifest_sha256": "7e8b0ac4adcd48eceabca7c9cc4f2c42a8746ebc673aee4490bae5a4746bbe12",
+    "checksums_sha256": "bf8eaad5963e6a6cf6bada6024ba37a36a0acb064bfc0beacd9c69dfd074b5c8"
+  },
+  "experiments/phase4ae-author-runtime": {
+    "pass": true,
+    "checked": 916,
+    "mismatches": [],
+    "manifest_sha256": "a86caca4ecbd96c2b7cf24371b28f80f37170fa8769cdd9a31c822434be1eef5",
+    "checksums_sha256": "7bd84b8365953964b24684830e1fd97fca04bef8f8c051dcad3ff95633a1ae82"
+  },
+  "models/male-cns-lif/author-fullgraph-lab-v1": {
+    "pass": true,
+    "checked": 11,
+    "mismatches": [],
+    "manifest_sha256": "ead78ed89d0daebee5281ef285bbfe9d79c69b5034830609414f7b130d3c5827",
+    "checksums_sha256": "6fd184043777b190006ce344861477b91df908eac5351f74efeb3fd1151011a0"
+  },
+  "experiments/phase4af-author-fullgraph": {
+    "pass": true,
+    "checked": 129,
+    "mismatches": [],
+    "manifest_sha256": "0646b5fc232ee44912f1c3a60d600355f5a6d97dff7cf59fccea612d822fb899",
+    "checksums_sha256": "f4d502c32ce80c70ff5271a686f09d9f72e1dc277863df1d0135ddeb09475736"
+  },
+  "models/male-cns-lif/author-apl-lab-v1": {
+    "pass": true,
+    "checked": 16,
+    "mismatches": [],
+    "manifest_sha256": "6aa01a937f1f3c6504ee92e847cf7b3a884e88aa4ef37a68b0b7d4e7deed4bf2",
+    "checksums_sha256": "8768d1cf1a4ae4de595aa5623b27c77b84b620767d202c74db5a69e7617f42b3"
+  },
+  "experiments/phase4ag-author-apl": {
+    "pass": true,
+    "checked": 333,
+    "mismatches": [],
+    "manifest_sha256": "4920e331efb7d0db6366ef1ef727c180a179c298834e45a9c06eb8e5bfc489d6",
+    "checksums_sha256": "06e0cc917ee3bf194384262d34c0762641e0403468ec556cd09866572fb87cde"
+  },
+  "models/male-cns-lif/author-apl-lab-v2": {
+    "pass": true,
+    "checked": 17,
+    "mismatches": [],
+    "manifest_sha256": "208c00961b9d895d14ac050bc23fbc18db49d0df1fcf5c20d4c3eaa8e15ff7ff",
+    "checksums_sha256": "effb9ef2cbd08ec973a01c2b9b2a9047fc0a42732601a734e733d56b93029ff1"
+  },
+  "experiments/phase4ag-author-apl-r2": {
+    "pass": true,
+    "checked": 1718,
+    "mismatches": [],
+    "manifest_sha256": "21593297c40bee58516d4d7fd16e9d8d20ffdea5f8e0652fa5dd4e903b4d96ee",
+    "checksums_sha256": "dcc61d2251cb1b425196f180e3ec3816d1fa5eb91aefda7940f9d821aae82d19"
+  },
+  "models/male-cns-lif/kc-drive-audit-v1": {
+    "pass": true,
+    "checked": 11,
+    "mismatches": [],
+    "manifest_sha256": "fa89cb0a6e2dc77462057b672ffbcfabbe74b893d8f70e4b41d8b5202de15530",
+    "checksums_sha256": "ed082e56978ac841c1fd92810eb611b63d6c2238d0406c92c281bb5023bc9f70"
+  },
+  "experiments/phase4ah-kc-drive-audit": {
+    "pass": true,
+    "checked": 415,
+    "mismatches": [],
+    "manifest_sha256": "fb30ca09068d5d8dc1dc9972e00f674c5dc3aa49c7117d630607b5d9067927db",
+    "checksums_sha256": "567a3eb5758763c86146235835984a352dd860bf69489d1cf2b048d93fba05c9"
+  }
+}
@@ -0,0 +1,18 @@
+{
+  "command": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "-m",
+    "unittest",
+    "-v",
+    "test_pn_observer",
+    "test_apl_sources",
+    "test_structure_metrics",
+    "test_harness",
+    "test_validate_events",
+    "test_publication"
+  ],
+  "exit_code": 0,
+  "pass_all": true,
+  "sha256": "c3fa21aa9b3dd8e82c1f6daee6c8bdfe3ad5750daf62c57d45634fc609a170f3"
+}
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 100,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 2,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 0,
+      "input_supported_spikes": 0,
+      "first_actual_spike_tick": null,
+      "first_nonzero_drive_tick": null,
+      "cumulative_drive_by_apl": [
+        0.0,
+        0.0
+      ],
+      "cumulative_state_by_apl": [
+        0.0,
+        0.0
+      ],
+      "h_sum_mV": 0.0,
+      "h_before_first_KC_sum_mV": 0.0,
+      "h_never_fired_KC_sum_mV": 0.0,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": null,
+      "drive_fraction": null
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 0,
+      "input_supported_spikes": 0,
+      "first_actual_spike_tick": null,
+      "first_nonzero_drive_tick": null,
+      "cumulative_drive_by_apl": [
+        0.0,
+        0.0
+      ],
+      "cumulative_state_by_apl": [
+        0.0,
+        0.0
+      ],
+      "h_sum_mV": 0.0,
+      "h_before_first_KC_sum_mV": 0.0,
+      "h_never_fired_KC_sum_mV": 0.0,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": null,
+      "drive_fraction": null
+    },
+    "KC": {
+      "actual_spikes": 0,
+      "input_supported_spikes": 0,
+      "first_actual_spike_tick": null,
+      "first_nonzero_drive_tick": null,
+      "cumulative_drive_by_apl": [
+        0.0,
+        0.0
+      ],
+      "cumulative_state_by_apl": [
+        0.0,
+        0.0
+      ],
+      "h_sum_mV": 0.0,
+      "h_before_first_KC_sum_mV": 0.0,
+      "h_never_fired_KC_sum_mV": 0.0,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": null,
+      "drive_fraction": null
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 0,
+    "non_design_ALPN": 686,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 0,
+    "non_design_ALPN": 282,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": null,
+  "ever_fired_KC": 0,
+  "never_fired_KC": 4064,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 200,
+      "max_abs_error": 0.0,
+      "max_error_bound": 5e-323,
+      "max_bound_utilization": 0.0,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 0.0
+    },
+    "state": {
+      "elements": 200,
+      "max_abs_error": 0.0,
+      "max_error_bound": 9.397e-321,
+      "max_bound_utilization": 0.0,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 0.0
+    },
+    "inhibition": {
+      "elements": 406400,
+      "max_abs_error": 0.0,
+      "max_error_bound": 5.43e-322,
+      "max_bound_utilization": 0.0,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 0.0
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "f280887885ac42602eed3797664549a47ee920c18703894296a21ca9104d2e7c",
+    "bytes": 2332
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "7b656cbab6a3d669d697e1bbe1f0f292d9605efad2de3f052c60cfed09ff4756",
+    "bytes": 7615
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "78fa84027da85d2025f1e34c3e8c8afe64d835c73ca130d2df47e8763b0423be",
+    "bytes": 4706
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "7048f979b2bdde63845476c0b1675bd501071e2a5ec121e37b7c88fb71c49c94",
+    "bytes": 62058
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "4033991453ba40920b385c1052af42e45b5618d942a8eb63a2b0b70a4a420ac0",
+    "bytes": 223175
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "1fa7444c3453560ead9aea031934ddc46fd75a3f8c73de0f8779703ab00c6798",
+    "bytes": 6011
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "b2a3ea4ccb556229cf6f3587628e1f5d89cf30daf4732737baa5a94a0ea2bc1c",
+    "bytes": 1586
+  },
+  {
+    "path": "summary.json",
+    "sha256": "21271a27c433a7da433c07720e53d02b60017ee02099a37834314202acc88978",
+    "bytes": 45159
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 120,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 3,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 1,
+      "input_supported_spikes": 1,
+      "first_actual_spike_tick": 0,
+      "first_nonzero_drive_tick": 0,
+      "cumulative_drive_by_apl": [
+        0.7249453663825989,
+        0.0
+      ],
+      "cumulative_state_by_apl": [
+        65.58100232458416,
+        0.0
+      ],
+      "h_sum_mV": 1479.57053343245,
+      "h_before_first_KC_sum_mV": 0.1920184560247642,
+      "h_never_fired_KC_sum_mV": 1478.006439897682,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.24794953895749264,
+      "drive_fraction": 0.23529412333698968
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 0,
+      "input_supported_spikes": 0,
+      "first_actual_spike_tick": null,
+      "first_nonzero_drive_tick": null,
+      "cumulative_drive_by_apl": [
+        0.0,
+        0.0
+      ],
+      "cumulative_state_by_apl": [
+        0.0,
+        0.0
+      ],
+      "h_sum_mV": 0.0,
+      "h_before_first_KC_sum_mV": 0.0,
+      "h_never_fired_KC_sum_mV": 0.0,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.0,
+      "drive_fraction": 0.0
+    },
+    "KC": {
+      "actual_spikes": 2,
+      "input_supported_spikes": 2,
+      "first_actual_spike_tick": 0,
+      "first_nonzero_drive_tick": 0,
+      "cumulative_drive_by_apl": [
+        2.3157976269721985,
+        0.040274739265441895
+      ],
+      "cumulative_state_by_apl": [
+        195.51355875989617,
+        3.226036398510055
+      ],
+      "h_sum_mV": 4487.653844775008,
+      "h_before_first_KC_sum_mV": 0.2560246027704652,
+      "h_never_fired_KC_sum_mV": 4482.989362689465,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.7520504610425073,
+      "drive_fraction": 0.7647058766630103
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 1,
+    "non_design_ALPN": 685,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 1,
+    "non_design_ALPN": 281,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 0,
+  "ever_fired_KC": 2,
+  "never_fired_KC": 4062,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 240,
+      "max_abs_error": 0.0,
+      "max_error_bound": 0.016975864649566085,
+      "max_bound_utilization": 0.0,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 0.0
+    },
+    "state": {
+      "elements": 240,
+      "max_abs_error": 9.640703977353837e-07,
+      "max_error_bound": 0.029058704062550275,
+      "max_bound_utilization": 5.2935382852483495e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.718757899668305e-07
+    },
+    "inhibition": {
+      "elements": 487680,
+      "max_abs_error": 4.85168186181717e-08,
+      "max_error_bound": 0.001413577532279786,
+      "max_bound_utilization": 6.446459317714411e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.0253352843547423e-09
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "d4b9e846fc0584305bdb660e67102987dbc877f03ae2ba29c023f76985a9e1a1",
+    "bytes": 6869
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "1f8b2383a954ed28851bdc383a8a6d30491feb5866eaa10e397b405b9127b905",
+    "bytes": 18777
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "a78c866c8f5d4c578a84d11efdf9f789106ab3be9b396a74e93f899fa27448a1",
+    "bytes": 5066
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "02bcc5bb8befb1b30e66b2c07d3293c65c7db6fb73c85f4e28c96aa18d5f7fe7",
+    "bytes": 85774
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "167537a93b0a7853e83e46da93d56b274a1ddd9cf74ef42483fcd4539b05bcbc",
+    "bytes": 229374
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "10134725dbbe001e865c050bf9d978bef6d4db71f82f41cad10633915e44d455",
+    "bytes": 10261
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "f98f6f286ae6bfb90ca89363911939dc4a26f6a0e06b613f02584a5b31cb5cd0",
+    "bytes": 1626
+  },
+  {
+    "path": "summary.json",
+    "sha256": "ab5634cf8444d0d732657c1500986042667639d2060804a72ab77c28819347f5",
+    "bytes": 45190
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 29518,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 577,
+      "input_supported_spikes": 539,
+      "first_actual_spike_tick": 1,
+      "first_nonzero_drive_tick": 1,
+      "cumulative_drive_by_apl": [
+        124.6100475937128,
+        182.2029278948903
+      ],
+      "cumulative_state_by_apl": [
+        19312.66458053334,
+        29440.519064538516
+      ],
+      "h_sum_mV": 1135485.097169629,
+      "h_before_first_KC_sum_mV": 478.92877410480514,
+      "h_never_fired_KC_sum_mV": 1125589.5064368434,
+      "h_before_first_any_KC_sum_mV": 29474.96713487513,
+      "generated_h_fraction": 0.20948061756878525,
+      "drive_fraction": 0.2076088723120932
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4692,
+      "input_supported_spikes": 2490,
+      "first_actual_spike_tick": 81,
+      "first_nonzero_drive_tick": 81,
+      "cumulative_drive_by_apl": [
+        531.3849336318672,
+        595.864794421941
+      ],
+      "cumulative_state_by_apl": [
+        81835.48371074088,
+        94310.17760589367
+      ],
+      "h_sum_mV": 4087949.408284465,
+      "h_before_first_KC_sum_mV": 1241.3663423384025,
+      "h_never_fired_KC_sum_mV": 4050841.149820725,
+      "h_before_first_any_KC_sum_mV": 53779.32674486551,
+      "generated_h_fraction": 0.7541676846063011,
+      "drive_fraction": 0.7627677560985618
+    },
+    "KC": {
+      "actual_spikes": 41,
+      "input_supported_spikes": 41,
+      "first_actual_spike_tick": 165,
+      "first_nonzero_drive_tick": 165,
+      "cumulative_drive_by_apl": [
+        28.09163188934326,
+        15.687011480331421
+      ],
+      "cumulative_state_by_apl": [
+        5479.053882973093,
+        3089.349030137921
+      ],
+      "h_sum_mV": 197043.58148289914,
+      "h_before_first_KC_sum_mV": 103.16222048180636,
+      "h_never_fired_KC_sum_mV": 195070.08691072458,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.03635169782491356,
+      "drive_fraction": 0.029623371589344895
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 48,
+    "non_design_ALPN": 638,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 44,
+    "non_design_ALPN": 238,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 165,
+  "ever_fired_KC": 38,
+  "never_fired_KC": 4026,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 1.1883676052093506e-06,
+      "max_error_bound": 0.08851700591819535,
+      "max_bound_utilization": 1.3425302775238501e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.6856938600540162e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.0001467736110498663,
+      "max_error_bound": 1.7234670898131146,
+      "max_bound_utilization": 9.011960851284681e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.576079287468788e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 5.454211202682302e-06,
+      "max_error_bound": 0.07556047939475438,
+      "max_bound_utilization": 9.842235763762577e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 4.10620688793368e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "a14e7d2cfaf2fc442fcdface1f8914b0ee6d6ac849759117d86be236df1e3c99",
+    "bytes": 13835643
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "e216536d6bbddcaaab011975271dbc3fea8149a95cce8105ce1a3fe8b03260d8",
+    "bytes": 200773
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "3308a515eef6e6f2351ece8ca97970a21ef812608f5d5c8325c4ccf42bb1b24f",
+    "bytes": 5328
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "18881c686d2aae8ad7c50aa8fa2b029f95a155297446e0114e93bfefc8f57ba8",
+    "bytes": 112169
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "11fb20837a3adf71aef1000a5f068c1c3d0ae942d7c9ae89f3198efeaafa9159",
+    "bytes": 525648
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "1e5908472d06a33f536dd6effe5b70d97ef706dc9049fc9d97a16ab16400375d",
+    "bytes": 743557
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "c949ce9bf7da4d8c19e8c713c0655344cf3e2225f4ade56780e826b4b6fd6ebf",
+    "bytes": 25335
+  },
+  {
+    "path": "summary.json",
+    "sha256": "d7c022d057848421870529103a0a2617456d7171ddfc26dbbc0b4fc116c8f825",
+    "bytes": 47840
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 29518,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 577,
+      "input_supported_spikes": 539,
+      "first_actual_spike_tick": 1,
+      "first_nonzero_drive_tick": 1,
+      "cumulative_drive_by_apl": [
+        124.6100475937128,
+        182.2029278948903
+      ],
+      "cumulative_state_by_apl": [
+        19312.66458053334,
+        29440.519064538516
+      ],
+      "h_sum_mV": 1135485.097169629,
+      "h_before_first_KC_sum_mV": 478.92877410480514,
+      "h_never_fired_KC_sum_mV": 1125589.5064368434,
+      "h_before_first_any_KC_sum_mV": 29474.96713487513,
+      "generated_h_fraction": 0.20948061756878525,
+      "drive_fraction": 0.2076088723120932
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4692,
+      "input_supported_spikes": 2490,
+      "first_actual_spike_tick": 81,
+      "first_nonzero_drive_tick": 81,
+      "cumulative_drive_by_apl": [
+        531.3849336318672,
+        595.864794421941
+      ],
+      "cumulative_state_by_apl": [
+        81835.48371074088,
+        94310.17760589367
+      ],
+      "h_sum_mV": 4087949.408284465,
+      "h_before_first_KC_sum_mV": 1241.3663423384025,
+      "h_never_fired_KC_sum_mV": 4050841.149820725,
+      "h_before_first_any_KC_sum_mV": 53779.32674486551,
+      "generated_h_fraction": 0.7541676846063011,
+      "drive_fraction": 0.7627677560985618
+    },
+    "KC": {
+      "actual_spikes": 41,
+      "input_supported_spikes": 41,
+      "first_actual_spike_tick": 165,
+      "first_nonzero_drive_tick": 165,
+      "cumulative_drive_by_apl": [
+        28.09163188934326,
+        15.687011480331421
+      ],
+      "cumulative_state_by_apl": [
+        5479.053882973093,
+        3089.349030137921
+      ],
+      "h_sum_mV": 197043.58148289914,
+      "h_before_first_KC_sum_mV": 103.16222048180636,
+      "h_never_fired_KC_sum_mV": 195070.08691072458,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.03635169782491356,
+      "drive_fraction": 0.029623371589344895
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 48,
+    "non_design_ALPN": 638,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 44,
+    "non_design_ALPN": 238,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 165,
+  "ever_fired_KC": 38,
+  "never_fired_KC": 4026,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 1.1883676052093506e-06,
+      "max_error_bound": 0.08851700591819535,
+      "max_bound_utilization": 1.3425302775238501e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.6856938600540162e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.0001467736110498663,
+      "max_error_bound": 1.7234670898131146,
+      "max_bound_utilization": 9.011960851284681e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.576079287468788e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 5.454211202682302e-06,
+      "max_error_bound": 0.07556047939475438,
+      "max_bound_utilization": 9.842235763762577e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 4.10620688793368e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "a14e7d2cfaf2fc442fcdface1f8914b0ee6d6ac849759117d86be236df1e3c99",
+    "bytes": 13835643
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "e216536d6bbddcaaab011975271dbc3fea8149a95cce8105ce1a3fe8b03260d8",
+    "bytes": 200773
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "3308a515eef6e6f2351ece8ca97970a21ef812608f5d5c8325c4ccf42bb1b24f",
+    "bytes": 5328
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "18881c686d2aae8ad7c50aa8fa2b029f95a155297446e0114e93bfefc8f57ba8",
+    "bytes": 112169
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "11fb20837a3adf71aef1000a5f068c1c3d0ae942d7c9ae89f3198efeaafa9159",
+    "bytes": 525648
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "1e5908472d06a33f536dd6effe5b70d97ef706dc9049fc9d97a16ab16400375d",
+    "bytes": 743557
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "c949ce9bf7da4d8c19e8c713c0655344cf3e2225f4ade56780e826b4b6fd6ebf",
+    "bytes": 25335
+  },
+  {
+    "path": "summary.json",
+    "sha256": "b98b20611027e2521eed3b9bd7a8bd4e73628ea2260e065b3a49fe8566bd60e0",
+    "bytes": 47839
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 29706,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 565,
+      "input_supported_spikes": 524,
+      "first_actual_spike_tick": 14,
+      "first_nonzero_drive_tick": 14,
+      "cumulative_drive_by_apl": [
+        122.91850854828954,
+        179.02122324705124
+      ],
+      "cumulative_state_by_apl": [
+        19019.720544095177,
+        28036.73579052539
+      ],
+      "h_sum_mV": 1095509.4207400742,
+      "h_before_first_KC_sum_mV": 520.9944079643926,
+      "h_never_fired_KC_sum_mV": 1085275.0144026382,
+      "h_before_first_any_KC_sum_mV": 28839.42604251171,
+      "generated_h_fraction": 0.20568573618946367,
+      "drive_fraction": 0.20607476527586466
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4680,
+      "input_supported_spikes": 2469,
+      "first_actual_spike_tick": 97,
+      "first_nonzero_drive_tick": 99,
+      "cumulative_drive_by_apl": [
+        529.2302348837256,
+        585.7961091473699
+      ],
+      "cumulative_state_by_apl": [
+        81734.87018220802,
+        91305.2057162865
+      ],
+      "h_sum_mV": 4014254.1812883234,
+      "h_before_first_KC_sum_mV": 1500.3104652279267,
+      "h_never_fired_KC_sum_mV": 3974862.0181663022,
+      "h_before_first_any_KC_sum_mV": 48992.75644043607,
+      "generated_h_fraction": 0.753690302336364,
+      "drive_fraction": 0.7610087972071228
+    },
+    "KC": {
+      "actual_spikes": 46,
+      "input_supported_spikes": 46,
+      "first_actual_spike_tick": 177,
+      "first_nonzero_drive_tick": 177,
+      "cumulative_drive_by_apl": [
+        32.441303968429565,
+        15.78769826889038
+      ],
+      "cumulative_state_by_apl": [
+        6319.065079658829,
+        3105.0647002957908
+      ],
+      "h_sum_mV": 216368.5889319207,
+      "h_before_first_KC_sum_mV": 157.4682705792522,
+      "h_never_fired_KC_sum_mV": 213944.93006193143,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.040623961474172264,
+      "drive_fraction": 0.032916437517012544
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 48,
+    "non_design_ALPN": 638,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 44,
+    "non_design_ALPN": 238,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 177,
+  "ever_fired_KC": 43,
+  "never_fired_KC": 4021,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 3.6135315895080566e-07,
+      "max_error_bound": 0.05092759305143226,
+      "max_bound_utilization": 1.2363925014863508e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.747161149978638e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.00011445548102528846,
+      "max_error_bound": 1.737777502327432,
+      "max_bound_utilization": 7.561098220012821e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.461728825245063e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 5.788075889689992e-06,
+      "max_error_bound": 0.07723133072726945,
+      "max_bound_utilization": 8.538893813784874e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.815168936034606e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "2e0ce386ca3d37d079cf00cbb6d628ba7a3fc073460b1ded5ec0ee5427def6e6",
+    "bytes": 13817537
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "105198550cbf836833d0b756313bdcbf5d30bd29161709f7cd4a7da3f798732a",
+    "bytes": 199120
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "19eb0801e91adce536ef4b99f4958e55c0221425f55d910f7b9fe5cf39c52d6a",
+    "bytes": 5334
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "ed581eb14fc0772d192650c2bc3817c26386cf8f0a8fbd3979537126cea3ef91",
+    "bytes": 113049
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "cdb21f860aa026931546cc0b2e097f5832e8ae026f9b030a2fc68332b94a4878",
+    "bytes": 526912
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "8ac8fa43e2b3a4493ef24332e969dc24ea4afd1a3acea4fcdd98ab50e6d7eb1a",
+    "bytes": 763489
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "0bfceca8078b394a25c019015c133eb0fe5958f1951d242b5c1102633761c36f",
+    "bytes": 25196
+  },
+  {
+    "path": "summary.json",
+    "sha256": "79a13b59b9b69c2df1cc77b855cf5e6cb9d19e5003e7f9891585140249e3eb2e",
+    "bytes": 47712
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 31138,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 559,
+      "input_supported_spikes": 523,
+      "first_actual_spike_tick": 12,
+      "first_nonzero_drive_tick": 12,
+      "cumulative_drive_by_apl": [
+        129.90617613121867,
+        169.83858256042004
+      ],
+      "cumulative_state_by_apl": [
+        20687.568988998057,
+        26234.450352213396
+      ],
+      "h_sum_mV": 1090299.0971201973,
+      "h_before_first_KC_sum_mV": 697.912781102972,
+      "h_never_fired_KC_sum_mV": 1077760.5072528685,
+      "h_before_first_any_KC_sum_mV": 25208.28525567288,
+      "generated_h_fraction": 0.20320039722521516,
+      "drive_fraction": 0.20382871991581278
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4621,
+      "input_supported_spikes": 2449,
+      "first_actual_spike_tick": 72,
+      "first_nonzero_drive_tick": 72,
+      "cumulative_drive_by_apl": [
+        553.7575522847474,
+        557.3017298690975
+      ],
+      "cumulative_state_by_apl": [
+        86777.87374892972,
+        86208.46129160424
+      ],
+      "h_sum_mV": 4006884.487210058,
+      "h_before_first_KC_sum_mV": 1834.2722817253268,
+      "h_never_fired_KC_sum_mV": 3959321.1323415483,
+      "h_before_first_any_KC_sum_mV": 44843.68305109175,
+      "generated_h_fraction": 0.7467680396940445,
+      "drive_fraction": 0.755528777952631
+    },
+    "KC": {
+      "actual_spikes": 60,
+      "input_supported_spikes": 60,
+      "first_actual_spike_tick": 176,
+      "first_nonzero_drive_tick": 176,
+      "cumulative_drive_by_apl": [
+        41.26147240400314,
+        18.506243348121643
+      ],
+      "cumulative_state_by_apl": [
+        8082.163455574612,
+        3622.76780477203
+      ],
+      "h_sum_mV": 268451.089659949,
+      "h_before_first_KC_sum_mV": 170.8712321217736,
+      "h_never_fired_KC_sum_mV": 264951.4285164287,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.05003156308074043,
+      "drive_fraction": 0.0406425021315563
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 48,
+    "non_design_ALPN": 638,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 44,
+    "non_design_ALPN": 238,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 176,
+  "ever_fired_KC": 57,
+  "never_fired_KC": 4007,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 3.129243850708008e-07,
+      "max_error_bound": 0.05779877557864344,
+      "max_bound_utilization": 1.3210665959054213e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.6890466213226318e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.00015086747023929092,
+      "max_error_bound": 1.691139908177055,
+      "max_bound_utilization": 9.387801959930177e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.8038065110246423e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 5.886414617073399e-06,
+      "max_error_bound": 0.07686068713580031,
+      "max_bound_utilization": 0.00010394352669462853,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.2446534180057555e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "0f3c31f0fd7dab7f988e89c1ba452ff3aa612318b07a6f8194653ad4ba9dc1c1",
+    "bytes": 14098574
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "e5ef632f8e2abfdca09f78b6cdb248851d9d1c35e0ead451bfdd90a85c7ac4d0",
+    "bytes": 197911
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "73a0e18c3ddf422b33ca41900cfe91f558f07f685d592dd6e39eceed406ba40a",
+    "bytes": 5330
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "e045ebce8a7c5d1d104a3d9639d35160f7941bcb1bf74cbf729f2cb12498e5ac",
+    "bytes": 114212
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "180217811d07c36cf07e5a5ec570d2535ee2dc9639b40ec363a5ecf12b02b8ab",
+    "bytes": 526528
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "e04b43f1fadcd4e7be45bd2dd7d9e51b2ecfd75c1088ba72658b405e8d2b9668",
+    "bytes": 770361
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "80acc8773d345f6698f02c9db77395a9d10647c376f9e4455541e07047488156",
+    "bytes": 25274
+  },
+  {
+    "path": "summary.json",
+    "sha256": "8c1ebb56482b7cf63b9f5a89c20c39b12078a8bb80dc347f8ececf776bfca8fc",
+    "bytes": 47812
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 27333,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 516,
+      "input_supported_spikes": 480,
+      "first_actual_spike_tick": 13,
+      "first_nonzero_drive_tick": 13,
+      "cumulative_drive_by_apl": [
+        109.66811884194613,
+        166.23399310559034
+      ],
+      "cumulative_state_by_apl": [
+        16571.06323765051,
+        25338.37190161504
+      ],
+      "h_sum_mV": 976127.8431555083,
+      "h_before_first_KC_sum_mV": 383.25903992961844,
+      "h_never_fired_KC_sum_mV": 967551.8521044163,
+      "h_before_first_any_KC_sum_mV": 25835.372499102075,
+      "generated_h_fraction": 0.2054679387173769,
+      "drive_fraction": 0.20616028062028383
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4232,
+      "input_supported_spikes": 2245,
+      "first_actual_spike_tick": 183,
+      "first_nonzero_drive_tick": 183,
+      "cumulative_drive_by_apl": [
+        476.8932090550661,
+        539.1378216594458
+      ],
+      "cumulative_state_by_apl": [
+        71369.09904675321,
+        82459.35789793175
+      ],
+      "h_sum_mV": 3570135.1207185513,
+      "h_before_first_KC_sum_mV": 1118.4430958819144,
+      "h_never_fired_KC_sum_mV": 3536480.645811454,
+      "h_before_first_any_KC_sum_mV": 47507.8935424991,
+      "generated_h_fraction": 0.7514879422199738,
+      "drive_fraction": 0.7592013012602469
+    },
+    "KC": {
+      "actual_spikes": 44,
+      "input_supported_spikes": 44,
+      "first_actual_spike_tick": 254,
+      "first_nonzero_drive_tick": 254,
+      "cumulative_drive_by_apl": [
+        34.59600245952606,
+        11.760224282741547
+      ],
+      "cumulative_state_by_apl": [
+        6648.051832273418,
+        2293.1352408800603
+      ],
+      "h_sum_mV": 204492.06510484772,
+      "h_before_first_KC_sum_mV": 163.94661621372,
+      "h_never_fired_KC_sum_mV": 202020.00879668127,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.04304411906264924,
+      "drive_fraction": 0.03463841811946931
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 48,
+    "non_design_ALPN": 638,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 44,
+    "non_design_ALPN": 238,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 254,
+  "ever_fired_KC": 41,
+  "never_fired_KC": 4023,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 3.5762786865234375e-07,
+      "max_error_bound": 0.05779877617682077,
+      "max_bound_utilization": 1.2032971185216292e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.47353857755661e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.00016921779939593762,
+      "max_error_bound": 1.7326540181900123,
+      "max_bound_utilization": 0.00010413197620684211,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.955686268679806e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 6.750277709244301e-06,
+      "max_error_bound": 0.07621114641163441,
+      "max_bound_utilization": 0.00010998979829723486,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.371105083690943e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "3ad4d95634927d35c967d252d6f24ee869bcee2ff389a850548ad42bd6e0d127",
+    "bytes": 13086712
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "e1e34ea0dad07a8033617bc4b29404feb39e683e394ebbfd4d92e98aa33816d3",
+    "bytes": 191873
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "4846b3bd9ef68e21f9f44fc00ce2daad53ae9139e710d583d4c63402b7f14c94",
+    "bytes": 5333
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "b422d8f2bcc8673c21bd7ca1095c58fb8436fcff4e1d4f8d71135346465d3ce1",
+    "bytes": 112479
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "59b439bf5048121b48ce996a9f994561907738d6584dbc7a3f14c9157bde371d",
+    "bytes": 522543
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "d36c36b6f57be7a9b617b56c2fb18c441f36e6f8ff22c716419cfe882a446065",
+    "bytes": 760326
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "bbff421b5341927544a192ca14d1dba884dc3f71db3f72dddf64ff2945c093a4",
+    "bytes": 24124
+  },
+  {
+    "path": "summary.json",
+    "sha256": "e5906aa7606b3321f1dfcf9ac406119ef86507805ebd700829f219e286e56f9e",
+    "bytes": 47732
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 29779,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 548,
+      "input_supported_spikes": 511,
+      "first_actual_spike_tick": 1,
+      "first_nonzero_drive_tick": 1,
+      "cumulative_drive_by_apl": [
+        117.9445781186223,
+        175.8596561923623
+      ],
+      "cumulative_state_by_apl": [
+        18201.212633479623,
+        27582.756120019403
+      ],
+      "h_sum_mV": 1066252.4347465204,
+      "h_before_first_KC_sum_mV": 407.1345771336941,
+      "h_never_fired_KC_sum_mV": 1055575.426857865,
+      "h_before_first_any_KC_sum_mV": 17910.732226247343,
+      "generated_h_fraction": 0.2023088707824843,
+      "drive_fraction": 0.20385351513917727
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4605,
+      "input_supported_spikes": 2422,
+      "first_actual_spike_tick": 90,
+      "first_nonzero_drive_tick": 90,
+      "cumulative_drive_by_apl": [
+        511.9120961166918,
+        584.2656689323485
+      ],
+      "cumulative_state_by_apl": [
+        78928.69993659886,
+        92272.99560072547
+      ],
+      "h_sum_mV": 3973947.7135089003,
+      "h_before_first_KC_sum_mV": 1428.4382760025949,
+      "h_never_fired_KC_sum_mV": 3932121.088707176,
+      "h_before_first_any_KC_sum_mV": 44670.778800722044,
+      "generated_h_fraction": 0.7540098838412005,
+      "drive_fraction": 0.7605734176932502
+    },
+    "KC": {
+      "actual_spikes": 49,
+      "input_supported_spikes": 49,
+      "first_actual_spike_tick": 170,
+      "first_nonzero_drive_tick": 170,
+      "cumulative_drive_by_apl": [
+        33.7703703045845,
+        17.49937480688095
+      ],
+      "cumulative_state_by_apl": [
+        6574.736178035171,
+        3445.073125524784
+      ],
+      "h_sum_mV": 230218.44793613825,
+      "h_before_first_KC_sum_mV": 152.49007247554343,
+      "h_never_fired_KC_sum_mV": 227428.35067247853,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.043681245376315216,
+      "drive_fraction": 0.03557306716757256
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 48,
+    "non_design_ALPN": 638,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 44,
+    "non_design_ALPN": 238,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 170,
+  "ever_fired_KC": 46,
+  "never_fired_KC": 4018,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 7.152557373046875e-07,
+      "max_error_bound": 0.05577783945326113,
+      "max_bound_utilization": 1.296421132566556e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.6098842024803163e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.00011394801103392638,
+      "max_error_bound": 1.705642237252246,
+      "max_bound_utilization": 7.991641296608152e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.8430392833715637e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 4.59826007581654e-06,
+      "max_error_bound": 0.075777598045684,
+      "max_bound_utilization": 8.87417463658191e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.2585649021245546e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "e5c52c727dce96b2a2688301e2e8e1fb639de2e2e0c76153d2c71df7c35f3c92",
+    "bytes": 13831257
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "937fdbfdd2f5a2896a9275de22a03385345711743b3f950a7494f49c4a8e6934",
+    "bytes": 201226
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "1e572f9f22d8b4c81d164a53ac6958b5997240de328474dcdd3285fcf9dbbb9a",
+    "bytes": 5327
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "e96b088612fdeee7d59047fe453de0c5ead54fd615411d21d3b4edf51827b398",
+    "bytes": 112915
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "963676e149322d565e3defeb81df63a5d45700222b6864bb24da985ac52eb0f0",
+    "bytes": 525264
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "79a6e0cfb41d67d733ee5b6bcf62f2c408f3591a38c7b9de1dfeb6c8cd05d596",
+    "bytes": 764092
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "a238ef341fb3ad92b50c79471fa2c3edafab9a64f239217ff650ad6dca7d7da1",
+    "bytes": 25335
+  },
+  {
+    "path": "summary.json",
+    "sha256": "4875c9966343a7d3bb86d75ff4c039b64df3369db4ff58bcfcf0b97900cbc0bc",
+    "bytes": 47842
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 31493,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 580,
+      "input_supported_spikes": 539,
+      "first_actual_spike_tick": 11,
+      "first_nonzero_drive_tick": 11,
+      "cumulative_drive_by_apl": [
+        127.32859267666936,
+        181.31688337028027
+      ],
+      "cumulative_state_by_apl": [
+        20149.51887392528,
+        28961.971743068636
+      ],
+      "h_sum_mV": 1142990.7263539862,
+      "h_before_first_KC_sum_mV": 545.1434418252679,
+      "h_never_fired_KC_sum_mV": 1132322.166239471,
+      "h_before_first_any_KC_sum_mV": 31989.36171053407,
+      "generated_h_fraction": 0.20496115064962833,
+      "drive_fraction": 0.20417760020868872
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4778,
+      "input_supported_spikes": 2541,
+      "first_actual_spike_tick": 71,
+      "first_nonzero_drive_tick": 71,
+      "cumulative_drive_by_apl": [
+        548.0989510826766,
+        601.6643570289016
+      ],
+      "cumulative_state_by_apl": [
+        86031.67052130381,
+        94789.45984797612
+      ],
+      "h_sum_mV": 4194011.499007223,
+      "h_before_first_KC_sum_mV": 1407.6160090573464,
+      "h_never_fired_KC_sum_mV": 4152843.5952232457,
+      "h_before_first_any_KC_sum_mV": 54183.4776975047,
+      "generated_h_fraction": 0.7520703386775077,
+      "drive_fraction": 0.7606005312791796
+    },
+    "KC": {
+      "actual_spikes": 53,
+      "input_supported_spikes": 53,
+      "first_actual_spike_tick": 158,
+      "first_nonzero_drive_tick": 158,
+      "cumulative_drive_by_apl": [
+        36.89166295528412,
+        16.351544737815857
+      ],
+      "cumulative_state_by_apl": [
+        7227.053998993397,
+        3221.4102047829374
+      ],
+      "h_sum_mV": 239619.11351815888,
+      "h_before_first_KC_sum_mV": 120.26807763341955,
+      "h_never_fired_KC_sum_mV": 236880.7262350515,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.04296851067286393,
+      "drive_fraction": 0.035221868512131674
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 55,
+    "non_design_ALPN": 631,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 51,
+    "non_design_ALPN": 231,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 158,
+  "ever_fired_KC": 50,
+  "never_fired_KC": 4014,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 5.811452865600586e-07,
+      "max_error_bound": 0.05739458895174431,
+      "max_bound_utilization": 1.2557310225580515e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.7398968338966368e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.00011896190170546106,
+      "max_error_bound": 1.762211820518357,
+      "max_bound_utilization": 8.0191268647537e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.960629024321905e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 5.7778859350321454e-06,
+      "max_error_bound": 0.07594877686027263,
+      "max_bound_utilization": 8.761158074362719e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.3793150923072603e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "b00ce578b9e2296b984fed0fb176e897145c32f1b52fe1c3a7a1fbc5da5a8c72",
+    "bytes": 13755799
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "804599256e2be45ef2bda027f5dd40af2cb6106f8b9ed38dd5bec71e943a5df8",
+    "bytes": 198595
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "918dfb60b4e26182d0474563a96f741ff9b4fcb2494430c3d7fa9299ff583952",
+    "bytes": 5333
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "5761b9285a390b1f183e7458ed64a9035ac465526943d36c296797dba84a2b68",
+    "bytes": 113536
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "121d245c089b0ac186425fae93c276eea82009387c292b7b013aaa8551803b7e",
+    "bytes": 524480
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "7492d791e9eff33e21c6910dfcb92cf64b37566fc7529475747d63704020af37",
+    "bytes": 753530
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "217d74b25dcec13b31f1eb0cf72ee1651c7813acc8e20ae9e84732dd7fa67e4c",
+    "bytes": 25725
+  },
+  {
+    "path": "summary.json",
+    "sha256": "7b5edc6bcdf7fe861c5e61714659dcefc419bf0fa6f9c263f59142a7a307d2dc",
+    "bytes": 47752
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 31493,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 580,
+      "input_supported_spikes": 539,
+      "first_actual_spike_tick": 11,
+      "first_nonzero_drive_tick": 11,
+      "cumulative_drive_by_apl": [
+        127.32859267666936,
+        181.31688337028027
+      ],
+      "cumulative_state_by_apl": [
+        20149.51887392528,
+        28961.971743068636
+      ],
+      "h_sum_mV": 1142990.7263539862,
+      "h_before_first_KC_sum_mV": 545.1434418252679,
+      "h_never_fired_KC_sum_mV": 1132322.166239471,
+      "h_before_first_any_KC_sum_mV": 31989.36171053407,
+      "generated_h_fraction": 0.20496115064962833,
+      "drive_fraction": 0.20417760020868872
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4778,
+      "input_supported_spikes": 2541,
+      "first_actual_spike_tick": 71,
+      "first_nonzero_drive_tick": 71,
+      "cumulative_drive_by_apl": [
+        548.0989510826766,
+        601.6643570289016
+      ],
+      "cumulative_state_by_apl": [
+        86031.67052130381,
+        94789.45984797612
+      ],
+      "h_sum_mV": 4194011.499007223,
+      "h_before_first_KC_sum_mV": 1407.6160090573464,
+      "h_never_fired_KC_sum_mV": 4152843.5952232457,
+      "h_before_first_any_KC_sum_mV": 54183.4776975047,
+      "generated_h_fraction": 0.7520703386775077,
+      "drive_fraction": 0.7606005312791796
+    },
+    "KC": {
+      "actual_spikes": 53,
+      "input_supported_spikes": 53,
+      "first_actual_spike_tick": 158,
+      "first_nonzero_drive_tick": 158,
+      "cumulative_drive_by_apl": [
+        36.89166295528412,
+        16.351544737815857
+      ],
+      "cumulative_state_by_apl": [
+        7227.053998993397,
+        3221.4102047829374
+      ],
+      "h_sum_mV": 239619.11351815888,
+      "h_before_first_KC_sum_mV": 120.26807763341955,
+      "h_never_fired_KC_sum_mV": 236880.7262350515,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.04296851067286393,
+      "drive_fraction": 0.035221868512131674
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 55,
+    "non_design_ALPN": 631,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 51,
+    "non_design_ALPN": 231,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 158,
+  "ever_fired_KC": 50,
+  "never_fired_KC": 4014,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 5.811452865600586e-07,
+      "max_error_bound": 0.05739458895174431,
+      "max_bound_utilization": 1.2557310225580515e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.7398968338966368e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.00011896190170546106,
+      "max_error_bound": 1.762211820518357,
+      "max_bound_utilization": 8.0191268647537e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.960629024321905e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 5.7778859350321454e-06,
+      "max_error_bound": 0.07594877686027263,
+      "max_bound_utilization": 8.761158074362719e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.3793150923072603e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "b00ce578b9e2296b984fed0fb176e897145c32f1b52fe1c3a7a1fbc5da5a8c72",
+    "bytes": 13755799
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "804599256e2be45ef2bda027f5dd40af2cb6106f8b9ed38dd5bec71e943a5df8",
+    "bytes": 198595
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "918dfb60b4e26182d0474563a96f741ff9b4fcb2494430c3d7fa9299ff583952",
+    "bytes": 5333
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "5761b9285a390b1f183e7458ed64a9035ac465526943d36c296797dba84a2b68",
+    "bytes": 113536
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "121d245c089b0ac186425fae93c276eea82009387c292b7b013aaa8551803b7e",
+    "bytes": 524480
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "7492d791e9eff33e21c6910dfcb92cf64b37566fc7529475747d63704020af37",
+    "bytes": 753530
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "217d74b25dcec13b31f1eb0cf72ee1651c7813acc8e20ae9e84732dd7fa67e4c",
+    "bytes": 25725
+  },
+  {
+    "path": "summary.json",
+    "sha256": "32827808d88d5381fb0c0a958a3246583c32de32afc7d81d152b6e3ffe468cee",
+    "bytes": 47752
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 30929,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 562,
+      "input_supported_spikes": 523,
+      "first_actual_spike_tick": 0,
+      "first_nonzero_drive_tick": 0,
+      "cumulative_drive_by_apl": [
+        123.80455295741558,
+        176.24226624518633
+      ],
+      "cumulative_state_by_apl": [
+        19351.5802124069,
+        28141.10278990673
+      ],
+      "h_sum_mV": 1105477.1973704514,
+      "h_before_first_KC_sum_mV": 476.37701500020745,
+      "h_never_fired_KC_sum_mV": 1093546.5472193249,
+      "h_before_first_any_KC_sum_mV": 21199.1648362222,
+      "generated_h_fraction": 0.19909843703791133,
+      "drive_fraction": 0.19884960730218476
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4818,
+      "input_supported_spikes": 2542,
+      "first_actual_spike_tick": 47,
+      "first_nonzero_drive_tick": 47,
+      "cumulative_drive_by_apl": [
+        552.3479363881052,
+        598.8652626909316
+      ],
+      "cumulative_state_by_apl": [
+        85830.57262196575,
+        94718.70352908991
+      ],
+      "h_sum_mV": 4187792.7272602757,
+      "h_before_first_KC_sum_mV": 1590.7951153311546,
+      "h_never_fired_KC_sum_mV": 4139552.695460711,
+      "h_before_first_any_KC_sum_mV": 46524.5562559031,
+      "generated_h_fraction": 0.7542290231038097,
+      "drive_fraction": 0.7629419074207375
+    },
+    "KC": {
+      "actual_spikes": 55,
+      "input_supported_spikes": 55,
+      "first_actual_spike_tick": 148,
+      "first_nonzero_drive_tick": 148,
+      "cumulative_drive_by_apl": [
+        41.38229662179947,
+        16.270995378494263
+      ],
+      "cumulative_state_by_apl": [
+        8104.002014443209,
+        3210.5312241771517
+      ],
+      "h_sum_mV": 259145.32190358848,
+      "h_before_first_KC_sum_mV": 181.91529160135067,
+      "h_never_fired_KC_sum_mV": 255481.29689268532,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.046672539858278926,
+      "drive_fraction": 0.03820848527707766
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 55,
+    "non_design_ALPN": 631,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 51,
+    "non_design_ALPN": 231,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 148,
+  "ever_fired_KC": 52,
+  "never_fired_KC": 4012,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 6.705522537231445e-07,
+      "max_error_bound": 0.061638555263680166,
+      "max_bound_utilization": 1.487904823728152e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.879781484603882e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.00010741338269326661,
+      "max_error_bound": 1.721608392141025,
+      "max_bound_utilization": 6.59064507549826e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.9376340397276296e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 4.473448710129446e-06,
+      "max_error_bound": 0.07703443656194955,
+      "max_bound_utilization": 7.681072811831131e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.3676904025102205e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "8e811e81b324390da65c29635422522a713c0895dcfd99eba716dc81ec109b92",
+    "bytes": 13802850
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "c25592bfb99b2951844bada381f67cc413dadccdeeebbc87bea0f4855c3e6719",
+    "bytes": 201716
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "42a43f8a20ba9fd3b84882d7ad8258a9cf158b41e3fb6843bbb3bbbf1507e8da",
+    "bytes": 5331
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "5561b7b84d94a1e5249b1e0038097f3c1ab0c7c33604827dee1f71fc55153175",
+    "bytes": 113550
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "e1bbe166c8140717b5c9a8d1e35464ff5f5f66634b843412913ee33bbc4bde7f",
+    "bytes": 529515
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "265226bdde49cb5522e32c60a3d361e6a2991014187aadb9188d3b5f8c85fd8f",
+    "bytes": 759220
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "3af7773dc6bee3032e495c178e3013f1234f3b25561e7800f64ebf44a41d32ef",
+    "bytes": 25475
+  },
+  {
+    "path": "summary.json",
+    "sha256": "4ffadbf7168a33f973bc1d51ee0ca5590ba122de903f85972232848f23a37c29",
+    "bytes": 47856
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 30248,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 559,
+      "input_supported_spikes": 523,
+      "first_actual_spike_tick": 0,
+      "first_nonzero_drive_tick": 0,
+      "cumulative_drive_by_apl": [
+        136.20917321369052,
+        168.50951582193375
+      ],
+      "cumulative_state_by_apl": [
+        21676.810425349762,
+        26220.68573314161
+      ],
+      "h_sum_mV": 1112290.1643139948,
+      "h_before_first_KC_sum_mV": 664.0159827881789,
+      "h_never_fired_KC_sum_mV": 1098225.2013420316,
+      "h_before_first_any_KC_sum_mV": 22509.842811480434,
+      "generated_h_fraction": 0.1990205246188318,
+      "drive_fraction": 0.20015343404371974
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4748,
+      "input_supported_spikes": 2524,
+      "first_actual_spike_tick": 48,
+      "first_nonzero_drive_tick": 48,
+      "cumulative_drive_by_apl": [
+        568.8605801202357,
+        577.4592378437519
+      ],
+      "cumulative_state_by_apl": [
+        89743.55876394873,
+        89577.33776400333
+      ],
+      "h_sum_mV": 4153868.1461458188,
+      "h_before_first_KC_sum_mV": 1721.0835135742163,
+      "h_never_fired_KC_sum_mV": 4099909.002704499,
+      "h_before_first_any_KC_sum_mV": 33452.27807393643,
+      "generated_h_fraction": 0.7432458221486348,
+      "drive_fraction": 0.7529562719109766
+    },
+    "KC": {
+      "actual_spikes": 75,
+      "input_supported_spikes": 75,
+      "first_actual_spike_tick": 142,
+      "first_nonzero_drive_tick": 142,
+      "cumulative_drive_by_apl": [
+        46.65828776359558,
+        24.728690922260284
+      ],
+      "cumulative_state_by_apl": [
+        9182.915723226133,
+        4858.743634927249
+      ],
+      "h_sum_mV": 322663.07589858264,
+      "h_before_first_KC_sum_mV": 253.24057786755978,
+      "h_never_fired_KC_sum_mV": 318111.0392766617,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.057733653232533474,
+      "drive_fraction": 0.04689029404530369
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 55,
+    "non_design_ALPN": 631,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 51,
+    "non_design_ALPN": 231,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 142,
+  "ever_fired_KC": 72,
+  "never_fired_KC": 3992,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 4.3585896492004395e-07,
+      "max_error_bound": 0.056384119692698506,
+      "max_bound_utilization": 1.6094910713620374e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.6573816537857055e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.00013229554787130837,
+      "max_error_bound": 1.7197022863695128,
+      "max_bound_utilization": 9.00934319009059e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.100107687389514e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 6.738164500141863e-06,
+      "max_error_bound": 0.07576768137685458,
+      "max_bound_utilization": 9.875325906631433e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.5304354743797553e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "052020f10e372b4f75caf353d648252c44e77b716accdd13006537f912fd27c5",
+    "bytes": 13789345
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "eddcdb7ecaf55d8c40b7a60185e1fdbba467a3da4d228b8657cba8ae62b3226b",
+    "bytes": 203123
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "3a58bb681648b7afcc48a0332e13dd9627fe40737716d9bc081719048b0dcbd7",
+    "bytes": 5335
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "8a91366b3688db920754dcbf49fbc9c036a14e1c33e5d75a00cbabef56dffa5b",
+    "bytes": 115525
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "2d6c8806ee6b360350739323abe8836f27cb7faa5cca0221fbd8fec2c9ef3655",
+    "bytes": 528100
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "d029b3d1f735ad957c331f3151e800064b78ba2e9e16531516fd1f84b1c6bbde",
+    "bytes": 763067
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "7cf143280c9637f258ac17109dd90cafa422f07cc160e4e2f828f818dbc50d3d",
+    "bytes": 25251
+  },
+  {
+    "path": "summary.json",
+    "sha256": "412b5425dab8e9f0b77883981de300a5be76d470b6543128080cb53085c0db86",
+    "bytes": 47801
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 29898,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 556,
+      "input_supported_spikes": 517,
+      "first_actual_spike_tick": 6,
+      "first_nonzero_drive_tick": 6,
+      "cumulative_drive_by_apl": [
+        118.83062243461609,
+        177.55119521170855
+      ],
+      "cumulative_state_by_apl": [
+        18463.438732778373,
+        28454.918833146072
+      ],
+      "h_sum_mV": 1092898.9760032215,
+      "h_before_first_KC_sum_mV": 417.7787600186299,
+      "h_never_fired_KC_sum_mV": 1082052.7273989357,
+      "h_before_first_any_KC_sum_mV": 22309.55217111442,
+      "generated_h_fraction": 0.2020516333238677,
+      "drive_fraction": 0.2012525286856829
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4706,
+      "input_supported_spikes": 2486,
+      "first_actual_spike_tick": 50,
+      "first_nonzero_drive_tick": 50,
+      "cumulative_drive_by_apl": [
+        518.8796263933182,
+        605.8932047896087
+      ],
+      "cumulative_state_by_apl": [
+        80059.87878169325,
+        95827.23529454487
+      ],
+      "h_sum_mV": 4083949.0528846863,
+      "h_before_first_KC_sum_mV": 1385.5005099518612,
+      "h_never_fired_KC_sum_mV": 4041857.281977813,
+      "h_before_first_any_KC_sum_mV": 46408.45231898509,
+      "generated_h_fraction": 0.755027312372906,
+      "drive_fraction": 0.7637559492351871
+    },
+    "KC": {
+      "actual_spikes": 49,
+      "input_supported_spikes": 49,
+      "first_actual_spike_tick": 150,
+      "first_nonzero_drive_tick": 150,
+      "cumulative_drive_by_apl": [
+        32.179518043994904,
+        19.352012932300568
+      ],
+      "cumulative_state_by_apl": [
+        6267.394884663895,
+        3818.4920971919973
+      ],
+      "h_sum_mV": 232160.3420140906,
+      "h_before_first_KC_sum_mV": 146.5307717757732,
+      "h_never_fired_KC_sum_mV": 229525.3735945751,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.042921054303226354,
+      "drive_fraction": 0.03499152207913004
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 55,
+    "non_design_ALPN": 631,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 51,
+    "non_design_ALPN": 231,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 150,
+  "ever_fired_KC": 46,
+  "never_fired_KC": 4018,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 5.066394805908203e-07,
+      "max_error_bound": 0.05800086919118168,
+      "max_bound_utilization": 1.8101352593040392e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.7054378986358644e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.0001500166519576851,
+      "max_error_bound": 1.7176949247966318,
+      "max_bound_utilization": 9.219999463242472e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.190046603334262e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 6.062785788962799e-06,
+      "max_error_bound": 0.07597529202008595,
+      "max_bound_utilization": 0.00010014060663077648,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.682052066020565e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "66ac749366009d3525c1d4c75df3bef00e4ef715541fce88fd9a53b7dcbfcec7",
+    "bytes": 14082919
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "249944d0a40b1c121128bc9a2b1b1a3b57054d678b265829d8045997d523934b",
+    "bytes": 204005
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "0cd5427ca9379b669f55e4f4aab2682092d692dccb0265fbc9f326ecaeca8612",
+    "bytes": 5331
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "29d951ac7575983300c5a54754bc486831363cde2c09b65319fd6b1f0fda56cc",
+    "bytes": 113006
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "4f425c46dfa2421b6c4910af2dd235ad721574899752a3a2a1ec72b45c27a60b",
+    "bytes": 529167
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "a8fd0ed632202d7596b9429b2c460575dfe7c563b35f4597a50f0e751b16ceac",
+    "bytes": 769067
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "bbc8470d6cbbb8dff4fdd95ee2119c8b29a5438fe67dcdaefe2acb0cae2f2342",
+    "bytes": 25394
+  },
+  {
+    "path": "summary.json",
+    "sha256": "79335ab1e6c646a6a1e8fc38cc76184e175fce11d9dd7076c96a219ee315295d",
+    "bytes": 47832
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 32029,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 570,
+      "input_supported_spikes": 531,
+      "first_actual_spike_tick": 26,
+      "first_nonzero_drive_tick": 26,
+      "cumulative_drive_by_apl": [
+        126.82515859603882,
+        181.51825716346502
+      ],
+      "cumulative_state_by_apl": [
+        19978.843938520316,
+        28784.80737241119
+      ],
+      "h_sum_mV": 1134929.1090027348,
+      "h_before_first_KC_sum_mV": 686.299541658686,
+      "h_never_fired_KC_sum_mV": 1118768.301977155,
+      "h_before_first_any_KC_sum_mV": 16223.905533235536,
+      "generated_h_fraction": 0.20021892746353312,
+      "drive_fraction": 0.20072887343814352
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4789,
+      "input_supported_spikes": 2537,
+      "first_actual_spike_tick": 66,
+      "first_nonzero_drive_tick": 66,
+      "cumulative_drive_by_apl": [
+        552.0056011304259,
+        598.8652625717223
+      ],
+      "cumulative_state_by_apl": [
+        86345.67262142805,
+        94094.97915424083
+      ],
+      "h_sum_mV": 4184588.551090612,
+      "h_before_first_KC_sum_mV": 1767.129423083821,
+      "h_never_fired_KC_sum_mV": 4123196.316526431,
+      "h_before_first_any_KC_sum_mV": 15609.928235227273,
+      "generated_h_fraction": 0.7382256961509687,
+      "drive_fraction": 0.7492068912017789
+    },
+    "KC": {
+      "actual_spikes": 75,
+      "input_supported_spikes": 75,
+      "first_actual_spike_tick": 133,
+      "first_nonzero_drive_tick": 133,
+      "cumulative_drive_by_apl": [
+        44.12097895145416,
+        32.78363907337189
+      ],
+      "cumulative_state_by_apl": [
+        8651.295003587635,
+        6468.139798636487
+      ],
+      "h_sum_mV": 348922.99824273936,
+      "h_before_first_KC_sum_mV": 255.81080235900527,
+      "h_never_fired_KC_sum_mV": 343597.24299523205,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.06155537638549827,
+      "drive_fraction": 0.05006423536007766
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 55,
+    "non_design_ALPN": 631,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 51,
+    "non_design_ALPN": 231,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 133,
+  "ever_fired_KC": 72,
+  "never_fired_KC": 3992,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 5.066394805908203e-07,
+      "max_error_bound": 0.0666908939321483,
+      "max_bound_utilization": 1.2588723225490655e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.817755401134491e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.00011654023199980656,
+      "max_error_bound": 1.7436218068865454,
+      "max_bound_utilization": 7.242833096751885e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.1460937291514382e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 4.794110927797135e-06,
+      "max_error_bound": 0.0771481441471464,
+      "max_bound_utilization": 7.899956291954169e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.4812672168216646e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "061d2ea0bd11dc76867972d83f4e5a5d30a167a491358f31b33ea1a95648251e",
+    "bytes": 13991851
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "188a913d451089affab376343e18c2578732c6d8ccfbccf00b0e52ba52be6fd6",
+    "bytes": 197118
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "880d69ccbbdaab0b1c98343e5f0cc1136b15414b1d50d8f6cb5fa84a2d8baab0",
+    "bytes": 5331
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "4ca31e93ac03a1c245aa2d29adf3d0d2c57550affd8e3f1e84f2fbcd6f487893",
+    "bytes": 115520
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "a1766cf80dd3c501c1021fd1b19e0964063ee303ec97aaebeb004e3075c94da8",
+    "bytes": 527462
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "b7b48ecb4158fe00c478b55985cce157d00116926d12617fec81fb3d4400c08f",
+    "bytes": 770321
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "7a27864fb761fe3970bbb830b9c95be93279231ec64bfce1b1496fd23af940d1",
+    "bytes": 25347
+  },
+  {
+    "path": "summary.json",
+    "sha256": "8efccb0b1e6f14e0fc7b480a8a7a78f84fde06c9aa65513595fd577f7e9fde51",
+    "bytes": 47633
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 30662,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 466,
+      "input_supported_spikes": 440,
+      "first_actual_spike_tick": 6,
+      "first_nonzero_drive_tick": 6,
+      "cumulative_drive_by_apl": [
+        185.2436708509922,
+        250.97204722464085
+      ],
+      "cumulative_state_by_apl": [
+        29031.97208254577,
+        40019.121750899154
+      ],
+      "h_sum_mV": 1606205.2310577803,
+      "h_before_first_KC_sum_mV": 940.0070383346799,
+      "h_never_fired_KC_sum_mV": 1586739.8195949472,
+      "h_before_first_any_KC_sum_mV": 47015.4378577138,
+      "generated_h_fraction": 0.2879419730581432,
+      "drive_fraction": 0.2871992032884383
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4884,
+      "input_supported_spikes": 2607,
+      "first_actual_spike_tick": 85,
+      "first_nonzero_drive_tick": 85,
+      "cumulative_drive_by_apl": [
+        506.8777534067631,
+        511.73086097091436
+      ],
+      "cumulative_state_by_apl": [
+        78513.85142437728,
+        80459.5647370322
+      ],
+      "h_sum_mV": 3683794.4528536005,
+      "h_before_first_KC_sum_mV": 1481.230204005128,
+      "h_never_fired_KC_sum_mV": 3636391.3855316574,
+      "h_before_first_any_KC_sum_mV": 50241.588082219205,
+      "generated_h_fraction": 0.6603882384300062,
+      "drive_fraction": 0.6706397096431231
+    },
+    "KC": {
+      "actual_spikes": 63,
+      "input_supported_spikes": 63,
+      "first_actual_spike_tick": 175,
+      "first_nonzero_drive_tick": 175,
+      "cumulative_drive_by_apl": [
+        44.382764637470245,
+        19.654073417186737
+      ],
+      "cumulative_state_by_apl": [
+        8699.041416147185,
+        3869.1924707136623
+      ],
+      "h_sum_mV": 288225.72726701887,
+      "h_before_first_KC_sum_mV": 218.04846427095498,
+      "h_never_fired_KC_sum_mV": 283925.5809955947,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.05166978851185062,
+      "drive_fraction": 0.0421610870684386
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 33,
+    "non_design_ALPN": 653,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 30,
+    "non_design_ALPN": 252,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 175,
+  "ever_fired_KC": 60,
+  "never_fired_KC": 4004,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 4.731118679046631e-07,
+      "max_error_bound": 0.0685097379404357,
+      "max_bound_utilization": 1.1419770467910595e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.6575679183006285e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 9.645811613268052e-05,
+      "max_error_bound": 1.7247066249503964,
+      "max_bound_utilization": 5.9355372356484395e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.986603382004859e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 4.096516611262757e-06,
+      "max_error_bound": 0.07713549052130594,
+      "max_bound_utilization": 6.728721933083597e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.29789438664593e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "be50536d41d98c8f9eda084908e9f302d830987fc7f4a4744c2a55bfc2f5e845",
+    "bytes": 13473443
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "fd09cbc093b0a886a57a625dd65bccce5188ead916bf40a1d9c9f9f6860c70f8",
+    "bytes": 197527
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "8ff4d114aeed9bb7ffc2aa0c852e0c08931079d0b78f5c40d313af95461cd3d5",
+    "bytes": 5328
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "af3b75cfc647626b98645cf71d29efa09ed5af95628c0ec7ed4c92a811969c99",
+    "bytes": 114589
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "62cc4ea1ca9000407d91ddd3c4569bc4aa10ee90e454cd61d075a633fd1e678b",
+    "bytes": 524639
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "2f5c4baf6cab67cf6877ebf8a0db55fc3b09a7b2c2886fb7133d62df160bd01a",
+    "bytes": 749583
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "bee035da95f7e393948666e945c2da70b6fe2df710ffea84f321adc84f5f1489",
+    "bytes": 25361
+  },
+  {
+    "path": "summary.json",
+    "sha256": "b8eb40e0314bd369195a35ad45a9c31624675f7de3b0e5afdb728e1b5a558b90",
+    "bytes": 47745
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 30662,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 466,
+      "input_supported_spikes": 440,
+      "first_actual_spike_tick": 6,
+      "first_nonzero_drive_tick": 6,
+      "cumulative_drive_by_apl": [
+        185.2436708509922,
+        250.97204722464085
+      ],
+      "cumulative_state_by_apl": [
+        29031.97208254577,
+        40019.121750899154
+      ],
+      "h_sum_mV": 1606205.2310577803,
+      "h_before_first_KC_sum_mV": 940.0070383346799,
+      "h_never_fired_KC_sum_mV": 1586739.8195949472,
+      "h_before_first_any_KC_sum_mV": 47015.4378577138,
+      "generated_h_fraction": 0.2879419730581432,
+      "drive_fraction": 0.2871992032884383
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4884,
+      "input_supported_spikes": 2607,
+      "first_actual_spike_tick": 85,
+      "first_nonzero_drive_tick": 85,
+      "cumulative_drive_by_apl": [
+        506.8777534067631,
+        511.73086097091436
+      ],
+      "cumulative_state_by_apl": [
+        78513.85142437728,
+        80459.5647370322
+      ],
+      "h_sum_mV": 3683794.4528536005,
+      "h_before_first_KC_sum_mV": 1481.230204005128,
+      "h_never_fired_KC_sum_mV": 3636391.3855316574,
+      "h_before_first_any_KC_sum_mV": 50241.588082219205,
+      "generated_h_fraction": 0.6603882384300062,
+      "drive_fraction": 0.6706397096431231
+    },
+    "KC": {
+      "actual_spikes": 63,
+      "input_supported_spikes": 63,
+      "first_actual_spike_tick": 175,
+      "first_nonzero_drive_tick": 175,
+      "cumulative_drive_by_apl": [
+        44.382764637470245,
+        19.654073417186737
+      ],
+      "cumulative_state_by_apl": [
+        8699.041416147185,
+        3869.1924707136623
+      ],
+      "h_sum_mV": 288225.72726701887,
+      "h_before_first_KC_sum_mV": 218.04846427095498,
+      "h_never_fired_KC_sum_mV": 283925.5809955947,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.05166978851185062,
+      "drive_fraction": 0.0421610870684386
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 33,
+    "non_design_ALPN": 653,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 30,
+    "non_design_ALPN": 252,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 175,
+  "ever_fired_KC": 60,
+  "never_fired_KC": 4004,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 4.731118679046631e-07,
+      "max_error_bound": 0.0685097379404357,
+      "max_bound_utilization": 1.1419770467910595e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.6575679183006285e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 9.645811613268052e-05,
+      "max_error_bound": 1.7247066249503964,
+      "max_bound_utilization": 5.9355372356484395e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.986603382004859e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 4.096516611262757e-06,
+      "max_error_bound": 0.07713549052130594,
+      "max_bound_utilization": 6.728721933083597e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.29789438664593e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "be50536d41d98c8f9eda084908e9f302d830987fc7f4a4744c2a55bfc2f5e845",
+    "bytes": 13473443
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "fd09cbc093b0a886a57a625dd65bccce5188ead916bf40a1d9c9f9f6860c70f8",
+    "bytes": 197527
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "8ff4d114aeed9bb7ffc2aa0c852e0c08931079d0b78f5c40d313af95461cd3d5",
+    "bytes": 5328
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "af3b75cfc647626b98645cf71d29efa09ed5af95628c0ec7ed4c92a811969c99",
+    "bytes": 114589
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "62cc4ea1ca9000407d91ddd3c4569bc4aa10ee90e454cd61d075a633fd1e678b",
+    "bytes": 524639
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "2f5c4baf6cab67cf6877ebf8a0db55fc3b09a7b2c2886fb7133d62df160bd01a",
+    "bytes": 749583
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "bee035da95f7e393948666e945c2da70b6fe2df710ffea84f321adc84f5f1489",
+    "bytes": 25361
+  },
+  {
+    "path": "summary.json",
+    "sha256": "092f4d74c4db93b94890c3c6dd9431deacf76625e088781a1775a00f53e64005",
+    "bytes": 47744
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 30262,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 453,
+      "input_supported_spikes": 428,
+      "first_actual_spike_tick": 20,
+      "first_nonzero_drive_tick": 20,
+      "cumulative_drive_by_apl": [
+        179.1017726957798,
+        248.45487602055073
+      ],
+      "cumulative_state_by_apl": [
+        27861.162533649273,
+        39312.469094922475
+      ],
+      "h_sum_mV": 1562994.1873998495,
+      "h_before_first_KC_sum_mV": 789.9160054763073,
+      "h_never_fired_KC_sum_mV": 1545909.440542028,
+      "h_before_first_any_KC_sum_mV": 33087.067015994915,
+      "generated_h_fraction": 0.28994041608648435,
+      "drive_fraction": 0.28975380622204305
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4788,
+      "input_supported_spikes": 2552,
+      "first_actual_spike_tick": 72,
+      "first_nonzero_drive_tick": 72,
+      "cumulative_drive_by_apl": [
+        482.51153502240777,
+        506.05212242901325
+      ],
+      "cumulative_state_by_apl": [
+        74211.2273735334,
+        79392.56587098847
+      ],
+      "h_sum_mV": 3561361.5771840755,
+      "h_before_first_KC_sum_mV": 1273.7396152614472,
+      "h_never_fired_KC_sum_mV": 3519896.3640928166,
+      "h_before_first_any_KC_sum_mV": 36201.02463801488,
+      "generated_h_fraction": 0.6606439523879117,
+      "drive_fraction": 0.6699465048650818
+    },
+    "KC": {
+      "actual_spikes": 57,
+      "input_supported_spikes": 57,
+      "first_actual_spike_tick": 168,
+      "first_nonzero_drive_tick": 168,
+      "cumulative_drive_by_apl": [
+        43.15438514947891,
+        16.31127005815506
+      ],
+      "cumulative_state_by_apl": [
+        8425.085833735178,
+        3210.4333666005236
+      ],
+      "h_sum_mV": 266386.9559260533,
+      "h_before_first_KC_sum_mV": 233.80454719476543,
+      "h_never_fired_KC_sum_mV": 262605.7788109801,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.04941563152560403,
+      "drive_fraction": 0.040299688912875234
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 33,
+    "non_design_ALPN": 653,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 30,
+    "non_design_ALPN": 252,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 168,
+  "ever_fired_KC": 54,
+  "never_fired_KC": 4010,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 4.6193599700927734e-07,
+      "max_error_bound": 0.06406367891322762,
+      "max_bound_utilization": 1.365443560967278e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.580081880092621e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.0001507579620749766,
+      "max_error_bound": 1.7401969550737288,
+      "max_bound_utilization": 9.220145026862412e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.087872048416404e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 6.095325965738141e-06,
+      "max_error_bound": 0.07689900555056041,
+      "max_bound_utilization": 0.00010085960043689285,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.5611802726728477e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "9ea7ecf704a7c9ae65bab8fc51ebe963ee11a9c23b08c8693cd1721acd79c5d3",
+    "bytes": 13196425
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "09e0d99f92f4f6f0e478a93e52ade5dc2012a6fd4579ea05e4405e7365c14746",
+    "bytes": 197852
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "68965a694af73a874409bf226502b36cafc1bcd3d8c25f57cf789491279416fb",
+    "bytes": 5336
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "cbc972f8433fc1df9306cead29075778e8c8d02fff5221a2369184bbfa310930",
+    "bytes": 113943
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "bd7150f67570820470fe5abc1df0c6c7dbfa58e68a870b59ed4e8c8a84b9174e",
+    "bytes": 529539
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "a20c90946ae6fa881c41624f85b5ff6cc190fdebcd7700e04b82046b52b8258b",
+    "bytes": 753944
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "56d0efdc6c5554f6a1ac637284d2c7fcb009dd5bb48667085f4a2bbac4d9c464",
+    "bytes": 25224
+  },
+  {
+    "path": "summary.json",
+    "sha256": "689bec79517789754291cc78c015a53a0155c9b0e2e6968fe10a03165670725a",
+    "bytes": 47760
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 29674,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 458,
+      "input_supported_spikes": 435,
+      "first_actual_spike_tick": 18,
+      "first_nonzero_drive_tick": 18,
+      "cumulative_drive_by_apl": [
+        181.92100462317467,
+        251.3949324041605
+      ],
+      "cumulative_state_by_apl": [
+        28517.943352647384,
+        39552.1973005942
+      ],
+      "h_sum_mV": 1583509.9034850688,
+      "h_before_first_KC_sum_mV": 654.5134419300524,
+      "h_never_fired_KC_sum_mV": 1570299.2390677498,
+      "h_before_first_any_KC_sum_mV": 39868.22633016447,
+      "generated_h_fraction": 0.29089082721987786,
+      "drive_fraction": 0.29031692158041356
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4807,
+      "input_supported_spikes": 2573,
+      "first_actual_spike_tick": 84,
+      "first_nonzero_drive_tick": 84,
+      "cumulative_drive_by_apl": [
+        497.43332670256495,
+        516.8457532301545
+      ],
+      "cumulative_state_by_apl": [
+        77735.21372164521,
+        80132.13157526651
+      ],
+      "h_sum_mV": 3658444.8658119496,
+      "h_before_first_KC_sum_mV": 1155.406264898,
+      "h_never_fired_KC_sum_mV": 3625859.851666605,
+      "h_before_first_any_KC_sum_mV": 42833.48937845612,
+      "generated_h_fraction": 0.672056455733046,
+      "drive_fraction": 0.6795558504715361
+    },
+    "KC": {
+      "actual_spikes": 44,
+      "input_supported_spikes": 44,
+      "first_actual_spike_tick": 163,
+      "first_nonzero_drive_tick": 163,
+      "cumulative_drive_by_apl": [
+        33.44817268848419,
+        11.518575847148895
+      ],
+      "cumulative_state_by_apl": [
+        6554.465505840512,
+        2264.59462395615
+      ],
+      "h_sum_mV": 201702.28451626387,
+      "h_before_first_KC_sum_mV": 89.87947975468772,
+      "h_never_fired_KC_sum_mV": 199510.60338943545,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.037052717047076175,
+      "drive_fraction": 0.03012722794805037
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 33,
+    "non_design_ALPN": 653,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 30,
+    "non_design_ALPN": 252,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 163,
+  "ever_fired_KC": 41,
+  "never_fired_KC": 4023,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 5.401670932769775e-07,
+      "max_error_bound": 0.06911601698351841,
+      "max_bound_utilization": 1.1671858967238458e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.6849488019943236e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.0001787305041602849,
+      "max_error_bound": 1.7498525479468674,
+      "max_bound_utilization": 0.00011160260063818865,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.9303349175647705e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 6.86765872259798e-06,
+      "max_error_bound": 0.07496265537094228,
+      "max_bound_utilization": 0.00012084152555924595,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 4.539653019686936e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "d74f03f28213ff842de01bd0c39c562677cddcd330eda6ddb24834cced4d6088",
+    "bytes": 13487749
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "b9280e3bd3cac9d5c4fb38882adb532db8610c0c4076402b48006cc6ad554d82",
+    "bytes": 198614
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "a6b6f7f39fae9f521ecfde83a9e4e65f17a1a02773c1796ebd46a9193bcea106",
+    "bytes": 5329
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "6749efc843522b699e277cfc973d9554ca3c4ad44b98b40c3c8f308e309aff3a",
+    "bytes": 112861
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "103a4241a0af3f2d8c653b4dbb7ab1e12e7dc5778c1a9acb8e3fa060fc664d92",
+    "bytes": 525750
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "ed5509b4aae6a0d2a97ae42e947c4cca8f0be84c0655b7e6247bd22f5ebda202",
+    "bytes": 762338
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "1afdb16cb2e5990a916176430d7cffc7485a4157ef368a45e0dd65f7268c543d",
+    "bytes": 25078
+  },
+  {
+    "path": "summary.json",
+    "sha256": "0c766c6e33857f7b47426b2dd1d88bad7237b32f7c20e3342f8d356628b84fc9",
+    "bytes": 47656
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 29904,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 445,
+      "input_supported_spikes": 418,
+      "first_actual_spike_tick": 11,
+      "first_nonzero_drive_tick": 30,
+      "cumulative_drive_by_apl": [
+        185.92834132909775,
+        226.22321923077106
+      ],
+      "cumulative_state_by_apl": [
+        29329.59688634719,
+        34626.51850669924
+      ],
+      "h_sum_mV": 1484742.9453944664,
+      "h_before_first_KC_sum_mV": 907.3161503197625,
+      "h_never_fired_KC_sum_mV": 1463487.064787962,
+      "h_before_first_any_KC_sum_mV": 19892.59861073717,
+      "generated_h_fraction": 0.2810608993051706,
+      "drive_fraction": 0.28277538947320885
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4678,
+      "input_supported_spikes": 2510,
+      "first_actual_spike_tick": 85,
+      "first_nonzero_drive_tick": 85,
+      "cumulative_drive_by_apl": [
+        511.87182132154703,
+        466.98562353104353
+      ],
+      "cumulative_state_by_apl": [
+        79732.09712535384,
+        71465.64203849995
+      ],
+      "h_sum_mV": 3497502.3642505845,
+      "h_before_first_KC_sum_mV": 1736.0020869682562,
+      "h_never_fired_KC_sum_mV": 3447308.0939586423,
+      "h_before_first_any_KC_sum_mV": 32799.579931494205,
+      "generated_h_fraction": 0.6620749826543633,
+      "drive_fraction": 0.6715898268853796
+    },
+    "KC": {
+      "actual_spikes": 66,
+      "input_supported_spikes": 66,
+      "first_actual_spike_tick": 176,
+      "first_nonzero_drive_tick": 176,
+      "cumulative_drive_by_apl": [
+        37.4152347445488,
+        29.098500162363052
+      ],
+      "cumulative_state_by_apl": [
+        7333.0561394091055,
+        5677.627416899851
+      ],
+      "h_sum_mV": 300392.5423827435,
+      "h_before_first_KC_sum_mV": 216.32254433944797,
+      "h_never_fired_KC_sum_mV": 296075.84997025825,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.05686411804046623,
+      "drive_fraction": 0.0456347836414116
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 33,
+    "non_design_ALPN": 653,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 30,
+    "non_design_ALPN": 252,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 176,
+  "ever_fired_KC": 63,
+  "never_fired_KC": 4001,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 4.209578037261963e-07,
+      "max_error_bound": 0.0600218065876908,
+      "max_bound_utilization": 1.0086247798441981e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.5832483768463135e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 9.172264907419958e-05,
+      "max_error_bound": 1.7203846514497718,
+      "max_bound_utilization": 6.369164458616535e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.8401427928430164e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 4.619876821543301e-06,
+      "max_error_bound": 0.07722541917323043,
+      "max_bound_utilization": 7.277787345949282e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.1024910460186217e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "e11714c8303fab203ad936d8a2a57dede3d45a36eccd5ec8433225a46af6e87c",
+    "bytes": 13651401
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "17af86eec5cb3e736ef9608d0aad291fe5f8e81b72f0a0155f3c308daf7a72c9",
+    "bytes": 194938
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "7138acb697bb9d0a8ceb06ac374fcd7cd3c1b4e35f46a48e3b038ed49eebc68b",
+    "bytes": 5334
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "f51d252ade1e58e85daf2f3a26462f156deb20171894cc1f7ec402899a2361ff",
+    "bytes": 114518
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "7d07e478c67fc444c2dc5a32dab6b9d35b50c76bb491475202ccb7cef8994010",
+    "bytes": 526974
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "40abcae883b058e667da283ebc0a0f7256ccbba4dc29af5181ec338324b22142",
+    "bytes": 770847
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "cf9efaf0a40878ce2b9233a64903b4a90872454b24e403f38ac4b3fe30dd26f7",
+    "bytes": 24971
+  },
+  {
+    "path": "summary.json",
+    "sha256": "21fa105a946c4f996360fc24de68b8d81724ae39a9a744def402aa8d5362c658",
+    "bytes": 47776
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 30972,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 460,
+      "input_supported_spikes": 433,
+      "first_actual_spike_tick": 1,
+      "first_nonzero_drive_tick": 1,
+      "cumulative_drive_by_apl": [
+        186.8143856227398,
+        239.67498250305653
+      ],
+      "cumulative_state_by_apl": [
+        29704.251645852328,
+        37133.48614659674
+      ],
+      "h_sum_mV": 1552783.7247321885,
+      "h_before_first_KC_sum_mV": 734.8257287706468,
+      "h_never_fired_KC_sum_mV": 1536515.261551317,
+      "h_before_first_any_KC_sum_mV": 23596.619781185007,
+      "generated_h_fraction": 0.2862992352979797,
+      "drive_fraction": 0.28581260582054385
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4851,
+      "input_supported_spikes": 2596,
+      "first_actual_spike_tick": 62,
+      "first_nonzero_drive_tick": 62,
+      "cumulative_drive_by_apl": [
+        519.4031979627907,
+        492.90241945162416
+      ],
+      "cumulative_state_by_apl": [
+        81275.2373178968,
+        75601.95963638312
+      ],
+      "h_sum_mV": 3630633.3795507997,
+      "h_before_first_KC_sum_mV": 1423.2112637743483,
+      "h_never_fired_KC_sum_mV": 3591357.643284351,
+      "h_before_first_any_KC_sum_mV": 38623.92319555157,
+      "generated_h_fraction": 0.6694091029270604,
+      "drive_fraction": 0.6783984033914966
+    },
+    "KC": {
+      "actual_spikes": 54,
+      "input_supported_spikes": 54,
+      "first_actual_spike_tick": 161,
+      "first_nonzero_drive_tick": 161,
+      "cumulative_drive_by_apl": [
+        34.93833811581135,
+        18.4659686088562
+      ],
+      "cumulative_state_by_apl": [
+        6840.3149181475665,
+        3613.856921666507
+      ],
+      "h_sum_mV": 240221.98827712343,
+      "h_before_first_KC_sum_mV": 125.48953627808658,
+      "h_never_fired_KC_sum_mV": 237470.16232488502,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.04429166177496,
+      "drive_fraction": 0.03578899078795958
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 33,
+    "non_design_ALPN": 653,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 30,
+    "non_design_ALPN": 252,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 161,
+  "ever_fired_KC": 50,
+  "never_fired_KC": 4014,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 4.209578037261963e-07,
+      "max_error_bound": 0.05597993306579937,
+      "max_bound_utilization": 1.1397805383644332e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.8166378140449524e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.00010890142726793783,
+      "max_error_bound": 1.7706345183044607,
+      "max_bound_utilization": 7.293931535496436e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.7494741492724295e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 5.316641217945062e-06,
+      "max_error_bound": 0.07633156439237752,
+      "max_bound_utilization": 8.278656147439621e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 3.149739747209693e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "d35fcd607930571fd30ac222680a08b5225fab1d8f989e7632a0c61bc967623e",
+    "bytes": 13742429
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "953d7de18bd0c691521154a5f88cb375ba10eec7e179cbee9eb890296b5727d8",
+    "bytes": 199890
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "e0c0c0a30966507d0dba0ac5cff471b87c4eddce4797f78cf49480a8ee210d62",
+    "bytes": 5328
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "f1e63ebc9c6d4895cf8033d5bed75bdf0c9751d22a48e4655b31a3d16b564f4f",
+    "bytes": 113360
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "c96b33d91ddeba904b929cd979f9d57fe34823c4dec5ba7b45b55ab38f1f0dce",
+    "bytes": 528255
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "b257e539df1fbaeb88cb994660ed7b3866388a8dde0b0371bda6c7b6c8953134",
+    "bytes": 772201
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "0f9a400791f1cea36a3e3d29be68cf9fb49aeb79677f985976dea6ef1f227435",
+    "bytes": 25205
+  },
+  {
+    "path": "summary.json",
+    "sha256": "a0a7968d5e12198a9990317c2448a5b8de42053afa45037d697b6da140b42fca",
+    "bytes": 47654
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 31685,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 506,
+      "input_supported_spikes": 468,
+      "first_actual_spike_tick": 2,
+      "first_nonzero_drive_tick": 2,
+      "cumulative_drive_by_apl": [
+        112.32625231519341,
+        145.51263842731714
+      ],
+      "cumulative_state_by_apl": [
+        17913.40839036574,
+        22783.387543194516
+      ],
+      "h_sum_mV": 945682.9232569406,
+      "h_before_first_KC_sum_mV": 641.768768647648,
+      "h_never_fired_KC_sum_mV": 935548.5907393516,
+      "h_before_first_any_KC_sum_mV": 27133.54446878606,
+      "generated_h_fraction": 0.1771250674493472,
+      "drive_fraction": 0.17571257920205247
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4730,
+      "input_supported_spikes": 2511,
+      "first_actual_spike_tick": 86,
+      "first_nonzero_drive_tick": 91,
+      "cumulative_drive_by_apl": [
+        559.7383508011699,
+        597.5966087915003
+      ],
+      "cumulative_state_by_apl": [
+        86650.62796819997,
+        92761.0997077314
+      ],
+      "h_sum_mV": 4159763.606901722,
+      "h_before_first_KC_sum_mV": 1822.9591379519231,
+      "h_never_fired_KC_sum_mV": 4113345.572116404,
+      "h_before_first_any_KC_sum_mV": 46675.00276130395,
+      "generated_h_fraction": 0.7791178113994772,
+      "drive_fraction": 0.7887030159225047
+    },
+    "KC": {
+      "actual_spikes": 51,
+      "input_supported_spikes": 51,
+      "first_actual_spike_tick": 184,
+      "first_nonzero_drive_tick": 184,
+      "cumulative_drive_by_apl": [
+        38.542927265167236,
+        13.673274457454681
+      ],
+      "cumulative_state_by_apl": [
+        7529.091075247245,
+        2682.4283476507144
+      ],
+      "h_sum_mV": 233622.28079537954,
+      "h_before_first_KC_sum_mV": 206.88214926748057,
+      "h_never_fired_KC_sum_mV": 230391.5525653161,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.04375712115117569,
+      "drive_fraction": 0.03558440487544279
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 44,
+    "non_design_ALPN": 642,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 40,
+    "non_design_ALPN": 242,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 184,
+  "ever_fired_KC": 48,
+  "never_fired_KC": 4016,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 2.905726432800293e-07,
+      "max_error_bound": 0.06568042837432471,
+      "max_bound_utilization": 1.0810616850431653e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.6184523701667786e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.0001542923027670895,
+      "max_error_bound": 1.7135104051979253,
+      "max_bound_utilization": 9.283692562232882e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.1015675074436247e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 6.101642446409983e-06,
+      "max_error_bound": 0.07670476128519117,
+      "max_bound_utilization": 0.00010036286022925243,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.425265845268999e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
@@ -0,0 +1,42 @@
+[
+  {
+    "path": "accepted-prefirst-edge-events.parquet",
+    "sha256": "d113735ea826fec1da6db1200d71b514dd2532ac41b83b9d9ebd1df78b712cd9",
+    "bytes": 13545883
+  },
+  {
+    "path": "apl-per-tick.parquet",
+    "sha256": "354a3f50e7cf71489f6b9d42c15632561da339537ae6c30a386f8aa2dc9e99bc",
+    "bytes": 200845
+  },
+  {
+    "path": "apl-source-summary.json",
+    "sha256": "cfea1561fbc398b8a63437b0bada60d956ced986673e06ce0e331da5b1fb14b5",
+    "bytes": 5329
+  },
+  {
+    "path": "per-kc-apl-sources.parquet",
+    "sha256": "f068aca8cb7bdbb6c7151997774aca539cb6151f787a860b85e356025c094ef1",
+    "bytes": 113124
+  },
+  {
+    "path": "per-pn.parquet",
+    "sha256": "2af3e52b9345544af22665f5ba728a451e6b77c811a4ce48fcd56005854d219f",
+    "bytes": 527978
+  },
+  {
+    "path": "prefirst-edge-summary.parquet",
+    "sha256": "e3f0b79a312daa4a5d8edec2185eb4a82ee6deef979564d37e3a21cb9c1daae8",
+    "bytes": 754940
+  },
+  {
+    "path": "replay-final.npz",
+    "sha256": "7469c6335422ac373658d34fc5853dba53d60ee5bdac1067a4e10037418c6a7c",
+    "bytes": 25116
+  },
+  {
+    "path": "summary.json",
+    "sha256": "967d0f9cfbd66d1fcf35f9d03da4799b8a23327972723be74aebc0961129c1aa",
+    "bytes": 47820
+  }
+]
@@ -0,0 +1,153 @@
+{
+  "pass_all": true,
+  "steps": 1000,
+  "neurons": 166700,
+  "apl": 2,
+  "bundle_KC": 4064,
+  "actual_events": 31685,
+  "groups": {
+    "design_ALPN": {
+      "actual_spikes": 506,
+      "input_supported_spikes": 468,
+      "first_actual_spike_tick": 2,
+      "first_nonzero_drive_tick": 2,
+      "cumulative_drive_by_apl": [
+        112.32625231519341,
+        145.51263842731714
+      ],
+      "cumulative_state_by_apl": [
+        17913.40839036574,
+        22783.387543194516
+      ],
+      "h_sum_mV": 945682.9232569406,
+      "h_before_first_KC_sum_mV": 641.768768647648,
+      "h_never_fired_KC_sum_mV": 935548.5907393516,
+      "h_before_first_any_KC_sum_mV": 27133.54446878606,
+      "generated_h_fraction": 0.1771250674493472,
+      "drive_fraction": 0.17571257920205247
+    },
+    "non_design_ALPN": {
+      "actual_spikes": 4730,
+      "input_supported_spikes": 2511,
+      "first_actual_spike_tick": 86,
+      "first_nonzero_drive_tick": 91,
+      "cumulative_drive_by_apl": [
+        559.7383508011699,
+        597.5966087915003
+      ],
+      "cumulative_state_by_apl": [
+        86650.62796819997,
+        92761.0997077314
+      ],
+      "h_sum_mV": 4159763.606901722,
+      "h_before_first_KC_sum_mV": 1822.9591379519231,
+      "h_never_fired_KC_sum_mV": 4113345.572116404,
+      "h_before_first_any_KC_sum_mV": 46675.00276130395,
+      "generated_h_fraction": 0.7791178113994772,
+      "drive_fraction": 0.7887030159225047
+    },
+    "KC": {
+      "actual_spikes": 51,
+      "input_supported_spikes": 51,
+      "first_actual_spike_tick": 184,
+      "first_nonzero_drive_tick": 184,
+      "cumulative_drive_by_apl": [
+        38.542927265167236,
+        13.673274457454681
+      ],
+      "cumulative_state_by_apl": [
+        7529.091075247245,
+        2682.4283476507144
+      ],
+      "h_sum_mV": 233622.28079537954,
+      "h_before_first_KC_sum_mV": 206.88214926748057,
+      "h_never_fired_KC_sum_mV": 230391.5525653161,
+      "h_before_first_any_KC_sum_mV": 0.0,
+      "generated_h_fraction": 0.04375712115117569,
+      "drive_fraction": 0.03558440487544279
+    }
+  },
+  "group_order": [
+    "design_ALPN",
+    "non_design_ALPN",
+    "KC"
+  ],
+  "input_support_partition_exact": true,
+  "unknown_nonzero_input_columns": 0,
+  "source_population_counts": {
+    "design_ALPN": 44,
+    "non_design_ALPN": 642,
+    "KC": 4064
+  },
+  "input_supported_population_counts": {
+    "design_ALPN": 40,
+    "non_design_ALPN": 242,
+    "KC": 4063
+  },
+  "first_any_KC_spike_tick": 184,
+  "ever_fired_KC": 48,
+  "never_fired_KC": 4016,
+  "decay_f32_bits": "3f7eb923",
+  "gain_f32_bits": "3c23d70a",
+  "comparison": {
+    "drive": {
+      "elements": 2000,
+      "max_abs_error": 2.905726432800293e-07,
+      "max_error_bound": 0.06568042837432471,
+      "max_bound_utilization": 1.0810616850431653e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 1.6184523701667786e-08
+    },
+    "state": {
+      "elements": 2000,
+      "max_abs_error": 0.0001542923027670895,
+      "max_error_bound": 1.7135104051979253,
+      "max_bound_utilization": 9.283692562232882e-05,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.1015675074436247e-05
+    },
+    "inhibition": {
+      "elements": 4064000,
+      "max_abs_error": 6.101642446409983e-06,
+      "max_error_bound": 0.07670476128519117,
+      "max_bound_utilization": 0.00010036286022925243,
+      "bound_violations": 0,
+      "zero_reference_nonzero_actual": 0,
+      "mean_abs_error": 2.425265845268999e-07
+    }
+  },
+  "theoretical_bound": {
+    "applicable": true,
+    "normal_or_zero_arithmetic": true,
+    "historical_standard_fp32_verified_by_caller": true,
+    "gamma_definition": "gamma_n=n*u/(1-n*u); u32=2^-24,u64=2^-53; outward rounded",
+    "drive_terms_bound": 166699,
+    "state_operation_bound": 2,
+    "output_operation_bound": 5,
+    "group_sum_operation_bound": 2,
+    "state_recurrence": "E_p<=d*E_p_prev+gamma_2,p*(d*abs(s_p_prev)+D_upper)+(1+u_p)*gamma_(N-1),p*D_upper",
+    "grouped_f64_bound": "Sum source-group error bounds, plus gamma_2,64*upward_sum(group_values) for per-tick compared drive/state/h totals only",
+    "output_bound": "q*upward_dot(E_p,O)+gamma_5,p*q*upward_dot(s_p,O); f32 error plus all f64 group/output/sum errors",
+    "tolerance_fitted_to_observed_error": false,
+    "scope": "Per-tick summed-source drive/state/h trace comparisons only; not cumulative source fractions"
+  },
+  "early_definition": "strict tick<each observed first KC spike; never-fired columns separate; same-tick end APL excluded",
+  "value_units": {
+    "drive64": "legacy normalized-contact spike drive",
+    "state64": "legacy normalized-drive accumulator",
+    "h": "legacy mV per state-update step; sums span output KC and recorded ticks, not instantaneous conductance"
+  },
+  "generated_full_bundle_trace": true,
+  "fixture_absent_KC_output_is_not_claimed_applied": true,
+  "row_source_spikes_repeated_for_each_APL": true,
+  "nonfeedback": true,
+  "CUDA_float32_bitwise_replay": false,
+  "cumulative_and_fraction_metrics_descriptive_float64": true,
+  "cumulative_source_fraction_error_bounds_verified": false,
+  "source_majority_robustness_proven": false,
+  "independent_brain_oracle": false,
+  "lesion_or_counterfactual": false,
+  "parameters_changed": false
+}
--- a/Show More
+++ b/Show More