docs/STATUS.md

Status against the 12-week plan

2026-09-13 correction: the historical decoder results below used incorrect intrinsic/FoV supervision and biased validation subsets. They do not establish the value of geometry pretraining. The repaired implementation and its validation are described in the repair report. Formal training with the repaired code and full test/OOD comparisons remain to be run.

Design-doc section 14 lays out twelve weeks with four go/no-go gates. This maps each row to what exists in this repository, what was measured, and what is blocked and why. Nothing below is aspirational: every "done" has a command that reproduces it.

Legend: done = implemented and verified with measured numbers · code-complete = implemented and unit-tested, not yet run at the doc's scale · blocked = cannot be done here, with the reason.

week	plan	status	evidence
1	environment, VACE inference, AnyCalib/GeoCalib baselines; 50-image closure report; gate < 0.05 px	done	tests/test_cameras.py::test_projection_closure — all five models close at machine precision (median 0.00e+00, p99 < 1e-13 px), against a gate of 0.05 px. Official AnyCalib (320 M) and GeoCalib (28.9 M) checkpoints load and are wrapped as baselines. Our camera models agree with AnyCalib's own implementations to < 1e-4 deg (tests/test_third_party_agreement.py).
2	OpenPano download, trajectory pool, ERP rendering; 200-clip smoke set; no leakage / seam / misalignment	done	749 panoramas fetched. tools/render_calib_clips.py produced 200 clips in 285 s with zero split leakage and zero integrity errors. End-to-end render geometry verified to ~7e-6 deg by decoding a coordinate-encoding panorama.
3	three camera models, overlays, QC; 10k-clip MVP; auto QC pass rate > 99%	done	MVP tier: 11,984 clips from 749 panoramas, AnyCalib's exact 0.34/0.33/0.33 mixture. tools/validate_dataset.py gate passes at pass-rate 1.000 on a 400-clip random sample of the MVP tier with every check enabled, including the two that decode and re-render the stored overlay video; zero clips failed anything.
4	video baselines and solver; single-frame/video table; dense field to parameters converges > 95%	done	tools/fit_camera_from_field.py recovers every clip's parameters: solver success 1.0, family accuracy 1.0, median ray AE < 1e-3 deg on the generated data. The single-frame / frame-pooled / video table is measured on the MVP test split (docs/RESULTS.md section 11), together with the clip-length sweep, which shows the same trained model improving 15.68 -> 11.82 deg from 1 to 17 frames and saturating there. At 4,000 steps (~1.5 epochs) the temporal architecture does not yet pay for its extra parameters, and all three of our models sit 3x behind published AnyCalib -- so the week-4 gate's premise (a saturated simple baseline) does not hold yet.
5	VACE Stage 1a	gate passed at reduced scale	tools/train_vace_overlay.py with the real Wan2.1-VACE-1.3B checkpoint: 30 layers, dim 1536, 12 heads, 15 VACE blocks, token grid 21 x 30 x 52 — all confirmed against the published config. Rectified-flow objective, frozen base. The overfit gate passes: measured at fixed timesteps with fixed noise, the flow-matching loss on a held clip drops 0.648 -> 0.085 (7.6x) over 1,200 steps on 16 clips. Not trained to the doc's 25k steps at 81 frames / 480p, which is 116 GPU-hours on one H200 at the throughput measured in docs/RESULTS.md.
6	VACE Stage 1b	code-complete	Stage-1b overlays generated for the whole MVP tier with the doc's 40/30/20/10 task mixture; --stage 1b --resume continues from Stage 1a.
7	intermediate features and decoder; L/tau ablation	runs end to end at reduced scale	DiTFeatureHooks hooks blocks[L] and vace_blocks[k] and reshapes the padded token sequence back to [B, 1536, 21, 30, 52] (verified against the real checkpoint); layer / tau / source are arguments with the doc's ablation grids as defaults. train_geometry_decoder.py --backbone vace trains a 4.9 M-parameter decoder on the frozen 2.15 B backbone: the loss falls and validation ray AE is produced. What the DiT is fed at time tau is the choice that is not obvious and is documented in the code -- the RGB clip's own noised latent, because that is what exists at test time. Not run at the doc's 30k-step budget: the frozen backbone forward is the per-step cost.
8	Lensfun/Optiland profile bank; unseen-lens test set	done	Built bank: 6,474 profiles across 1,436 families (6,432 Lensfun + 42 Optiland), all converted to pixel -> ray. Distortion families covered: pincushion 2,732, barrel 2,203, negligible 1,326, moustache 177, fisheye 36. Family-level splits give a fully disjoint unseen-family test set (test_families_unseen_fraction = 1.0). Two gaps documented rather than hidden: 4,255 of the profiles are near-duplicates, and no open source covers decentred distortion (correction 7).
9	TUM VI / KITTI-360 / ADT evaluation	blocked	KITTI-360 and ADT need registration; TUM VI is public but was not fetched. Adapters and the fetcher exist (tools/build_trajectories.py --source tumvi, fetch.py info kitti360).
10	real 7V GT and fine-tuning	blocked	Needs the vehicle, the rig and the calibration workflow. The manifest fields, split policy and weak-GT weighting are implemented.
11	full ablations, downstream VIO/3DGS	partial	AblationTable tracks all 22 ablations the doc lists and reports coverage. Downstream: straight-line residual and rectification-flow error are implemented detector-free and verified exact for a correct camera; VIO/SLAM and 3DGS are declared and explicitly marked not-run.
12	paper and open-source cleanup; data card, model card	done for the repository	docs/DATA.md, docs/CONVENTIONS.md, this file, docs/RESULTS.md. Every experiment is reproducible from a manifest plus a config; every generated clip records its generator version, encoder settings and SHA-256.

The four gates

1. Week 3 — "if the synthesiser's closure is not exact, stop all training." Passed with margin: projection closure is at machine precision, 10^12 times better than the 0.05 px gate, and the end-to-end render (unproject, rotate, ERP map, sample, decode) closes to ~7e-6 deg.
2. Week 4 — "if a simple video baseline already saturates, redefine VACE's value as cross-domain generalisation rather than average accuracy." Answered: it has not saturated. All three of our trained baselines sit at 9.5-11.8 deg median ray AE against published AnyCalib's 3.42 deg on the same test clips through the same metric code -- 3x of headroom, so redefining VACE's value on saturation grounds would be premature. Two supporting measurements: the clip-length sweep shows the same trained model improving 15.68 -> 11.82 deg from 1 to 17 frames and saturating there, so frames do carry usable information; and temporal aggregation alone cuts gravity error 10x versus a single frame (1.29 -> 0.13 deg) with no learned model at all. What did not pay off at this budget is the temporal architecture: at 4,000 steps it has 36% more parameters than the frame-pooled model and is worse than it. See docs/RESULTS.md section 11 for the caveats, chiefly that clean renders from a static panorama are the regime where aggregation should help least.
3. Week 7 — "if VACE features are no better than a small video network, cut the generative training." Not reached; the decision requires the Stage-1a/1b training budget.
4. Week 10 — "if the real 7V domain gap persists, fix the ISP/crop/EIS metadata first." Not reached; blocked on the rig.

Corrections to the design doc

Found while implementing, and fixed here rather than reproduced:

1. Feature cache arithmetic (section 10). The doc says caching raw DiT features for 50k clips is "about 4.8 PiB". 96 MiB x 50,000 = 4.6 TiB; the figure is 1000x too large. The conclusion (do not cache at scale) is unaffected, and feature_bytes_per_clip documents both numbers.

2. Residual field versus prediction noise (sections 11.1, 17.3). The doc's rule — declare a lens non-parametric when the edge residual stays large — fires on white noise of the same magnitude. Measured: 0.5 deg of isotropic ray noise produced an edge P95 of 1.23 deg, well over the 0.25 deg threshold, with no lens residual present at all. Added residual_structure, the spatial autocorrelation of the signed tangent residual: 0.002 for white noise, 0.989 for a smooth lens residual, 0.668 for a mixture. Selection now requires both a large edge residual and spatial structure.

3. Trajectory amplitudes are duration-dependent. The doc's motion families are specified for the reference 81-frame, 16 fps (5 s) clip. Reusing the same amplitudes for a 9-frame clip packs the same rotation into 0.5 s and violates the angular-velocity limit. duration_scale now scales amplitudes with clip duration so the rates stay constant; violations across 5 clip lengths x 6 seeds x 200 clips are zero.

4. The global head needs supervision. The head that section 10 specifies (FoV, principal point, gravity, uncertainty) received no gradient in the first implementation, because the loss list of section 11 never references it — yet section 11.1 step 2 uses its output to initialise the solver. Added FoV, principal-point, clip-level-gravity and uncertainty-calibration terms; a test now asserts every head receives finite gradients.

5. EUCM's sampled alpha/beta range exceeds the stated FoV range. The example parameters in section 7.4 (alpha=0.63, beta=1.34, fx=241 at 832 px wide) give a ~253 deg horizontal FoV, not the <= 180 deg the section-7.2 sampling range implies. The sampler therefore solves for the focal length from a target FoV and rejects on the achieved FoV, rather than sampling alpha/beta/f independently.

6. Stage-1b colour encodings must be decodable. The doc asks for perceptual colour maps ("latitude continuous colour map"). A perceptual map is not invertible, so the target cannot be validated. Both are provided: perceptual for contact sheets and papers, and an invertible codec family used as the actual generation target, with round-trip error through 8-bit video measured at 0.18 deg (latitude), 0.06 deg (up), 0.22 deg (ray).

7. The open profile bank cannot cover decentred distortion. Section 8.3 grades the bank on covering barrel, pincushion, moustache, fisheye and "clearly asymmetric / decentred residuals", and section 8.1 presents the open path as an equivalent substitute for LensView. It is not, on that last family: Lensfun's three present models (ptlens, poly3, poly5) are radial in one variable, the database holds no acm entries (the only format with tangential terms), and Optiland's sample designs are centred. Measured on the built bank: p1, p2 fitted from 120 real profiles stay within +-2e-4 of zero. The v1 synthetic sampling does not fill the gap either, because it follows AnyCalib's radial:1 with p1 = p2 = 0. Decentring is therefore carried only by the non-parametric residual field, which represents it but provides no training signal for it. docs/DATA.md states this rather than letting the family counts imply coverage.

8. The ray and gravity angular losses cannot be arccos. Section 11 specifies acos(clamp(r_pred . r_gt)), which is the right metric and the wrong loss: its derivative is -1/sqrt(1 - cos^2), infinite at zero error. Measured here -- at exactly zero error arccos produces a NaN gradient; at 1e-7 rad it produces a gradient of 2.7e7. The consequence is that a run turns to NaN precisely because it started fitting, which is how this was found: the decoder overfit gate reached ~0 gravity error at step ~200 and every loss term went NaN together. stable_angle uses the half-angle form 2 * atan2(||a - b||, ||a + b||), which agrees with arccos to 4e-9 degrees, has a bounded derivative (0.203 at 1e-7 rad), and is used by every angular loss; arccos stays in the metrics, where no gradient is taken. tests/test_geometry.py asserts both the agreement and that the bad case is still bad, so the two cannot be confused again.

9. "Single frame" has to mean one frame. Doc section 15 asks for a capacity-matched single-frame baseline. The obvious implementation -- take the video network and delete the temporal blocks -- is not one: it still ingests every frame of the clip and pools them into the clip-level ray field, so it measures whether explicit temporal mixing helps, not whether video beats a single frame. Verified structurally: with temporal=False the encoder has 0 SpaceTimeBlock and the decoder 0 TemporalAttention, yet a 17-frame input still produces one clip-level ray field. The three configurations are now distinct and separately named -- video (temporal mixing over N frames), frame_pooled (no temporal mixing, N frames pooled), and single_frame (same architecture, --frames forced to 1) -- because the first version's naming would have turned a temporal-mixing ablation into an unsupported claim about video versus single frame.

Implementation findings

Not errors in the plan -- integration details that fail silently or confusingly, recorded so they are not rediscovered.

• enable_gradient_checkpointing was a no-op. The natural first implementation sets a flag on each block; the upstream Wan blocks never read it, so nothing changed and the 81-frame 480p step OOMed at over 90 GiB. It now wraps all 45 block forwards in torch.utils.checkpoint with use_reentrant=False (required -- the blocks take keyword arguments), and the same step runs in 41.7 GiB.

• Wan's forward must be wrapped in a bf16 autocast. time_embedding forces float32 internally and hands the result to bf16 blocks; without the wrapper the first attention fails on a dtype mismatch. WanVaceBackbone.forward does it so callers cannot forget.

• VACE's context is [inactive | reactive | mask], 16 + 16 + 64 = 96 channels. Putting the conditioning latent in the wrong slot does not crash; the branch simply receives the RGB in the slot reserved for the region it is supposed to invent. build_vace_context names the split and validates the channel count.

• Freezing has to be verified by comparison, not inspection. After an optimiser step, patch_embedding.weight is bit-identical (max delta 0) while vace_blocks.0.modulation moves by 5.9e-03 -- that check is what actually demonstrates the base is frozen.

• GeoCalib's gravity vector is the negation of ours. Its Gravity.from_rp is (-sin r cos p, -cos r cos p, sin p) against our (sin r cos p, cos r cos p, -sin p). The first adapter carried it through unchanged and the evaluation reported ~147 degrees of gravity error, which reads as a broken model rather than a broken adapter. tests/test_third_party_agreement.py now pins the conversion against GeoCalib's own class rather than against a remembered formula.

• Fixing a baseline's camera family measures the mismatch, not the baseline. Evaluating AnyCalib with cam_id="pinhole" on 230-degree EUCM clips gives 34 degrees of ray error -- a number about the protocol, not the model. AnyCalib predicts a dense ray field and fits whatever family it is asked for, so the fair protocol passes each clip's true family (--anycalib-camera gt), and the fixed-family run is reported separately as the cost of getting model selection wrong.

• This cuDNN build cannot run the bf16 convolution backward at all for two whole classes of convolution. Measured here (cuDNN 9.21, H200), all in the backward and all reported as a bare RuntimeError: GET was unable to find an engine to execute this computation that names neither the layer nor the reason:

  convolution	with cuDNN	cuDNN disabled
  Conv2d(64, 128, 1, stride=1)	works	works
  Conv2d(64, 128, 3, stride=1)	works	works
  Conv2d(64, 128, 2, stride=2)	fails	works
  Conv2d(64, 128, 3, stride=2)	fails	works
  Conv2d(64, 128, 7, stride=4)	fails	works
  Conv2d(1552, 256, 1)	works	works
  Conv2d(1554, 256, 1)	fails	works
  Conv2d(64, 8, 1)	works	works
  Conv2d(64, 4, 1)	fails	works

  So: any stride > 1, and any 1x1 whose channel counts are not 8-aligned. Both are natural to write here -- an RGB stem is Conv2d(3, 64, 7, stride=4), a stage downsample is stride 2, the neck input is 1536 DiT channels plus 18 coordinate-PE channels, and the heads project to 2, 4 and 12 channels.

  Two responses, both kept. AlignedConv1x1 / AlignedConv2d pad both channel counts to a multiple of 8 and slice the output back, which is good practice regardless and makes the model portable; a test asserts structurally that no convolution anywhere in the model is misaligned. And ensure_conv_backend probes the shapes this project uses at trainer construction and disables cuDNN only if they fail, logging what it changed. On this machine the fallback costs nothing: a full training step of the video baseline (batch 2, 9 frames, 240x416) takes 0.117 s either way.

• The Wan VAE compresses time 4x, so the DiT predicts at latent-frame rate. A 33-frame clip becomes 9 latent frames, and the per-frame heads produce 9 predictions, not 33. Comparing those with 33 frames of labels is a shape error if you are lucky and a silently wrong loss if broadcasting saves you. latent_frame_centres encodes Wan's causal grouping -- frame 0 maps to latent 0, then each group of 4 -- and upsample_to interpolates on those centres rather than on a naive linspace.

• A single-batch loss is not a readable trend, and neither is a 12-clip validation median. One batch of 4 clips mixes a 65-degree pinhole with a 250-degree fisheye -- different problems -- so the instantaneous loss swings by about 2 nats with no change in the model, and the von Mises-Fisher term amplifies it. Observed on a real run: instantaneous loss 1.02 / 0.12 / 0.23 over three consecutive log points while the 100-step mean fell monotonically 2.82 / 1.78 / 1.31. The training log now reports both. This is the same mistake as reading the rectified-flow loss as a curve, in a different guise: the fix in both cases is to hold constant whatever is varying.

• Tracking best_val without saving it makes selection impossible. The first implementation recorded the best validation ray AE and then wrote the final weights, so a run whose validation degraded shipped the worse model -- while doc section 10 says explicitly that the decoder is chosen on validation ray angular error. decoder.pt is now the selected checkpoint (best, or final if final is better), decoder_final.pt and decoder_best.pt are both kept, and the summary records which was chosen and at which step.

• Label generation, not the GPU, is what limits training throughput. The up field is two camera projections per pixel per frame; generating it at 832x480 and resizing to the 240x416 training grid cost about 8x more than generating it at 240x416 directly, and expanding all 81 frames of a clip when a sample uses 17 cost another ~5x. Measured per clip: 13.5 s at full resolution and all frames, 1.66 s at the training stride and the selected frames. Two further cuts followed from looking at the profile rather than guessing: the validation set does not need the up field or latitude at all (it measures ray angular error), and QC was unprojecting the same pixel grid twice per clip. With the GPU step at 0.117 s, anything above that in the loader is the whole cost of a run.

• Grouped 3-D convolution has bf16 kernel gaps too. The temporal depthwise convolution was originally a Conv3d with a (k, 1, 1) kernel; it is now the arithmetically identical grouped Conv1d over [B*H*W, C, T], which has full kernel coverage and is faster. A test pins the equivalence.

• The rectified-flow training loss cannot be read as a curve. It resamples the timestep every step and the objective's magnitude depends strongly on it, so consecutive losses vary ~5x with no learning involved. evaluate_fixed_timesteps holds the timestep, the noise and the clip fixed; that is what the gate uses.

Paper tier (doc sections 9.1, 12.4, 13.1)

The MVP tier answered doc section 15 with a clean dataset, and that turned out to be the limit of what it could answer. Rendering a static panorama with no noise, no occlusion and no exposure integral gives every frame of a clip identical lens information, so temporal aggregation has nothing to suppress and the measured result -- a video network no better than a single frame -- is a statement about the data, not about video. The paper tier exists to make the claim testable.

What changed

• Imaging conditions (vidicalib/render/conditions.py), mixed per clip at the doc's section 9.1 weights: clean 0.40, noise 0.12, night 0.12, low_texture 0.12, motion_blur 0.08, dynamic_occlusion 0.16. --conditions default on tools/render_calib_clips.py; --conditions clean (the default) reproduces the MVP path exactly.
• Motion blur is an exposure integral, not a post-process. Each output frame is the mean of sub-frames whose orientations are interpolated across exposure_fraction of the interval to the next frame, so the smear follows the actual motion and its length varies with the local angular velocity.
• Measured-profile OOD clips (tools/render_ood_clips.py): real Lensfun and Optiland profiles from lens families the training split never contains, rendered through render_clip_rays with the profile's own ray grid as the ground truth.

Findings

• Every pixel has to be visible in some frame, and that does not happen by itself. The point of dynamic occlusion is the asymmetry -- a per-frame method cannot recover an occluded region from that frame, a temporal one can, because the occluders move. A pixel hidden in every frame is recoverable by nothing and only adds label noise. Two independently sampled occluders can between them cover a pixel for a whole clip: rare per pair, but at four occluders it happened on 1 seed in 6 and hid 5.6% of pixels permanently. Occluders are now accepted greedily under the invariant -- a candidate is kept only if, after compositing it, essentially every pixel is still visible somewhere. Measured over 24 seeds at four clip shapes: 28-38% mean occlusion, worst-case permanently-hidden fraction 0.0008, at a cost of about one rejection per clip. On the 230-clip full-resolution pilot the worst case was 0.00047.
• A clip can be assigned motion blur and have none. On a stop-and-go trajectory the camera is stationary, the exposure integral is a no-op, and the render is byte-identical to the clean one -- physically correct, but it would put an easy clip in the "hard" bucket of the results table. The generator now measures the achieved blur (exposure_sweep_deg / clip_deg_per_px) and relabels the clip clean below half a pixel, recording relabelled_from so the relabelling is visible rather than silent.
• Blur direction needed a single-orientation test to settle. A checkerboard suggested the smear ran the wrong way; a checkerboard has both edge orientations and cannot separate them. With single-orientation stripes the answer is unambiguous: yaw destroys vertical-stripe contrast by 70% and leaves horizontal stripes untouched (0%), pitch does the reverse (69% against 9%).
• Running the conditions on the CPU cost more than rendering the clip. At 832x480x81 each non-clean condition takes 19-32 s on CPU against 18.5 s for the render itself, and with twelve render workers on twenty-four cores the thread oversubscription made it worse: throughput fell from 0.65 to 0.121 clips/s, a 5x regression, for work that is 0.0-0.35 s on the GPU. The conditions now run on the device the frames are already on, and the pilot measured 0.70 clips/s -- slightly faster than the clean MVP run. The scalar parameters (which condition, how strong, where the occluders go) still come from a CPU generator, so they stay reproducible across devices; only the per-pixel noise realisation is device-local, because drawing 400M samples on the CPU and copying them costs more than the render.
• The condition RNG must not be seeded from hash(). Python salts string hashing per process, so seeding from hash(clip_id) would have given a different condition for the same clip on every run -- unreproducible in the way that is hardest to notice, since any single run looks perfectly consistent. It uses zlib.crc32 instead.
• 88% of held-out lens profiles have no converged parametric fit. The OOD ground truth therefore cannot be "the fitted Brown-Conrady": of the 12% that do fit, the fit is off from the true profile by a median of 0.007 degrees but up to 1.0 degree, which is the same order as the effect being measured. The profile's own ray grid is stored as the ground truth instead, evaluated on both the output and the supersampled lattice rather than interpolated from one to the other. Round-trip through the manifest is exact to 2.4e-6 degrees, the arccos metric's own noise floor.
• An ablation that runs is not an ablation that varies anything. The doc section 12.4 pair fixed_principal_point / variable_principal_point ran green and produced byte-identical rows, including the principal-point error itself. fit_camera's principal_point argument only seeds the multistart and centres the pixel sampler; the optimiser then moved cx, cy straight back to the truth. Holding a parameter requires removing it from the step, which is now done by solving the reduced normal equations -- not by computing the full step and zeroing the fixed entries, which would let the remaining parameters absorb a direction they should never have seen. Measured on a camera whose principal point is 8.5 px off centre: free recovers (112.00, 55.00) exactly at 0.0000 degrees, fixed holds (103.50, 59.50) exactly at 2.95 degrees. Four tests pin it, including one asserting that on a centred camera the constrained and unconstrained fits agree -- the check that distinguishes a reduced solve from a zeroed one.
• The measured-profile renderer is the same renderer. render_clip_rays and render_clip share _sample_frames; a test asserts that feeding a parametric camera's own ray field to the measured path reproduces its render bit for bit, so the OOD numbers cannot be an artefact of a second implementation.

The mainline: VACE generative geometry pre-training (doc Phase 1a/1b/2)

Everything reported before this section used --feature-source base: the raw Wan2.1 video-generation features with no geometric pre-training at all. That is not the design doc's method. The doc's mechanism is Stage 1a (sparse geometry overlays) then Stage 1b (dense ray / latitude / up encodings) as generative pre-training of the VACE branch, and only then reading features out for the geometry decoder. Running the mainline is what this section records.

The doc is unambiguous that the base stays frozen -- sections at lines 12, 56, 518, 533 and 764 all say so, and 764 lists it as the cost-control measure. Only the VACE branch trains: 735 M of 2,154 M parameters.

Stage 1a, as run

8,500 optimizer steps, 81 frames, 480p, 56.9 wall-hours. The recorded batch history is 3,250 steps at batch 1 followed by 5,250 at batch 3: approximately 19,000 sample presentations on the retained branch, not 25,500. The design document specifies 25,000 steps, so this is not the same training budget. The 8,500-step stopping point was a user-approved adjustment. Fixed-timestep flow-matching loss 1.100 -> 0.031, a 36x reduction. Two methodological discontinuities are baked into that curve and it must not be read as one trajectory: batch changed 1 -> 3 at step 3,250, and the cosine schedule was re-scoped from 25,000 to 8,500 steps at step 3,500, which stepped the learning rate down from 9.7e-5 to 8.3e-5.

Throughput is flat in batch size: 13.71 s/sample at batch 1 and 13.66 s/sample at batch 3, i.e. 0.4% apart, while memory went 45.8 GB -> 119.0 GB. The workload is compute-bound on a single 81-frame 480p forward through a 2.15 B DiT, so a larger batch buys wall-clock nothing. Batch 4 needs ~156 GB and does not fit in 143 GB.

A stage that reported success having trained nothing

Stage 1b "completed" in 48 seconds with rc=0 and a normal-looking summary.json. It had trained zero steps.

The resume guard added to make a 100-hour run restartable contained this:

same_stage = str((sd.get("config") or {}).get("stage", args.stage)) == args.stage

The default for the lookup is the value it is compared against, so a checkpoint that records no stage matches every stage -- and none recorded one, because the stage lived in the CLI arguments and never reached the serialised config. Stage 1b therefore restored Stage 1a's optimiser and its step counter of 8,500 against its own budget of 3,334. while step < args.steps was false on entry, the loop never ran, and the stage wrote a summary claiming completion.

The tell was in the summary all along: first_loss: null, last_loss: null, fixed_ratio: 1.0 -- before and after identical to the last decimal -- and two log rows carrying the same numbers. Nothing in the pipeline looked at any of them.

What it cost: the geometry decoder then trained for 17 hours on Stage-1a-only features while being labelled 1a+1b. That run is real but answers a different question, and is reported as such below.

Four things changed:

• the checkpoint records stage at its top level, from the trainer config;
• an absent stage counts as a different stage. Unknown must mean "different", because the unsafe direction inherits an optimiser and a step count across a curriculum boundary;
• resuming at or past the step budget is an error that returns non-zero and refuses to write a summary, instead of completing silently;
• the chain verifies first_loss is not None and steps >= 3000 before it will train a decoder on those weights.

tests/test_models.py pins all four, including the faulty comparison written out as an explicit assertion.

Historical decoder results: not a controlled comparison

actual run	decoder steps	historical best validation ray AE
paper_single_frame, 1 frame	20,000	8.2210 deg
paper_video, 17 frames	20,000	9.1937 deg
fair_vace, base features, no geometry pretraining	1,500	8.0847 deg
Stage-1a-only, vace features	20,000	7.99 deg (conversation record only)
Stage-1a+1b, vace features, pre-fix archive	20,000	7.5741 deg

The original Stage-1a-only decoder weights and logs were overwritten. Its 7.99-degree number cannot be treated as a preserved reevaluable checkpoint. The surviving Stage-1a and Stage-1b branch weights and the pre-fix 1a+1b decoder are archived under archive/2026-09-12_pre_fix/.

These runs changed feature source, training schedule and validation selection; the early convolutional runs used 32 validation clips, and the later VACE runs used the first 128 clips from only two panoramas. All pre-fix decoder training also used inconsistent camera intrinsics after resizing. Neither improvement nor regression in this table can be attributed solely to geometric pretraining. The previous conclusion that sparse-overlay pretraining was nearly useless, or that these runs could refute the design, is withdrawn.

The corrected comparison is implemented in tools/run_vace_controlled.py. For each of base, vace and fused, it independently compares bundled VACE weights, Stage-1a, and Stage-1a+1b with the same decoder settings, feature task, seed and validation subset. Feature-source changes are a separate ablation. Full evaluation uses OpenPano test and the Lensfun/Optiland OOD manifest.