Add selective real imaging pilots and standalone benchmark client

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+assets/dandi-000715-sub-56-YAaDV/reference.nwb filter=lfs diff=lfs merge=lfs -text

LICENSE-code.txt

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 WormTrack-Verify contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

assets/ascent-opterra/pilot.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a2e44df9e5f6f0a2b9273fc95cc7c3100ce19f547226deee34edb59f54cc93e6
+size 17810930

assets/dandi-000541-sub-20190924-01/pilot.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b9a74b74140fd2b5a20af8bc3d1d1da5045a60dc39f2e20012425b2fd8eca9a7
+size 250230

assets/dandi-000715-sub-56-YAaDV/reference.nwb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8fac20135945a039301002a68fbc12b5384b36642f26d60f81bc7ecbaf2aa009
+size 77073624

assets/nerve-al-w1-via-zephir/annotations.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1b4531260e8cace262c6caf517a13d565c431bbc071df7fb297209fa30757b7
+size 3887104

assets/nerve-al-w1-via-zephir/metadata.json

@@ -0,0 +1,19 @@
+{
+    "shape_t": 1536,
+    "shape_c": 2,
+    "shape_z": 33,
+    "shape_y": 600,
+    "shape_x": 600,
+    "t_ref_fn1536": [
+        412,
+        539,
+        182,
+        908,
+        1246,
+        489,
+        270,
+        690,
+        808,
+        1260
+    ]
+}

assets/nerve-al-w1-via-zephir/worldlines.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e919f281c5448f613713abe297206ffcff1d981498a068bad954e822c2c3b8a4
+size 3568

assets/targettrack-epfl10/pilot.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c79b0601b33363893040cac97976ec29abc11b09dd60ad5be704a23fc31376ea
+size 465651

assets/zephir-zm9624/annotations.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8b91f55ce566146ab7cc75f5f1c32bc5e83cc080fa3d64caa165a28e0fd0456
+size 6041856

assets/zephir-zm9624/metadata.json

@@ -0,0 +1,22 @@
+{
+    "shape_t": 1060,
+    "shape_c": 2,
+    "shape_z": 23,
+    "shape_y": 512,
+    "shape_x": 512,
+    "dtype": "np.uint8",
+    "t_ref": [
+        498,
+        444,
+        463
+    ],
+    "t_ref_fn1060": [
+        271,
+        640,
+        764,
+        149,
+        1038,
+        95,
+        806
+    ]
+}

assets/zephir-zm9624/pilot.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c14ab5c0dca0a0b2064fe860a22afc4791db64546897f3f208616b0831143f81
+size 786338

assets/zephir-zm9624/timestamps_s.json

@@ -0,0 +1 @@
+[1631827565.191196, 1631827565.4415264, 1631827565.6868942, 1631827565.9392192, 1631827566.1925423, 1631827566.4319212, 1631827566.697213, 1631827566.9345777, 1631827567.1829135, 1631827567.443218, 1631827567.6845732, 1631827567.9449098, 1631827568.1882596, 1631827568.4455714, 1631827568.693908, 1631827568.9342654, 1631827569.196564, 1631827569.443903, 1631827569.6912696, 1631827569.943595, 1631827570.1939259, 1631827570.4412646, 1631827570.6846142, 1631827570.949905, 1631827571.1922803, 1631827571.4426107, 1631827571.6839657, 1631827571.95225, 1631827572.1896143, 1631827572.4489617, 1631827572.6893198, 1631827572.9496245, 1631827573.1919754, 1631827573.4503264, 1631827573.6876915, 1631827573.9499905, 1631827574.192342, 1631827574.4456851, 1631827574.6920266, 1631827574.9493387, 1631827575.1887298, 1631827575.436069, 1631827575.687398, 1631827575.935733, 1631827576.1860638, 1631827576.4373922, 1631827576.6897173, 1631827576.9380538, 1631827577.1933708, 1631827577.4387155, 1631827577.689046, 1631827577.9374006, 1631827578.2036886, 1631827578.446041, 1631827578.6933799, 1631827578.950692, 1631827579.1970334, 1631827579.4473963, 1631827579.6887512, 1631827579.9510503, 1631827580.1953967, 1631827580.4487193, 1631827580.6890957, 1631827580.9394264, 1631827581.1937482, 1631827581.4510586, 1631827581.690419, 1631827581.9487514, 1631827582.1901069, 1631827582.4404368, 1631827582.6947572, 1631827582.9531088, 1631827583.1934557, 1631827583.4517653, 1631827583.6971092, 1631827583.9454458, 1631827584.2017803, 1631827584.444132, 1631827584.700476, 1631827584.950807, 1631827585.2061245, 1631827585.4474788, 1631827585.7057889, 1631827585.944177, 1631827586.2024863, 1631827586.4428437, 1631827586.7031717, 1631827586.9485161, 1631827587.2018385, 1631827587.4432156, 1631827587.691552, 1631827587.9438894, 1631827588.1942315, 1631827588.4545357, 1631827588.7018747, 1631827588.9512367, 1631827589.2065544, 1631827589.450901, 1631827589.704224, 1631827589.9475732, 1631827590.1969256, 1631827590.4532406, 1631827590.702574, 1631827590.9439292, 1631827591.1952572, 1631827591.4615636, 1631827591.7029192, 1631827591.9602306, 1631827592.199591, 1631827592.4539108, 1631827592.6952655, 1631827592.9496064, 1631827593.212901, 1631827593.4522614, 1631827593.7065814, 1631827593.9529226, 1631827594.1962917, 1631827594.4466226, 1631827594.6959558, 1631827594.9462864, 1631827595.2115777, 1631827595.4459507, 1631827595.6963007, 1631827595.9576025, 1631827596.202946, 1631827596.456269, 1631827596.6966267, 1631827596.9609509, 1631827597.2033033, 1631827597.44765, 1631827597.707954, 1631827597.9592822, 1631827598.2056239, 1631827598.4539597, 1631827598.711272, 1631827598.9546218, 1631827599.210936, 1631827599.4572778, 1631827599.699662, 1631827599.9609635, 1631827600.2063074, 1631827600.4576356, 1631827600.7049744, 1631827600.966276, 1631827601.2076557, 1631827601.459982, 1631827601.7053256, 1631827601.9656296, 1631827602.2019978, 1631827602.457336, 1631827602.710659, 1631827602.9570007, 1631827603.20035, 1631827603.4606538, 1631827603.710985, 1631827603.9593453, 1631827604.207682, 1631827604.457015, 1631827604.716322, 1631827604.957677, 1631827605.2050345, 1631827605.453371, 1631827605.7106826, 1631827605.9580214, 1631827606.2023683, 1631827606.4636905, 1631827606.7080371, 1631827606.9623575, 1631827607.2116907, 1631827607.45504, 1631827607.7193336, 1631827607.9527323, 1631827608.2040606, 1631827608.4693515, 1631827608.7087116, 1631827608.9660237, 1631827609.2153795, 1631827609.4637156, 1631827609.7040732, 1631827609.9683676, 1631827610.209721, 1631827610.4610674, 1631827610.7034197, 1631827610.954748, 1631827611.205596, 1631827611.4619105, 1631827611.7172282, 1631827611.9675975, 1631827612.2079551, 1631827612.467262, 1631827612.7156165, 1631827612.9599645, 1631827613.218273, 1631827613.46262, 1631827613.7159424, 1631827613.9562998, 1631827614.217601, 1631827614.4629452, 1631827614.7132978, 1631827614.9626312, 1631827615.214957, 1631827615.4642904, 1631827615.7176127, 1631827615.9629571, 1631827616.2128122, 1631827616.4651377, 1631827616.7075124, 1631827616.965822, 1631827617.222137, 1631827617.4635108, 1631827617.7078576, 1631827617.957191, 1631827618.2095163, 1631827618.4728134, 1631827618.7091808, 1631827618.9715102, 1631827619.2158568, 1631827619.459206, 1631827619.7225025, 1631827619.9668493, 1631827620.2092311, 1631827620.4615571, 1631827620.71089, 1631827620.9632154, 1631827621.2105541, 1631827621.459906, 1631827621.716221, 1631827621.9735336, 1631827622.2188768, 1631827622.467242, 1631827622.715578, 1631827622.9599473, 1631827623.212273, 1631827623.4745715, 1631827623.7149293, 1631827623.9742355, 1631827624.2176118, 1631827624.4619584, 1631827624.7132866, 1631827624.975586, 1631827625.22093, 1631827625.4662738, 1631827625.7236054, 1631827625.9629655, 1631827626.2282565, 1631827626.4706101, 1631827626.7119634, 1631827626.9633367, 1631827627.2276304, 1631827627.466991, 1631827627.7282915, 1631827627.9636624, 1631827628.2309477, 1631827628.4663186, 1631827628.723631, 1631827628.9759562, 1631827629.2252898, 1631827629.4636526, 1631827629.7159977, 1631827629.964334, 1631827630.2146647, 1631827630.4809527, 1631827630.7243292, 1631827630.9646864, 1631827631.2279825, 1631827631.4643507, 1631827631.7156787, 1631827631.9660292, 1631827632.2173574, 1631827632.4686852, 1631827632.7180188, 1631827632.9833097, 1631827633.2157207, 1631827633.479017, 1631827633.7193744, 1631827633.9667447, 1631827634.2280462, 1631827634.4703984, 1631827634.732697, 1631827634.9730544, 1631827635.223405, 1631827635.4667542, 1631827635.7310681, 1631827635.9744172, 1631827636.2287579, 1631827636.4701126, 1631827636.7264493, 1631827636.9717724, 1631827637.2340703, 1631827637.4704382, 1631827637.7327375, 1631827637.970124, 1631827638.2194574, 1631827638.4677937, 1631827638.7271001, 1631827638.9764338, 1631827639.2188094, 1631827639.4701378, 1631827639.7194712, 1631827639.9757857, 1631827640.2201326, 1631827640.489436, 1631827640.7218149, 1631827640.9711483, 1631827641.2384338, 1631827641.4708323, 1631827641.7211633, 1631827641.9745052, 1631827642.2328146, 1631827642.4751668, 1631827642.7374656, 1631827642.9818122, 1631827643.2212029, 1631827643.4795122, 1631827643.7218642, 1631827643.986158, 1631827644.2265153, 1631827644.4768665, 1631827644.7301896, 1631827644.9795232, 1631827645.2308512, 1631827645.4742007, 1631827645.7295182, 1631827645.9848354, 1631827646.2282186, 1631827646.4785495, 1631827646.7348645, 1631827646.9792113, 1631827647.2305396, 1631827647.4759023, 1631827647.7242382, 1631827647.9825664, 1631827648.235889, 1631827648.4772441, 1631827648.726577, 1631827648.9859102, 1631827649.2332492, 1631827649.4756014, 1631827649.7249346, 1631827649.9752655, 1631827650.2365873, 1631827650.477942, 1631827650.734276, 1631827650.9816146, 1631827651.2249641, 1631827651.476315, 1631827651.730635, 1631827651.983958, 1631827652.2273076, 1631827652.4806306, 1631827652.734969, 1631827652.988292, 1631827653.2346332, 1631827653.4829698, 1631827653.7293108, 1631827653.9886174, 1631827654.2339928, 1631827654.485321, 1631827654.7356513, 1631827654.9849846, 1631827655.227337, 1631827655.4846687, 1631827655.7419808, 1631827655.9843328, 1631827656.236658, 1631827656.4849944, 1631827656.7393143, 1631827656.9836812, 1631827657.2300224, 1631827657.4793558, 1631827657.7276921, 1631827657.989991, 1631827658.2283823, 1631827658.4926782, 1631827658.7330334, 1631827658.9803722, 1631827659.242671, 1631827659.4810338, 1631827659.7333786, 1631827659.9936826, 1631827660.23404, 1631827660.4883597, 1631827660.74268, 1631827660.990041, 1631827661.2353852, 1631827661.4877107, 1631827661.7300632, 1631827661.993359, 1631827662.2397008, 1631827662.4860618, 1631827662.7453692, 1631827662.9857264, 1631827663.2330894, 1631827663.4834204, 1631827663.745742, 1631827663.9870965, 1631827664.2384248, 1631827664.4827912, 1631827664.743095, 1631827664.98445, 1631827665.2467706, 1631827665.4841359, 1631827665.7474322, 1631827665.9818332, 1631827666.248121, 1631827666.4855187, 1631827666.7448256, 1631827666.9901693, 1631827667.2424948, 1631827667.4868417, 1631827667.7451513, 1631827667.9835374, 1631827668.2483368, 1631827668.486699, 1631827668.747003, 1631827668.9903524, 1631827669.2426984, 1631827669.4960213, 1631827669.7423632, 1631827669.9936912, 1631827670.2390354, 1631827670.4953501, 1631827670.744713, 1631827670.9950435, 1631827671.2453744, 1631827671.4867291, 1631827671.73706, 1631827671.9963858, 1631827672.2427275, 1631827672.4850793, 1631827672.7374046, 1631827672.9947364, 1631827673.236091, 1631827673.496395, 1631827673.741739, 1631827673.9870832, 1631827674.237414, 1631827674.4957235, 1631827674.7440786, 1631827674.996404, 1631827675.2487297, 1631827675.495071, 1631827675.7374234, 1631827675.999734, 1631827676.2430944, 1631827676.501405, 1631827676.7437563, 1631827677.0000713, 1631827677.2374368, 1631827677.4957666, 1631827677.738118, 1631827678.003409, 1631827678.2457845, 1631827678.4961152, 1631827678.7394898, 1631827679.0007913, 1631827679.2381568, 1631827679.499458, 1631827679.7438262, 1631827679.9981463, 1631827680.2435114, 1631827680.497831, 1631827680.749159, 1631827680.9945037, 1631827681.2518344, 1631827681.492192, 1631827681.77344, 1631827681.9918563, 1631827682.2431843, 1631827682.4995189, 1631827682.7508473, 1631827682.9951956, 1631827683.2535036, 1631827683.4958563, 1631827683.751173, 1631827684.0005066, 1631827684.244873, 1631827684.4981952, 1631827684.7505212, 1631827685.0048418, 1631827685.2521803, 1631827685.4995189, 1631827685.7518716, 1631827686.0022023, 1631827686.249541, 1631827686.504859, 1631827686.7472389, 1631827686.9925826, 1631827687.241916, 1631827687.493244, 1631827687.7605295, 1631827687.9929085, 1631827688.2512176, 1631827688.4975598, 1631827688.7429037, 1631827688.996226, 1631827689.2475543, 1631827689.4938958, 1631827689.7492135, 1631827690.0015388, 1631827690.2448883, 1631827690.504195, 1631827690.7465472, 1631827690.9938858, 1631827691.245214, 1631827691.4955451, 1631827691.7448783, 1631827691.9952092, 1631827692.24554, 1631827692.4958704, 1631827692.7462015, 1631827692.9975297, 1631827693.2458656, 1631827693.4961963, 1631827693.7485218, 1631827693.9978552, 1631827694.2461913, 1631827694.4965224, 1631827694.749845, 1631827694.9971838, 1631827695.2465174, 1631827695.4958508, 1631827695.7581496, 1631827695.998507, 1631827696.2468429, 1631827696.4991946, 1631827696.7485278, 1631827696.9998555, 1631827697.248192, 1631827697.4975255, 1631827697.7468781, 1631827697.9982066, 1631827698.2485373, 1631827698.4988682, 1631827698.7521908, 1631827698.9985323, 1631827699.2498825, 1631827699.4992154, 1631827699.749546, 1631827699.9988797, 1631827700.2492106, 1631827700.4995415, 1631827700.750901, 1631827701.0012317, 1631827701.2495675, 1631827701.501893, 1631827701.7512267, 1631827702.00056, 1631827702.251888, 1631827702.501222, 1631827702.7505548, 1631827703.001883, 1631827703.2512167, 1631827703.5015473, 1631827703.7518785, 1631827704.001212, 1631827704.2515426, 1631827704.5028715, 1631827704.752204, 1631827705.0035322, 1631827705.2528658, 1631827705.505191, 1631827705.7515326, 1631827706.0068507, 1631827706.2771282, 1631827706.5055172, 1631827706.7568455, 1631827707.0031867, 1631827707.2525198, 1631827707.5038488, 1631827707.7821045, 1631827708.0084991, 1631827708.2548406, 1631827708.5041742, 1631827708.7545047, 1631827709.00683, 1631827709.2551663, 1631827709.5064948, 1631827709.755828, 1631827710.006159, 1631827710.254495, 1631827710.505823, 1631827710.7581487, 1631827711.0075095, 1631827711.2558453, 1631827711.5081716, 1631827711.756507, 1631827712.006838, 1631827712.261158, 1631827712.5074995, 1631827712.756833, 1631827713.008161, 1631827713.2554998, 1631827713.5058308, 1631827713.7591538, 1631827714.0074894, 1631827714.256823, 1631827714.5071537, 1631827714.7564871, 1631827715.0088131, 1631827715.2561514, 1631827715.5094743, 1631827715.7588081, 1631827716.008141, 1631827716.257475, 1631827716.5098002, 1631827716.7571387, 1631827717.0104623, 1631827717.2647817, 1631827717.5091288, 1631827717.7594595, 1631827718.0107875, 1631827718.2581265, 1631827718.5393746, 1631827718.7607832, 1631827719.0151026, 1631827719.2704203, 1631827719.5127726, 1631827719.7730765, 1631827720.0084472, 1631827720.27374, 1631827720.5170872, 1631827720.7694132, 1631827721.0197437, 1631827721.2591038, 1631827721.5204055, 1631827721.7657495, 1631827722.0100963, 1631827722.2694032, 1631827722.516742, 1631827722.7670727, 1631827723.0233874, 1631827723.2697287, 1631827723.5190628, 1631827723.7614148, 1631827724.012743, 1631827724.2750416, 1631827724.5153992, 1631827724.7737083, 1631827725.0220447, 1631827725.2713778, 1631827725.5217087, 1631827725.7690482, 1631827726.012397, 1631827726.2786846, 1631827726.5160506, 1631827726.763389, 1631827727.0246909, 1631827727.270035, 1631827727.5233576, 1631827727.7706966, 1631827728.02003, 1631827728.2633798, 1631827728.5137103, 1631827728.764041, 1631827729.030329, 1631827729.2726812, 1631827729.5260043, 1631827729.7743404, 1631827730.014698, 1631827730.2660258, 1631827730.523338, 1631827730.7636957, 1631827731.0160208, 1631827731.2783196, 1631827731.520672, 1631827731.774992, 1631827732.0263202, 1631827732.273659, 1631827732.5259843, 1631827732.7663417, 1631827733.0276432, 1631827733.2759793, 1631827733.5263102, 1631827733.7666678, 1631827734.0319583, 1631827734.2713187, 1631827734.5166626, 1631827734.7809565, 1631827735.0173242, 1631827735.2676551, 1631827735.5279593, 1631827735.7673192, 1631827736.0336075, 1631827736.273965, 1631827736.5282853, 1631827736.7756238, 1631827737.0289466, 1631827737.2673097, 1631827737.5355933, 1631827737.772958, 1631827738.0183017, 1631827738.2815988, 1631827738.5229537, 1631827738.7762756, 1631827739.0186276, 1631827739.2779346, 1631827739.5222812, 1631827739.7785962, 1631827740.0209482, 1631827740.2832468, 1631827740.5265963, 1631827740.7699459, 1631827741.024267, 1631827741.2815783, 1631827741.52393, 1631827741.771269, 1631827742.0345657, 1631827742.2699358, 1631827742.5332327, 1631827742.7795734, 1631827743.0259156, 1631827743.2872164, 1631827743.5275738, 1631827743.7878785, 1631827744.0282357, 1631827744.2815583, 1631827744.531889, 1631827744.779228, 1631827745.0345454, 1631827745.2759, 1631827745.532215, 1631827745.7815483, 1631827746.0229027, 1631827746.2822099, 1631827746.527554, 1631827746.7858636, 1631827747.0242262, 1631827747.2865255, 1631827747.5308719, 1631827747.7861893, 1631827748.0275447, 1631827748.2858536, 1631827748.5302005, 1631827748.7835233, 1631827749.032857, 1631827749.2742114, 1631827749.5375078, 1631827749.7808568, 1631827750.0321853, 1631827750.2835133, 1631827750.5308518, 1631827750.78218, 1631827751.0305164, 1631827751.2758605, 1631827751.5361645, 1631827751.7835035, 1631827752.0328372, 1631827752.2881544, 1631827752.5334985, 1631827752.7868214, 1631827753.030172, 1631827753.276512, 1631827753.5378134, 1631827753.7811637, 1631827754.0384753, 1631827754.282822, 1631827754.5351477, 1631827754.7864754, 1631827755.0368063, 1631827755.2841454, 1631827755.5394626, 1631827755.7838094, 1631827756.0271587, 1631827756.29245, 1631827756.5328074, 1631827756.7781518, 1631827757.043442, 1631827757.278813, 1631827757.5411117, 1631827757.7854583, 1631827758.0317998, 1631827758.280136, 1631827758.5434322, 1631827758.7827928, 1631827759.039107, 1631827759.2854488, 1631827759.5297954, 1631827759.780126, 1631827760.042425, 1631827760.2797904, 1631827760.5420895, 1631827760.7874334, 1631827761.0317807, 1631827761.29408, 1631827761.5384257, 1631827761.779781, 1631827762.0430765, 1631827762.285429, 1631827762.5467303, 1631827762.7841163, 1631827763.0354445, 1631827763.292775, 1631827763.5371218, 1631827763.7904446, 1631827764.0407758, 1631827764.2821302, 1631827764.5464242, 1631827764.7817948, 1631827765.0351174, 1631827765.282456, 1631827765.5467505, 1631827765.7881045, 1631827766.037438, 1631827766.2957473, 1631827766.5390966, 1631827766.795411, 1631827767.0397584, 1631827767.2910864, 1631827767.54145, 1631827767.7828047, 1631827768.044106, 1631827768.2874749, 1631827768.5497732, 1631827768.7861414, 1631827769.0374691, 1631827769.2848082, 1631827769.5471072, 1631827769.7934487, 1631827770.0338063, 1631827770.300127, 1631827770.542479, 1631827770.7898376, 1631827771.035182, 1631827771.3004725, 1631827771.5358434, 1631827771.7981417, 1631827772.0424886, 1631827772.2958117, 1631827772.5441477, 1631827772.7984912, 1631827773.0388489, 1631827773.3061345, 1631827773.5415053, 1631827773.801809, 1631827774.043164, 1631827774.2895055, 1631827774.5478148, 1631827774.7861779, 1631827775.0484765, 1631827775.2878368, 1631827775.5531719, 1631827775.7955241, 1631827776.0378761, 1631827776.3031666, 1631827776.5475132, 1631827776.7968469, 1631827777.041194, 1631827777.2875352, 1631827777.5478394, 1631827777.797173, 1631827778.0445118, 1631827778.2978346, 1631827778.544176, 1631827778.7905176, 1631827779.0508213, 1631827779.297163, 1631827779.5544953, 1631827779.798842, 1631827780.041194, 1631827780.2905276, 1631827780.5558186, 1631827780.7951782, 1631827781.0425367, 1631827781.3018434, 1631827781.5521743, 1631827781.7995322, 1631827782.0418847, 1631827782.2912173, 1631827782.5545413, 1631827782.8018804, 1631827783.0432348, 1631827783.291589, 1631827783.5548851, 1631827783.7992501, 1631827784.054568, 1631827784.2919333, 1631827784.5432613, 1631827784.8115437, 1631827785.048421, 1631827785.3082404, 1631827785.549595, 1631827785.8049316, 1631827786.043295, 1631827786.2936254, 1631827786.5449865, 1631827786.8042932, 1631827787.042656, 1631827787.307947, 1631827787.5493014, 1631827787.7946675, 1631827788.0569663, 1631827788.303308, 1631827788.5436654, 1631827788.7950127, 1631827789.052325, 1631827789.3166401, 1631827789.5520115, 1631827789.794363, 1631827790.0456917, 1631827790.298038, 1631827790.5563471, 1631827790.7947102, 1631827791.0639904, 1631827791.302353, 1631827791.5466998, 1631827791.7970304, 1631827792.0613244, 1631827792.3006842, 1631827792.556999, 1631827792.8113194, 1631827793.055666, 1631827793.3070123, 1631827793.5583405, 1631827793.7967036, 1631827794.0629916, 1631827794.3073385, 1631827794.5586665, 1631827794.806035, 1631827795.0473893, 1631827795.299715, 1631827795.5590217, 1631827795.8033683, 1631827796.0517244, 1631827796.299063, 1631827796.5563967, 1631827796.797752, 1631827797.0530694, 1631827797.3193753, 1631827797.5557523, 1631827797.808077, 1631827798.050429, 1631827798.3007782, 1631827798.5640748, 1631827798.8054492, 1631827799.0587723, 1631827799.3110976, 1631827799.5554445, 1631827799.8097646, 1631827800.0491366, 1631827800.316433, 1631827800.549809, 1631827800.8170943, 1631827801.060444, 1631827801.301825, 1631827801.570111, 1631827801.8044827, 1631827802.0518386, 1631827802.315135, 1631827802.552501, 1631827802.815817, 1631827803.0611613, 1631827803.3144834, 1631827803.560825, 1631827803.8031769, 1631827804.062484, 1631827804.3108451, 1631827804.5681572, 1631827804.8015335, 1631827805.059843, 1631827805.3231392, 1631827805.5585303, 1631827805.8118534, 1631827806.0542054, 1631827806.3165042, 1631827806.56087, 1631827806.81918, 1631827807.062559, 1631827807.316879, 1631827807.5652149, 1631827807.803578, 1631827808.054906, 1631827808.3042583, 1631827808.5755332, 1631827808.8109038, 1631827809.0612347, 1631827809.326526, 1631827809.561896, 1631827809.8172412, 1631827810.0635822, 1631827810.3049371, 1631827810.5732205, 1631827810.8046017, 1631827811.0569553, 1631827811.307286, 1631827811.5735753, 1631827811.8089452, 1631827812.0702472, 1631827812.3175855, 1631827812.5659213, 1631827812.8192444, 1631827813.0685778, 1631827813.3089545, 1631827813.5662663, 1631827813.815619, 1631827814.0599663, 1631827814.3102965, 1631827814.5696223, 1631827814.815964, 1631827815.0673194, 1631827815.3086743, 1631827815.568978, 1631827815.818312, 1631827816.0666482, 1631827816.324987, 1631827816.5653448, 1631827816.8276434, 1631827817.070993, 1631827817.3153396, 1631827817.5746462, 1631827817.8150036, 1631827818.0593505, 1631827818.325639, 1631827818.5699856, 1631827818.8203163, 1631827819.0586793, 1631827819.3210044, 1631827819.5703378, 1631827819.8166795, 1631827820.069005, 1631827820.3113573, 1631827820.5696878, 1631827820.8110423, 1631827821.0623708, 1631827821.3276615, 1631827821.5710108, 1631827821.822339, 1631827822.0707092, 1631827822.3200426, 1631827822.5703738, 1631827822.8117476, 1631827823.0630758, 1631827823.3154197, 1631827823.5767214, 1631827823.8220654, 1631827824.061426, 1631827824.3157456, 1631827824.581076, 1631827824.8224313, 1631827825.0837324, 1631827825.3191035, 1631827825.5794072, 1631827825.8197846, 1631827826.063134, 1631827826.3264303, 1631827826.566788, 1631827826.8141265, 1631827827.0654545, 1631827827.3277833, 1631827827.5741246, 1631827827.8144822, 1631827828.0837622, 1631827828.320149, 1631827828.5794568, 1631827828.8138292, 1631827829.076128, 1631827829.3254614, 1631827829.574795, 1631827829.8151524, 1631827830.0665002]

assets/zephir-zm9624/worldlines.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c4ac04fb461fd3336d6decf81dd4009f7ef1f188ebc6c0193a797b1a6eaff70
+size 5449

examples/pilot.py

@@ -0,0 +1,44 @@
+"""Run the actual ASCENT pilot; accept either a local assembly or pinned Hub revision."""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+from cell_tracking.data.wormtrack_verify import BenchmarkClient
+from cell_tracking.evaluation.wormtrack_verify import (
+    association_metrics,
+    corrupt_tracks,
+    reference_residual_scores,
+    verifier_metrics,
+)
+
+
+def run(client):
+    clean = client.load_tracks("ascent-opterra", label_source="human_corrected")
+    cloud = client.load_reference_cloud("ascent-opterra")
+    corrupt = corrupt_tracks(
+        clean, kind="swap_recovery", seed=20261007, start_frame=300, stop_frame=700
+    )
+    scores = reference_residual_scores(corrupt, cloud)
+    metrics = verifier_metrics(scores, corrupt.is_error, threshold=5.0)
+    metrics.pop("risk_coverage")
+    volume = client.load_volume("ascent-opterra", frame=0)
+    print(
+        json.dumps(
+            {
+                "volume_czyx": list(volume.shape),
+                "association": association_metrics(clean, corrupt),
+                "verifier": metrics,
+            },
+            indent=2,
+        )
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root")
+    parser.add_argument("--revision")
+    args = parser.parse_args()
+    run(BenchmarkClient(root=args.root, revision=args.revision))

examples/stream.py

@@ -0,0 +1,12 @@
+"""Inspect the published annotation stream without downloading microscopy volumes."""
+
+from datasets import load_dataset
+
+stream = load_dataset(
+    "pytc/trackingBench",
+    name="tracks",
+    revision="v0.1.0-alpha.1",
+    split="development",
+    streaming=True,
+)
+print(next(iter(stream)))

pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+[project]
+name = "wormtrack-verify"
+version = "0.1.0a1"
+requires-python = ">=3.12"
+description = "Selective client and evaluation helpers for WormTrack-Verify"
+readme = "README.md"
+license = {text = "MIT (helper code only)"}
+dependencies = ["huggingface_hub>=1.0", "pyarrow>=20", "pandas>=2.2", "h5py>=3.12", "numpy>=2.2", "scipy>=1.15", "scikit-learn>=1.6", "requests>=2.32", "PyYAML>=6"]
+[tool.hatch.build.targets.wheel]
+packages = ["src/cell_tracking"]

requirements.lock.txt

@@ -0,0 +1,116 @@
+PyYAML==6.0.3
+PyYAML==6.0.3
+Pygments==2.21.0
+Pygments==2.21.0
+aiohappyeyeballs==2.7.1
+aiohappyeyeballs==2.7.1
+aiohttp==3.14.4
+aiohttp==3.14.4
+aiosignal==1.4.0
+aiosignal==1.4.0
+anyio==4.15.1
+anyio==4.15.1
+attrs==26.1.0
+attrs==26.1.0
+certifi==2026.7.22
+certifi==2026.7.22
+charset-normalizer==3.5.2
+charset-normalizer==3.5.2
+click==8.5.0
+click==8.5.0
+cloudpickle==3.1.2
+cloudpickle==3.1.2
+datasets==5.1.0
+datasets==5.1.0
+dill==0.4.1
+dill==0.4.1
+donfig==0.8.1.post1
+donfig==0.8.1.post1
+filelock==4.0.12
+filelock==4.0.12
+frozenlist==1.8.0
+frozenlist==1.8.0
+fsspec==2026.7.0
+fsspec==2026.7.0
+google-crc32c==1.9.0
+google-crc32c==1.9.0
+h11==0.16.0
+h11==0.16.0
+h5py==3.16.0
+h5py==3.16.0
+hf-xet==1.7.0
+hf-xet==1.7.0
+httpcore2==2.13.1
+httpcore2==2.13.1
+httpx2==2.13.1
+httpx2==2.13.1
+huggingface_hub==2.1.1
+huggingface_hub==2.1.1
+idna==3.20
+idna==3.20
+iniconfig==2.3.1
+iniconfig==2.3.1
+joblib==1.6.0
+joblib==1.6.0
+jsonschema-specifications==2025.9.1
+jsonschema-specifications==2025.9.1
+jsonschema==4.26.0
+jsonschema==4.26.0
+msgspec==0.22.0
+msgspec==0.22.0
+multidict==6.9.1
+multidict==6.9.1
+multiprocess==0.70.19
+multiprocess==0.70.19
+narwhals==2.26.0
+narwhals==2.26.0
+numcodecs==0.17.0
+numcodecs==0.17.0
+numpy==2.5.3
+numpy==2.5.3
+packaging==26.3
+packaging==26.3
+pandas==3.0.6
+pandas==3.0.6
+pluggy==1.6.0
+pluggy==1.6.0
+propcache==0.5.4
+propcache==0.5.4
+pyarrow==25.0.1
+pyarrow==25.0.1
+pytest==9.1.1
+pytest==9.1.1
+python-dateutil==2.9.0.post0
+python-dateutil==2.9.0.post0
+referencing==0.37.0
+referencing==0.37.0
+requests==2.34.2
+requests==2.34.2
+rpds-py==2026.9.1
+rpds-py==2026.9.1
+ruff==0.16.10
+ruff==0.16.10
+scikit-learn==1.9.1
+scikit-learn==1.9.1
+scipy==1.18.1
+scipy==1.18.1
+six==1.17.0
+six==1.17.0
+threadpoolctl==3.7.0
+threadpoolctl==3.7.0
+tifffile==2026.9.20
+tifffile==2026.9.20
+tqdm==4.70.1
+tqdm==4.70.1
+truststore==0.10.4
+truststore==0.10.4
+typing_extensions==4.16.0
+typing_extensions==4.16.0
+urllib3==2.8.0
+urllib3==2.8.0
+xxhash==4.0.1
+xxhash==4.0.1
+yarl==1.25.1
+yarl==1.25.1
+zarr==3.4.0
+zarr==3.4.0

src/cell_tracking/__init__.py

@@ -0,0 +1 @@
+"""WormTrack-Verify benchmark helpers."""

src/cell_tracking/data/__init__.py

@@ -0,0 +1 @@
+"""WormTrack-Verify benchmark helpers."""

src/cell_tracking/data/wormtrack_verify/__init__.py

@@ -0,0 +1,5 @@
+"""Selective access and assembly tools for the WormTrack-Verify pilot."""
+
+from .client import BenchmarkClient, MissingComponentError
+
+__all__ = ["BenchmarkClient", "MissingComponentError"]

src/cell_tracking/data/wormtrack_verify/adapters.py

@@ -0,0 +1,126 @@
+"""Native ASCENT and ZephIR table adapters with conservative annotation provenance."""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+XYZ = ["x_voxel", "y_voxel", "z_voxel"]
+TRUSTED = {"human_corrected", "manually_verified", "verified_checkpoint"}
+
+
+def _physical(df, spacing_xyz):
+    for axis, scale in zip("xyz", spacing_xyz or [None] * 3, strict=True):
+        df[f"{axis}_um"] = df[f"{axis}_voxel"] * scale if scale is not None else np.nan
+    df["coordinate_system"] = "source_microscope"
+    df["annotation_confidence"] = np.nan
+    df["validity"] = True
+    return df
+
+
+def ascent_tracks(path, recording_id, *, predicted=False):
+    """Read native ZYX CSV; physical spacing is from Zenodo 17561700 metadata."""
+    df = pd.read_csv(path).rename(
+        columns={
+            "TrackID": "track_id",
+            "ObjectID": "detection_id",
+            "t": "frame_index",
+            "x": "x_voxel",
+            "y": "y_voxel",
+            "z": "z_voxel",
+        }
+    )
+    required = {"track_id", "detection_id", "frame_index", *XYZ}
+    if not required.issubset(df.columns):
+        raise ValueError(f"Missing ASCENT fields: {sorted(required - set(df.columns))}")
+    df["recording_id"] = recording_id
+    df["annotation_type"] = "algorithm_prediction" if predicted else "human_corrected"
+    df["source_provenance"] = "ASCENT-PRED" if predicted else "ASCENT-GT-proofread-ZephIR"
+    df["label_set"] = "prediction" if predicted else "reference"
+    df["track_id"] = df.track_id.astype(str)
+    df["detection_id"] = df.detection_id.map(lambda i: f"{'pred' if predicted else 'gt'}:{i}")
+    return _physical(df, [0.243, 0.243, 1.5])
+
+
+def zephir_tracks(path, metadata, recording_id):
+    """Retain scorer codes; only documented ZEIR results are classified as predictions.
+
+    Other codes remain unknown until their human/algorithm provenance is verified.
+    Normalized coordinates map to voxel index x*size-0.5 using the native viewer
+    convention. No voxel spacing is inferred from the neuron arrangement.
+    """
+    import h5py
+
+    with h5py.File(path, "r") as h:
+        df = pd.DataFrame({k: h[k][()] for k in h})
+    df = df.rename(
+        columns={
+            "t_idx": "frame_index",
+            "worldline_id": "track_id",
+            "id": "detection_id",
+            "provenance": "source_provenance",
+        }
+    )
+    df["source_provenance"] = df.source_provenance.map(lambda s: s.decode("utf-8"))
+    for axis in "xyz":
+        df[f"{axis}_normalized"] = df[axis]
+        df[f"{axis}_voxel"] = df[axis] * metadata[f"shape_{axis}"] - 0.5
+        df = df.drop(columns=axis)
+    df["annotation_type"] = np.where(
+        df.source_provenance == "ZEIR", "algorithm_prediction", "unknown"
+    )
+    df["recording_id"] = recording_id
+    df["label_set"] = "source_mixed"
+    df["track_id"] = df.track_id.astype(str)
+    df["detection_id"] = df.detection_id.map(lambda i: f"source:{i}")
+    df = _physical(df, None)
+    normalized = df[[f"{axis}_normalized" for axis in "xyz"]].to_numpy(dtype=float)
+    df["validity"] = (
+        np.isfinite(normalized).all(axis=1)
+        & (normalized >= 0).all(axis=1)
+        & (normalized <= 1).all(axis=1)
+    )
+    return df
+
+
+def validate_tracks(df, *, shape_xyz=None):
+    """Reject ambiguous assignments and nonfinite observed points; never clamp or interpolate."""
+    required = {
+        "recording_id",
+        "frame_index",
+        "track_id",
+        "detection_id",
+        *XYZ,
+        "annotation_type",
+        "label_set",
+        "validity",
+    }
+    if not required.issubset(df.columns):
+        raise ValueError(f"Missing fields: {sorted(required - set(df.columns))}")
+    if df.empty:
+        raise ValueError("Empty tracking table")
+    valid = df.loc[df.validity]
+    scope = ["recording_id", "label_set", "frame_index"]
+    if valid.duplicated(scope + ["track_id"]).any():
+        raise ValueError("Duplicate track assignments")
+    if valid.duplicated(scope + ["detection_id"]).any():
+        raise ValueError("Duplicate detection assignments")
+    if valid.track_id.isna().any() or valid.detection_id.isna().any():
+        raise ValueError("Missing identity on a valid observation")
+    if not np.isfinite(valid[XYZ].to_numpy(dtype=float)).all():
+        raise ValueError("Nonfinite observed coordinates")
+    if (valid.frame_index < 0).any() or (valid.frame_index % 1 != 0).any():
+        raise ValueError("Invalid frame index")
+    # Centers use pixel boundaries [-0.5, size-0.5], including ZephIR normalized endpoints.
+    if shape_xyz is not None:
+        points = valid[XYZ].to_numpy(dtype=float)
+        if ((points < -0.5) | (points > np.asarray(shape_xyz) - 0.5)).any():
+            raise ValueError("Spatial coordinates outside source bounds")
+    return {
+        "observations": len(valid),
+        "frames": int(valid.frame_index.nunique()),
+        "tracks": int(valid.track_id.nunique()),
+        "annotation_types": {
+            str(k): int(v) for k, v in valid.annotation_type.value_counts().items()
+        },
+    }

src/cell_tracking/data/wormtrack_verify/assembly.py

@@ -0,0 +1,678 @@
+"""Build a development pilot from audited, checksum-pinned upstream assets.
+
+Usage: python -m cell_tracking.data.wormtrack_verify.assembly WORKSPACE OUTPUT
+Acquisition is deliberately separate: this command never downloads large files.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import shutil
+import sys
+from datetime import datetime
+from pathlib import Path
+from zoneinfo import ZoneInfo
+
+import h5py
+import numpy as np
+import pandas as pd
+
+from cell_tracking.data.wormtrack_verify.adapters import (
+    XYZ,
+    ascent_tracks,
+    validate_tracks,
+    zephir_tracks,
+)
+from cell_tracking.data.wormtrack_verify.inventory import DANDI_COHORTS, WORMND_COMMIT
+from cell_tracking.evaluation.wormtrack_verify import (
+    association_metrics,
+    corrupt_tracks,
+    oracle_association_baseline,
+    reference_residual_scores,
+    verifier_metrics,
+)
+
+VERSION = "0.1.0-alpha.1"
+SEED = 20261007
+
+
+def digest(path, algorithm="sha256"):
+    h = hashlib.new(algorithm)
+    with Path(path).open("rb") as stream:
+        for chunk in iter(lambda: stream.read(8 * 1024**2), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def dump(path, data):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2, allow_nan=False) + "\n")
+
+
+def table(root, path, df):
+    target = root / path
+    target.parent.mkdir(parents=True, exist_ok=True)
+    df.to_parquet(target, index=False)
+    return path
+
+
+def harmonize_tables(root):
+    """Align per-recording Parquet schemas without dropping source-specific fields."""
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+
+    for folder in Path(root).glob("data/*"):
+        files = sorted(folder.glob("*.parquet"))
+        if not files:
+            continue
+        schema = pa.unify_schemas(
+            [pq.read_schema(path) for path in files], promote_options="permissive"
+        ).remove_metadata()
+        for path in files:
+            original = pq.read_table(path)
+            arrays = [
+                original[field.name].cast(field.type)
+                if field.name in original.column_names
+                else pa.nulls(original.num_rows, type=field.type)
+                for field in schema
+            ]
+            pq.write_table(pa.Table.from_arrays(arrays, schema=schema), path)
+
+
+def build(workspace, destination):
+    workspace, root = Path(workspace), Path(destination)
+    root.mkdir(parents=True, exist_ok=True)
+    audit, raw = workspace / "audit", workspace / "raw"
+    now = datetime.now(ZoneInfo("America/New_York")).isoformat()
+    sources, recordings, upstream, overlaps = [], [], [], []
+    original = pd.read_csv(audit / "wormid-tracking-split.csv")
+    split_lookup = original.drop_duplicates("filename").set_index("filename")
+    provenance_path = audit / "dandi-asset-provenance.json"
+    provenance = json.loads(provenance_path.read_text()) if provenance_path.exists() else {}
+    subject_groups = {}
+    for identifier, cohort in DANDI_COHORTS.items():
+        release = json.loads((audit / f"dandi-{identifier}-pinned.json").read_text())
+        assets = json.loads((audit / f"dandi-{identifier}-assets.json").read_text())
+        sources.append(
+            {
+                "source_id": f"dandi-{identifier}",
+                "name": cohort,
+                "priority": "P0" if identifier not in {"001623", "000981"} else "P1",
+                "version": assets["version"],
+                "url": f"https://dandiarchive.org/dandiset/{identifier}/{assets['version']}",
+                "license": release.get("license"),
+                "license_status": "verified_release_metadata",
+                "asset_count": len(assets["assets"]),
+                "bytes": sum(a["size"] for a in assets["assets"]),
+                "assembly_status": "inventoried_assets_not_bulk_ingested",
+            }
+        )
+        for asset in assets["assets"]:
+            subject = asset["path"].split("/")[0]
+            rid = f"dandi-{identifier}-{subject}"
+            animal = f"dandi:{identifier}:{subject}"
+            subject_groups.setdefault(subject, []).append(rid)
+            full_name = f"{identifier}/{asset['path']}"
+            split = split_lookup.loc[full_name] if full_name in split_lookup.index else None
+            tracking = bool(split.use_for_calcium_task == 1) if split is not None else False
+            # SF is explicitly excluded from the published trusted tracking subset.
+            tracking = tracking and cohort != "SF"
+            record = {
+                "recording_id": rid,
+                "source_dataset": f"dandi-{identifier}",
+                "source_cohort": cohort,
+                "source_version": assets["version"],
+                "source_asset": asset["asset_id"],
+                "source_path": asset["path"],
+                "source_checksum": json.dumps(provenance.get(asset["asset_id"], {}).get("digest")),
+                "source_size_bytes": asset["size"],
+                "lab_id": None,
+                "animal_id": animal,
+                "session_id": asset["path"].split("/")[-1].removesuffix(".nwb"),
+                "species": None,
+                "sex": None,
+                "stage": None,
+                "strain": None,
+                "fov_region": "unknown",
+                "acquisition_setup": "unknown",
+                "shape_tczyx": None,
+                "voxel_size_um": None,
+                "timestamps_status": "not_inspected",
+                "channels": None,
+                "tracking_gt_level": "not_inspected",
+                "posture_gt_level": "not_inspected",
+                "source_overlap_group": subject,
+                "license": ";".join(release.get("license", [])),
+                "qc_status": "inventory_only",
+                "hosted_tracks": False,
+                "hosted_volume": False,
+                "wormid_tracking_subset": tracking,
+                "wormid_fold": str(split.dataset_split) if split is not None else None,
+            }
+            recordings.append(record)
+            upstream.append(
+                {
+                    "recording_id": rid,
+                    "asset_id": asset["asset_id"],
+                    "source_version": assets["version"],
+                    "path": asset["path"],
+                    "bytes": asset["size"],
+                    "digests": provenance.get(asset["asset_id"], {}).get("digest"),
+                    "location": "external",
+                    "url": f"https://api.dandiarchive.org/api/assets/{asset['asset_id']}/download/",
+                }
+            )
+    for subject, ids in subject_groups.items():
+        if len(ids) > 1:
+            overlaps.append(
+                {
+                    "group_id": subject,
+                    "recording_ids": ids,
+                    "status": "potential_same_animal_or_acquisition",
+                    "evidence": "shared upstream subject identifier",
+                    "split_policy": "keep together; prohibit separate test assignments until audited",
+                }
+            )
+    components, qc, counts = {}, {}, {}
+
+    def recording(rid):
+        return next(r for r in recordings if r["recording_id"] == rid)
+
+    def register_tracks(rid, df, shape_xyz):
+        qc[rid] = validate_tracks(df, shape_xyz=shape_xyz)
+        qc[rid]["invalid_observations_preserved"] = int((~df.validity).sum())
+        counts[rid] = qc[rid]
+        entry = components.setdefault(rid, {})
+        entry["tracks"] = table(root, f"data/tracks/{rid}.parquet", df)
+        detections = df.drop(columns=["track_id"]).copy()
+        entry["detections"] = table(root, f"data/detections/{rid}.parquet", detections)
+        recording(rid).update(
+            hosted_tracks=True,
+            qc_status="table_validated",
+            tracking_gt_level="trusted_human_corrected"
+            if set(df.annotation_type) == {"human_corrected"}
+            else "unknown_or_mixed_provenance",
+        )
+
+    # Small real recordings and trusted ASCENT annotations.
+    for source, identifier in [
+        ("ASCENT", "17561700"),
+        ("ZephIR", "10818810"),
+        ("Targettrack", "10008744"),
+    ]:
+        meta = json.loads((audit / f"zenodo-{identifier}.json").read_text())
+        sources.append(
+            {
+                "source_id": source.lower(),
+                "name": source,
+                "priority": "P0" if source == "ZephIR" else "P1",
+                "version": f"10.5281/zenodo.{identifier}",
+                "url": f"https://zenodo.org/records/{identifier}",
+                "license": meta["metadata"].get("license", {}).get("id"),
+                "license_status": "verified_record_metadata",
+                "asset_count": len(meta["files"]),
+                "bytes": sum(a["size"] for a in meta["files"]),
+                "assembly_status": "pilot_assets_and_tables",
+            }
+        )
+        for asset in meta["files"]:
+            upstream.append(
+                {
+                    "recording_id": None,
+                    "source_dataset": source.lower(),
+                    "path": asset["key"],
+                    "bytes": asset["size"],
+                    "digests": {"md5": asset["checksum"].split(":", 1)[-1]},
+                    "location": "external",
+                    "url": asset["links"]["self"],
+                }
+            )
+            local = raw / asset["key"]
+            if local.exists() and digest(local, "md5") != asset["checksum"].split(":", 1)[-1]:
+                raise ValueError(f"Upstream checksum mismatch: {local.name}")
+    template = {
+        "source_checksum": None,
+        "source_size_bytes": None,
+        "species": "Caenorhabditis elegans",
+        "sex": None,
+        "stage": None,
+        "strain": None,
+        "fov_region": "unknown",
+        "acquisition_setup": "unknown",
+        "shape_tczyx": None,
+        "voxel_size_um": None,
+        "timestamps_status": "unknown",
+        "channels": None,
+        "tracking_gt_level": "unknown",
+        "posture_gt_level": "unavailable",
+        "license": "CC-BY-4.0",
+        "qc_status": "inventory_only",
+        "hosted_tracks": False,
+        "hosted_volume": False,
+        "wormid_tracking_subset": False,
+        "wormid_fold": None,
+    }
+
+    def new_record(rid, source, version, asset, **kwargs):
+        record = dict(
+            template,
+            recording_id=rid,
+            source_dataset=source,
+            source_cohort=source,
+            source_version=version,
+            source_asset=asset,
+            source_path=asset,
+            lab_id=None,
+            animal_id=rid,
+            session_id=rid,
+            source_overlap_group=rid,
+        )
+        record.update(kwargs)
+        recordings.append(record)
+
+    rid = "ascent-opterra"
+    new_record(
+        rid,
+        "ascent",
+        "10.5281/zenodo.17561700",
+        "InHouse_Opterra_tracks_GT.csv",
+        fov_region="head",
+        acquisition_setup="device_restricted",
+        strain="ZM9624",
+        shape_tczyx=json.dumps([1100, 2, 9, 512, 512]),
+        voxel_size_um=json.dumps([0.243, 0.243, 1.5]),
+        timestamps_status="nominal_3.3Hz_not_measured_timestamps",
+        channels=json.dumps(
+            [
+                {"index": 0, "name": "mNeptune", "role": "structural"},
+                {"index": 1, "name": "GCaMP6", "role": "calcium"},
+            ]
+        ),
+    )
+    clean = ascent_tracks(raw / "InHouse_Opterra_tracks_GT.csv", rid)
+    register_tracks(rid, clean, [512, 512, 9])
+    pred = ascent_tracks(raw / "InHouse_Opterra_tracks_PRED.csv", rid, predicted=True)
+    qc["ascent-source-predictions"] = validate_tracks(pred, shape_xyz=[512, 512, 9])
+    table(root, "evaluation/source_predictions/ascent.parquet", pred)
+    # Source-predicted objects differ from oracle detections: do not score these as oracle association.
+    ref = clean.loc[clean.frame_index == clean.frame_index.min()].copy()
+    ref["reference_origin"] = "same_animal_human_corrected_reference_frame"
+    components[rid]["anatomy"] = table(root, f"data/anatomy/{rid}.parquet", ref)
+    scenarios, verification, results = [], [], {}
+    clean_control = clean.copy()
+    clean_control["scenario_id"] = "clean"
+    clean_control["is_error"] = False
+    clean_control["reference_track_id"] = clean_control.track_id
+    clean_control["corruption_type"] = "clean"
+    clean_control["seed"] = SEED
+    scenarios.append(clean_control)
+    # Choose a nearby pair using only the development reference frame.
+    positions = ref[["x_um", "y_um", "z_um"]].to_numpy()
+    distance = np.linalg.norm(positions[:, None] - positions[None], axis=2)
+    np.fill_diagonal(distance, np.inf)
+    i, j = np.unravel_index(distance.argmin(), distance.shape)
+    pair = [ref.track_id.iloc[i], ref.track_id.iloc[j]]
+    for kind in [
+        "single_frame_swap",
+        "persistent_swap",
+        "swap_recovery",
+        "nearby_swap",
+        "fragmentation",
+        "dropout",
+    ]:
+        stop = 700 if kind in {"swap_recovery", "nearby_swap"} else None
+        corrupted = corrupt_tracks(
+            clean,
+            kind=kind,
+            seed=SEED,
+            start_frame=300,
+            stop_frame=stop,
+            pair=pair if kind == "nearby_swap" else None,
+        )
+        scenarios.append(corrupted)
+    for df in scenarios:
+        scores = reference_residual_scores(df, ref)
+        report = verifier_metrics(scores, df.is_error, threshold=5.0)
+        # Keep exact risk/coverage breakpoints in a separate tabular artifact.
+        curve = report.pop("risk_coverage")
+        table(
+            root, f"evaluation/risk_coverage/{df.scenario_id.iloc[0]}.parquet", pd.DataFrame(curve)
+        )
+        scenario = df.scenario_id.iloc[0]
+        report["association"] = association_metrics(clean, df)
+        results[scenario] = report
+        verification.append(
+            pd.DataFrame(
+                {
+                    "recording_id": rid,
+                    "scenario_id": scenario,
+                    "frame_index": df.frame_index,
+                    "detection_id": df.detection_id,
+                    "reference_track_id": df.reference_track_id,
+                    "proposed_track_id": df.track_id,
+                    "is_error": df.is_error,
+                    "score_um": scores,
+                    "verifier": "fixed_reference_distance",
+                    "threshold_um": 5.0,
+                    "partition": "development",
+                }
+            )
+        )
+    components[rid]["perturbations"] = table(
+        root, f"data/perturbations/{rid}.parquet", pd.concat(scenarios, ignore_index=True)
+    )
+    table(root, f"data/verification/{rid}.parquet", pd.concat(verification, ignore_index=True))
+    for method in ["nearest_neighbor", "hungarian"]:
+        prediction = oracle_association_baseline(clean.drop(columns="track_id"), method=method)
+        table(root, f"evaluation/baseline_predictions/{method}.parquet", prediction)
+        results[method] = association_metrics(clean, prediction)
+    dump(root / "evaluation/pilot_results.json", results)
+
+    for name, rid, source in [
+        ("ZM9624_Ex(myo-20_mCherry)", "zephir-zm9624", "zephir"),
+        ("nguyen2017_AL_w1", "nerve-al-w1-via-zephir", "nerve"),
+    ]:
+        folder = raw / "zephir/zephir" / name
+        meta = json.loads((folder / "metadata.json").read_text())
+        new_record(
+            rid,
+            source,
+            "10.5281/zenodo.10818810",
+            f"zephir/{name}/annotations.h5",
+            acquisition_setup="freely_moving",
+            shape_tczyx=json.dumps([meta[f"shape_{a}"] for a in "tczyx"]),
+            source_overlap_group="nerve-al-w1" if source == "nerve" else rid,
+            timestamps_status="source_times_hosted" if source == "zephir" else "unknown",
+        )
+        register_tracks(
+            rid,
+            zephir_tracks(folder / "annotations.h5", meta, rid),
+            [meta[f"shape_{a}"] for a in "xyz"],
+        )
+        dest = root / "assets" / rid
+        dest.mkdir(parents=True, exist_ok=True)
+        for filename in ["annotations.h5", "worldlines.h5", "metadata.json"]:
+            shutil.copy2(folder / filename, dest / filename)
+    if (audit / "zephir-image-times.json").exists():
+        shutil.copy2(
+            audit / "zephir-image-times.json", root / "assets/zephir-zm9624/timestamps_s.json"
+        )
+
+    rid = "targettrack-epfl10"
+    new_record(
+        rid,
+        "targettrack",
+        "10.5281/zenodo.10008744",
+        "Targettrack/epfl10_CZANet_Final.h5",
+        shape_tczyx=json.dumps([761, 1, 32, 128, 192]),
+        acquisition_setup="unknown",
+        tracking_gt_level="mask_provenance_unresolved",
+    )
+    points, transforms = [], []
+    with h5py.File(raw / "Targettrack/epfl10_CZANet_Final.h5") as h:
+        for t in range(int(h.attrs["T"])):
+            g = h[str(t)]
+            transforms.append(
+                {
+                    "recording_id": rid,
+                    "frame_index": t,
+                    "original_frame_index": int(g["original_fr"][()]),
+                    "source_transform": g["transfo_matrix"][()].reshape(-1).tolist(),
+                    "direction": "unknown",
+                    "units": "unknown",
+                }
+            )
+            if "mask" not in g:
+                continue
+            mask = g["mask"][()]
+            for identity in np.unique(mask):
+                if identity == 0:
+                    continue
+                xyz = np.argwhere(mask == identity).mean(axis=0)
+                points.append(
+                    {
+                        "recording_id": rid,
+                        "frame_index": t,
+                        "track_id": str(identity),
+                        "detection_id": f"{t}:{identity}",
+                        **dict(zip(XYZ, xyz.tolist(), strict=True)),
+                        "x_um": np.nan,
+                        "y_um": np.nan,
+                        "z_um": np.nan,
+                        "annotation_type": "unknown",
+                        "annotation_confidence": np.nan,
+                        "label_set": "source_mask",
+                        "source_provenance": "centroid_of_native_mask; manual_or_propagated_unresolved",
+                        "coordinate_system": "source_processed_CXYZ",
+                        "validity": True,
+                    }
+                )
+    register_tracks(rid, pd.DataFrame(points), [192, 128, 32])
+    table(root, "metadata/targettrack_transforms.parquet", pd.DataFrame(transforms))
+
+    # Same-animal NeuroPAL cloud from a directly inspected CC-BY NWB.
+    asset = json.loads((audit / "dandi-000715-assets.json").read_text())["assets"][0]
+    rid = "dandi-000715-" + asset["path"].split("/")[0]
+    with h5py.File(raw / "neuropal-reference.nwb") as h:
+        group = h["processing/NeuroPAL/NeuroPALSegmentation/NeuroPALNeurons"]
+        voxels, ids = group["voxel_mask"][()], group["id"][()]
+        spacing = h["general/optophysiology/NeuroPALImVol/grid_spacing"]
+        if spacing.attrs["unit"] != "micrometers":
+            raise ValueError("Unsupported physical calibration")
+        cloud = pd.DataFrame(
+            {
+                "recording_id": rid,
+                "track_id": ids.astype(str),
+                **{f"{a}_voxel": voxels[a].astype(float) for a in "xyz"},
+                **{f"{a}_um": voxels[a] * spacing[i] for i, a in enumerate("xyz")},
+                "reference_origin": "same_animal_structural_volume",
+                "annotation_type": "source_annotation_uncertainty_unknown",
+                "coordinate_system": "source_microscope",
+                "uncertainty_um": np.nan,
+            }
+        )
+        components.setdefault(rid, {})["anatomy"] = table(
+            root, f"data/anatomy/{rid}.parquet", cloud
+        )
+        recording(rid).update(
+            qc_status="reference_cloud_validated", voxel_size_um=json.dumps(spacing[()].tolist())
+        )
+    # Preserve the original small structural NWB; explicit component download only.
+    (root / "assets" / rid).mkdir(parents=True, exist_ok=True)
+    shutil.copy2(raw / "neuropal-reference.nwb", root / "assets" / rid / "reference.nwb")
+
+    if (raw / "wormid-ey-pilot.parquet").exists():
+        meta = json.loads((audit / "wormid-ey-pilot.json").read_text())
+        rid = "dandi-000541-" + meta["asset"]["path"].split("/")[0]
+        df = pd.read_parquet(raw / "wormid-ey-pilot.parquet")
+        for i, a in enumerate("xyz"):
+            df[f"{a}_um"] = df[f"{a}_voxel"] * meta["spacing_xyz"][i]
+        df["recording_id"], df["annotation_type"], df["label_set"] = (
+            rid,
+            "unknown",
+            "source_segmentation",
+        )
+        df["annotation_confidence"] = np.nan
+        df["source_provenance"] = "native_NWB_plane_segmentation_ID; temporal_identity_QC_pending"
+        df["coordinate_system"], df["validity"] = "source_microscope", True
+        register_tracks(rid, df, list(reversed(meta["shape_tczyx"][2:])))
+        recording(rid).update(
+            shape_tczyx=json.dumps(meta["shape_tczyx"]),
+            voxel_size_um=json.dumps(meta["spacing_xyz"]),
+            timestamps_status="starting_time_and_rate_4Hz",
+            fov_region="unknown",
+        )
+        dump(root / "metadata/wormid_ey_image_annotation_discrepancy.json", meta)
+    if (raw / "sf-behavior.parquet").exists():
+        meta = json.loads((audit / "sf-behavior.json").read_text())
+        rid = "dandi-000776-" + meta["asset"]["path"].split("/")[0]
+        df = pd.read_parquet(raw / "sf-behavior.parquet")
+        df["recording_id"], df["component_type"], df["status"] = rid, "behavior_summary", "measured"
+        components.setdefault(rid, {})["posture"] = table(root, f"data/posture/{rid}.parquet", df)
+        recording(rid)["posture_gt_level"] = "behavioral_summaries_only_no_centerline"
+        dump(root / "metadata/sf_behavior_provenance.json", meta)
+    for stem, rid, frames in [
+        ("ascent-opterra", "ascent-opterra", list(range(4))),
+        ("zephir-zm9624", "zephir-zm9624", list(range(4))),
+        ("targettrack-epfl10", "targettrack-epfl10", list(range(32))),
+        ("wormid-ey-20190924-01", "dandi-000541-sub-20190924-01", list(range(4))),
+    ]:
+        src = workspace / "volumes" / (stem + ".h5")
+        if src.exists():
+            dest = root / "assets" / rid / "pilot.h5"
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src, dest)
+            components.setdefault(rid, {})["volume"] = {
+                "path": str(dest.relative_to(root)),
+                "frames": frames,
+                "axis_order": "CZYX",
+                "transformation": "axis_permutation_only",
+            }
+            recording(rid)["hosted_volume"] = True
+    for source, name, priority, url, status in [
+        (
+            "nerve",
+            "NeRVE original release",
+            "P0",
+            "https://doi.org/10.21227/H2901H",
+            "one_annotation_recording_via_ZephIR; original_inventory_pending",
+        ),
+        (
+            "cender",
+            "CeNDeR C1-C3",
+            "P0",
+            "https://osf.io/v2b5n/",
+            "blocked_data_license_unstated; OSF_storage_empty; linked_Google_Drive_API_404",
+        ),
+        (
+            "brainalignnet",
+            "BrainAlignNet / ANTSUN 2.0",
+            "P1",
+            "https://doi.org/10.7910/DVN/8UE0H9",
+            "Dataverse_API_unavailable; license_and_overlap_pending",
+        ),
+        (
+            "skuhersky-atlas",
+            "Skuhersky 3D anatomical atlas",
+            "P2",
+            "https://github.com/bluevex/elegans-atlas",
+            "data_license_unresolved; external_reference_only",
+        ),
+        (
+            "neuropal-canonical",
+            "NeuroPAL canonical positions",
+            "P2",
+            "https://github.com/openworm/NeuroPAL",
+            "shared_Skuhersky_CSV; data_license_unresolved",
+        ),
+        (
+            "stat-atlas",
+            "Statistical anatomical atlas",
+            "P2",
+            "https://github.com/amin-nejat/stat-atlas",
+            "data_license_unresolved; external_reference_only",
+        ),
+        (
+            "openworm-movement",
+            "OpenWorm Movement Database",
+            "P2",
+            "https://movement.openworm.org/",
+            "DNS_resolution_failed; license_and_assets_unresolved",
+        ),
+        (
+            "eigenworms",
+            "Stephens et al. 2008",
+            "P2",
+            "https://doi.org/10.1371/journal.pcbi.1000028",
+            "paper_audited; reusable_basis_asset_not_ingested",
+        ),
+    ]:
+        sources.append(
+            {
+                "source_id": source,
+                "name": name,
+                "priority": priority,
+                "url": url,
+                "version": None,
+                "license": None,
+                "license_status": "verify",
+                "assembly_status": status,
+                "asset_count": None,
+                "bytes": None,
+            }
+        )
+    # All pilots are development assets. No small single-worm split is presented as generalization.
+    active = sorted(components)
+    splits = {
+        p: {"train": [], "validation": [], "test": [], "development": active, "quarantine": []}
+        for p in ["tracking_gt", "anatomical_verification", "anatomical_consistency"]
+    }
+    splits["tracking_gt"]["development"] = ["ascent-opterra"]
+    splits["anatomical_verification"]["development"] = ["ascent-opterra"]
+    table(root, "data/recordings/recordings.parquet", pd.DataFrame(recordings))
+    dump(root / "metadata/sources.json", sources)
+    dump(root / "metadata/upstream_assets.json", upstream)
+    dump(root / "metadata/overlap_registry.json", overlaps)
+    dump(
+        root / "metadata/client_manifest.json",
+        {
+            "schema_version": VERSION,
+            "recordings": "data/recordings/recordings.parquet",
+            "components": components,
+            "splits": splits,
+        },
+    )
+    dump(
+        root / "splits/assignments.json",
+        {
+            "seed": SEED,
+            "status": "development_only_no_frozen_test",
+            "protocols": splits,
+            "original_wormid_commit": WORMND_COMMIT,
+        },
+    )
+    table(root, "splits/original_wormid_folds.parquet", original)
+    dump(
+        root / "evaluation/validation.json",
+        {"status": "passed", "scope": "published_table_invariants", "tables": qc},
+    )
+    dump(
+        root / "metadata/assembly_counts.json",
+        {
+            "version": VERSION,
+            "assembled_at": now,
+            "inventory_recordings": len(recordings),
+            "wormid_inventory_assets": sum(
+                r["source_dataset"] in {f"dandi-{i}" for i in list(DANDI_COHORTS)[:7]}
+                for r in recordings
+            ),
+            "ingested": counts,
+            "source_inventory_entries": len(sources),
+            "pilot_imaging_frames": sum(
+                len(c.get("volume", {}).get("frames", [])) for c in components.values()
+            ),
+            "anatomical_clouds": sum("anatomy" in c for c in components.values()),
+            "measured_centerlines": 0,
+            "independent_behavior_summary_recordings": sum(
+                "posture" in c for c in components.values()
+            ),
+            "release_gates": {
+                "A": "partial: full non-DANDI inventories pending",
+                "B": "partial: independent moving-worm GT and centerline pending",
+                "C": "not_passed: all P0 ingestion and held-out evaluation pending",
+            },
+        },
+    )
+    harmonize_tables(root)
+    print(
+        json.dumps(
+            {"root": str(root), "inventory_recordings": len(recordings), "ingested": counts},
+            indent=2,
+        )
+    )
+    return root
+
+
+if __name__ == "__main__":
+    build(*sys.argv[1:3])

src/cell_tracking/data/wormtrack_verify/client.py

@@ -0,0 +1,131 @@
+"""Recording-selective Hub access; metadata never triggers volume acquisition."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+class MissingComponentError(LookupError):
+    """A requested component is unavailable, rather than an empty measurement."""
+
+
+class BenchmarkClient:
+    """Read a pinned release or local assembly with a per-file download budget.
+
+    Tables retain native XYZ voxel coordinates. Physical XYZ fields are null if
+    calibration is unknown. Volumes return CZYX, without intensity normalization.
+    Local assemblies support the same API as remote commits. Remote callers must
+    explicitly select a revision; this prevents silent changes in experiments.
+    """
+
+    def __init__(
+        self,
+        repo_id="pytc/trackingBench",
+        *,
+        revision=None,
+        root=None,
+        cache_dir=None,
+        max_download_bytes=128 * 1024**2,
+    ):
+        if root is None and revision is None:
+            raise ValueError("Pin a Hub commit/tag with revision, or supply root")
+        self.repo_id = repo_id
+        self.revision = revision
+        self.root = Path(root) if root is not None else None
+        self.cache_dir = cache_dir
+        self.max_download_bytes = max_download_bytes
+        self.manifest = json.loads(self._file("metadata/client_manifest.json").read_text())
+
+    def _file(self, path):
+        logical = Path(path)
+        if logical.is_absolute() or ".." in logical.parts:
+            raise ValueError("Manifest paths must stay within the repository")
+        if self.root is not None:
+            return self.root / logical
+        from huggingface_hub import HfApi, hf_hub_download
+
+        info = next(
+            iter(
+                HfApi().get_paths_info(
+                    self.repo_id, [path], repo_type="dataset", revision=self.revision
+                )
+            ),
+            None,
+        )
+        if info is None or getattr(info, "size", None) is None:
+            raise MissingComponentError(path)
+        if info.size > self.max_download_bytes:
+            raise ValueError(f"{path} exceeds the {self.max_download_bytes}-byte file budget")
+        return Path(
+            hf_hub_download(
+                self.repo_id,
+                path,
+                repo_type="dataset",
+                revision=self.revision,
+                cache_dir=self.cache_dir,
+            )
+        )
+
+    def list_recordings(self, **filters):
+        import pandas as pd
+
+        df = pd.read_parquet(self._file(self.manifest["recordings"]))
+        for key, value in filters.items():
+            df = df.loc[df[key] == value]
+        return df.reset_index(drop=True)
+
+    def _component(self, recording_id, component):
+        import pandas as pd
+
+        entry = self.manifest["components"].get(recording_id)
+        if entry is None:
+            raise MissingComponentError(f"Unknown recording: {recording_id}")
+        path = entry.get(component)
+        if path is None:
+            raise MissingComponentError(f"{component} unavailable for {recording_id}")
+        return pd.read_parquet(self._file(path))
+
+    def load_detections(self, recording_id):
+        return self._component(recording_id, "detections")
+
+    def load_tracks(self, recording_id, label_source=None):
+        df = self._component(recording_id, "tracks")
+        if label_source is not None:
+            df = df.loc[df.annotation_type == label_source].reset_index(drop=True)
+        return df
+
+    def load_reference_cloud(self, recording_id):
+        return self._component(recording_id, "anatomy")
+
+    def load_posture(self, recording_id):
+        return self._component(recording_id, "posture")
+
+    def load_corruptions(self, recording_id):
+        return self._component(recording_id, "perturbations")
+
+    def get_split(self, protocol, partition):
+        if protocol not in {"tracking_gt", "anatomical_verification", "anatomical_consistency"}:
+            raise ValueError(f"Unknown protocol: {protocol}")
+        if partition not in {"train", "validation", "test", "development", "quarantine"}:
+            raise ValueError(f"Unknown partition: {partition}")
+        return self.manifest["splits"][protocol].get(partition, [])
+
+    def load_volume(self, recording_id, frame, channels=None):
+        """Download only the small declared imaging pilot and return one CZYX frame.
+
+        Frames outside the hosted pilot raise MissingComponentError with upstream
+        resolution details. Original multi-GB recordings are never auto-downloaded.
+        """
+        import h5py
+        import numpy as np
+
+        entry = self.manifest["components"].get(recording_id, {})
+        volume = entry.get("volume")
+        if volume is None or frame not in volume["frames"]:
+            raise MissingComponentError(
+                f"No hosted frame {frame} for {recording_id}; consult metadata/upstream_assets.json"
+            )
+        with h5py.File(self._file(volume["path"]), "r") as h:
+            data = h[f"frames/{frame}"][()]
+        return data if channels is None else np.take(data, channels, axis=0)

src/cell_tracking/data/wormtrack_verify/inventory.py

@@ -0,0 +1,66 @@
+"""Pin official source metadata without bulk acquisition."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import requests
+
+DANDI_COHORTS = {
+    "000541": "EY",
+    "000692": "KK",
+    "000565": "SK1",
+    "000472": "SK2",
+    "000776": "SF",
+    "000715": "NP",
+    "000714": "HL",
+    "001623": "Dunn",
+    "000981": "Chemosensory",
+}
+ZENODO = {"17561700": "ASCENT", "10818810": "ZephIR", "10008744": "Targettrack"}
+WORMND_COMMIT = "0c74e9ddffee138cfc6330ab65c0e690e8e199dd"
+
+
+def inventory(workspace):
+    """Save release metadata, immutable asset IDs/checksums, and the original split CSV.
+
+    Re-running an inventory captures the current latest upstream release. Assembly
+    uses saved snapshots, never silently updates an existing experiment. Original
+    data licenses are taken from release metadata, separately from code licenses.
+    """
+    out = Path(workspace) / "audit"
+    out.mkdir(parents=True, exist_ok=True)
+    for identifier in DANDI_COHORTS:
+        base = f"https://api.dandiarchive.org/api/dandisets/{identifier}/versions/"
+        versions = requests.get(base, timeout=60)
+        versions.raise_for_status()
+        versions = versions.json()
+        versions = versions.get("results", versions) if isinstance(versions, dict) else versions
+        published = [v["version"] for v in versions if v["version"] != "draft"]
+        version = max(published) if published else "draft"
+        metadata = requests.get(base + version + "/", timeout=60)
+        metadata.raise_for_status()
+        (out / f"dandi-{identifier}-pinned.json").write_text(json.dumps(metadata.json(), indent=2))
+        assets = []
+        url = base + version + "/assets/?page_size=1000"
+        while url:
+            response = requests.get(url, timeout=60)
+            response.raise_for_status()
+            page = response.json()
+            assets.extend(page["results"])
+            url = page.get("next")
+        (out / f"dandi-{identifier}-assets.json").write_text(
+            json.dumps({"version": version, "assets": assets}, indent=2)
+        )
+    for identifier in ZENODO:
+        response = requests.get(f"https://zenodo.org/api/records/{identifier}", timeout=60)
+        response.raise_for_status()
+        (out / f"zenodo-{identifier}.json").write_text(json.dumps(response.json(), indent=2))
+    url = (
+        f"https://raw.githubusercontent.com/focolab/WormND/{WORMND_COMMIT}"
+        "/neuron_tracking/3deecelltracker/dataset_split.csv"
+    )
+    response = requests.get(url, timeout=60)
+    response.raise_for_status()
+    (out / "wormid-tracking-split.csv").write_text(response.text)

src/cell_tracking/evaluation/__init__.py

@@ -0,0 +1 @@
+"""WormTrack-Verify benchmark helpers."""

src/cell_tracking/evaluation/wormtrack_verify.py

@@ -0,0 +1,245 @@
+"""Explicit pilot diagnostics for association-only corruption and abstention.
+
+These metrics are defined in the benchmark specification, not replacements for
+canonical HOTA/IDF1. Detections stay fixed. One global identity alignment is allowed.
+"""
+
+from __future__ import annotations
+
+import itertools
+
+import numpy as np
+import pandas as pd
+from scipy.optimize import linear_sum_assignment
+from sklearn.metrics import average_precision_score, roc_auc_score
+
+from cell_tracking.data.wormtrack_verify.adapters import TRUSTED, XYZ, validate_tracks
+
+
+def corrupt_tracks(tracks, *, kind, seed, start_frame, stop_frame=None, pair=None):
+    """Deterministic swaps/fragmentation with row-level error labels and fixed observations.
+
+    Labels mark correspondence to the original reference identity. Purely global
+    renaming is not an error; start_frame must follow the first reference frame.
+    Original images, detection IDs, and coordinates are preserved.
+    """
+    validate_tracks(tracks)
+    if not set(tracks.annotation_type).issubset(TRUSTED):
+        raise ValueError("Corruptions require independently trusted source annotations")
+    if tracks.recording_id.nunique() != 1 or tracks.label_set.nunique() != 1:
+        raise ValueError("Corrupt one recording and one label set at a time")
+    frames = sorted(tracks.frame_index.unique())
+    if start_frame <= frames[0] or start_frame > frames[-1]:
+        raise ValueError("Corruption must follow the identity anchor and lie inside the recording")
+    stop_frame = frames[-1] + 1 if stop_frame is None else stop_frame
+    if stop_frame <= start_frame or stop_frame > frames[-1] + 1:
+        raise ValueError("Invalid corruption interval")
+    rng = np.random.default_rng(seed)
+    ids = sorted(tracks.track_id.unique())
+    if pair is None:
+        if len(ids) < 2:
+            raise ValueError("Need two tracks")
+        pair = list(rng.choice(ids, 2, replace=False))
+    if len(pair) != 2 or pair[0] == pair[1] or not set(pair).issubset(ids):
+        raise ValueError("Pair must identify two distinct source tracks")
+    df = tracks.copy()
+    df["reference_track_id"] = df.track_id
+    interval = (df.frame_index >= start_frame) & (df.frame_index < stop_frame)
+    affected = interval & df.track_id.isin(pair)
+    if not affected.any():
+        raise ValueError("No observations in the selected corruption interval")
+    if kind in {"single_frame_swap", "persistent_swap", "swap_recovery", "nearby_swap"}:
+        if kind == "single_frame_swap":
+            affected &= df.frame_index == start_frame
+        df.loc[affected, "track_id"] = df.loc[affected, "track_id"].map(
+            {pair[0]: pair[1], pair[1]: pair[0]}
+        )
+    elif kind == "fragmentation":
+        affected = interval & (df.track_id == pair[0])
+        df.loc[affected, "track_id"] = pair[0] + f":fragment:{seed}"
+    elif kind == "dropout":
+        affected = interval & (df.track_id == pair[0])
+        df.loc[affected, "validity"] = False
+    else:
+        raise ValueError(f"Unsupported pilot corruption: {kind}")
+    df["is_error"] = affected
+    df["corruption_type"] = kind
+    df["seed"] = seed
+    df["scenario_id"] = f"{kind}:seed{seed}"
+    return df
+
+
+def association_metrics(reference, prediction):
+    """Score shared oracle detections with one recording-wide identity permutation.
+
+    Missing predictions count against coverage and correct-observation rate.
+    Switches are changes in predicted identity along each reference trajectory;
+    fragmented runs also count reappearance after a missing prediction. Evaluation
+    covers only source-supported reference observations, not unannotated frames.
+    """
+    validate_tracks(reference)
+    validate_tracks(prediction)
+    if reference.recording_id.nunique() != 1 or prediction.recording_id.nunique() != 1:
+        raise ValueError("Evaluate each independent recording separately")
+    if reference.recording_id.iloc[0] != prediction.recording_id.iloc[0]:
+        raise ValueError("Mismatched recording")
+    key = ["frame_index", "detection_id"]
+    valid_prediction = prediction.loc[prediction.validity]
+    joined = reference.loc[reference.validity].merge(
+        valid_prediction[key + ["track_id"]],
+        on=key,
+        how="left",
+        suffixes=("_gt", "_pred"),
+        validate="one_to_one",
+    )
+    gt = sorted(joined.track_id_gt.unique())
+    pred = sorted(valid_prediction.track_id.unique())
+    counts = (
+        pd.crosstab(joined.track_id_gt, joined.track_id_pred)
+        .reindex(index=gt, columns=pred, fill_value=0)
+        .to_numpy()
+    )
+    mapping = {}
+    if counts.size:
+        rows, cols = linear_sum_assignment(-counts)
+        mapping = {pred[c]: gt[r] for r, c in zip(rows, cols, strict=True)}
+    correct = joined.track_id_pred.map(mapping).eq(joined.track_id_gt)
+    switches = fragments = 0
+    for _, group in joined.sort_values("frame_index").groupby("track_id_gt"):
+        ids = group.track_id_pred.tolist()
+        observed = [i for i in ids if pd.notna(i)]
+        switches += sum(a != b for a, b in itertools.pairwise(observed))
+        fragments += max(
+            0,
+            sum(
+                pd.notna(v) and (j == 0 or pd.isna(ids[j - 1]) or v != ids[j - 1])
+                for j, v in enumerate(ids)
+            )
+            - 1,
+        )
+    extra = len(
+        valid_prediction.merge(joined[key], on=key, how="left", indicator=True).query(
+            '_merge == "left_only"'
+        )
+    )
+    return {
+        "reference_observations": len(joined),
+        "predicted_observations": len(valid_prediction),
+        "coverage": float(joined.track_id_pred.notna().mean()),
+        "correct_observation_rate": float(correct.mean()),
+        "identity_switches": int(switches),
+        "fragmentations": int(fragments),
+        "extra_observations": int(extra),
+    }
+
+
+def reference_residual_scores(tracks, reference_cloud, *, physical=True):
+    """Identity-sensitive distance from the fixed first-frame reference.
+
+    This intentionally simple consistency diagnostic includes genuine tissue motion.
+    It is not an independent deformation model or a certificate of correctness.
+    Reference cloud must come from an independently trusted reference observation.
+    """
+    cols = [f"{a}_um" for a in "xyz"] if physical else XYZ
+    ref = reference_cloud.set_index("track_id")
+    if ref.index.duplicated().any():
+        raise ValueError("Reference identities must be unique")
+    a = tracks[cols].to_numpy(dtype=float)
+    b = ref.reindex(tracks.track_id)[cols].to_numpy(dtype=float)
+    scores = np.linalg.norm(a - b, axis=1)
+    scores[~tracks.validity.to_numpy()] = np.inf
+    # Unseen fragment IDs are unsupported; preserve absence rather than fit a new anatomy.
+    scores[np.isnan(scores)] = np.inf
+    return scores
+
+
+def verifier_metrics(scores, is_error, *, threshold):
+    """Fixed-population selective risk/coverage; ties enter a risk curve together.
+
+    False certification = accepted errors / all labeled errors. Selective risk =
+    accepted errors / accepted observations. Unsupported scores abstain. Threshold
+    must be specified before evaluation; this function does not select it.
+    """
+    scores = np.asarray(scores, dtype=float)
+    labels = np.asarray(is_error, dtype=bool)
+    if len(scores) != len(labels) or not len(scores) or np.isnan(scores).any():
+        raise ValueError("Scores and labels must be aligned, nonempty, and non-NaN")
+    if np.isnan(threshold):
+        raise ValueError("Threshold cannot be NaN")
+    accept = np.isfinite(scores) & (scores <= threshold)
+    # Infinity denotes abstention; map it above all finite scores for ranking metrics.
+    finite = scores[np.isfinite(scores)]
+    ranked = np.where(np.isfinite(scores), scores, (finite.max() + 1 if len(finite) else 1))
+    both = labels.any() and not labels.all()
+    curve = []
+    order = np.flatnonzero(np.isfinite(scores))
+    order = order[np.argsort(scores[order], kind="stable")]
+    if len(order):
+        ordered_scores = scores[order]
+        cumulative_errors = np.cumsum(labels[order])
+        ends = np.r_[np.flatnonzero(np.diff(ordered_scores) != 0), len(order) - 1]
+        curve = [
+            {
+                "threshold": float(ordered_scores[i]),
+                "coverage": float((i + 1) / len(scores)),
+                "risk": float(cumulative_errors[i] / (i + 1)),
+            }
+            for i in ends
+        ]
+    return {
+        "observations": len(scores),
+        "error_prevalence": float(labels.mean()),
+        "auroc": float(roc_auc_score(labels, ranked)) if both else None,
+        "auprc": float(average_precision_score(labels, ranked)) if both else None,
+        "false_certification_rate": float((accept & labels).sum() / labels.sum())
+        if labels.any()
+        else None,
+        "certified_coverage": float(accept.mean()),
+        "selective_risk": float(labels[accept].mean()) if accept.any() else None,
+        "correct_certified_coverage": float((accept & ~labels).mean()),
+        "threshold": float(threshold),
+        "risk_coverage": curve,
+    }
+
+
+def oracle_association_baseline(detections, *, method="hungarian", physical=True):
+    """Untrained Euclidean nearest-neighbor or bipartite association on fixed detections."""
+    if method not in {"nearest_neighbor", "hungarian"}:
+        raise ValueError(method)
+    cols = [f"{a}_um" for a in "xyz"] if physical else XYZ
+    output = []
+    previous = None
+    next_id = 0
+    for frame, points in detections.sort_values("frame_index").groupby("frame_index"):
+        points = points.copy().reset_index(drop=True)
+        xyz = points[cols].to_numpy(dtype=float)
+        if not np.isfinite(xyz).all():
+            raise ValueError("Baseline requires valid coordinates in the selected units")
+        ids = [None] * len(points)
+        if previous is not None:
+            old_xyz, old_ids = previous
+            distance = np.linalg.norm(old_xyz[:, None] - xyz[None], axis=2)
+            if method == "hungarian":
+                rows, columns = linear_sum_assignment(distance)
+            else:
+                pairs = sorted((distance[i, j], i, j) for i, j in enumerate(distance.argmin(1)))
+                chosen = set()
+                matches = []
+                for _, i, j in pairs:
+                    if j not in chosen:
+                        matches.append((i, j))
+                        chosen.add(j)
+                rows = [p[0] for p in matches]
+                columns = [p[1] for p in matches]
+            for i, j in zip(rows, columns, strict=True):
+                ids[j] = old_ids[i]
+        for i, identity in enumerate(ids):
+            if identity is None:
+                ids[i] = f"baseline:{next_id}"
+                next_id += 1
+        points["track_id"] = ids
+        points["annotation_type"] = "algorithm_prediction"
+        points["label_set"] = "prediction"
+        output.append(points)
+        previous = xyz, ids
+    return pd.concat(output, ignore_index=True)