Continuous five-parameter pose refinement numerical validation¶

Contract status: FINAL (FROZEN)

Execution plan status: FINAL

Approved amendment: Forward-validation recovery
Execution status: NUMERICAL VALIDATION COMPLETE — PHASES 0–11 COMPLETE; NO PRODUCTION CALLER
Updated: 2026-08-31
Rebased two-document checkpoint: f78d9dff3
Completed history: completed/continuous_3D_pose_end_polishing_history_and_handoff.md
Completed evidence: completed/continuous_3D_pose_end_polishing_validation_evidence.md
Scientific review: completed/continuous_3D_pose_end_polishing_scientific_review.md

This is the single living development record. The approval-controlled requirements come first. The execution approach and progress record follow the contract approval boundary. After the contract becomes FINAL, the preceding requirements remain frozen unless a requirement review returns the contract to IN REVIEW; implementation discoveries and evidence update only the later execution portion.

How to test the completed numerical package¶

Build SIMPLE through the normal Linux workflow, place the resulting build/bin and build/scripts directories on PATH, and run the single authoritative entry point from the stable project parent:

cd "$HOME/Projects"
bash "$HOME/Projects/hael_SIMPLE-rsync-test/production/tests/pose_cont_validation/run_oracle_validation.sh"

The runner creates one timestamped continuous_3D_pose_validation_* directory directly below ~/Projects, continues through independent cases after an individual failure, and writes the aggregate result to STATUS.txt and analysis/summary.json. A valid package ends with STATUS.txt equal to PASS. The retained PCG reconstruction mother suite is expected to return status 1 only for the exact frozen Phase 2 halfset_fsc disposition; the analyzer rejects any different PCG result. Python 3 is used only by this validation-package analyzer and is not a SIMPLE runtime dependency. The complete prerequisites, contents, and known-PCG rule are documented in production/tests/pose_cont_validation/README.md.

The latest authoritative handoff rerun is ~/Projects/continuous_3D_pose_validation_20260831_121306. Passing this package establishes the numerical and regression contracts in this record. It does not activate pose_cont, add a refine3D caller, or establish real-data utility.

Request and context¶

Hans requested implementation validation before production policy. The existing research code supplies a local five-parameter analytic Jacobian and Levenberg--Marquardt (LM) solve in a Cartesian Fourier-plane workspace. It has passed componentwise finite differences and matched-model capture experiments, but its complete weighted objective, normal equations, LM proposal, and independent forward model have not yet been verified by structurally separate oracles.

Hans also clarified the ownership boundary: particle-pose refinement must not be implemented as a callable feature of reconstructor_pcg. It requires its own particle-pose numerical module. Operations proven independent of reconstruction state may move to a neutral shared module used by reconstruction and pose refinement.

The feature must not be called PCG pose polishing. PCG solves for a 3-D volume at fixed particle poses. The five-parameter LM solves for one particle pose against a fixed volume.

Baseline and problem¶

reconstructor_pcg provisionally contains the Cartesian forward-plane, CTF/sigma, pose-normal-term, and bounded LM routines used by the research tests.
Focused tests cover fast Kaiser--Bessel derivatives, normalized stencils, shift and rotation derivatives, exact-pose stationarity, capture range, route dependence, bounds, and terminal states.
The principal capture observations were generated by the same forward evaluator used by the optimizer, so they do not provide an independent forward-model test.
No normal refine3D workflow calls the five-parameter LM, and ordinary SIMPLE behavior is unchanged.

Substantial risk remains in shell weighting, CTF application, $J^HJ$, $J^Hr$, damping and scaling, the dense five-by-five solve, rollback, shared forward-model assumptions, and numerical ownership. Production integration is premature until these contracts are independently verified and particle-pose code no longer depends on a volume-reconstruction object.

Required outcome¶

Separate particle-pose numerics from the PCG volume solver without intentionally changing the mathematics, then independently validate the Cartesian five-parameter evaluator and LM driver over representative CTF, shell-variance, volume, box, and frequency configurations. The completed work provides numerical evidence and a handoff only; it adds no production caller.

Completion requires:

independent agreement for the weighted objective, gradient, Gauss--Newton matrix, and one damped LM proposal under tolerances frozen before formal acceptance;
explicit finite behavior for valid CTF/sigma configurations and an explicit nonfatal outcome for unusable variance inputs;
separately declared contracts for analytic Fourier objects, tiny-box brute-force DFT, slow Cartesian interpolation, and finite-box projection;
complete pose restoration after every rejected outcome;
consistent results across multiple boxes, Fourier ranges, and asymmetric volumes;
a particle-pose module independent of reconstructor_pcg, with only proven state-independent operations in a neutral shared module;
focused pose and ordinary reconstruction regression evidence on Oracle Linux; and
no UI, production caller, persistence, distributed workflow, or automatic activation.

Passing this endpoint permits a separate future development record for a standalone continuous refine3D validation mode. It does not authorize that caller or normal refinement integration.

Mathematical and numerical contract¶

Pose, prepared reference, and weighted objective¶

For an input pose $(R_0,t_0)$,

$$ q=(\omega_x,\omega_y,\omega_z,t_x,t_y), \qquad R=R_0\exp([\omega]_\times). $$

Rotations are right tangent-space increments in radians and shifts are image-plane pixels of the reference box. A pose-reference constructor accepts the physical volume $X$, applies the inverse Kaiser--Bessel envelope internally,

$$ X_{\mathrm{prep}}=E^{-1}X, $$

and retains one immutable Cartesian Fourier reference until the physical volume changes. Callers do not pass an ambiguously pre-corrected volume.

For detector frequency $(h,k)$, define

$$ S(h,k;t)=\exp\left[i\frac{2\pi}{N}(ht_x+kt_y)\right], \qquad T_{\mathrm{pose}}(h,k)=\frac{C(h,k)}{\sqrt{\sigma^2_{s(h,k)}}}. $$

$T_{\mathrm{pose}}$ contains the CTF and noise amplitude only; it never contains a shift phase. The pose evaluator alone applies $S(t)$, so a shift cannot be counted twice. The whitened prediction, observation, residual, and objective are

$$ \widehat Y_w=S(t)T_{\mathrm{pose}}G_R(X_{\mathrm{prep}}), \qquad Y_w=\frac{Y}{\sqrt{\sigma^2_s}}, \qquad r=\widehat Y_w-Y_w, \qquad \Phi(q)=\frac12\sum_{(h,k)\in\Omega}|r(h,k)|^2. $$

The CTF is applied to the prediction, not divided out of the observation. CTFFLAG_NO gives $C=1$, the normal mode uses the signed CTF, and CTFFLAG_FLIP uses $|C|$. A physical CTF zero is valid. This is not the PFTC matcher objective and requires no polar-coordinate radial/Jacobian scaling factor.

Executed forward-model conventions¶

$N$ is even. The spatial origin is zero-based $j=N/2$, or one-based Fortran $i=N/2+1$.
$(h,k)$ are native integer Fourier coordinates. The gather samples the padded lattice at $\mathrm{padf}[h,k,0]R$.
The forward transform uses the negative exponential. The padded FFT contributes $1/N_{\mathrm{pd}}^3$ and the gather contributes $\mathrm{padf}^3$, giving native normalization $1/N^3$.
The rotation update is right-sided. For Cartesian unit axis $e_a$, $\partial\operatorname{loc}/\partial\omega_a=\operatorname{loc}\times e_a$.
The positive shift phase above gives $\partial M/\partial t_x=i(2\pi h/N)M$ and $\partial M/\partial t_y=i(2\pi k/N)M$.
The active domain is the full redundant Fourier disk

$$ \Omega=\left{(h,k)\in[-N/2,N/2]^2: k_{\min}^2\le h^2+k^2\le k_{\max,\mathrm{effective}}^2\right}. $$

Conjugate mates and logical positive and negative Nyquist endpoints remain explicitly counted. Validation, the later standalone mode, and the first complete refine3D integration retain this representation and log fourier_domain=full_redundant_disk, requested and effective shell limits, and active sample count. A weighted half-plane requires a separate post-integration review, conjugate/DC/Nyquist weighting, equivalence tests, and real-dataset A/B evidence.

The variance input contains one noise-power value per shell, with $s(h,k)=\operatorname{nint}\sqrt{h^2+k^2}$, and the pose path sets

$$ k_{\max,\mathrm{effective}}= \min\left(k_{\max,\mathrm{requested}},\operatorname{ubound}(\sigma^2),N/2\right). $$

Every used variance must be positive and finite. No usable shell overlap or an invalid used value returns a nonfatal invalid-noise-range outcome without changing the pose or stopping SIMPLE. The pose path does not extend the final variance into unknown shells. The existing PCG helper retains its last-shell fallback unchanged; implementation comments and diagnostics must make the difference visible for later dataset testing.

The fast normalized Kaiser--Bessel derivative holds $i_0=\operatorname{nint}(\operatorname{loc})-\mathrm{iwinsz}$ fixed. Half-integer stencil boundaries are non-differentiable, and switches are measured separately rather than included in centered finite-difference acceptance.

Local derivatives and LM¶

The five residual-Jacobian columns differentiate the executed fast Kaiser--Bessel polynomial and normalized stencil inside one fixed interpolation cell. The LM step is

$$ (J^H J+\mu D)\delta=-J^H r. $$

Independent evidence covers the unscaled and scaled normal terms, damping diagonal, proposed step, predicted reduction, recomputed objective, gain ratio, decision, and rollback.

Tolerance-calibration protocol¶

Use separate algebraic, LM, derivative, and forward-model tolerance families. Existing finite-difference tolerances do not qualify as algebraic or forward-model tolerances. Scalar, vector, matrix, and complex comparisons use the componentwise combined rule

$$ |a-b|\le\tau_{\mathrm{abs}}+\tau_{\mathrm{rel}}\max(|a|,|b|). $$

For complex values, $|\cdot|$ is complex magnitude. Relative comparison applies to every gradient component as well as values, residuals, and normal terms.

The original calibration fixtures use boxes $8^3$ and $12^3$. The observed box-$10^3$ and box-$16^3$ forward-hierarchy cases are retained as diagnostic regressions, not reused as untouched acceptance evidence after the 2026-08-28 amendment. The amended forward calibration must predeclare fresh holdout boxes, volumes, and rotations before execution. Calibration and holdout sets use different deterministic asymmetric volumes and poses and cover the complete declared sampling domain for their tolerance family. Before calibration, each family records its absolute floor, relative floor, and relative-scale floor. Calibration records maximum absolute and scaled-relative errors and sets

$$ \mathrm{atol}=8E_{\mathrm{abs,max}}, \qquad \mathrm{rtol}=8E_{\mathrm{rel,max}}, $$

subject to the predeclared floors. A scientifically loose result stops for diagnosis rather than becoming an acceptance threshold.

For the scaled LM system $Az=b$, compare every solution component, the physical step after coordinate rescaling, predicted and actual reductions, gain ratio, and backward error

$$ \eta=\frac{\lVert Az-b\rVert_\infty} {\lVert A\rVert_\infty\lVert z\rVert_\infty+\lVert b\rVert_\infty}. $$

Tight step agreement applies only to reliable systems; singular or poorly conditioned fixtures verify their terminal outcome instead. Ordinary decision fixtures remain away from the LM ratio threshold: for the current $0.25$ threshold, use ratios below approximately $0.20$ or above $0.30$ and test the boundary separately.

Terminal status, sample counts, active masks, invalid-input classification, symmetry, and zero contracts remain exact. Rejected-trial rollback is bitwise identical where the representation permits it. The evidence package records fixtures, raw error tables, derived tolerances, safety factor, source commit, compiler, precision, and a pre-acceptance freeze marker. A failed acceptance test reopens the protocol or implementation; it never changes a threshold in place.

Approved forward-model amendment — 2026-08-28¶

Only the executed_dft, slow_gather, and finite_projection tolerance families are reopened. The algebraic, LM-system, derivative, and analytic-DFT families remain frozen. The amended calibration must sample multiple predeclared arbitrary rotations over every point in the full redundant Fourier disk at the calibration boxes, retain structurally separate direct-DFT and slow-gather paths, and report stencil-switch counts separately.

The arbitrary-rotation finite-box comparison is split into two contracts. The acceptance contract compares the normalized two-dimensional DFT of a line-sum projection of a rotated/resampled finite volume $X_R$ with the three-dimensional DFT of that same $X_R$ at $l=0$. A separate diagnostic compares $X_R$ with the original physical volume evaluated at rotated frequencies and reports clipping fraction, real-space interpolation error, and support margin without requiring machine agreement.

The expanded calibration derives and freezes new values for the three reopened families before any fresh holdout case runs. The already observed box-$10^3$ and box-$16^3$ results cannot set a tolerance and remain diagnostic evidence. Candidate fresh holdout boxes $14^3$ and $18^3$ require a static indexing and runtime-cost check before they are declared and frozen.

Numerical ownership¶

The dependency direction is

$$ \text{pose refinement}\longrightarrow\text{neutral Cartesian/KB utilities} \longleftarrow\text{PCG reconstruction}. $$

The pose owner never imports simple_reconstructor_pcg, and the reconstruction owner never imports the pose owner. A later refine3D strategy may orchestrate the pose owner, but no strategy owns its numerical objective or LM implementation.

Particle-pose owner¶

Create src/main/volume/simple_cartesian_pose_refiner.f90 with module simple_cartesian_pose_refiner. The file is under volume because it owns an immutable padded Fourier representation of a fixed physical volume and therefore depends on image/FFT infrastructure; logically, its unknown is still one particle pose, not a volume. It is not a reconstructor, a PCG component, or a workflow strategy.

The module owns:

the cartesian_pose_refiner lifecycle and its private immutable Fourier-reference state;
construction from one physical real-space volume, including the contractually required inverse-envelope preparation, centered padding, FFT, packed-lattice snapshot, wrap metadata, and full-disk bounds;
the pose-specific effective shell range and invalid-noise-range outcome;
pose transfer and observation preparation, with build_pose_transfer accepting CTF and variance but no shift argument;
right tangent-space rotation increments;
value/gradient sampling wrappers, shift validation primitives, the five-column residual Jacobian, fused objective, $J^Hr$, $J^HJ$, and stencil-switch telemetry;
the two-parameter validation LM and the five-parameter scaled LM, including masks, damping, Cholesky solve, bounds, gain ratio, terminal outcomes, traces, and rollback; and
pose-owned status constants and numerical floors.

The public pose API accepts a physical volume and particle data. A private-field cartesian_pose_data value is prepared once from the raw observation, CTF parameters, variance vector, and requested shell range; it contains the whitened observation, shift-free transfer, and effective range. Objective and LM calls accept this prepared value rather than an arbitrary transfer array. The API does not accept a reconstructor_pcg, pcg_fourier_workspace, PCG transfer object, PCG envelope array, solver accumulator, or reconstruction policy. The physical-volume constructor is the only normal route to a reference, so callers cannot silently omit or double-apply $E^{-1}$.

Current routines move from simple_reconstructor_pcg.f90 to this owner without intentional mathematical change:

Current routine	Current line	Target responsibility
`right_increment_rotation`	312	Right-sided $SO(3)$ update
`begin_fourier_workspace` and `kill_fourier_workspace`	1041, 1064	Replace with the pose-reference constructor/destructor
`get_fourier_workspace_lims2` and `set_fourier_workspace_shell_range`	1081, 1088	Pose-domain and effective-shell access
`sample_fourier_with_grad`	1102	Pose wrapper over the neutral packed gather
`shift_residual`, `shift_jvp`, `shift_jhz`, `shift_normal_terms`, and `shift_objective_gradient`	1125–1279	Retained validation-facing shift primitives
`rotation_jvp`, `pose_normal_terms`, and `pose_objective_gradient`	1282–1389	Five-parameter derivative and normal terms
`count_stencil_switches`	1393	Local-cell telemetry
`refine_shift_lm`	1414	Retained two-parameter validation solver
`refine_pose_lm`, `apply_pose_parameter_mask`, and `solve_pose_cholesky`	1547–1801	Five-parameter LM and dense solve

The current pcg_fourier_workspace type and pose/shift LM constants leave simple_reconstructor_pcg after all pose tests use the new owner. They are not kept as forwarding aliases because that would preserve the wrong public ownership boundary.

Neutral numerical owners¶

Neutral interfaces contain no particle policy, LM state, reconstruction accumulators, or owner types. Their array bounds, normalization, precision, packing, periodic wrapping, and failure behavior are explicit arguments or documented return contracts.

Keep the executed kernel and envelope mathematics in their existing neutral modules:

Neutral routine	File and line	Decision
`kbinterpol%apod_fast_value_deriv`	`src/main/interp/simple_kbinterpol.f90:181`	Keep as the derivative of the executed fast polynomial
`kbinterpol%apod_mat_3d_fast_grad`	`src/main/interp/simple_kbinterpol.f90:343`	Keep as the normalized fixed-cell stencil derivative
`kb_stencil_envelope_1d`	`src/main/interp/simple_gridding.f90:78`	Keep as the common discrete KB-envelope definition
`kb_stencil_inv_envelope_1d` and `deapodize3D_inplace`	`src/main/interp/simple_gridding.f90:109,128`	Keep; add an explicit centered-crop variant for a native volume inside a padded-period envelope

The centered-crop inverse-envelope operation is defined by the padded period $N_{\mathrm{pd}}$, native box $N$, centered offset $o=(N_{\mathrm{pd}}-N)/2$, and the production KB window. It evaluates and center-normalizes the one-dimensional discrete envelope over period $N_{\mathrm{pd}}$, takes the guarded reciprocal only at padded indices $o+1:o+N$, and returns exactly $N$ native-axis factors. It must not substitute the native-period result from kb_stencil_inv_envelope_1d(N,...). The eventual procedure name and Fortran argument form are implementation decisions for Phase 2; these numerical inputs and returned indexing are contractual.

Create src/main/interp/simple_cartesian_fourier.f90 for the state-independent Cartesian-lattice operations that are currently embedded in the PCG owner:

Current routine	Current line	Neutral operation
`pad_vol` and `crop_vol`	865, 876	Exact centered array embedding/cropping pair
`extract_native_plane`	1993	Full redundant native-disk extraction from an FFT image
`gather_window`	3630	Packed/Friedel Kaiser–Bessel value gather
`gather_window_grad`	3663	Identical gather traversal for value and three fixed-cell derivatives

The neutral gather accepts the Fourier array, wrap table, stencil origin, and weights explicitly. It does not accept either owner object. PCG value gathers and pose value/gradient gathers must call these common routines. PCG scatter, folding, kernel, prior, accumulation, and solver operations are not neutral and do not move.

simple_reconstructor_pcg.f90:481 retains the reconstruction operator's three-dimensional build_env state, but its one-dimensional envelope and centered reciprocal construction use simple_gridding. The pose constructor uses the same neutral envelope definition. This shares the convention without transferring PCG deapodization policy into pose refinement.

PCG reconstruction owner¶

src/main/volume/simple_reconstructor_pcg.f90 continues to own reconstructor_pcg, pcg_solver_outcome, operator-mode constants, particle accumulation, forward/adjoint reconstruction operators, preconditioner, kernel, priors, PCG solve, and profiling. In particular:

set_volume, forward_plane, fourier_dot, and adjoint_plane_add remain reconstruction-facing methods;
build_transfer remains unchanged because reconstruction includes the stored particle shift and retains its existing last-variance-shell fallback;
whiten_observation remains unchanged as a PCG-side compatibility helper for reconstruction regression tests;
extract_native_plane may remain as a thin reconstruction wrapper over the neutral routine so existing reconstruction strategies do not acquire a new dependency during the first extraction; and
simple_rec3D_pcg_strategy.f90 remains the owner of reconstruction batching and calls no pose LM.

The pose module deliberately implements a distinct build_pose_transfer and variance check because its transfer excludes shift and must cap the effective shell range rather than repeat the last known variance. These differing policies must not be hidden behind one ambiguous shared helper.

Strategy and test ownership¶

src/main/strategies/search/simple_pcg_pose_polisher.f90 is not a valid numerical owner and has no production caller. Its disposition is:

Current content	Current line	Action
`polish_fixed_volume_shifts`	52	Move batch accounting/rollback coverage to a test helper; call the pose owner per particle
`polish_fixed_volume_poses` and `refine_one_pose`	131, 195	Move OpenMP batch/equivalence coverage to a test helper; keep single-particle LM in the pose owner
`execute_final_pcg_pose_polish`	243	Delete after migration; do not translate this retired post-reconstruction workflow
`validate_batch_shapes` and `pcg_pose_polish_summary`	484, 30	Move only the evidence-oriented shape/accounting logic needed by tests

The test helper is production/tests/simple_pose_cont_refinement_batch_helpers.f90; it is not production API. Existing derivative, recovery, capture, mechanism, contract, and operator tests migrate from pcg_fourier_workspace and simple_pcg_pose_polisher to the new pose owner. Ordinary PCG tests continue to exercise reconstructor_pcg directly.

Extraction invariants¶

The ownership change is accepted only if all of the following remain true:

The new pose module contains no use simple_reconstructor_pcg and exposes no PCG-named type or argument.
Neutral modules contain no pose status, LM, CTF/sigma policy, PCG accumulator, or solver state.
PCG and pose gathers call the same neutral packed/Friedel traversal and executed KB routines.
PCG transfer semantics and last-shell fallback remain byte-for-byte source-equivalent until separately reviewed.
Pose transfer has no shift input and reports its requested/effective shell range and full-disk sample count.
The retired post-reconstruction routine and its strategy module disappear once their test-only logic has moved.
Current pose evidence is reproduced before new oracle acceptance, and ordinary reconstruction satisfies AC-12.

This map defines ownership only. It does not authorize implementation until the contract and later execution approach are separately approved.

Independent forward evidence and comparison contracts¶

Independence comes from four paths: the executed fast gather, a structurally separate slow interpolator, a tiny-box brute-force DFT, and a finite-box real-space projection followed by FFT. The direct oracle uses

$$ F(\boldsymbol{\xi})=\frac{1}{N^3}\sum_{\mathbf{x}}X(\mathbf{x}) \exp\left(-2\pi i\boldsymbol{\xi}\cdot\mathbf{x}\right), \qquad \boldsymbol{\xi}_R=N^{-1}[h,k,0]R, $$

with spatial-frequency derivative

$$ \nabla_{\boldsymbol{\xi}}F(\boldsymbol{\xi}) =-\frac{2\pi i}{N^3}\sum_{\mathbf{x}}\mathbf{x}X(\mathbf{x}) \exp\left(-2\pi i\boldsymbol{\xi}\cdot\mathbf{x}\right). $$

The four comparison contracts are:

Analytic object versus brute-force DFT: a tight double-precision convention test for origin, sign, frequency, and normalization.
Brute-force DFT of $X$ versus executed $G(E^{-1}X)$: an interpolation-accuracy contract, not machine equality.
Independent slow interpolation versus executed gather: a tighter source-fidelity contract using the same polynomial Kaiser--Bessel function, normalization, padding, packed/Friedel rules, and periodic wrapping without calling the executed gather or stencil helper.
Finite-box projection versus direct DFT: a separate discrete-model contract that declares whether projection rays are summed or averaged. Line sums followed by a normalized two-dimensional FFT require an explicit $1/N$ factor to match the normalized three-dimensional DFT. Arbitrary rotations report additional clipping and real-space interpolation effects separately.

Analytic fixtures include centered and off-center deltas, separated points, and a non-collinear unequal-amplitude point set. Sampled Gaussian and sphere fixtures test robustness, not exact continuous-transform identities; a sphere cannot test rotational identifiability and a two-point object is degenerate about its connecting axis.

Preserve the existing evidence distinction. simple_continuous_3D_pcg_refinement_rotation_test.f90 remains a matched-model derivative-consistency test and is not independent evidence for CTF or whitening order. New independent CTF/whitening tests follow simple_continuous_3D_pcg_refinement_shift_test.f90: form the raw CTF-distorted observation first, whiten it separately, and never generate oracle observations with the evaluator under test.

Scope boundaries¶

Included:

independent weighted-objective, $J^Hr$, $J^HJ$, and dense LM-step oracles;
ownership audit and extraction into a particle-pose module, with neutral sharing only where proven;
CTF and shell-variance validation;
analytic objects, tiny-box direct DFT, slow Cartesian interpolation, and finite-box comparison;
multiple volumes, boxes, and Fourier ranges;
focused tests, Oracle Linux evidence, and documentation that separates pose LM from PCG reconstruction.

Excluded:

refine3D UI, commander, strategy, metadata, restart, or distributed integration;
replacement or modification of inpl_cont;
PFTC pose derivatives or a PFTC five-parameter objective;
production acceptance, reference-refresh, frequency, pose-prior, or route-selection policy;
behavioral changes to ordinary reconstruction;
claims of FSC, real-data, workflow, or scientific benefit.

Acceptance criteria¶

AC-1 — Objective: independent scalar accumulation agrees with the fused objective for constant and nonconstant positive shell-variance profiles under the frozen metric.
AC-2 — Derivatives and normals: every residual-Jacobian column, $J^Hr$ component, and symmetric $J^HJ$ entry agrees componentwise.
AC-3 — LM proposal: accepted and rejected proposals agree with a separate dense five-by-five solve and acceptance calculation.
AC-4 — State restoration: rejected, invalid, singular, bounded-out, and finite-no-improvement trials preserve the complete input pose within the declared representation tolerance.
AC-5 — CTF and sigma: valid CTF/sigma configurations remain finite and agree with their oracles; short variance vectors cap the pose shell range; unusable variance returns the declared nonfatal outcome; the existing PCG fallback remains unchanged.
AC-6 — Forward hierarchy: analytic identities and each named pair of computational paths satisfy their separately frozen contracts over the full redundant disk on fresh holdout fixtures; the matched finite-box projection contract compares the same rotated/resampled finite object, while clipping, real-space interpolation, support margin, and stencil switches remain separately reported diagnostics.
AC-7 — Robustness: at least two boxes, two Fourier ranges, and three deterministic asymmetric volumes pass without post-result tolerance changes.
AC-8 — Pose regression: existing derivative, capture, pose-recovery, and contract cases pass or receive explicitly reviewed updates.
AC-9 — Oracle evidence: focused cases and the complete mother suite compile and pass on Oracle Linux with retained logs.
AC-10 — No activation: source contains no production caller or user-visible option for this numerical-validation slice.
AC-11 — Ownership: particle-pose tests call the dedicated pose module; that module does not import reconstructor_pcg; shared interfaces expose no owner-specific solver or particle-policy state.
AC-12 — Reconstruction regression: moving shared operations does not change ordinary PCG results outside its existing numerical contract.

Constraints and review status¶

Preserve continuous_3D_refinement_on_pcg_operator.md as the frozen original proposal.
Keep calibration fixtures distinct from acceptance fixtures. Freeze metric definitions and tolerances before acceptance and do not weaken them after observing failures.
Use the executed polynomial and interpolation path for the implementation under test while keeping independent oracles structurally separate.
Hard-limit brute-force DFT to declared tiny test boxes.
Keep source inspection, compilation, runtime evidence, and scientific validation separate. Oracle Linux supplies authoritative compilation and runtime evidence; agents do not compile unless explicitly requested.

Known challenges are single precision and accumulated complex error, hidden reconstruction-workspace dependencies, interpolation-stencil switches, accidental inverse crime, analytic-versus-sampled fixture confusion, and objective reduction without pose correctness.

Review decisions:

IN REVIEW — forward-only tolerance amendment: executed_dft, slow_gather, and finite_projection require expanded arbitrary-rotation, full-disk calibration and fresh holdout fixtures. All other tolerance families remain frozen.
IN REVIEW — finite-projection comparison: the matched finite-object acceptance contract and separate clipping/interpolation diagnostic are approved for implementation but are not frozen until the amended calibration fixtures and derived tolerances are reviewed.
RESOLVED — numerical ownership: the approved routine-by-routine map separates particle, reconstruction, neutral, strategy, and test ownership.
FINAL — unaffected contract: the required outcome, scope exclusions, numerical ownership, AC-1 through AC-5, and AC-7 through AC-12 remain frozen as of 2026-08-26. Only the forward portions of the tolerance protocol and AC-6 are reopened by the 2026-08-28 amendment.

Contract approval boundary¶

Everything above this boundary is approval-controlled. When Contract status becomes FINAL, these sections remain unchanged during ordinary implementation. A discovery that changes the required outcome, scope, acceptance criteria, or architectural constraints returns the contract to IN REVIEW and stops requirement-changing implementation until reapproved.

Everything below this boundary is the approved execution approach and living progress record. Phase status and evidence entries may advance during implementation. Changing phase scope, ordering, or gates requires plan review; changing anything above this boundary returns the contract to IN REVIEW.

Implementation approach¶

Review base and repository scan¶

The final-plan audit used local HEAD=f78d9dff3 after the user pulled and rebased onto origin/master=77e90026b. The branch is one focused design commit ahead of origin. The working tree contains the one-note consolidation and evidence-runner reference updates; it contains no uncommitted Fortran change.

The newest upstream commit, 77e90026b (rename strategy2D test to cavg_registration utility), changes 2-D test naming, test UI routing, and simple_strategy2D_utils. It does not touch Cartesian pose refinement, interpolation, PCG reconstruction, or these validation runners.

Relevant later repository evolution was also checked:

35a7695bc extends PCG priors and reconstruction tests. It does not change the existing pose objective or LM block, but its new PCG behavior increases the importance of AC-12 after neutral extraction.
118388291 establishes simple_gridding as the shared owner of the discrete KB-stencil envelope. This supports the approved neutral-owner design; the pose path still needs the distinct padded-period/center-crop operation defined above.
1d32b830a removes the pcg_pose_polish production activation from reconstruct3D. No current UI, parameter, commander, execution, or reconstruction strategy calls the pose LM.
116c9ae0b is the latest commit changing the isolated pose-capture diagnostics and the current five-parameter LM block. Later PCG commits affect reconstruction state around it, not its mathematics.

The live caller scan found:

thirteen test source files import pcg_fourier_workspace, its pose/shift methods, or right_increment_rotation;
four test source files use the batch wrappers from simple_pcg_pose_polisher;
execute_final_pcg_pose_polish has no caller and is private under the module's default visibility;
the mother executable schedules ten regression groups, while the fixed-reference, forward-path, matched-window, reference-bias, operator-contract, capture-range, and mechanism diagnostics are explicit keyed cases outside that default schedule;
the then-existing runners under production/tests/continuous_3D_pcg_pose_validation/ retained historical pcg_pose_polish production experiments and were not valid acceptance runners for this contract; those runners were later retired and replaced by the authoritative production/tests/pose_cont_validation/run_oracle_validation.sh; and
the ignored local .codex/codex_exec_resume.cmd and its prompt still name the removed parallel SPEC and PLAN. They must be updated to this living note before unattended implementation is started.

Current numerical anchors¶

These were the numerical anchors at that review base; the implementation records in the completed phases below supersede their line numbers:

src/main/interp/simple_kbinterpol.f90:181 — executed fast-KB value derivative;
src/main/interp/simple_kbinterpol.f90:343 — normalized fixed-cell stencil derivative;
src/main/interp/simple_gridding.f90:78 — shared discrete KB envelope;
src/main/volume/simple_reconstructor_pcg.f90:481 — PCG padded-period three-dimensional envelope state;
src/main/volume/simple_reconstructor_pcg.f90:1041 — current PCG-owned Fourier-workspace snapshot;
src/main/volume/simple_reconstructor_pcg.f90:1102 — current packed value/gradient sampler;
src/main/volume/simple_reconstructor_pcg.f90:1317 — fused pose objective and normal terms;
src/main/volume/simple_reconstructor_pcg.f90:1547 — bounded five-parameter LM;
src/main/volume/simple_reconstructor_pcg.f90:1808 — reconstruction-facing Cartesian forward plane;
src/main/volume/simple_reconstructor_pcg.f90:1895 — reconstruction CTF/sigma/shift transfer with last-shell fallback;
src/main/volume/simple_reconstructor_pcg.f90:1964 — PCG observation-whitening helper with the same fallback;
src/main/volume/simple_reconstructor_pcg.f90:3630 — packed/Friedel value gather;
src/main/volume/simple_reconstructor_pcg.f90:3663 — packed/Friedel value/gradient gather;
src/main/strategies/search/simple_pcg_pose_polisher.f90:52 — current test-used batch wrappers; and
src/main/strategies/search/simple_pcg_pose_polisher.f90:243 — retired post-reconstruction routine.

Execution controls¶

Implement one phase at a time. A failed or scientifically unresolved gate stops later phases.
Each implementation phase has a preparation turn and a separate validation/review turn. The validation turn verifies the diff and evidence before marking the phase complete.
Preserve unrelated work and stage only phase-owned files.
Agents perform source and lightweight static checks. Compilation and runtime remain with the user unless the user explicitly approves the controlled Oracle workflow.
Put substantive new test cases in separate child modules. Shared helpers contain only repeated fixture, assertion, oracle, or reporting code.
Keep production/CMakeLists.txt unchanged and off-limits. Name every test dependency with its mother suite's established simple_<test_id>_* prefix so the existing dependency glob discovers it. If two mothers need similar fixtures, give each suite an owning helper instead of adding a build-system exception.
Regenerate doc/code_overview/code_base_map.md and the Fortran indexes after adding or deleting source modules; verify a clean generated diff rather than editing generated indexes manually.
Before using the ignored Codex runner, update it and its prompt to read this one living note and start at the first authorized incomplete or revalidation phase. While the forward amendment is in review, the runner may implement and validate only the approved Phase 4 calibration rework; it must not run a fresh holdout acceptance case. After the amended fixtures and derived tolerances are reviewed, frozen, and the contract status returns to FINAL (FROZEN), it may continue with the Phase 5 BLAS revalidation, Phase 6 LAPACK revalidation, and revised Phase 8 acceptance. This local-tool update is required execution preflight, not a source acceptance criterion.
Historical runners that require pcg_pose_polish=yes must not be run as current evidence. Retain them only as clearly historical material or remove their obsolete execution path when the new validation package supersedes them.

Acceptance-to-phase map¶

Criterion	Owning phase	Required evidence
AC-1	Phase 5	explicit and BLAS weighted-objective accumulation
AC-2	Phase 5	componentwise residual Jacobian plus explicit/BLAS $J^Hr$ and $J^HJ$
AC-3	Phase 6	production Cholesky, pivoted dense, and LAPACK reliable-system agreement plus LM decision
AC-4	Phase 6	accepted/rejected transaction and rollback evidence
AC-5	Phase 7	CTF modes, constant/varying/short/invalid variance evidence
AC-6	Phase 8	analytic, DFT, slow-gather, matched finite-projection, and separate clipping/interpolation diagnostics
AC-7	Phase 9	approved box, range, volume, and pose matrix
AC-8	Phase 3, finalized in Phase 9	migrated legacy pose regressions and capture diagnostics
AC-9	Phase 10	authoritative Oracle package and analysis
AC-10	Phase 3, rechecked in Phase 9	no production activation or user-visible option
AC-11	Phase 3, rechecked in Phase 9	import/API ownership audit
AC-12	Phase 2, finalized in Phases 9–10	unchanged ordinary PCG numerical contract

Development phases¶

Phase 0 — consolidate the development record¶

Status: COMPLETE

Commit f78d9dff3 preserves the reviewed parallel documents after the rebase onto 77e90026b. This living note replaces them in the tracked development record, and the completed history and active operator/truth evidence snapshots refer to it.

Gate: the tracked living record has one contract and plan; Git and the completed history retain the superseded pair. Ignored local runner references are handled by the execution preflight above.

Phase 1 — finalize the contract and execution approach¶

Status: COMPLETE

The tolerance protocol, forward-model conventions, comparison contracts, numerical ownership, scope, acceptance criteria, repository scan, and AC-to-phase map are approved. The contract is FINAL (FROZEN), and this execution approach is FINAL.

Gate: Contract status and Execution plan status are FINAL, and acceptance requires no decision made after observing acceptance results.

Phase 2 — extract neutral Cartesian and envelope operations¶

Status: COMPLETE

Prepare evidence — 2026-08-26:

Added neutral centered real-array embed/crop, full redundant native-plane extraction, and packed/Friedel value and value-gradient gathers in src/main/interp/simple_cartesian_fourier.f90:15,32,49,66,101. The gather APIs take the wrap-table lower bound explicitly, preserve the 27-tap traversal and accumulation order, and do not apply padsc.
Added the padded-period/center-crop inverse-envelope factors in src/main/interp/simple_gridding.f90:129. The helper returns exactly the native-axis factors and applies the guard after selecting the centered padded-period indices.
Rewired the PCG envelope, fixed-volume gradient sampler, Cartesian forward plane, native-plane wrapper, normal-operator gathers, centered embedding, and centered cropping to the neutral operations in src/main/volume/simple_reconstructor_pcg.f90:480,1065,1772,1957. build_transfer, whiten_observation, solve_core, the prior setters, and profiling procedures remain source-identical to HEAD.
Added case=neutral_extract in production/tests/simple_continuous_3D_pcg_refinement_neutral_extract_test.f90:24 and registered it in production/tests/simple_test_continuous_3D_pcg_refinement.f90:75,203. The case compares old and neutral centered embed/crop, padded-period factors and PCG 3-D envelopes, packed value/value-gradient gathers with a negative-bound wrap table, and native-plane extraction. The hypotheses are exact parity for index/traversal operations and no PCG envelope drift beyond single-precision roundoff.
Refreshed doc/code_overview/code_base_map.md and all Fortran indexes. Four final generator invocations exited 0; a second pass was byte-stable. The refresh also records broad pre-existing current-HEAD index drift, which is separate from the Phase 2 source changes.
Lightweight source checks are PASS: path-limited git diff --check exited 0; phase Fortran files have zero trailing-whitespace findings, zero lines longer than 132 columns, zero conflict markers, zero new multiline macro hazards, zero retired private-operation references, and zero pose/PCG-policy references in the neutral modules. The production test dependency glob includes the new child module. No compiler or SIMPLE executable was run.
Required Oracle commands, pending authorization and execution: simple_test_continuous_3D_pcg_refinement case=neutral_extract tests the direct extraction parity; the complete simple_test_continuous_3D_pcg_refinement suite tests the retained component and reconstruction baselines; simple_test_exec test=pcg_recon tests the operator, deapodization, kernel-versus-matrix-free, streaming, symmetry, and fixed-iteration gates; simple_test_exec test=pcg_priors tests prior attachment and parity.
The UCRT64 environment check exited 0 and reported /home/hossainm7/hael_SIMPLE, /usr/bin/rsync, and rsync 3.4.4 protocol 32. The exact authorized rsync -avn --delete exited 0. It proposed 204 file transfers and 16 deletions, including transfer of codex_logs/. The proposed deletions are .codex/origin-push-workflow.md, fourteen retired or remote-only implementation-note files, and production/tests/simple_test_strat2D_utils.f90. No synchronization, remote normalization, compilation, runtime test, or scientific test occurred.
Local prepare evidence is in codex_logs/pose_cont_20260826_144540_289/phase02/prepare_20260826_144540_289.events.jsonl and its sibling prompt and stderr files. The dry-run target is ~/Projects/hael_SIMPLE-rsync-test; the dry run created no remote evidence artifact.

Validate preflight evidence — 2026-08-26:

The independent phase-order gate passed at turn entry: Phase 0 and Phase 1 were COMPLETE, and Phase 2 was READY FOR ORACLE VALIDATION.
Validation stopped before the real transfer because the reviewed dry run no longer described the current source tree. The prepare turn used HEAD=4cdce17b98d16bcaa537d0c05a30f5e3811b840a; validation found HEAD=origin/master=5f84de401a7bacb2795fe07255f9de1c959b9102.
The intervening range changes nine synchronized files, including src/main/strategies/parallelization/simple_rec3D_pcg_strategy.f90 and src/main/commanders/test/simple_commanders_test_highlevel.f90. Therefore the recorded 204 proposed transfers and 16 proposed deletions are stale evidence for the approved real rsync --delete operation.
No rsync, remote line-ending normalization, Oracle compilation, runtime test, scientific test, or commit occurred. The safe next action is a new Phase 2 prepare turn with one exact UCRT64 environment check and one exact rsync -n dry run against the current tree.

Re-prepare evidence — 2026-08-26:

Rebased-current verification used HEAD=origin/master=5f84de401a7bacb2795fe07255f9de1c959b9102. The three intervening PCG commits do not overlap the Phase 2 neutral module or PCG-owner diff; protected transfer, whitening, solver, prior, and profiling procedures remain outside the Phase 2 diff.
Regenerated doc/code_overview/code_base_map.md and all Fortran indexes against the current tree. Restricted MSYS2 Perl attempts failed before script execution with Win32 signal-pipe error 5; each exact elevated retry succeeded and wrote the declared outputs.
Current lightweight source checks are PASS: git diff --check exited 0; phase Fortran files have zero trailing-whitespace findings, zero lines longer than 132 columns, zero conflict markers, zero new multiline macro hazards, zero retired private-operation references, and zero pose/PCG-policy references in the neutral modules. The production test dependency glob includes the new child module.
The authorized UCRT64 check resolved UCRT64, /home/hossainm7/hael_SIMPLE, /usr/bin/rsync, and rsync 3.4.4 protocol 32. Its restricted attempt failed before Bash execution with Win32 signal-pipe error 5; the exact elevated retry exited 0.
A host-quoting attempt invoked rsync incorrectly, printed usage, and exited 1 before remote comparison. The corrected documented rsync -avn --delete command then exited 0 and completed the one effective dry run. It proposed 215 file transfers and the same 16 deletions recorded above. Added transfers are the current upstream PCG changes, regenerated navigation, and controller evidence under codex_logs/; all proposed paths are inside the declared source and destination. No build_debug_incremental_failed.log deletion is proposed.
Local re-prepare evidence is in codex_logs/pose_cont_20260826_144540_289/phase02/prepare_20260826_220957_302.events.jsonl and its sibling prompt and stderr files. No real synchronization, remote normalization, compilation, runtime test, scientific test, or commit occurred.

Oracle validation evidence — 2026-08-26:

The documented real rsync -av --delete exited 0, transferred 219 current-tree files to ~/Projects/hael_SIMPLE-rsync-test, and applied the 16 reviewed deletions. Four added transfers relative to the 215-file dry run were active controller evidence and this phase-note update; no unreviewed deletion occurred. The explicit MSYS2 SSH normalization command exited 0. Earlier Windows-SSH attempts did not provide reliable remote evidence and were terminated; all evidence below uses C:\msys64\usr\bin\ssh.exe.
The default incremental logged .codex/compile_debug.sh command, after module load gcc/15.2.0, exited 0 and installed the Debug build. The conditional SIMPLE_CLEAN_BUILD=yes retry was not used. The remote build log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log.
With the documented SIMPLE environment, simple_test_continuous_3D_pcg_refinement case=neutral_extract exited 0. Centered embed/crop, the padded-period factors, the native plane, and both gathers had exact parity. The PCG envelope absolute error was 0; the inverse-envelope relative maximum was 2.219693E-07 against tolerance 2.0E-06. The log is validation/phase2_20260826_223159/neutral_extract.log. An earlier host-quoting attempt did not preserve the remote PATH, exited 127, and is retained as neutral_extract_env_failed.log.
simple_test_exec test=pcg_recon exited 0 and passed all 12 stages, including adjoint identities, masked-operator symmetry/positivity, synthetic recovery, kernel parity, streaming accumulation, deapodization, symmetry, crop parity, and ML-prior parity. simple_test_exec test=pcg_priors exited 0 and passed all nine stages. Their logs are validation/phase2_20260826_223159/pcg_recon.log and pcg_priors.log.
The complete simple_test_continuous_3D_pcg_refinement suite exited 1: 11 groups ran, 10 passed, and halfset_fsc failed the preliminary AC-12 scale-sensitive comparison. The best noisy PCG lambda was 10 for each half; its raw L2 errors were 6.612755E-01 and 6.608928E-01, while conventional gridding gave 6.518738E-01 and 6.388823E-01. The log is validation/phase2_20260826_223159/mother_suite.log.
Neutral parity and both operator-level regressions pass, but the PCG-versus-gridding miss is material and does not satisfy the Phase 2 scientific gate. No justified Phase 2 source correction follows from this evidence. Do not weaken the gate and do not start Phase 3. A scientific owner must decide whether the retained half-set comparison exposes an upstream PCG baseline regression or invalidates preliminary AC-12; after that decision, return Phase 2 to REWORK REQUIRED for an approved correction or to REVALIDATION REQUIRED for an unchanged repeat.

Approved Phase 2 A/B resolution — 2026-08-27:

Run case=halfset_fsc from an unchanged origin/master source and build.
Run the same deterministic case=halfset_fsc from the Phase 2 source and build.
Compare the complete PCG lambda, raw/scaled L2, residual, correlation, FSC, norm, and iteration tables before assigning the failure to upstream PCG or to Phase 2.
Use separate source/build roots but the same compiler, environment, command, fixture, and test working-directory policy. Record both source commits and checksums of both executables.
Create the timestamped A/B evidence directory directly below ~/Projects, but run each test with ~/Projects as its working directory. Send named logs, tables, manifests, and analyses to the appropriate evidence arm by absolute path. Each generated continuous_3D_matrix_volumes_* directory must therefore be directly below ~/Projects; keep all runtime evidence outside both source checkouts. The previous ~/Projects/hael_SIMPLE-rsync-test/continuous_3D_matrix_volumes_20260826_223316752 location violated this rule and is retained only as historical evidence.
If unchanged origin/master reproduces the same failure within deterministic tolerance, classify the strict PCG-beats-gridding assertion as an upstream/pre-existing baseline question and return for scientific review without weakening it. If only Phase 2 fails, diagnose and correct the neutral extraction before repeating validation.

A/B re-prepare evidence — 2026-08-27:

The independent gate passed at turn entry: Phase 0 and Phase 1 were COMPLETE, and Phase 2 was REWORK REQUIRED. HEAD and the local origin/master ref were both 5f84de401a7bacb2795fe07255f9de1c959b9102.
Applicable policies were doc/policies/KB_Interpolation_Policy.md for padded-grid KB coordinates and scaling, doc/policies/reconstruct3D_pcg_policy.md for the PCG operator, envelope, output, and AC-12 contracts, and doc/policies/refine3D_policy.md for the unchanged particle/volume workflow boundary.
The approved A/B has unchanged origin/master as the control and the Phase 2 tree as the experimental arm. The single planned difference is the neutral Cartesian and envelope extraction. Both arms must run the deterministic case=halfset_fsc with separate source/build roots and identical compiler, environment, fixture, command, and ~/Projects working-directory policy.
Lightweight checks are PASS: path-limited git diff --check exited 0; the phase Fortran files have zero trailing-whitespace findings, zero lines longer than 132 columns, zero conflict markers, zero new multiline macro hazards, zero retired private-operation calls, and zero pose/PCG-policy references in simple_cartesian_fourier. The test dependency glob includes the neutral child module, and generated navigation contains the new neutral module and test.
The restricted UCRT64 check failed before Bash execution with Win32 signal-pipe error 5. Its one exact elevated retry exited 0 and reported UCRT64, /home/hossainm7/hael_SIMPLE, /usr/bin/rsync, and rsync 3.4.4 protocol 32.
A PowerShell-to-Bash quoting attempt invoked rsync incorrectly, printed usage, and exited 1 before remote comparison. The corrected exact documented rsync -avn --delete exited 0 and completed the one effective dry run. It proposed 82 file transfers and seven deletion entries.
The transfers are current scripts, the development note, controller evidence, and other files whose remote normalized line endings or timestamps differ; all are within the declared source and destination. The deletion set is not safe: it contains five prior Phase 2 validation logs under validation/phase2_20260826_223159/ plus that directory and validation/. These logs are historical test evidence, not the exact disposable build_debug_incremental_failed.log artifact allowed by the Oracle workflow.
No real synchronization, remote preservation, remote normalization, compilation, runtime test, scientific A/B, or commit occurred. Phase 2 cannot request Oracle validation while the authoritative --delete would remove unpreserved evidence. The safe next action needs separate approval to copy the five logs to a timestamped evidence package directly below ~/Projects, verify their checksums, and then start a new Phase 2 prepare turn with a new exact dry run.
Local evidence is codex_logs/pose_cont_20260826_144540_289/phase02/prepare_20260827_071645_075.events.jsonl and its sibling prompt and stderr files. The dry-run destination was ~/Projects/hael_SIMPLE-rsync-test; the dry run made no remote change.

Required Phase 2 rerun — 2026-08-27:

The user reports that the misplaced remote ~/Projects/hael_SIMPLE-rsync-test/validation/ directory was subsequently deleted by rsync. Do not attempt to recover or reuse that source-checkout evidence.
Rerun every Phase 2 Oracle test with ~/Projects as the runtime working directory: case=neutral_extract, the complete mother suite, test=pcg_recon, and test=pcg_priors.
Also run the approved deterministic case=halfset_fsc A/B from unchanged origin/master and from the Phase 2 tree. Compare the complete PCG lambda/error tables as specified above.
Create named logs, tables, manifests, checksums, and analyses below one new timestamped A/B evidence package directly under ~/Projects. Each test-generated continuous_3D_matrix_volumes_* directory must be created directly under ~/Projects. No runtime evidence may be created below either source checkout.
Phase 2 can become COMPLETE only when all focused and regression tests pass, the A/B result is classified, every reported runtime path satisfies this rule, and the controller's runtime-evidence gate passes.

Second A/B re-prepare evidence — 2026-08-27:

The independent gate passed at turn entry: Phase 0 and Phase 1 were COMPLETE, and Phase 2 was REWORK REQUIRED. HEAD and the local origin/master ref remained 5f84de401a7bacb2795fe07255f9de1c959b9102; no Phase 2 source or generated-navigation drift was found.
Lightweight checks are PASS: path-limited git diff --check exited 0; the phase Fortran files again had zero trailing-whitespace findings, zero lines longer than 132 columns, zero conflict markers, zero new multiline macro hazards, zero retired private-operation calls, and zero pose/PCG-policy references in simple_cartesian_fourier. Generated navigation and test registration still contain the neutral module and focused test.
The restricted UCRT64 check failed before Bash execution with Win32 signal-pipe error 5. Its one exact elevated retry exited 0 and reported UCRT64, /home/hossainm7/hael_SIMPLE, /usr/bin/rsync, and rsync 3.4.4 protocol 32.
The exact documented rsync -avn --delete exited 0 and proposed 89 file transfers with zero deletions. Transfers are current controller/workflow files, normalized scripts, the living note, and controller evidence. Every proposed path is inside C:/msys64/home/hossainm7/hael_SIMPLE/ and ~/Projects/hael_SIMPLE-rsync-test; the prior unsafe source-checkout validation/ deletion set is absent.
The validation turn must run all four declared Phase 2 tests and both deterministic case=halfset_fsc A/B arms from ~/Projects, retain named evidence below one timestamped package directly under ~/Projects, and run the post-test source-checkout evidence checks before it reports acceptance. The control is unchanged origin/master; the experimental arm is this Phase 2 tree; the neutral extraction is the only planned difference.
Local evidence is codex_logs/pose_cont_20260826_144540_289/phase02/prepare_20260827_075145_909.events.jsonl and its sibling prompt and stderr files. No real synchronization, remote normalization, compilation, runtime test, scientific A/B, or commit occurred.

A/B validation preflight — 2026-08-27:

The independent gate passed at turn entry: Phase 0 and Phase 1 were COMPLETE, and Phase 2 was READY FOR ORACLE VALIDATION. HEAD and the local origin/master ref were both 5f84de401a7bacb2795fe07255f9de1c959b9102.
The approved real rsync -av --delete exited 0, transferred 93 files, and deleted no path. The four transfers beyond the reviewed 89 were the active validate prompt, JSONL, stderr file, and current living-note update. The first normalization wrapper failed locally with a quote error and exited 1 before SSH execution; the corrected explicit-MSYS2-SSH normalization exited 0 and changed only copied *.pl and *.sh line endings in ~/Projects/hael_SIMPLE-rsync-test.
A read-only Oracle inventory exited 0 and found only ~/Projects/hael_SIMPLE-GPU and ~/Projects/hael_SIMPLE-rsync-test among candidate hael_SIMPLE* roots. Neither root contains Git metadata. Therefore no Oracle source root can be verified as the required unchanged origin/master control at 5f84de401a7bacb2795fe07255f9de1c959b9102.
Compilation and runtime stopped before execution. Building only the Phase 2 arm would not satisfy the approved matched A/B, and creating or transferring a separate baseline source root is not authorized by this turn's real-rsync, normalization, compilation, or runtime approvals. No compiler log, runtime package, generated matrix directory, A/B table, executable checksum, or scientific result was created.
Phase 2 is BLOCKED on an exact, separately authorized baseline-materialization workflow. The safe next action is to define and approve the baseline source path and transfer or checkout command, require source identity and cleanliness checks before compilation, then return Phase 2 to REWORK REQUIRED for a dry run that reviews every destination and deletion involved before another validation turn.
Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase02/validate_20260827_075427_701.events.jsonl and its sibling prompt and stderr files. The remote experimental source is ~/Projects/hael_SIMPLE-rsync-test; no runtime evidence was created in it.

Baseline path resolution — 2026-08-27:

The prior validation inventory was too narrow: it searched only candidate hael_SIMPLE* roots and therefore did not inspect the user-provided unchanged baseline at ~/Projects/SIMPLE.
The fixed A/B source roots are ~/Projects/SIMPLE for the pinned upstream snapshot and ~/Projects/hael_SIMPLE-rsync-test for Phase 2. The common runtime working directory remains ~/Projects; neither source root is a runtime evidence directory.
The 2026-08-27 rebase advanced the shared Phase 2 base by eight upstream commits to dde8dde905b376f90bd352d0f4b6d6a46ef5db0b. Those commits do not touch simple_reconstructor_pcg.f90 or simple_gridding.f90, but they change PCG prior workflows and one mother-suite dependency. Therefore the matched A/B control must use this new exact base, not the historical 5f84de401 snapshot.
Before compiling, verify that ~/Projects/SIMPLE contains Git metadata and has no tracked modification. Pin the control independently of the moving origin/master tip with git checkout --detach dde8dde905b376f90bd352d0f4b6d6a46ef5db0b. If the commit object is missing locally, fetch from origin only to obtain that commit, then repeat the exact detached checkout. Verify HEAD equals the required commit afterward. No reset, source edit, commit, push, branch update, or checkout of any other commit is allowed in ~/Projects/SIMPLE.
Build the baseline from its own root. Because the baseline clone need not contain local-only .codex helpers, invoke ~/Projects/hael_SIMPLE-rsync-test/.codex/compile_debug.sh while the current directory is ~/Projects/SIMPLE; the helper operates on the current source root and writes only its ignored build/ tree. Use the ordinary conditional clean-retry policy independently for each arm, and verify afterward that the baseline still has no tracked modification.
After both builds, set each arm's SIMPLE_PATH to that arm's build directory before its test, return to ~/Projects as the runtime working directory, and record both executable checksums. Rerun the complete Phase 2 test set and the matched halfset_fsc A/B defined above.

Baseline-control re-prepare evidence — 2026-08-27:

The independent gate passed at turn entry: Phase 0 and Phase 1 were COMPLETE, and Phase 2 was REWORK REQUIRED. HEAD and the local origin/master ref were both dde8dde905b376f90bd352d0f4b6d6a46ef5db0b.
Applicable policies remain doc/policies/KB_Interpolation_Policy.md for padded-period KB coordinates and scaling, doc/policies/reconstruct3D_pcg_policy.md for the PCG operator, envelope, output, and AC-12 contracts, and doc/policies/refine3D_policy.md for the unchanged particle/volume workflow boundary.
The control-source blocker is resolved by the fixed ~/Projects/SIMPLE baseline root and the exact detached-checkout procedure above. The later validation turn must verify Git metadata and tracked cleanliness, pin the control to dde8dde905b376f90bd352d0f4b6d6a46ef5db0b, build each arm independently, and preserve the common ~/Projects runtime working directory. This prepare turn did not inspect or change either remote source root.
Lightweight checks are PASS: path-limited git diff --check exited 0; all five Phase 2 Fortran files have zero trailing-whitespace findings, zero lines longer than 132 columns, zero conflict markers, zero new multiline macro hazards, and zero retired private-operation calls. The neutral interpolation modules contain zero pose/PCG-policy references. Generated navigation and test registration contain the neutral module and focused test.
The restricted UCRT64 check failed before Bash execution with Win32 signal-pipe error 5 and exit 1. Its one exact elevated retry exited 0 and reported UCRT64, /home/hossainm7/hael_SIMPLE, /usr/bin/rsync, and rsync 3.4.4 protocol 32.
The exact documented rsync -avn --delete exited 0 and proposed 112 file transfers with zero deletions. Transfers are current build and workflow scripts, controller evidence, generated navigation, Phase 2 source and tests, and current upstream files that differ from the remote copy. Every proposed path is inside C:/msys64/home/hossainm7/hael_SIMPLE/ and ~/Projects/hael_SIMPLE-rsync-test; no unexpected source, destination, or deletion is present.
Local evidence is codex_logs/pose_cont_20260826_144540_289/phase02/prepare_20260827_092044_715.events.jsonl and its sibling prompt and stderr files. The dry run created no remote artifact. No real synchronization, remote normalization, compilation, runtime test, scientific test, or commit occurred.

Matched A/B Oracle validation evidence — 2026-08-27:

The independent gate passed at turn entry: Phase 0 and Phase 1 were COMPLETE, and Phase 2 was READY FOR ORACLE VALIDATION. Local HEAD and origin/master were both dde8dde905b376f90bd352d0f4b6d6a46ef5db0b; git diff --check exited 0.
The reviewed rsync -av --delete --info=progress2 with the documented exclusions exited 0, transferred 116 files to ~/Projects/hael_SIMPLE-rsync-test, and deleted no path. The four transfers beyond the reviewed 112 were the active validate prompt, JSONL, stderr file, and completed prepare report. The explicit MSYS2 SSH line-ending normalization exited 0.
~/Projects/SIMPLE was a valid clean Git checkout at c44f1bffb6098894f1efa3237cdb18035a29ade4, but the required object was absent, so the initial git cat-file -e preflight exited 1. The authorized git fetch origin dde8dde905b376f90bd352d0f4b6d6a46ef5db0b and exact git checkout --detach dde8dde905b376f90bd352d0f4b6d6a46ef5db0b then exited 0. Verified control HEAD is the required commit, and tracked status remained empty before and after compilation and testing.
With module load gcc/15.2.0, the control command cd ~/Projects/SIMPLE && mkdir -p build && set -o pipefail && ~/Projects/hael_SIMPLE-rsync-test/.codex/compile_debug.sh 2>&1 | tee build/build_debug.log exited 0. The experimental command cd ~/Projects/hael_SIMPLE-rsync-test && mkdir -p build && set -o pipefail && .codex/compile_debug.sh 2>&1 | tee build/build_debug.log exited 0. Neither conditional clean retry was used.
Runtime saved the module-loaded base PATH, reconstructed PATH independently from each arm's build/scripts and build/bin, and used /home/hossainm7/Projects as the working directory for every command. case=neutral_extract exited 0; the complete experimental mother suite exited 1; test=pcg_recon exited 0; test=pcg_priors exited 0; unchanged-control case=halfset_fsc exited 1; and experimental case=halfset_fsc exited 1.
Neutral embed/crop, factors, native-plane extraction, and packed gathers passed. The factor and envelope absolute errors were 0; the inverse-envelope relative maximum was 2.219693E-07 against tolerance 2.0E-06. pcg_recon passed all 12 stages, including 27-iteration recovery correlation 0.97558, and pcg_priors passed all nine stages with final route-parity error 3.260160E-05.
The complete mother suite ran 11 groups, passed 10, and failed only halfset_fsc. Both A/B arms selected lambda 10 and reported identical decisive values: PCG noisy raw L2 6.612755E-01/6.608928E-01 versus gridding 6.518738E-01/6.388823E-01. Both stopped on the best scale-sensitive PCG reconstruction does not beat conventional gridding.
The full A/B extraction contains 205 matrix rows per arm. Seventy-three rows are text-identical; the rest include distinct timestamped volume paths and small numerical differences. Across declared trajectory, FSC, norm, residual, error, and iteration fields, the maximum absolute difference is 1.700000000E-04 and maximum relative difference is 3.349704456E-03, both in the 40-iteration unmasked diagnostic. The best lambda, decisive raw L2 values, and gate outcome are identical, so the failure is upstream/pre-existing and is not caused by Phase 2 neutral extraction.
Executable SHA-256 values are e06a9c0ac6a8fc25f0f978ed07b21762ef4533b5c7cc03dbdec9764df184d7ff (control mother test), 88f6d0a9348c6bf608b3d7d4037ce4b3bfb8d34af171cbeb3238292365b8194c (experimental mother test), ba1c58916dd2599c3887a20f73ad7a4683b40aac7b6a2f38d0fc642b7b861529 (control simple_test_exec), and 1e9f2462450189d0da372cbee7f9a1c01f2e04b1975b455d754d75620ab2a2cf (experimental simple_test_exec).
Runtime evidence is ~/Projects/continuous_3D_phase2_validation_20260827_093030/, including manifest.txt, command_status.tsv, executable_sha256.txt, six named test directories, control_halfset_matrix_table.txt, experimental_halfset_matrix_table.txt, halfset_matrix_table.diff, and halfset_ab_analysis.txt. Post-test checks found no top-level validation/ or continuous_3D_matrix_volumes_* directory in either source checkout. Test-generated matrix directories were created directly below ~/Projects and removed by the test cleanup.
Phase 2 cannot become COMPLETE because the declared regression suite and strict scientific gate fail in the unchanged control and experimental arms. A scientific owner must decide how the frozen completion contract handles this confirmed upstream baseline failure. Do not weaken the gate, change Phase 2 source, repeat synchronization, commit, or start Phase 3 until that decision is recorded and Phase 2 is explicitly returned to REWORK REQUIRED or REVALIDATION REQUIRED.
Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase02/validate_20260827_092505_181.events.jsonl and its sibling prompt and stderr files. No focused commit was made because Phase 2 did not pass its scientific completion gate.

Scientific-owner decision — 2026-08-27:

Classify the strict halfset_fsc failure as a pre-existing PCG-reconstruction issue because unchanged origin/master and the Phase 2 tree produce the same best lambda, decisive raw L2 values, and failing assertion. This classification does not claim that PCG reconstruction is correct or that the quality assertion should be removed.
Accept the matched A/B parity as satisfying AC-12: Phase 2 did not change ordinary PCG behavior outside its existing numerical contract. Keep the absolute PCG-versus-gridding failure visible as a separate unresolved reconstruction issue; do not change its fixture, metric, or threshold as part of continuous-pose work.
Phase 2 is complete. Phase 3 may proceed with the particle-pose ownership migration and test-name split. No repeat synchronization or Phase 2 runtime is required for this decision.

Create the approved neutral Cartesian Fourier module and padded-period/center-crop envelope helper. Rewire PCG wrappers to those neutral operations before moving any pose routine. Do not change the PCG public transfer, variance fallback, forward/adjoint, solver, prior, or profiling contracts.

Implementation guardrails:

implement the centered-crop inverse envelope exactly as defined under Neutral numerical owners, then compare it directly with the current PCG padded-period/cropped result before replacing either caller;
preserve the wrap table's actual lower and upper bounds when passing it to a neutral gather;
preserve the packed half-complex/Friedel index mapping, the 27-tap traversal and accumulation order, and the current real/complex precision; and
keep padsc outside the neutral gather so each owner applies the existing native-Fourier scaling exactly once.

Tests and reason: compare old and neutral centered embed/crop, envelope factors, value gather, and value/gradient gather on deterministic arrays; run the existing PCG operator, deapodization, prior-attachment, kernel-versus-matrix-free, and reconstruction baselines because shared interpolation can change every PCG result.

Gate: neutral interfaces contain no pose or PCG policy, direct old/new comparisons pass without unexplained drift, and matched unchanged-control/Phase 2 evidence satisfies AC-12. An absolute reconstruction-quality assertion that fails identically in both arms remains a separately reported PCG issue and does not become a continuous-pose source correction.

Phase 3 — create the particle-pose owner and migrate regressions¶

Status: COMPLETE

Create simple_cartesian_pose_refiner and its private fixed-reference and prepared-particle data. Move the pose/shift methods and constants listed under Particle-pose owner without intentional mathematical change. Migrate test callers and batch accounting to test-only helpers, delete simple_pcg_pose_polisher, and update generated source maps.

Retain the current keyed diagnostics, but rename new pose-owned helpers and evidence so they do not claim to be PCG algorithms. Adapt run_oracle_pose_capture.sh for the new source owner. Do not adapt the historical production A/B or truth-matrix runners into acceptance tests.

Perform the test rename as an ownership split, not as a blind replacement of PCG with pose_cont:

create the simple_test_pose_cont_refinement mother executable, simple_pose_cont_refinement_* dependency files, and pose_cont_refinement_* test modules for shift/rotation derivatives, shift and joint-pose recovery, pose contracts, fixed-reference diagnostics, capture-range trials, and mechanism routes;
move neutral Cartesian Fourier and KB interpolation checks to a neutral Cartesian-Fourier test owner because these operations are shared by pose refinement and reconstruction;
retain the volume-noise, half-set, and reconstruction-comparison cases under an explicitly PCG-reconstruction test name, without the word refinement, because they test reconstruction rather than pose_cont;
rename production/tests/continuous_3D_pcg_pose_capture/ and its outputs to pose_cont terminology while preserving the isolated numerical experiment;
retire production/tests/continuous_3D_pcg_pose_validation/ after preserving its historical evidence references because its runners still invoke the removed pcg_pose_polish production option and are not valid acceptance paths for the new owner; and
remove the old continuous_3D_pcg_refinement executable, filename prefix, module prefix, log labels, and generated-index entries only after every retained case has a named destination and source-reference checks find no remaining caller.

The current inventory contains no orphaned Fortran test source under the old prefix: the CMake dependency glob compiles all of them, and every module is reachable directly or indirectly from the mother executable. scaffold is a retirement candidate because it now checks only test-harness seeding and assertions; fold any still-useful deterministic-fixture check into the neutral test support before deleting it. The keyed fixed-reference, forward-path, matched-window, reference-bias, operator-contract, capture-range, and mechanism cases are not in the default schedule, but they remain reachable diagnostics and must not be classified as unused merely because the mother suite does not schedule them by default.

Tests and reason: run source import/API checks, all ten mother-suite groups, componentwise derivative checks, shift and pose recovery, serial/parallel batch equivalence, capture range, mechanism routes, and operator diagnostics. These tests prove migration parity and ownership; they do not yet provide the independent acceptance evidence.

Gate: AC-8 passes as a migration regression, AC-10 and AC-11 pass, no test imports pcg_fourier_workspace for pose work, and the deleted strategy has no remaining caller or manifest entry.

production/CMakeLists.txt is a frozen boundary for this development. Phase 3 must conform to the existing simple_<test_id>_* dependency convention; neither this phase nor a later phase may add a special test-source exception.

Prepare evidence — 2026-08-27:

The independent gate passed at turn entry. Phases 0, 1, and 2 were COMPLETE, Phase 3 was NOT STARTED, and the tracked worktree was clean at 13f84ef3a before this phase started.
Applicable policies are doc/policies/KB_Interpolation_Policy.md for padded Cartesian KB coordinates and scaling, doc/policies/reconstruct3D_pcg_policy.md for the reconstruction-only PCG boundary and regression owner, and doc/policies/refine3D_policy.md for the particle-domain versus volume-domain ownership boundary. No UI policy applies because Phase 3 adds no command, option, or production caller.
cartesian_pose_refiner and private-field cartesian_pose_data now own the immutable physical-volume reference, exactly-once padded-period inverse-envelope preparation, strict effective noise-shell range, shift-free CTF/noise transfer, whitened observation, right-increment rotation, derivative and normal terms, bounded LM, and status constants (src/main/volume/simple_cartesian_pose_refiner.f90:40, src/main/volume/simple_cartesian_pose_refiner.f90:50, src/main/volume/simple_cartesian_pose_refiner.f90:102, src/main/volume/simple_cartesian_pose_refiner.f90:168, src/main/volume/simple_cartesian_pose_refiner.f90:234, src/main/volume/simple_cartesian_pose_refiner.f90:540, src/main/volume/simple_cartesian_pose_refiner.f90:788). The explicitly named new_prepared_test constructor is test-only and preserves the retained prepared-volume model diagnostics.
simple_reconstructor_pcg now exports only the reconstruction owner and PCG controls; it no longer contains a pose workspace, pose constants, rotation update, derivative evaluator, or pose/shift LM (src/main/volume/simple_reconstructor_pcg.f90:48, src/main/volume/simple_reconstructor_pcg.f90:282). simple_pcg_pose_polisher.f90 was deleted; its regression-only batch accounting and rollback checks moved to the pose-owned test helper, now production/tests/simple_pose_cont_refinement_batch_helpers.f90:19.
The old mixed suite is split into simple_test_pose_cont_refinement, simple_test_cartesian_fourier, and simple_test_continuous_3D_pcg_reconstruction. Together they preserve the ten former default groups as five pose, two neutral Cartesian-Fourier, and three PCG-reconstruction regressions. Child-process isolation is retained through suite-owned launchers at production/tests/simple_pose_cont_refinement_test_helpers.f90:29, production/tests/simple_cartesian_fourier_test_helpers.f90:29, and production/tests/simple_continuous_3D_pcg_reconstruction_test_helpers.f90:29. The pose-contract case adds source coverage for exactly-once inverse-envelope construction and the nonfatal invalid-noise-range result. The rejected CMake exception from this prepare state is superseded by the correction recorded below.
The capture package is now production/tests/pose_cont_capture/; its default executable and source manifest use pose-owned names (production/tests/pose_cont_capture/README.md:1, production/tests/pose_cont_capture/run_oracle_pose_capture.sh:17, production/tests/pose_cont_capture/run_oracle_pose_capture.sh:54). The obsolete production-option validation directory and scaffold-only case were retired. Generated navigation lists the new pose owner and contains no deleted strategy or old workspace entry (doc/code_overview/code_base_map.md:658).
Lightweight source checks are PASS. git diff --check exited 0; the Phase 3 Fortran and CMake files have zero trailing-whitespace findings, zero lines longer than 132 columns, zero conflict markers, and zero new multiline macro hazards. All 27 renamed dependency modules resolve within the three test targets. Source searches find zero pcg_fourier_workspace, begin_fourier_workspace, simple_pcg_pose_polisher, old executable-name, or old module-prefix references below src/ and production/. The pose owner imports no reconstruction module, and production source imports no pose owner. The code-overview generator first failed before execution with the documented MSYS2 Win32 signal-pipe error and exit 1; its exact elevated retry exited 0. The Fortran-index generator exited 0.
The restricted UCRT64 check failed before Bash execution with Win32 signal-pipe error 5 and exit 1. Its elevated retry reached UCRT64, /home/hossainm7/hael_SIMPLE, and /usr/bin/rsync, but a local PowerShell quoting error removed the sed program, so that command exited 1 before it printed the rsync version. The check was not repeated. The subsequent exact approved rsync command executed rsync successfully.
The exact documented rsync -avn --delete --info=progress2 exited 0 and proposed 138 file transfers and 45 deletions. The deletions are exactly eight paths below the renamed old capture directory, including two generated __pycache__ files and their directory; 29 old mixed-suite files replaced by the three named owners, including the retired scaffold; seven obsolete production-option validation files; and src/main/strategies/search/simple_pcg_pose_polisher.f90. All replacement files are in the transfer list. Every transfer and deletion is inside C:/msys64/home/hossainm7/hael_SIMPLE/ and ~/Projects/hael_SIMPLE-rsync-test; no unrelated or unexplained deletion is present.
The focused runtime hypotheses remain for Oracle validation: the five pose groups must preserve derivative, recovery, batch, contract, and rollback behavior; the two neutral groups must preserve KB and extracted Cartesian operations; the three reconstruction groups must preserve volume, noise, and half-set behavior. The keyed fixed-reference, forward-path, matched-window, reference-bias, operator-contract, capture-range, and mechanism diagnostics must remain callable from the pose executable. No compilation, SIMPLE runtime, scientific acceptance test, real synchronization, remote normalization, or commit occurred in this prepare turn.
Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase03/prepare_20260827_101406_696.events.jsonl and its sibling prompt and stderr files. The dry run created no remote artifact. The reviewed remote destination is ~/Projects/hael_SIMPLE-rsync-test.

Validation evidence — 2026-08-27:

Real rsync -av --delete --info=progress2 synchronization exited 0. It applied the reviewed 45 deletions and transferred 142 files. Four additional transfers were current controller evidence files created or changed after the prepare dry run; all remained inside the declared checkout.
The first normalization command exited 1 before SSH because PowerShell rejected its quoting. The next attempt exited 0 but did not remove CRLF. The first build-helper invocation then failed before compilation with /bin/bash^M and exit 1. The direct-SSH normalization retry exited 0, and od verified the helper shebang ended in byte 0a with no 0d.
The first compile command exited 0 after SSH quoting reduced the remote command to bare module; it did not compile and is not compilation evidence. The direct-SSH incremental logged build loaded GCC 15.2.0, configured Debug successfully, and reached gfortran, but exited 1. The first causal compiler error was src/main/volume/simple_reconstructor_pcg.f90:47: Unclassifiable statement; later diagnostics were parser cascades.
Source inspection found that the Phase 3 extraction had removed end type pcg_solver_outcome. The smallest correction restores that one line before type :: reconstructor_pcg (src/main/volume/simple_reconstructor_pcg.f90:46). No clean retry was run because a clean build cannot correct this source syntax defect. No runtime or scientific test was run.
Safe next action: run a new Phase 3 prepare turn. Regenerate navigation and current line references, repeat lightweight checks, and review a new exact rsync dry run before any new synchronization or compilation approval.

Rework prepare evidence — 2026-08-27:

The independent gate passed with Phases 0, 1, and 2 COMPLETE and Phase 3 REWORK REQUIRED. The rework restores only end type pcg_solver_outcome before the reconstruction owner (src/main/volume/simple_reconstructor_pcg.f90:46); reconstructor_pcg now starts at line 48 and ends at line 282.
Both restricted MSYS2 Perl generator attempts failed before script execution with Win32 signal-pipe error 5 and exit 1. Each exact elevated retry exited 0. The code overview reports 57 directories and 745 listed files, and all six generated Fortran navigation files are current.
Lightweight source checks are PASS. git diff --check exited 0; 33 Phase 3 Fortran and CMake files have zero trailing-whitespace findings, zero lines longer than 132 columns, zero conflict markers, and zero multiline macro hazards. Source and generated-navigation searches contain no old pose workspace, deleted pose-polisher, old executable, or old module-prefix reference. The pose owner does not import the reconstructor, and no production source imports the pose owner.
The restricted UCRT64 check failed before Bash execution with Win32 signal-pipe error 5 and exit 1. Its exact elevated retry exited 0 and confirmed UCRT64, /home/hossainm7/hael_SIMPLE, /usr/bin/rsync, and rsync 3.4.4 protocol 32.
The exact documented rsync -avn --delete --info=progress2 exited 0 and proposed 83 transfers and zero deletions. The script transfers are expected line-ending reversions after the prior validation normalized the remote copies. The other transfers are the one-line Fortran correction, regenerated navigation, updated execution-plan evidence, and current controller logs. All paths are inside C:/msys64/home/hossainm7/hael_SIMPLE/ and ~/Projects/hael_SIMPLE-rsync-test; no unexpected or unexplained transfer is present.
Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase03/prepare_20260827_105937_336.events.jsonl and its sibling prompt and stderr files. The dry run created no remote artifact. No real synchronization, normalization, compilation, runtime test, scientific gate, or commit occurred in this rework prepare turn.

Second validation evidence — 2026-08-27:

Real rsync -av --delete --info=progress2 synchronization exited 0, transferred 87 files, and made no deletion. Four transfers beyond the reviewed dry run were current controller evidence files created after prepare. Direct-SSH line-ending normalization and the helper-shebang verification exited 0; the shebang contained LF byte 0a and no CR byte 0d.
The incremental logged GCC 15.2.0 Debug build configured successfully and reached gfortran, then exited 1. The clean retry was not run because the errors are source defects. No runtime or scientific test was run.
The pose-owner compiler diagnostics showed that pose_refinement_summary was declared in the module procedure section at src/main/volume/simple_cartesian_pose_refiner.f90:1029. The smallest correction moves this public result type into the module specification section before the first contains (src/main/volume/simple_cartesian_pose_refiner.f90:89).
The reconstruction compiler diagnostics also found four surviving calls to removed type-bound pad_vol and crop_vol helpers in the nonuniform-prior path. The smallest owner-aligned correction uses the already imported neutral functions center_embed_real3d and center_crop_real3d at src/main/volume/simple_reconstructor_pcg.f90:849, src/main/volume/simple_reconstructor_pcg.f90:871, src/main/volume/simple_reconstructor_pcg.f90:873, and src/main/volume/simple_reconstructor_pcg.f90:887.
Safe next action: run a new Phase 3 prepare turn. Regenerate navigation and current references, repeat lightweight checks, and review a new exact rsync dry run before any new synchronization or compilation approval.

Code-review rework — 2026-08-27:

P1 — numerical ownership: the production owner now exports only the fixed-reference and single-particle numerical API (src/main/volume/simple_cartesian_pose_refiner.f90:11, src/main/volume/simple_cartesian_pose_refiner.f90:40, src/main/volume/simple_cartesian_pose_refiner.f90:50). Batch summaries, rollback accounting, OpenMP equivalence, and shape checks reside in the pose-owned test helper (production/tests/simple_pose_cont_refinement_batch_helpers.f90:19, production/tests/simple_pose_cont_refinement_batch_helpers.f90:40, production/tests/simple_pose_cont_refinement_batch_helpers.f90:115, production/tests/simple_pose_cont_refinement_batch_helpers.f90:222). Its filename matches the existing pose-suite dependency glob; no CMake exception is used.
P2 — reference memory: prepared-particle objective and LM calls no longer assign the complete cartesian_pose_refiner. They reuse its immutable padded Fourier lattice and pass the effective shell range as local call state (src/main/volume/simple_cartesian_pose_refiner.f90:234, src/main/volume/simple_cartesian_pose_refiner.f90:245, src/main/volume/simple_cartesian_pose_refiner.f90:540, src/main/volume/simple_cartesian_pose_refiner.f90:788). The pose-contract case compares the prepared shell-local objective and gradient with a direct fixed-reference evaluation (production/tests/simple_pose_cont_refinement_pose_contract_test.f90:129).
P1 — complete suite evidence: the neutral Cartesian and PCG-reconstruction mothers now reject duplicate or empty case= selectors, execute every scheduled child despite individual failures, and report complete pass/skip/fail summaries (production/tests/simple_test_cartesian_fourier.f90:21, production/tests/simple_test_cartesian_fourier.f90:30, production/tests/simple_test_continuous_3D_pcg_reconstruction.f90:22, production/tests/simple_test_continuous_3D_pcg_reconstruction.f90:32, production/tests/simple_cartesian_fourier_test_helpers.f90:29, production/tests/simple_continuous_3D_pcg_reconstruction_test_helpers.f90:29).
P3 — cleanup: the unused old-PCG skip reporter and the orphaned reconstruction workspace comment were removed.
Lightweight source checks pass: git diff --check reports no error; changed Fortran and CMake sources have no line beyond 132 columns; source searches find no production batch-summary export, full-reference assignment, old pose workspace, deleted pose-polisher, old executable name, or old module prefix. The code-overview and Fortran-index generators completed successfully after the normal PowerShell path lacked Perl and restricted MSYS2 hit its known signal-pipe boundary. No compilation or runtime test was performed after these corrections.
The local branch was rebased onto origin/master before restart. The prior prepare dry run predates the P1–P3 corrections and is not valid for the current source. Phase 3 is therefore REWORK REQUIRED; the controller must record a fresh source fingerprint and exact rsync dry run before validation.
The next authorized action is a fresh Phase 3 prepare/validation cycle: review the exact rsync dry run, compile on Oracle Linux, run the five pose, two neutral, and three reconstruction mother groups, then run the retained keyed pose diagnostics. Phase 3 is not complete until those results pass or receive an explicit reviewed disposition.

Code-review rework prepare evidence — 2026-08-27:

The independent gate passed with Phases 0, 1, and 2 COMPLETE and Phase 3 REWORK REQUIRED. The prepared branch is master at 0166485508660ea4919f038cf4f50c8a9c5f23e7; origin/master is 4619e406a48259bab32439923decb4eac1fe08d0. The controller must bind validation to the post-prepare Git identity and deterministic content fingerprint.
The applicable policies remain doc/policies/KB_Interpolation_Policy.md for padded Cartesian KB ownership and scaling, doc/policies/reconstruct3D_pcg_policy.md for the reconstruction-only PCG boundary, and doc/policies/refine3D_policy.md for particle-domain versus volume-domain ownership. No UI policy applies because Phase 3 changes no command, option, or production caller.
The production pose owner contains only fixed-reference and single-particle numerical operations (src/main/volume/simple_cartesian_pose_refiner.f90:11, src/main/volume/simple_cartesian_pose_refiner.f90:40, src/main/volume/simple_cartesian_pose_refiner.f90:50, src/main/volume/simple_cartesian_pose_refiner.f90:234, src/main/volume/simple_cartesian_pose_refiner.f90:540, src/main/volume/simple_cartesian_pose_refiner.f90:788). Test-only batch summaries, rollback accounting, OpenMP equivalence, and shape validation are in production/tests/simple_pose_cont_refinement_batch_helpers.f90:19, production/tests/simple_pose_cont_refinement_batch_helpers.f90:40, production/tests/simple_pose_cont_refinement_batch_helpers.f90:115, and production/tests/simple_pose_cont_refinement_batch_helpers.f90:222; the owning prefix makes it part of only the pose test target. The reconstruction owner has the restored result-type terminator and neutral embed/crop calls (src/main/volume/simple_reconstructor_pcg.f90:46, src/main/volume/simple_reconstructor_pcg.f90:849, src/main/volume/simple_reconstructor_pcg.f90:871, src/main/volume/simple_reconstructor_pcg.f90:873, src/main/volume/simple_reconstructor_pcg.f90:887).
Lightweight source checks are PASS. git diff --check exits 0. The 34 Phase 3 Fortran and CMake files have zero trailing-whitespace findings, zero lines longer than 132 columns, zero conflict markers, and zero multiline macro hazards. Source searches find zero stale type-bound pad_vol or crop_vol calls, production batch API declarations, old pose workspace, deleted pose-polisher, old executable name, or old module prefix. Generated navigation lists the test-only helper (doc/code_overview/code_base_map.md:28) and pose owner (doc/code_overview/code_base_map.md:658).
The focused Oracle hypotheses are unchanged: the five pose groups must preserve derivative, recovery, batch, contract, and rollback behavior; the two neutral groups must preserve KB and extracted Cartesian operations; the three reconstruction groups must preserve volume, noise, and half-set behavior. The retained keyed pose diagnostics must remain callable. These tests establish migration parity and ownership; later phases provide independent scientific acceptance.
The restricted UCRT64 environment check failed before Bash execution with Win32 signal-pipe error 5 and exit 1. Its exact elevated retry exited 0 and confirmed UCRT64, /home/hossainm7/hael_SIMPLE, /usr/bin/rsync, and rsync 3.4.4 protocol 32.
The exact documented rsync -avn --delete --info=progress2 exited 0 and proposed 146 transfers and one deletion. The only deletion is the empty remote directory production/tests/continuous_3D_pcg_pose_validation/; this is the expected final removal of the retired production-option validation directory. Transfers include current Phase 3 sources, test owners, generated navigation, execution evidence, controller fingerprint inputs, and expected script line-ending reversions. All paths are inside C:/msys64/home/hossainm7/hael_SIMPLE/ and ~/Projects/hael_SIMPLE-rsync-test; no unexpected, unexplained, or out-of-scope transfer or deletion is present.
Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase03/prepare_20260827_120206_509.events.jsonl and its sibling prompt and stderr files. The dry run created no remote artifact. The reviewed remote destination is ~/Projects/hael_SIMPLE-rsync-test. No real synchronization, normalization, compilation, runtime test, scientific gate, or commit occurred in this prepare turn.

Validation approval-boundary evidence — 2026-08-27:

The independent gate passed with Phases 0, 1, and 2 COMPLETE and Phase 3 READY FOR ORACLE VALIDATION. The prepared-state check exited 0 and verified digest 8E628D81A64FCCBC175A7F98DE57A00051924BA4800D95A10C2C50A5DA00EE56, HEAD=0166485508660ea4919f038cf4f50c8a9c5f23e7, and origin/master=4619e406a48259bab32439923decb4eac1fe08d0.
The exact approved real rsync -av --delete --info=progress2 request was rejected by the tool approval reviewer before process creation. The reviewer classified synchronization of the repository to hossainm7@fwl-c143206.ncifcrf.gov:~/Projects/hael_SIMPLE-rsync-test with remote deletion as unacceptable risk despite the controller-injected scoped approval. No rsync process ran and no local or remote file changed.
Validation stopped at the approval boundary. Remote normalization, compilation, runtime tests, scientific checks, and the post-test source-checkout evidence checks did not run. No compiler or runtime evidence exists for this attempt.
No Fortran, CMake, test, generated-navigation, or controller-input file changed. This required execution-plan evidence update changes a tracked file that participates in the controller digest, so the saved prepare fingerprint is now stale for a later validation turn. Phase 3 is REWORK REQUIRED. Run a fresh prepare turn and exact dry run after the controller or approval policy permits the declared source, host, destination, exclusions, and --delete operation.
Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase03/validate_20260827_120753_106.events.jsonl and its sibling prompt and stderr files. No focused commit was made because Phase 3 did not reach compilation or runtime validation.

CMake-boundary correction — 2026-08-27:

Owner review rejected the Phase 3 special dependency block in production/CMakeLists.txt. The file now has no Git diff from HEAD and is an explicit off-limits boundary in this phase and in the unattended controller.
The generic helper was replaced by suite-owned, automatically discovered helpers: production/tests/simple_pose_cont_refinement_test_helpers.f90:2, production/tests/simple_cartesian_fourier_test_helpers.f90:2, and production/tests/simple_continuous_3D_pcg_reconstruction_test_helpers.f90:2. The batch helper is now production/tests/simple_pose_cont_refinement_batch_helpers.f90:2.
Pose diagnostics no longer import continuous_3D_pcg_reconstruction_halfset_support. Reconstructed-reference controls are isolated in the pose-owned, test-only production/tests/simple_pose_cont_refinement_reference_support.f90:3; its PCG calls construct historical reference-bias fixtures and do not make PCG part of the production pose API.
All new support filenames now match one of the three existing CMake dependency globs. Phase 3 remains REWORK REQUIRED; the prior dry run and source fingerprint are stale, and no Oracle validation is authorized until a fresh prepare turn reviews this corrected tree.

CMake-boundary re-prepare evidence — 2026-08-27:

The independent gate passed with Phases 0, 1, and 2 COMPLETE and Phase 3 REWORK REQUIRED. The applicable policies remain doc/policies/KB_Interpolation_Policy.md for padded Cartesian KB ownership and scaling, doc/policies/reconstruct3D_pcg_policy.md for the reconstruction-only PCG boundary, and doc/policies/refine3D_policy.md for particle-domain versus volume-domain ownership. No UI policy applies.
production/CMakeLists.txt remained off-limits and byte-identical throughout this turn at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4. It has no Git diff. Its existing simple_${test_id}_*.[fF]90 dependency glob is at production/CMakeLists.txt:201; the pose, Cartesian-Fourier, and PCG-reconstruction suite-owned helper names match that glob without an exception.
The production pose owner retains only fixed-reference and single-particle numerical operations (src/main/volume/simple_cartesian_pose_refiner.f90:11, src/main/volume/simple_cartesian_pose_refiner.f90:40, src/main/volume/simple_cartesian_pose_refiner.f90:50, src/main/volume/simple_cartesian_pose_refiner.f90:234, src/main/volume/simple_cartesian_pose_refiner.f90:540, src/main/volume/simple_cartesian_pose_refiner.f90:788). Batch accounting remains in production/tests/simple_pose_cont_refinement_batch_helpers.f90:19; suite utilities are in production/tests/simple_pose_cont_refinement_test_helpers.f90:2, production/tests/simple_cartesian_fourier_test_helpers.f90:2, and production/tests/simple_continuous_3D_pcg_reconstruction_test_helpers.f90:2. Pose-only reconstructed-reference fixtures are isolated in production/tests/simple_pose_cont_refinement_reference_support.f90:3.
Lightweight source checks are PASS. git diff --check exited 0. The 36 current Phase 3 Fortran files have zero trailing-whitespace findings, zero lines longer than 132 columns, zero conflict markers, and zero multiline macro hazards. Searches find zero old pose workspace, deleted pose-polisher, old executable/module prefix, production batch API, production pose-owner import, pose-owner reconstruction import, or stale type-bound pad_vol/crop_vol call. Generated navigation lists the three suite-owned helpers and pose owner (doc/code_overview/code_base_map.md:18, doc/code_overview/code_base_map.md:28, doc/code_overview/code_base_map.md:37, doc/code_overview/code_base_map.md:660).
The focused Oracle hypotheses remain unchanged. Five pose groups must preserve derivative, recovery, batch, contract, and rollback behavior. Two neutral groups must preserve KB and Cartesian operations. Three reconstruction groups must preserve volume, noise, and half-set behavior. Retained keyed pose diagnostics must remain callable. These Phase 3 tests establish migration parity and ownership; they do not provide the later independent scientific acceptance evidence.
The restricted UCRT64 check failed before Bash execution with the documented Win32 signal-pipe error and process status -1073741502. Its exact elevated retry confirmed UCRT64, /home/hossainm7/hael_SIMPLE, and /usr/bin/rsync, but a PowerShell quoting defect removed the sed program; the retry exited 1. The check was not repeated. The subsequent exact approved dry run executed rsync successfully.
The exact documented rsync -avn --delete --info=progress2 exited 0 and proposed 157 transfers and two deletions. The deletions are the empty retired directory production/tests/continuous_3D_pcg_pose_validation/ and obsolete remote helper production/tests/simple_continuous_3D_test_helpers.f90; the three suite-owned replacements are in the transfer list. The proposed production/CMakeLists.txt transfer restores the unchanged canonical local file over the prior remote validation copy that contained the rejected special dependency block. All transfers and deletions are inside C:/msys64/home/hossainm7/hael_SIMPLE/ and ~/Projects/hael_SIMPLE-rsync-test; no unexpected, unexplained, or out-of-scope item is present.
Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase03/prepare_20260827_125910_384.events.jsonl and its sibling prompt and stderr files. The dry run created no remote artifact. No real synchronization, normalization, compilation, runtime test, scientific gate, or commit occurred in this prepare turn.

Successful validation evidence — 2026-08-27:

The independent gate passed with Phases 0, 1, and 2 COMPLETE and Phase 3 READY FOR ORACLE VALIDATION. The controller prepared-state check exited 0 at HEAD=0166485508660ea4919f038cf4f50c8a9c5f23e7, origin/master=4619e406a48259bab32439923decb4eac1fe08d0, 1545 files, and digest D685476624364987F4006A1FA84E5BA4F41802F1BD4603AA64ABF37F546D0F15.
The exact approved rsync -av --delete --info=progress2, with exclusions for .git/, .codex/.local-history.git/, build/, and compiled artifacts, exited 0. It transferred 161 files and applied the two reviewed deletions: the empty retired production/tests/continuous_3D_pcg_pose_validation/ directory and obsolete remote production/tests/simple_continuous_3D_test_helpers.f90. Direct-SSH normalization with find . -type f $ -name '*.pl' -o -name '*.sh' $ -exec sed -i 's/\r$//' {} + exited 0 in ~/Projects/hael_SIMPLE-rsync-test.
module load gcc/15.2.0 && cd ~/Projects/hael_SIMPLE-rsync-test && mkdir -p build && set -o pipefail && .codex/compile_debug.sh 2>&1 | tee build/build_debug.log exited 0. The incremental Debug build compiled and installed all three Phase 3 test executables. The conditional clean retry was not used. The compiler log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log.
With SIMPLE_EMAIL=my.name@uni.edu, SIMPLE_QSYS=local, SIMPLE_PATH=~/Projects/hael_SIMPLE-rsync-test/build, and that build's scripts and bin first in PATH, all SIMPLE commands ran from ~/Projects. simple_test_pose_cont_refinement exited 0 and passed 5 of 5 groups; simple_test_cartesian_fourier exited 0 and passed 2 of 2 groups. Their logs are ~/Projects/continuous_3D_phase3_pose_mother_20260827_131900/run.log and ~/Projects/continuous_3D_phase3_cartesian_mother_20260827_131910/run.log.
simple_test_continuous_3D_pcg_reconstruction exited 1: volume_fixture and volume_noise passed, and halfset_fsc reproduced the documented unchanged-baseline absolute reconstruction failure. At the best noisy lambda 10, PCG raw L2 errors were 0.6612755 and 0.6608928; conventional-gridding errors were 0.6518738 and 0.6388823. The log is ~/Projects/continuous_3D_phase3_pcg_mother_20260827_131920/run.log, and its generated matrix package is ~/Projects/continuous_3D_matrix_volumes_20260827_130803765. Phase 2 already established this same result in the unchanged control and migrated arm. Thus, Phase 3 preserves the reconstruction behavior required by its ownership-migration gate; the absolute PCG reconstruction premise remains the separate future-work item below and is not a pose-source correction or a weakened pose gate.
Direct keyed calls for fixed_reference, forward_path, matched_window, reference_bias, and operator_contract all exited 0 and emitted their evidence-complete markers. The per-case logs are below ~/Projects/continuous_3D_phase3_<case>_20260827_13240*, and the status table is ~/Projects/continuous_3D_phase3_keyed_status_20260827_132400.tsv.
bash ~/Projects/hael_SIMPLE-rsync-test/production/tests/pose_cont_capture/run_oracle_pose_capture.sh --output-parent ~/Projects --executable ~/Projects/hael_SIMPLE-rsync-test/build/bin/simple_test_pose_cont_refinement exited 0. It completed 138 capture trials with zero integrity failures, passed the default LM recovery, completed the three-volume mechanism diagnostic, and returned POSE_CAPTURE_ANALYSIS: PASS. The package is ~/Projects/continuous_3D_pose_capture_20260827_131315; STATUS.txt is PASS, and all four recorded child or analysis statuses are 0. Its 29 scientific-recovery warnings are the declared gross-capture observations with no automatic acceptance threshold; they remain evidence for later scientific policy and do not fail this migration-parity phase.
Post-test canonical-path checks exited 0. ~/Projects resolves to /usr/local/cache/mazhar/Projects. The top level of ~/Projects/hael_SIMPLE-rsync-test contains no validation/ directory and no continuous_3D_matrix_volumes_* directory. Runtime evidence is directly below ~/Projects; only build/build_debug.log is inside the validation checkout, as permitted for compilation evidence.
Source and ownership checks are PASS. git diff --check exited 0; production/CMakeLists.txt has no Git diff and remains byte-identical at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4. Searches find no old pose workspace, deleted pose-polisher, old executable, or old module prefix. The fixed-reference and single-particle owner remains at src/main/volume/simple_cartesian_pose_refiner.f90:40, src/main/volume/simple_cartesian_pose_refiner.f90:50, and src/main/volume/simple_cartesian_pose_refiner.f90:790; it does not import the reconstruction owner. The reconstruction owner and neutral embed/crop calls remain at src/main/volume/simple_reconstructor_pcg.f90:48, src/main/volume/simple_reconstructor_pcg.f90:849, src/main/volume/simple_reconstructor_pcg.f90:871, and src/main/volume/simple_reconstructor_pcg.f90:887. The three mother schedules are at production/tests/simple_test_pose_cont_refinement.f90:65, production/tests/simple_test_cartesian_fourier.f90:30, and production/tests/simple_test_continuous_3D_pcg_reconstruction.f90:32; keyed pose dispatch is at production/tests/simple_test_pose_cont_refinement.f90:185 through line 198.
Phase 3 satisfies AC-8, AC-10, and AC-11 as an ownership-migration regression. It makes no production call, UI option, persistence path, or scientific-benefit claim. Formal independent numerical acceptance remains for Phases 4 through 10. Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase03/validate_20260827_130303_014.events.jsonl and its sibling prompt and stderr files.

Phase 4 — implement and freeze calibration infrastructure¶

Status: COMPLETE

Approved forward-calibration rework — 2026-08-28:

Preserve the completed algebraic, LM-system, derivative, and analytic-DFT calibration records and frozen tolerances.
Recalibrate executed_dft, slow_gather, and finite_projection over every point in the full redundant disk for multiple predeclared arbitrary rotations at boxes $8^3$ and $12^3$, using more than one deterministic asymmetric physical volume.
Keep the executed gather, structurally separate slow gather, and brute-force direct DFT as distinct computational paths. Record sample counts, stencil switches, absolute errors, and scaled-relative errors for every comparison.
Replace the arbitrary-rotation finite-projection acceptance comparison with the matched discrete contract defined in the approved forward-model amendment: projection/2-D DFT of $X_R$ versus the 3-D DFT of that same rotated/resampled finite $X_R$ at $l=0$.
Retain original-volume rotated-frequency agreement, clipping fraction, interpolation error, and support margin as diagnostics rather than forcing them into the matched finite-projection tolerance.
Treat the observed boxes $10^3$ and $16^3$ as diagnostics. Perform a static even-box indexing, full-disk population, memory, and brute-force operation-count review before declaring fresh holdout boxes; $14^3$ and $18^3$ are candidates, not yet frozen.
Derive the three amended tolerances with the existing componentwise metric, predeclared floors, and safety factor. Write a new forward-amendment freeze marker before any fresh holdout test runs. A loose calibration result stops for scientific review.

Rework gate: the three reopened families have full-domain calibration records, the finite-projection acceptance paths operate on the same finite object, fresh holdout fixtures are declared but untouched, and the amended tolerances are reviewed and frozen before Phase 8 resumes.

Local rework implementation — 2026-08-28:

production/tests/simple_pose_cont_refinement_calibration_helpers.f90:9 declares two calibration-volume variants and candidate holdout boxes $14^3$ and $18^3$ while preserving boxes $10^3$ and $16^3$ as observed diagnostics. build_calibration_fixture at line 90 now produces two deterministic asymmetric volumes per calibration box. The artifact writer at line 313 emits proposed rather than frozen forward tolerances and an AWAITING_SCIENTIFIC_REVIEW marker; it does not sample a fresh holdout.
production/tests/simple_pose_cont_refinement_calibration_test.f90:151 evaluates executed_dft, slow_gather, and finite_projection over four predeclared rotations and every point in the full redundant disk at boxes $8^3$ and $12^3$. The finite-projection comparison at lines 194–204 now uses the same rotated/resampled finite object on both sides. Original-volume disagreement, clipping fraction, interpolation-switch margin, and stencil-switch counts remain separate diagnostics.
The test repeats every calibration calculation and requires bitwise-identical records and aggregate diagnostics. It writes forward_calibration.tsv, proposed_tolerances.tsv, fixture_manifest.tsv, and forward_holdout_static_review.tsv before rejecting a scientifically loose proposal, so a failed run remains diagnosable.
Lightweight source inspection is complete: the changed Phase 4 sources contain no conflict markers or lines longer than 132 columns. Compilation and runtime evidence are not claimed. The next gate is the focused Oracle calibration run, followed by human review and explicit freezing of the three proposed families before any candidate holdout is constructed.

First amended calibration run and correction — 2026-08-30:

Oracle package ~/Projects/pose_cont_revalidation_20260830_225501 completed all calibration calculations and stopped at the intended scientifically-loose gate. slow_gather reached maximum absolute error $2.5123\times10^{-8}$ and finite_projection reached $8.2444\times10^{-9}$; both contracts are strong. executed_dft reached maximum absolute error $4.0364\times10^{-4}$ under arbitrary rotation, while identity remained near $10^{-8}$. This is the expected distinction between exact-grid evaluation and interpolation, not a fast/slow gather inconsistency.
The rejection came from the tolerance derivation rather than the forward numerics. The implementation independently multiplied the maximum absolute error and the maximum scaled-relative error by the safety factor. For low-amplitude Fourier samples whose comparison scale was clamped to $10^{-3}$, an absolute error near $1.0665\times10^{-4}$ became a 10.66-percent relative maximum; multiplying that number by eight proposed the meaningless relative tolerance $0.85319$.
The corrected combined derivation keeps each predeclared relative floor $r_0$ and calculates the part of each component error not already covered by it,

$$ q_i=\max(0,e_i-r_0s_i),\qquad a=\max(a_0,8\max_iq_i),\qquad r=r_0, $$

where $e_i$ is absolute error, $s_i$ is the stored comparison scale, and $a_0$ is the absolute floor. This matches the approved acceptance inequality $e_i\le a+rs_i$ and avoids treating low-amplitude interpolation samples as a separately maximized relative-error contract. Families 1–4 retain their exact frozen tolerances. - production/tests/simple_pose_cont_refinement_calibration_helpers.f90 now records every comparison scale and maximum combined excess, writes both to the evidence tables, and derives only the reopened forward proposals with the combined rule. production/tests/simple_pose_cont_refinement_calibration_test.f90 requires every observation to pass that combined proposal and requires the forward relative tolerance to remain at its predeclared floor. The correction is source-checked only; Oracle must rebuild and rerun Phase 4 before scientific review.

Corrected calibration review and freeze — 2026-08-30:

Oracle package ~/Projects/pose_cont_revalidation_20260830_230740 completed with POSE_CONT_REFINEMENT_TOLERANCE_CALIBRATION: PASS. It reproduced the earlier raw maxima exactly and confirmed deterministic coverage under the combined rule. The package's STATUS.txt has a blank value because the interactive shell did not populate Bash's PIPESTATUS array; the executable's terminal PASS marker is present in the complete log and is the runtime result.
Scientific review accepts and freezes executed_dft at absolute tolerance $6.1319031142573850\times10^{-4}$ and relative tolerance $0.03$; slow_gather at $10^{-7}$ and $2\times10^{-5}$; and finite_projection at $10^{-5}$ and $0.05$. The safety factor remains eight. These thresholds cover the calibration domain without hiding the distinction between exact-grid identity evaluation and arbitrary-rotation interpolation.
Boxes $14^3$ and $18^3$ are frozen as the fresh Phase 8 forward holdouts after static review of their even indexing, full-disk populations of 149 and 253, and direct-DFT costs of 408,856 and 1,475,496 voxel terms per plane. They remain unsampled. Boxes $10^3$ and $16^3$ remain prior observed diagnostics and cannot become fresh acceptance evidence.
production/tests/simple_pose_cont_refinement_calibration_helpers.f90 now contains the reviewed constants and emits frozen_tolerances.tsv plus FORWARD_AMENDMENT.FROZEN. production/tests/simple_pose_cont_refinement_calibration_test.f90 requires the derived values to equal the frozen values exactly before emitting PASS. One Oracle rebuild and focused Phase 4 rerun must confirm this frozen source state before Phases 5 and 6 run.

Frozen-source Oracle confirmation — 2026-08-30:

~/Projects/pose_cont_revalidation_20260830_231612/phase4 completed with exit status 0, emitted POSE_CONT_REFINEMENT_FORWARD_AMENDMENT: FROZEN and POSE_CONT_REFINEMENT_TOLERANCE_CALIBRATION: PASS, and wrote FORWARD_AMENDMENT.FROZEN plus frozen_tolerances.tsv.
The derived values equal the reviewed source constants exactly. The four calibration fixtures, four full-disk rotations, diagnostic boxes 10 and 16, and unsampled frozen holdouts 14 and 18 were all reported as declared. Phase 4 is complete; no holdout observation was used to set a threshold.

Prepare evidence — 2026-08-27:

Added the seven-family tolerance registry, predeclared absolute, relative, and relative-scale floors, safety factor 8, loose-result stops, componentwise combined real/complex metric, raw observation retention, derived-tolerance calculation, and immutable pre-acceptance marker in production/tests/simple_pose_cont_refinement_calibration_helpers.f90:9,27,179,223,246,277.
Added disjoint deterministic calibration fixtures for boxes 8 and 12 and reserved acceptance fixtures for boxes 10 and 16 in production/tests/simple_pose_cont_refinement_calibration_helpers.f90:80,129. Each set has different asymmetric volumes, exact and nonstationary poses, constant and varying positive shell variances, and ordinary and attenuated CTF profiles. The calibration entry point cannot construct an acceptance fixture.
Added case=tolerance_calibration in production/tests/simple_pose_cont_refinement_calibration_test.f90:14 and production/tests/simple_test_pose_cont_refinement.f90:200. The case repeats the complete calibration in memory and requires bitwise-identical fixtures, raw error tables, maxima, and derived tolerances. It writes calibration_raw_errors.tsv, frozen_tolerances.tsv, fixture_manifest.tsv, and PRE_ACCEPTANCE_TOLERANCES.FROZEN to the caller's explicit evidence_dir.
Calibration probes include the executed physical-volume/deapodized Cartesian gather, normalized brute-force DFT, independent slow normalized-KB traversal, closed-form unequal-point DFT, centered finite differences, scaled five-variable system, and identity line-sum projection at production/tests/simple_pose_cont_refinement_calibration_test.f90:60,142,237,259.
Applicable policies are doc/policies/KB_Interpolation_Policy.md for padded-grid KB coordinates and normalization, doc/policies/reconstruct3D_pcg_policy.md for the unchanged reconstruction boundary, doc/policies/refine3D_policy.md for particle-pose versus volume ownership, and doc/policies/sigma_calculation_policy.md for positive shell-variance meaning and native-shell indexing. No UI policy applies because Phase 4 adds no option or production caller.
Lightweight source checks are PASS. git diff --check exited 0. The three Phase 4 Fortran files have zero lines longer than 132 columns, zero conflict markers, and filenames that match the existing simple_pose_cont_refinement_*.[fF]90 dependency glob. Static call inspection finds no call to build_acceptance_fixture from the calibration case. production/CMakeLists.txt remains unchanged at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4.
The first restricted MSYS2 Perl attempts for both navigation generators failed before script execution with Win32 signal-pipe error 5 and status -1073741502. Each exact elevated retry exited 0. doc/code_overview/code_base_map.md:38 lists both new modules; the source-only Fortran indexes had no content change.
Oracle must create a timestamped evidence directory directly below ~/Projects, then run simple_test_pose_cont_refinement case=tolerance_calibration evidence_dir=<absolute-phase4-directory> from ~/Projects. The hypothesis is that both calibration boxes repeat exactly, all seven derived tolerances remain below their predeclared loose-result stops, the marker freezes them before any acceptance fixture runs, and boxes 10 and 16 remain unsampled. The complete simple_test_pose_cont_refinement mother suite then tests that the new keyed case does not change the five scheduled pose regressions.
Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase04/prepare_20260827_131802_557.events.jsonl and its sibling prompt and stderr files. The exact approved rsync dry run is the final operation of this turn; its complete output and exit status remain in that JSONL record. No source or controller-input change is permitted after the dry run. No real synchronization, normalization, compilation, runtime test, scientific acceptance test, or commit occurs in this prepare turn.

Failed validation evidence — 2026-08-27:

The independent gate passed with Phases 0 through 3 COMPLETE and Phase 4 READY FOR ORACLE VALIDATION. The prepared local source remained at HEAD=264248c732bca0e5e7a1af256e3b7a85245105f1, and production/CMakeLists.txt remained unchanged at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4.
The exact approved rsync -av --delete --info=progress2, with the documented exclusions, exited 0. It transferred 92 files and reported no deletion. Direct-SSH line-ending normalization exited 0 in ~/Projects/hael_SIMPLE-rsync-test.
The default incremental logged command module load gcc/15.2.0 && cd ~/Projects/hael_SIMPLE-rsync-test && mkdir -p build && set -o pipefail && .codex/compile_debug.sh 2>&1 | tee build/build_debug.log exited 2. GNU Fortran 15.2.0 reported two argument-list syntax errors in production/tests/simple_pose_cont_refinement_calibration_test.f90, at the transferred-source lines 51 and 302. The compiler log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log.
The smallest local correction separates each diagnostic string from the preceding continuation marker at production/tests/simple_pose_cont_refinement_calibration_test.f90:50 and production/tests/simple_pose_cont_refinement_calibration_test.f90:302. The conditional clean retry was not used because a clean build cannot correct source syntax. No runtime or scientific test ran.
Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase04/validate_20260827_133607_261.events.jsonl and its sibling prompt and stderr files. The safe next action is a new Phase 4 prepare turn with lightweight checks and a new exact rsync dry run. No second real synchronization is permitted in this turn.

Rework prepare evidence — 2026-08-27:

The independent gate passed with Phases 0 through 3 COMPLETE and Phase 4 REWORK REQUIRED. The source remains at HEAD=264248c732bca0e5e7a1af256e3b7a85245105f1, and production/CMakeLists.txt remains unchanged at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4.
The two compile diagnostics required only Fortran continuation corrections. The diagnostic strings now start on separate continued lines at production/tests/simple_pose_cont_refinement_calibration_test.f90:50 and production/tests/simple_pose_cont_refinement_calibration_test.f90:302. No numerical expression, tolerance, fixture, artifact, production source, or build-system file changed.
Lightweight source checks are PASS. git diff --check exited 0. The three Phase 4 Fortran files have zero trailing-whitespace findings, zero lines longer than 132 columns, zero conflict markers, zero multiline-macro hazards, and zero remaining diagnostic-string continuation hazards. Both new filenames match the existing simple_${test_id}_*.[fF]90 dependency glob at production/CMakeLists.txt:201.
Static fixture inspection confirms that run_tolerance_calibration constructs only calibration boxes 8 and 12 at production/tests/simple_pose_cont_refinement_calibration_test.f90:23. The acceptance fixture builder remains isolated at production/tests/simple_pose_cont_refinement_calibration_helpers.f90:129; boxes 10 and 16 are recorded only as reserved and unsampled.
The Oracle hypotheses are unchanged. The focused calibration case must compile, repeat both calibration fixtures bitwise, populate all seven tolerance families, remain below all loose-result stops, write the four declared artifacts, and freeze the tolerances before any acceptance fixture runs. The mother suite must then preserve all five scheduled pose regressions.
Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase04/prepare_20260827_135122_394.events.jsonl and its sibling prompt and stderr files. The exact approved rsync dry run is the final operation of this turn; its complete output and exit status remain in that JSONL record. No source or controller-input change is permitted after the dry run. No real synchronization, normalization, compilation, runtime test, scientific acceptance test, or commit occurs in this prepare turn.

Validation approval-boundary evidence — 2026-08-27:

The independent gate passed with Phases 0 through 3 COMPLETE and Phase 4 READY FOR ORACLE VALIDATION. The prepared source remained at HEAD=264248c732bca0e5e7a1af256e3b7a85245105f1, and production/CMakeLists.txt remained unchanged at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4.
The exact approved real rsync -av --delete --info=progress2 request was rejected by the tool approval reviewer before process creation. The reviewer did not accept the controller-injected authorization for repository transfer to hossainm7@fwl-c143206.ncifcrf.gov:~/Projects/hael_SIMPLE-rsync-test. No rsync process ran, and no local or remote file changed.
Validation stopped at the approval boundary. Remote normalization, compilation, runtime tests, numerical artifact checks, scientific checks, and post-test source-checkout evidence checks did not run. No compiler or runtime evidence exists for this attempt.
This required execution-plan evidence update changes a tracked controller-input file and invalidates the prepared source fingerprint. The safe next action is a new Phase 4 prepare turn and exact dry run after the controller or approval policy permits the declared source, host, destination, exclusions, and --delete operation.
Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase04/validate_20260827_135554_641.events.jsonl and its sibling prompt and stderr files. No focused commit was made because Phase 4 did not reach synchronization, compilation, or runtime validation.

Approval-boundary reprepare evidence — 2026-08-27:

The independent gate passed with Phases 0 through 3 COMPLETE and Phase 4 REWORK REQUIRED. The source remains at HEAD=264248c732bca0e5e7a1af256e3b7a85245105f1, and production/CMakeLists.txt remains unchanged at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4.
No numerical source changed after the prior safe dry run. The corrected diagnostic continuations remain at production/tests/simple_pose_cont_refinement_calibration_test.f90:50 and production/tests/simple_pose_cont_refinement_calibration_test.f90:302. The tolerance registry, fixtures, artifacts, dispatch, generated navigation, and frozen contract are unchanged.
Lightweight source checks are PASS. git diff --check exited 0. The three Phase 4 Fortran files have zero trailing-whitespace findings, zero lines longer than 132 columns, zero conflict markers, zero multiline-macro hazards, and zero diagnostic-string continuation hazards. Static inspection finds no acceptance-fixture call from the calibration entry point.
Applicable policies remain doc/policies/KB_Interpolation_Policy.md for padded-grid normalization, doc/policies/reconstruct3D_pcg_policy.md for the unchanged reconstruction boundary, doc/policies/refine3D_policy.md for pose-versus-volume ownership, and doc/policies/sigma_calculation_policy.md for positive native-shell variance semantics. No UI policy applies.
The focused and mother-suite Oracle hypotheses remain unchanged. The exact approved rsync dry run is the final operation of this turn; its complete output and exit status remain in codex_logs/pose_cont_20260826_144540_289/phase04/prepare_20260827_140741_144.events.jsonl and its sibling prompt and stderr files. No source or controller-input change is permitted after that dry run. No real synchronization, normalization, compilation, runtime test, scientific acceptance test, or commit occurs in this prepare turn.

Oracle validation evidence — 2026-08-27:

The independent gate passed with Phases 0 through 3 COMPLETE and Phase 4 READY FOR ORACLE VALIDATION. The prepared source remained at HEAD=264248c732bca0e5e7a1af256e3b7a85245105f1. git diff --check exited 0, and production/CMakeLists.txt remained unchanged at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4.
The reviewed rsync -av --delete --info=progress2 with the documented exclusions exited 0, transferred 91 files, and deleted no path. The four transfers beyond the 87-file dry run were the completed prepare report and the active validate prompt, JSONL, and stderr files. The explicit MSYS2 SSH line-ending normalization command exited 0 and changed only copied *.pl and *.sh files below ~/Projects/hael_SIMPLE-rsync-test.
The default incremental logged command loaded gcc/15.2.0, ran .codex/compile_debug.sh through tee build/build_debug.log with pipefail, and exited 0. The Debug build installed simple_test_pose_cont_refinement. The conditional SIMPLE_CLEAN_BUILD=yes retry was not used. The compiler log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log.
With the documented SIMPLE environment and /home/hossainm7/Projects as the working directory, simple_test_pose_cont_refinement case=tolerance_calibration evidence_dir=/home/hossainm7/Projects/continuous_3D_phase4_calibration_20260827_141348 exited 0. It sampled only boxes 8 and 12, reported boxes 10 and 16 as reserved and unsampled, repeated the calibration exactly, populated all seven families, wrote all four declared artifacts, and reported POSE_CONT_REFINEMENT_TOLERANCE_CALIBRATION: PASS.
The frozen table records safety factor 8. The largest derived absolute tolerance is 4.9353318740941177E-04 for algebraic accumulation. The largest derived relative tolerance is 5.0000000000000003E-02 for finite projection. The slow-gather absolute tolerance is 1.1541020711748716E-04; the scaled LM absolute tolerance is 2.0599365235796085E-07. Every family remained within its predeclared loose-result stop. The marker records status=FROZEN_PRE_ACCEPTANCE, calibration boxes 8,12, and unsampled acceptance boxes 10,16.
The complete simple_test_pose_cont_refinement mother suite ran from /home/hossainm7/Projects, exited 0, and passed all five scheduled groups with zero skip and zero failure. Its evidence is ~/Projects/continuous_3D_phase4_mother_20260827_141401/mother_suite.log.
Calibration evidence is ~/Projects/continuous_3D_phase4_calibration_20260827_141348/, including calibration_raw_errors.tsv, frozen_tolerances.tsv, fixture_manifest.tsv, PRE_ACCEPTANCE_TOLERANCES.FROZEN, and tolerance_calibration.log. SHA-256 values are 9e30522ec5ff5225674a98cbee0f14d2cf9cd5e1074b211b4888d5c99948d48b, bb1b0bf09797b03b68c8d49a09c54678a292cc29d8bf243241f3f081cb8efd64, 753fe24ea4daf01dcfbc8edd97058cee63e53ad32be1005bc394db69da2f7384, 7e292419a7779edc805cf9c341d09036eedd9af47e9ea4830801b3c2b501c9b8, and 732c5b6fcf02031ff859986e1fb21c86b68d37c604512f3142eae0413f1deb5a, respectively. The mother log SHA-256 is 729e68b16ecb336d82113367d6bcc6903cb4ed389161bd3c904a698bd1f35d81.
The first read-only artifact-inspection command exited 1 because its helper path files contained a literal trailing n; no test or evidence artifact changed. Direct inspection of the known timestamped roots exited 0. Post-test checks found no top-level validation/ or continuous_3D_matrix_volumes_* directory in either ~/Projects/hael_SIMPLE-rsync-test or the unchanged Phase 2 control checkout ~/Projects/SIMPLE. No runtime evidence was created below a source checkout.
Phase 4 satisfies its calibration-infrastructure gate. This phase freezes validation tolerances; it does not apply acceptance fixtures or establish the Phase 5 through Phase 10 numerical claims. Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase04/validate_20260827_141110_192.events.jsonl and its sibling prompt and stderr files.

Preserve the completed calibration infrastructure and implement the approved forward-only amendment under Tolerance-calibration protocol. Expand only the executed-DFT, slow-gather, and finite-projection calibration domains; keep all other families and their evidence unchanged. Do not run fresh holdout fixtures before the amended forward tolerances are frozen.

Tests and reason: run boxes $8^3$ and $12^3$ over multiple predeclared arbitrary rotations and the full redundant disk, using the direct DFT, executed gather, slow gather, and matched finite-projection paths. Check deterministic repeatability, retain clipping/interpolation diagnostics, and prove that no fresh holdout fixture is constructed during calibration.

Gate: each reopened tolerance has a recorded floor, full-domain calibration maximum, derived value, justification, and new immutable forward-amendment marker; the fresh holdout fixtures remain untouched. A loose result stops for diagnosis rather than becoming a threshold.

Phase 5 — verify the weighted objective and normal equations¶

Status: COMPLETE

The existing explicit accumulator and Oracle evidence remain valid. Add a test-only BLAS oracle by stacking the real and imaginary residual/Jacobian components into a real design matrix and using BLAS for $A^Tb$ and $A^TA$. Compare the production fused accumulation, existing explicit Fortran loops, and BLAS results under the unchanged algebraic tolerance. Do not expose a new production BLAS API solely for this test, and do not treat BLAS accumulation as an independent oracle for the sampled Jacobian values themselves.

Revalidation gate: the BLAS objective, gradient, and normal matrix agree componentwise with both retained paths under the unchanged frozen algebraic tolerance, and the existing Phase 5 evidence files remain reproducible with the additional BLAS columns or a separate BLAS table.

Local BLAS revalidation implementation — 2026-08-28:

production/tests/simple_pose_cont_refinement_objective_normals_test.f90:24 declares test-only DDOT and DGEMM interfaces. blas_normal_terms at line 294 stacks each active complex residual and five-column Jacobian into a real $2N\times5$ design matrix, calculates $\frac12b^Tb$, $A^Tb$, and $A^TA$, and verifies that all active full-disk samples were packed.
The unchanged production fused path and explicit scalar-loop oracle remain authoritative for sampled values. The BLAS path is only an additional accumulation oracle. blas_normal_equations.tsv records BLAS-versus-fused and BLAS-versus-explicit objective, gradient, and Hessian errors for every retained variance and pose case.
Lightweight source inspection is complete: the changed test contains no conflict markers or lines longer than 132 columns. No compilation or runtime evidence is claimed; the focused Oracle objective_normals run must demonstrate agreement under the unchanged algebraic tolerance.

BLAS Oracle validation — 2026-08-30:

~/Projects/pose_cont_revalidation_20260830_231612/phase5 completed with exit status 0 and POSE_CONT_REFINEMENT_OBJECTIVE_NORMALS: PASS over boxes 10 and 16, unit/constant/varying variance, and exact/nonstationary poses.
BLAS versus explicit accumulation differed by at most $1.3553\times10^{-20}$ in objective, $9.7579\times10^{-19}$ in gradient, and $2.4287\times10^{-17}$ in the normal matrix. BLAS versus the production fused path differed by at most $5.8488\times10^{-12}$, $1.1493\times10^{-10}$, and $2.4287\times10^{-17}$, respectively. All are comfortably within the unchanged algebraic contract. AC-1 and AC-2 remain satisfied with the additional structurally separate accumulation path.

Prepare evidence — 2026-08-27:

The independent phase gate passed with Phases 0 through 4 COMPLETE and Phase 5 NOT STARTED. The prepared source starts from HEAD=b709b905b, with the worktree clean at turn entry.
src/main/volume/simple_cartesian_pose_refiner.f90:609 adds test-only access to the fused prepared objective, five-component $J^Hr$, symmetric $J^HJ$, and stencil margin. The component surface at src/main/volume/simple_cartesian_pose_refiner.f90:622 exposes each executed complex residual and all five complex Jacobian columns without changing or allocating in the production LM path.
production/tests/simple_pose_cont_refinement_calibration_helpers.f90:12 publishes the Phase 4 Oracle-frozen absolute and relative tolerance arrays without changing a derived value. production/tests/simple_pose_cont_refinement_objective_normals_test.f90:27 applies them to the untouched $10^3$ and $16^3$ acceptance fixtures. The independent accumulator at production/tests/simple_pose_cont_refinement_objective_normals_test.f90:186 reconstructs the whitened residual and right-tangent Jacobian and then accumulates the scalar objective, every $J^Hr$ component, and all 25 $J^HJ$ entries separately from the fused routine.
The focused case covers exact and nonstationary poses under unit, constant, and shell-varying positive variance. It retains residual_jacobian_components.tsv, normal_equation_components.tsv, and objective_normal_summary.tsv in the required Oracle evidence_dir. production/tests/simple_test_pose_cont_refinement.f90:203 exposes the keyed case=objective_normals entry without adding it to the established mother-suite schedule.
The focused hypothesis is that every executed residual and Jacobian component agrees with its independent counterpart under the frozen algebraic or derivative tolerance, and that the fused scalar objective, $J^Hr$, and symmetric $J^HJ$ agree with independent componentwise accumulation. The regression hypothesis is that all five established mother groups still pass unchanged.
Lightweight source checks are PASS: git diff --check exited 0; the four edited Fortran sources have no line longer than 132 columns, conflict marker, or invalid same-line diagnostic continuation. The new source follows the simple_pose_cont_refinement_* dependency-glob naming convention. production/CMakeLists.txt is unchanged at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4.
Applicable policies are doc/policies/KB_Interpolation_Policy.md for padded-grid normalization, doc/policies/reconstruct3D_pcg_policy.md for the unchanged reconstruction boundary, doc/policies/refine3D_policy.md for fixed-volume pose ownership, and doc/policies/sigma_calculation_policy.md for positive native-shell variance. No UI policy applies to this numerical test slice.
The restricted UCRT64 environment check failed before Bash execution with the documented signal- pipe Win32 error 5. Its one exact elevated retry exited 0 and reported UCRT64, source /home/hossainm7/hael_SIMPLE, /usr/bin/rsync, and rsync 3.4.4 protocol 32.
No local compilation, linking, CMake command, SIMPLE executable, real synchronization, remote normalization, runtime test, scientific acceptance test, or commit occurs in this prepare turn. The exact approved rsync dry run is the final operation. Its complete output remains in the controller JSONL evidence. Any subsequent tracked or untracked source or controller-input change invalidates the prepared fingerprint and requires a new Phase 5 prepare turn.

Oracle validation attempt — 2026-08-27:

The independent gate passed with Phases 0 through 4 COMPLETE and Phase 5 READY FOR ORACLE VALIDATION. The exact approved rsync -av --delete --info=progress2 command exited 0, transferred 85 files, and reported no deletion. The transfer used the prepared source, destination, and exclusions.
The first remote line-ending invocation failed locally with exit 1 because its nested shell quote was incomplete. SSH and sed did not run. The corrected invocation of the same approved command exited 0 and normalized only copied *.pl and *.sh files below ~/Projects/hael_SIMPLE-rsync-test.
The default incremental logged build loaded gcc/15.2.0, retained pipefail, and exited 1. GFortran rejected the two declarations at production/tests/simple_pose_cont_refinement_objective_normals_test.f90:254 and line 255 because an assumed-shape array cannot give its third dimension the explicit extent 5. The resulting unknown-type diagnostics and caller mismatches are consequences of those declarations, not separate failures. The failed log is retained at ~/Projects/hael_SIMPLE-rsync-test/build_debug_incremental_failed.log; the original is also at ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log.
A clean retry was not used because deletion and regeneration of build/ cannot correct a parsed source declaration. No SIMPLE runtime or numerical test ran, so AC-1 and AC-2 remain untested.
The smallest local correction changes only those two third-dimension declarations from explicit extent 5 to assumed shape : at production/tests/simple_pose_cont_refinement_objective_normals_test.f90:254. This source change invalidates the reviewed synchronization state. The safe next action is a new Phase 5 prepare turn, lightweight checks, and a new exact rsync dry run. Do not perform a second real rsync in this turn.
Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase05/validate_20260827_143010_050.events.jsonl and its sibling prompt and stderr files. No focused commit was made because compilation did not pass.

Compiler-correction reprepare evidence — 2026-08-27:

The independent gate passed with Phases 0 through 4 COMPLETE and Phase 5 REWORK REQUIRED. The branch remains at HEAD=b709b905b; the local origin/master ref advanced independently, so status reports ahead 3, behind 1. No pull, fetch, checkout, merge, rebase, reset, or stash ran.
The rework is limited to the compiler-rejected declarations at production/tests/simple_pose_cont_refinement_objective_normals_test.f90:254 and line 255. Both Jacobian dummy arrays now use an assumed third dimension :. The test still checks exactly five columns through its fixed axis loop and does not change a fixture, tolerance, formula, or gate.
Lightweight source checks are PASS: git diff --check exited 0; the four Phase 5 Fortran sources have zero lines longer than 132 columns, zero conflict markers, zero invalid diagnostic continuations, and zero occurrences of the rejected jacobian(-box/2:,-box/2:,5) declaration. production/CMakeLists.txt remains unchanged at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4.
Applicable policies remain doc/policies/KB_Interpolation_Policy.md for padded-grid normalization, doc/policies/reconstruct3D_pcg_policy.md for the unchanged reconstruction boundary, doc/policies/refine3D_policy.md for fixed-volume pose ownership, and doc/policies/sigma_calculation_policy.md for positive native-shell variance. No UI policy applies.
The restricted UCRT64 environment check failed before Bash execution with the documented signal- pipe Win32 error 5. Its one exact elevated retry exited 0 and reported UCRT64, source /home/hossainm7/hael_SIMPLE, /usr/bin/rsync, and rsync 3.4.4 protocol 32.
No local compilation, linking, CMake command, SIMPLE executable, real synchronization, remote normalization, runtime test, scientific acceptance test, or commit occurs in this reprepare turn. The exact approved rsync dry run is the final operation. The disposable remote-root build_debug_incremental_failed.log from the failed validation is the only pre-explained safe deletion. Any later source or controller-input change invalidates this dry run.

Successful Oracle validation evidence — 2026-08-27:

The independent gate passed with Phases 0 through 4 COMPLETE and Phase 5 READY FOR ORACLE VALIDATION. The authoritative source remained HEAD=b709b905b. The exact synchronization command was rsync -av --delete --info=progress2 --exclude='.git/' --exclude='.codex/.local-history.git/' --exclude='build/' --exclude='*.o' --exclude='*.mod' --exclude='*.a' --exclude='*.so' ~/hael_SIMPLE/ hossainm7@fwl-c143206.ncifcrf.gov:~/Projects/hael_SIMPLE-rsync-test; it exited 0, transferred 84 files, and deleted only the reviewed disposable remote-root build_debug_incremental_failed.log.
Remote normalization used find . -type f $ -name '*.pl' -o -name '*.sh' $ -exec sed -i 's/\r$//' {} + below ~/Projects/hael_SIMPLE-rsync-test and exited 0. The default incremental command module load gcc/15.2.0; set -o pipefail; .codex/compile_debug.sh 2>&1 | tee build/build_debug.log exited 0. The conditional clean retry was not used. The compiler log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log.
The first focused runtime wrapper exited 1 before test execution because PowerShell evaluated the remote timestamp expression and gave SSH an incomplete script. The corrected command loaded gcc/15.2.0, set SIMPLE_PATH=~/Projects/hael_SIMPLE-rsync-test/build, changed to ~/Projects, and ran simple_test_pose_cont_refinement case=objective_normals evidence_dir=<absolute-package>. It exited 0 and printed POSE_CONT_REFINEMENT_OBJECTIVE_NORMALS: PASS.
The focused evidence package is ~/Projects/continuous_3D_phase5_objective_normals_20260827_145659. It contains the runtime log, context, three component or summary tables, objective_normals_analysis.txt, and manifest.sha256. The evidence has 12 summary cases, 10,008 residual-Jacobian component rows, and 372 normal-equation component rows. It covers boxes 10 and 16, unit, constant, and varying variance, and exact and nonstationary poses.
The maximum observed residual, Jacobian, gradient, Hessian, and Hessian-asymmetry errors are 2.0825005858203301E-09, 0, 1.1492309090043590E-10, 0, and 0. The minimum switch margin is 2.5862455368041992E-03. These results pass the frozen algebraic absolute and relative gates 4.9353318740941177E-04 and 5.7686781070864920E-06, and the derivative absolute and relative gates 1.0E-08 and 5.0E-03. AC-1 and AC-2 pass without a tolerance change.
The regression command used the same module and environment, changed to ~/Projects, and ran simple_test_pose_cont_refinement. It exited 0; all five scheduled groups ran and passed, and zero groups failed. Evidence is in ~/Projects/continuous_3D_phase5_regression_20260827_145731, including mother_suite.log, runtime_context.txt, regression_analysis.txt, and manifest.sha256.
A first read-only evidence-display wrapper exited 1 because two display patterns were split; it did not change test evidence. A first regression-analysis wrapper exited 0 but produced an invalid analysis file because its patterns were split. The corrected token-safe analysis replaced that file, exited 0, and its checksum is in the final manifest.
Post-test checks returned zero top-level validation/ directories and zero continuous_3D_matrix_volumes_* directories in both ~/Projects/hael_SIMPLE-rsync-test and ~/Projects/SIMPLE. The project parent also contained zero continuous_3D_matrix_volumes_* directories. Both runtime tests used ~/Projects as their working directory; no runtime evidence was created below a source checkout.
Major implementation references remain src/main/volume/simple_cartesian_pose_refiner.f90:609, production/tests/simple_pose_cont_refinement_calibration_helpers.f90:12, production/tests/simple_pose_cont_refinement_objective_normals_test.f90:27, its independent accumulator at line 186 and corrected declarations at lines 254-255, and production/tests/simple_test_pose_cont_refinement.f90:203. The remaining limit is that this phase verifies the frozen weighted objective and normal equations only; LM transaction behavior starts in Phase 6 and was not tested here.

Implement AC-1 and AC-2 under Pose, prepared reference, and weighted objective, Executed forward-model conventions, Local derivatives and LM, and the frozen tolerance protocol.

Tests and reason: compare independent scalar objective accumulation, every complex residual-Jacobian column, every $J^Hr$ component, and all symmetric $J^HJ$ entries at exact and nonstationary poses with unit, constant, and varying valid variance. Componentwise tests prevent cancellation that a single directional derivative can hide.

Gate: AC-1 and AC-2 pass on untouched acceptance fixtures with retained component tables and no tolerance change.

Phase 6 — verify LM proposal and pose transactions¶

Status: COMPLETE

The existing production Cholesky and independent partial-pivot Gaussian evidence remain valid. Add a test-only LAPACK DPOSV solve for reliable positive-definite damped five-by-five systems and compare the scaled solution, physical step, residual, and backward error under the unchanged LM-system tolerance. Keep the existing classification tests authoritative for deliberately singular or unreliable systems; LAPACK success alone must not override SIMPLE's stricter reliability decision.

Revalidation gate: every reliable system agrees across production Cholesky, pivoted Gaussian elimination, and LAPACK; the existing accepted/rejected decisions and complete-pose rollback contracts remain unchanged.

Local LAPACK revalidation implementation — 2026-08-28:

production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:8 uses SIMPLE's existing hermitian_solve wrapper, whose real path calls LAPACK DPOSV. For each reliable positive-definite damped system, the test compares LAPACK's scaled solution, bounded physical step, residual, and backward error with the retained pivoted-Gaussian oracle and production proposal.
Deliberately singular and invalid systems continue to test SIMPLE's classification directly and do not use LAPACK success as an acceptance rule. The existing accepted/rejected gain-ratio decisions and complete-pose transaction checks are unchanged. lm_systems.tsv now records both independent backward errors and the LAPACK status.
Lightweight source inspection is complete: the changed test contains no conflict markers or lines longer than 132 columns. No compilation or runtime evidence is claimed; the focused Oracle lm_transactions run must pass under the unchanged LM-system tolerance.

LAPACK Oracle validation — 2026-08-30:

~/Projects/pose_cont_revalidation_20260830_231612/phase6 completed with exit status 0 and POSE_CONT_REFINEMENT_LM_TRANSACTIONS: PASS.
Reliable accepted, rejected, and bounded systems returned LAPACK info=0. LAPACK and pivoted-Gaussian backward errors were at most $2.1554\times10^{-17}$; accepted and rejected gain ratios remained 0.80 and 0.10. Singular and invalid systems remained nonaccepted without using LAPACK as a policy override.
Rejected, finite-no-improvement, singular, invalid, cumulative-bound, step-bound, and iteration-limit transactions retained rotation and shift exactly; the accepted transaction committed both fields. AC-3 and AC-4 remain satisfied with the additional LAPACK solve oracle.

Prepare evidence — 2026-08-27:

The independent gate passed with Phases 0-5 COMPLETE and Phase 6 NOT STARTED. The selected policies are doc/policies/KB_Interpolation_Policy.md because accepted trials can cross a nearest-grid KB stencil, doc/policies/reconstruct3D_pcg_policy.md because PCG remains a fixed-pose reconstruction owner, doc/policies/refine3D_policy.md because particle-pose updates remain in the particle domain, and doc/policies/sigma_calculation_policy.md because the physical accepted-trace fixture retains the established shell-weighted observation. No UI policy applies because this phase adds no command, option, or production caller.
The production LM now builds scaling, the masked scaled normal system, diagonal damping, the damped solve, coordinate rescaling, and independent rotation/shift bounds in one shared proposal routine used by the existing driver (src/main/volume/simple_cartesian_pose_refiner.f90:937, src/main/volume/simple_cartesian_pose_refiner.f90:1081). The explicitly test-only diagnostic surface publishes those terms and the predicted/actual reduction, gain ratio, reliability, bound, and decision without adding a workflow caller (src/main/volume/simple_cartesian_pose_refiner.f90:1024). Complete rotation-plus-shift commit or retention is one atomic selector used by the driver and exposed only for transaction evidence (src/main/volume/simple_cartesian_pose_refiner.f90:999, src/main/volume/simple_cartesian_pose_refiner.f90:1052, src/main/volume/simple_cartesian_pose_refiner.f90:1064).
The new keyed lm_transactions case compares reliable accepted (rho=0.80) and rejected (rho=0.10) systems with an independent partial-pivot Gaussian solve, including every scaled component, damping diagonal, scaled and physical steps, predicted and actual reductions, gain ratio, and backward error (production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:23, production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:211, production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:276, production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:316). It separately exercises an explicit step bound, singular and invalid systems, a physical accepted trace, exact-pose finite no improvement, zero-transfer unreliability, non-finite input, a cumulative bound, and exact complete-pose retention for rejected, finite-no-improvement, singular, invalid, cumulative-bound, step-bound, and iteration-limit outcomes (production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:39, production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:80, production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:365). The mother dispatch is keyed only, so the earlier default five-case regression schedule is unchanged (production/tests/simple_test_pose_cont_refinement.f90:206).
Lightweight source checks are PASS: git diff --check exits 0; the three changed Fortran sources have no line longer than 132 columns, no conflict marker, and balanced named subroutine terminators; the new source follows the simple_pose_cont_refinement_* dependency-glob convention. production/CMakeLists.txt has no diff and remains byte-identical at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4. Compilation and runtime execution are deliberately deferred to Oracle validation.
The focused Oracle hypotheses are: the independent dense solve must satisfy the frozen LM-system component tolerances and backward-error bound; decisions far from the threshold must remain accepted at 0.80 and rejected at 0.10; an accepted physical trace must decrease strictly; and every nonaccepted transaction must retain both pose fields exactly. The keyed command writes lm_systems.tsv and pose_transactions.tsv to its required timestamped evidence package below ~/Projects.
The reviewed synchronization target is ~/Projects/hael_SIMPLE-rsync-test. The exact approved UCRT64 environment check and rsync -avn --delete --info=progress2 review form the final boundary of this prepare turn. No real synchronization, normalization, compilation, runtime test, scientific acceptance, or commit is authorized in this turn.

Oracle validation attempt — 2026-08-27:

The approved rsync -av --delete --info=progress2 synchronization exited 0, transferred 86 files to ~/Projects/hael_SIMPLE-rsync-test, and deleted no file. The first normalization command failed locally in PowerShell parsing before SSH execution with exit 1; the corrected exact remote normalization exited 0.
The default incremental debug build loaded gcc/15.2.0, retained build/build_debug.log, and exited 2. GCC 15.2.0 rejected the two logical-equivalence assertions in production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:238-239 because their .eqv. expressions were not parenthesized as logical actual arguments. The one authorized clean retry preserved the incremental log as ~/Projects/hael_SIMPLE-rsync-test/build_debug_incremental_failed.log, rebuilt from a clean build/, reproduced the same diagnostics, and exited 2.
The smallest local test-only correction parenthesizes both .eqv. expressions in test_reliable_system (production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:238-239). No production source changed in this validation correction. Lightweight checks pass after the edit: git diff --check exits 0, the affected Fortran source has no line longer than 132 columns and no conflict marker, and production/CMakeLists.txt remains unchanged at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4.
Compilation is FAIL. Runtime and scientific evidence are NEEDS MORE TESTING because no SIMPLE executable ran. The post-attempt source-checkout tests for a top-level validation/ directory and a top-level continuous_3D_matrix_volumes_* directory both exit 0; the preserved incremental-failure log existence check also exits 0. Raw controller evidence is codex_logs/pose_cont_20260826_144540_289/phase06/validate_20260827_152156_572.events.jsonl. The safe next action is a new Phase 6 prepare turn. It must review a new authoritative dry run for this corrected source before another synchronization or Oracle build. No second real synchronization, runtime test, or commit occurred in this validation turn.

Rework prepare evidence — 2026-08-27:

The independent gate passed with Phases 0-5 COMPLETE and Phase 6 REWORK REQUIRED. The applicable policy set is unchanged: KB interpolation applies because an accepted step can cross a nearest-grid stencil; the PCG policy preserves fixed-pose reconstruction ownership; the refine3D policy preserves particle-domain pose ownership; and the sigma policy governs the physical weighted fixture. No UI policy applies.
The compile-only defect is corrected at production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:238-239 by parenthesizing each .eqv. logical expression passed to assert_true. The correction does not change the LM system, transaction logic, fixture values, frozen tolerances, or expected decisions. The focused hypotheses remain accepted rho=0.80, rejected rho=0.10, an independently solved scaled dense system within the frozen backward-error tolerance, a strictly decreasing physical accepted trace, and exact complete-pose retention for all nonaccepted outcomes.
Lightweight source checks are PASS: git diff --check exits 0; the three Phase 6 Fortran sources have zero lines longer than 132 columns and zero conflict markers; and the new test retains the established simple_pose_cont_refinement_* filename convention. production/CMakeLists.txt has no diff and remains byte-identical at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4. No compilation, link, CMake command, or SIMPLE executable ran in this prepare turn.
The exact authorized UCRT64 environment check and authoritative rsync -avn --delete --info=progress2 against ~/Projects/hael_SIMPLE-rsync-test form the final boundary of this prepare turn. No real synchronization, remote normalization, compilation, runtime test, scientific acceptance test, or commit is authorized.

Second Oracle validation attempt — 2026-08-27:

The independent gate passed with Phases 0-5 COMPLETE and Phase 6 READY FOR ORACLE VALIDATION. The prepared state matched HEAD=41928763f592e638355bb89a23e512e3386fc7d7, ORIGIN_MASTER=3e4a9da17c556e3c0c23cdc44945351dd7e04c47, FILE_COUNT=1510, and SOURCE_DIGEST=FA1F340A3E797542AD8F72394BCF77EF897874EB16F0F1ECD57B5210E5A9574A.
The approved rsync -av --delete --info=progress2 exited 0, transferred 85 files to ~/Projects/hael_SIMPLE-rsync-test, and deleted only the documented disposable build_debug_incremental_failed.log. Remote line-ending normalization exited 0.
Two local command-transport attempts exited 1 before compilation: the first had an unmatched remote quote, and the second treated the quoted SSH path as literal command text. The corrected PowerShell argument invocation reached Oracle and ran the approved incremental build.
With module load gcc/15.2.0, the incremental logged build command exited 1; its gmake diagnostic exited 2. GCC 15.2.0 accepted the parenthesized logical expressions but rejected the same-line &'message' tokens at production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:238-239. The one authorized clean retry copied build/build_debug.log to ~/Projects/hael_SIMPLE-rsync-test/build_debug_incremental_failed.log, rebuilt from a clean build/, and reproduced the same error with command exit 1 and gmake exit 2.
The smallest local test-only correction removes the invalid continuation ampersands from the two single-line assert_true calls (production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:238-239). The .eqv. operands remain parenthesized, and no fixture, tolerance, expected decision, LM production path, or frozen contract changes.
Lightweight source checks are PASS: git diff --check exits 0; the affected test has zero lines longer than 132 columns and zero conflict markers; and production/CMakeLists.txt has no diff and remains byte-identical at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4.
Compilation is FAIL. Runtime and scientific evidence are NEEDS MORE TESTING because no SIMPLE executable ran. The post-attempt checks for a top-level validation/ directory and a top-level continuous_3D_matrix_volumes_* directory in ~/Projects/hael_SIMPLE-rsync-test both exit 0; the preserved incremental-failure log existence check also exits 0. Raw controller evidence is codex_logs/pose_cont_20260826_144540_289/phase06/validate_20260827_154416_774.events.jsonl.
The safe next action is a new Phase 6 prepare turn. It must review a new authoritative dry run for this corrected source before another synchronization or Oracle build. No runtime test, scientific acceptance test, second synchronization, or commit occurred.

Second rework prepare evidence — 2026-08-27:

The independent gate passed with Phases 0-5 COMPLETE and Phase 6 REWORK REQUIRED. The applicable policy set remains KB_Interpolation_Policy.md for possible accepted-step stencil crossings, reconstruct3D_pcg_policy.md for the fixed-pose reconstruction boundary, refine3D_policy.md for particle-domain pose ownership, and sigma_calculation_policy.md for the shell-weighted physical fixture. No UI policy applies because this phase adds no command, option, or production caller.
The second compile-only defect is corrected at production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:238-239: both logical actual arguments retain the required .eqv. parentheses, and the invalid same-line continuation ampersands before the assertion messages are removed. The correction does not change the LM system, transaction behavior, fixtures, frozen tolerances, or expected decisions.
Lightweight source checks are PASS: git diff --check exits 0; the three Phase 6 Fortran sources have zero lines longer than 132 columns and zero conflict markers; the test module has 10 named subroutine starts and 10 ends; and its simple_pose_cont_refinement_* filename remains discoverable by the established dependency glob. production/CMakeLists.txt has no diff and remains byte-identical at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4. No compilation, link, CMake command, or SIMPLE executable ran in this prepare turn.
The focused Oracle hypotheses remain unchanged: rho=0.80 must be accepted and rho=0.10 rejected against the 0.25 threshold; the independent scaled dense solve must satisfy absolute tolerance 2.0599365235796085E-7, relative and backward-error tolerance 2.0E-5; an accepted physical trace must decrease strictly; and every nonaccepted transaction must retain the complete pose exactly. The unchanged default five-case mother suite remains the regression gate.
The exact authorized UCRT64 environment check and authoritative rsync -avn --delete --info=progress2 against ~/Projects/hael_SIMPLE-rsync-test form the final boundary of this prepare turn. No real synchronization, remote normalization, compilation, runtime test, scientific acceptance test, or commit is authorized.

Third Oracle validation attempt — 2026-08-27:

The independent gate passed with Phases 0-5 COMPLETE and Phase 6 READY FOR ORACLE VALIDATION. The prepared state matched HEAD=41928763f592e638355bb89a23e512e3386fc7d7, ORIGIN_MASTER=3e4a9da17c556e3c0c23cdc44945351dd7e04c47, FILE_COUNT=1510, and SOURCE_DIGEST=27FCC05A1DDA7FED8AFE5CCEF927CC8A3E8870AF0007508EC545C5B762CE64AC.
The approved UCRT64 rsync -av --delete --info=progress2 exited 0, transferred 83 files to ~/Projects/hael_SIMPLE-rsync-test, and deleted only the documented disposable build_debug_incremental_failed.log. The first PowerShell normalization wrapper exited 0 but did not remove the CR byte. The first build launcher then exited 1 before script execution with /bin/bash^M: bad interpreter. The corrected exact remote normalization exited 0, and head -n 1 .codex/compile_debug.sh | od -An -t x1 exited 0 with 23 21 2f 62 69 6e 2f 62 61 73 68 0a. This was a transport defect, not a compiler failure, so the conditional clean-build retry was not used.
With module load gcc/15.2.0, the default incremental .codex/compile_debug.sh 2>&1 | tee build/build_debug.log command ran with pipefail and exited 0. The retained compiler log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log.
The focused command ran from ~/Projects as simple_test_pose_cont_refinement case=lm_transactions evidence_dir=/home/hossainm7/Projects/continuous_3D_phase6_focused_20260827_181238/focused and exited 0. The independent systems produced accepted rho=0.80000000000000515 and rejected rho=0.10000000000000914 against threshold 0.25; the maximum backward error was 2.1553673818146108E-17 against limit 2.0E-5. The accepted physical trace decreased strictly. The rejected, finite-no-improvement, singular, invalid, cumulative-bound, step-bound, and iteration-limit rows retained both pose fields exactly. Evidence is in ~/Projects/continuous_3D_phase6_focused_20260827_181238, including focused/lm_transactions.log, focused/lm_systems.tsv, focused/pose_transactions.tsv, manifest.txt, analysis.txt, and executable_sha256.txt.
The unchanged default mother suite ran from ~/Projects, exited 0, and reported scheduled/run/passed/skipped/failed 5/5/5/0/0. Its retained package is ~/Projects/continuous_3D_phase6_regression_20260827_181253, including pose_mother_suite.log, manifest.txt, analysis.txt, and executable_sha256.txt. The tested executable SHA-256 was d1f48253334941aed53cac2c3d80ec0b1340231910461ff1a82e7908d1612a95 in both packages.
The authoritative post-test command exited 0: ~/Projects/hael_SIMPLE-rsync-test contains no top-level validation/, continuous_3D_matrix_volumes_*, or continuous_3D_phase6_* directory. The local source checkout has the same three zero findings. ~/Projects contains no continuous_3D_matrix_volumes_* directory, and all named runtime evidence is below the two timestamped project-parent packages.
Source checks, synchronization, compilation, runtime completion, and the AC-3/AC-4 scientific gate are PASS. Major implementation references are src/main/volume/simple_cartesian_pose_refiner.f90:1024, src/main/volume/simple_cartesian_pose_refiner.f90:1052, and src/main/volume/simple_cartesian_pose_refiner.f90:1081; the keyed dispatch is production/tests/simple_test_pose_cont_refinement.f90:206; and the independent LM and transaction evidence is production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:23, production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:211, and production/tests/simple_pose_cont_refinement_lm_transactions_test.f90:365. The remaining limit is that Phase 6 verifies proposal algebra and transaction safety only; the CTF, whitening, and variance-range matrix starts in Phase 7.

Implement AC-3 and AC-4 using the independent scaled dense solve and the frozen LM contract.

Tests and reason: compare scaling, damping diagonal, physical step, backward error, predicted/actual reduction, gain ratio, and decision for reliable accepted and rejected systems. Exercise finite no-improvement, singular/unreliable, invalid, cumulative-bound, step-bound, and iteration-limit outcomes because an objective test alone cannot prove state safety.

Gate: AC-3 and AC-4 pass; accepted traces are internally consistent, and every nonaccepted transaction restores the complete input pose under the declared exact/tolerance contract.

Phase 7 — verify CTF, whitening, and variance range¶

Status: COMPLETE

Implement AC-5 under the approved pose transfer and variance-range contracts. Keep the PCG transfer and fallback unchanged and visibly separate.

Tests and reason: construct raw observations independently, then test CTFFLAG_NO, signed CTF, phase-flipped $|C|$, physical CTF zeros, constant and shell-varying variance, short variance arrays, invalid used values, and no usable overlap. This proves order and failure behavior rather than matched-model consistency.

Gate: AC-5 passes; pose transfer has no shift input, requested/effective ranges and sample counts are reported, unusable ranges are nonfatal and transactional, and the PCG last-shell behavior remains unchanged.

Prepare evidence — 2026-08-27:

The independent phase gate passed with Phases 0 through 6 COMPLETE and Phase 7 NOT STARTED. The prepared branch is master at 7140ddc023f1c5fb93801a5130534ca816bd762a; the local origin/master ref is 3e4a9da17c556e3c0c23cdc44945351dd7e04c47.
The selected policies are doc/policies/sigma_calculation_policy.md because AC-5 verifies native shell-variance semantics, doc/policies/phase_shift_ctf_policy.md because AC-5 distinguishes signed and phase-flipped CTF transfer, and doc/policies/reconstruct3D_pcg_policy.md because the existing PCG last-shell fallback must remain unchanged. No UI, command, persistence, or production-caller policy applies.
cartesian_pose_data now retains the literal requested range, effective range, and exact active full-disk sample count, and it has a focused test-only component copy (src/main/volume/simple_cartesian_pose_refiner.f90:41, src/main/volume/simple_cartesian_pose_refiner.f90:109, and src/main/volume/simple_cartesian_pose_refiner.f90:121). Preparation validates only the effective variance interval, treats invalid intervals as nonfatal, and fills only the exact squared-radius disk (src/main/volume/simple_cartesian_pose_refiner.f90:196, src/main/volume/simple_cartesian_pose_refiner.f90:214, and src/main/volume/simple_cartesian_pose_refiner.f90:243). The pose-transfer interface has no shift argument.
The new keyed case=ctf_sigma diagnostic is production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:21 and is dispatched at production/tests/simple_test_pose_cont_refinement.f90:209. It constructs raw CTF-distorted observations first and whitens them separately, then compares the prepared transfer with the scalar CTF oracle (production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:197 and production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:238). It covers disabled, signed, flipped, and physical-zero CTF; constant, varying, short, invalid-used, invalid-unused, and no-overlap variance; requested/effective ranges; sample counts; and the unchanged PCG last-shell fallback (production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:56, production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:169, and production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:251). The default five-case mother-suite schedule remains unchanged at production/tests/simple_test_pose_cont_refinement.f90:70.
Lightweight source checks are PASS: git diff --check exits 0; all three Phase 7 Fortran files have zero lines longer than 132 columns, zero trailing-whitespace findings, and zero conflict markers; and the focused source has 10 procedure starts and 10 matching ends. production/CMakeLists.txt has no diff and remains byte-identical at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4. simple_reconstructor_pcg.f90 has no diff. No compilation, link, CMake command, or SIMPLE executable ran in this prepare turn.
Oracle validation must run from ~/Projects with a timestamped evidence directory directly below that root. Run simple_test_pose_cont_refinement case=ctf_sigma evidence_dir=<absolute-evidence-directory> and the unchanged default simple_test_pose_cont_refinement mother suite. The focused hypothesis is that all independent component errors are within 4.0E-6, physical CTF zeros remain valid, invalid used ranges return POSE_DATA_INVALID_NOISE_RANGE without active samples, requested/effective ranges and exact sample counts match the fixture, pose short variance stops at its effective upper shell, and the unchanged PCG short array equals explicit last-shell extension. Preserve ctf_sigma_cases.tsv, variance_outcomes.tsv, pcg_fallback.tsv, both runtime logs, and the compiler log as separate evidence. Compilation, runtime completion, and AC-5 scientific acceptance remain NEEDS MORE TESTING until that Oracle turn.

First Oracle validation attempt — 2026-08-27:

The independent gate passed with Phases 0 through 6 COMPLETE, Phase 7 READY FOR ORACLE VALIDATION, and prepared source digest E841F5A21962FD64AA6CE90EEAC31F00BB8166A29221A26A51E0CCA29D76F5A5. The approved rsync -av --delete --info=progress2 command exited 0, transferred 84 files to ~/Projects/hael_SIMPLE-rsync-test, and reported no deletion. The first PowerShell normalization launcher failed before SSH because its embedded && tokens were parsed locally; the corrected literal-argument retry normalized the remote Perl and shell files, verified the compile-helper shebang bytes, and exited 0.
With module load gcc/15.2.0, the default incremental logged build reached GNU Fortran 15.2.0 and exited 2. The focused source failed at production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:268 and production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:280 because two single-line assert_true calls contained invalid continuation ampersands. The failed incremental log is preserved at ~/Projects/hael_SIMPLE-rsync-test/build_debug_incremental_failed.log. The one authorized SIMPLE_CLEAN_BUILD=yes retry reproduced the same two syntax errors and exited 2.
The smallest local test-only correction removes those two invalid ampersands without changing an assertion, fixture, tolerance, expected result, production source, PCG fallback, or frozen contract. Lightweight checks are PASS: git diff --check exits 0; the three Phase 7 Fortran files have zero lines longer than 132 columns and zero conflict markers; and the focused source has six procedure starts and six matching ends. production/CMakeLists.txt has no diff and remains byte-identical at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4; simple_reconstructor_pcg.f90 also has no diff. Compilation is FAIL; runtime and scientific evidence are NEEDS MORE TESTING because no SIMPLE executable ran. No second synchronization, runtime test, or commit occurred.
The safe next action is a new Phase 7 prepare turn. It must review the corrected exact source and remote deletion candidates before another Oracle synchronization or build.

Rework prepare evidence — 2026-08-27:

The independent phase gate passed with Phases 0 through 6 COMPLETE and Phase 7 REWORK REQUIRED. The applicable policies remain doc/policies/sigma_calculation_policy.md for native shell variance, doc/policies/phase_shift_ctf_policy.md for signed, phase-flipped, and physical-zero CTF behavior, and doc/policies/reconstruct3D_pcg_policy.md for the unchanged reconstruction-only last-shell fallback. No UI policy applies because this phase adds no option, caller, or persistence path.
The two compile-only defects are corrected at production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:268 and production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:280: each single-line assert_true call now passes its message without an invalid continuation ampersand. No assertion, fixture, tolerance, expected result, production path, pose-transfer behavior, PCG fallback, or frozen contract changed.
Lightweight source checks are PASS: git diff --check exits 0; the three Phase 7 Fortran files have zero lines longer than 132 columns, zero trailing-whitespace findings, and zero conflict markers; and the focused source has six subroutine starts and six matching ends. production/CMakeLists.txt has no diff and remains byte-identical at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4; simple_reconstructor_pcg.f90 also has no diff. No compilation, link, CMake command, SIMPLE executable, real transfer, remote normalization, or commit ran in this prepare turn.
Oracle validation must repeat the default incremental logged build, then run simple_test_pose_cont_refinement case=ctf_sigma evidence_dir=<absolute-evidence-directory> and the unchanged default mother suite from ~/Projects. The focused hypotheses and 4.0E-6 component tolerance remain unchanged. The authoritative rsync -avn --delete --info=progress2 command is the final boundary of this prepare turn.

Second Oracle validation attempt — 2026-08-27:

The controller prepared-state check exited 0 and verified HEAD=7140ddc023f1c5fb93801a5130534ca816bd762a, ORIGIN_MASTER=3e4a9da17c556e3c0c23cdc44945351dd7e04c47, 1511 files, and digest 57E03D842D5D69F2C97D768883470E191FA895A1892FFB2F13108C4C382F0E66. git diff --check exited 0 before synchronization. The approved rsync -av --delete --info=progress2 command exited 0, transferred 82 files, and deleted only the documented disposable remote-root build_debug_incremental_failed.log. Remote line-ending normalization exited 0 and verified the LF-only compile-helper shebang.
With module load gcc/15.2.0, the default incremental .codex/compile_debug.sh 2>&1 | tee build/build_debug.log command exited 0; the conditional clean retry did not run. The compiler log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log.
The focused command ran from ~/Projects with evidence at ~/Projects/continuous_3D_phase7_focused_20260827_185257 and exited 1. All CTF and variance rows completed before the failure: component errors were at most 5.9604644775390625E-08, physical-zero errors were 0, requested/effective ranges and active counts were (0:5,0:5,81), (1:5,1:5,80), (1:5,1:3,28), and (1:2,1:2,12), and all three invalid/no-overlap cases returned status 1 with zero active samples. These partial values are below the 4.0E-6 tolerance but do not complete AC-5.
The test then stopped at production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:277: intrinsic assignment had allocated pcg_short and pcg_extended with default lower bounds of 1, so the intended physical (h,k)=(BOX/2,0) access indexed dimension 2 below its lower bound. The smallest test-only correction gets the PCG plane limits, explicitly allocates both arrays with those physical bounds, and then assigns the two transfer results (production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:273). It does not change PCG production source, fallback semantics, a tolerance, or the frozen contract.
Runtime completion is FAIL and scientific acceptance is NEEDS MORE TESTING. The PCG table contains only its header, and the default mother suite did not run. Post-test checks found no top-level validation/, continuous_3D_matrix_volumes_*, or Phase 7 evidence directory in the source checkout, and no continuous_3D_matrix_volumes_* directory below ~/Projects. No runtime evidence was created below a source checkout.
This local source correction invalidates the synchronized tree and prepared fingerprint. Phase 7 is REWORK REQUIRED; no second synchronization, compilation, runtime test, or commit is permitted in this turn. The safe next action is a new Phase 7 prepare turn with a new source fingerprint and exact rsync dry run.

Second rework prepare evidence — 2026-08-27:

The independent phase gate passed with Phases 0 through 6 COMPLETE and Phase 7 REWORK REQUIRED. The branch remains master at HEAD=7140ddc023f1c5fb93801a5130534ca816bd762a; the local origin/master ref remains 3e4a9da17c556e3c0c23cdc44945351dd7e04c47. The applicable policies remain doc/policies/sigma_calculation_policy.md, doc/policies/phase_shift_ctf_policy.md, and doc/policies/reconstruct3D_pcg_policy.md; no UI policy applies.
The focused fallback check now obtains the PCG plane limits and explicitly allocates both transfer arrays with those physical lower and upper bounds before assignment (production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:263 and production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:273). The intended physical (h,k)=(BOX/2,0) access is therefore in range (production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:280). This is a test-only correction; src/main/volume/simple_reconstructor_pcg.f90, its last-shell fallback, all tolerances, and the frozen contract are unchanged.
Lightweight source checks are PASS: git diff --check exits 0; the three Phase 7 Fortran files have zero lines longer than 132 columns, zero trailing-whitespace findings, and zero conflict markers; the focused source has six subroutine starts and six matching ends; and the multiline fatal-macro scan has no finding. production/CMakeLists.txt has no diff and remains byte-identical at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4. No compilation, link, CMake command, SIMPLE executable, real transfer, remote normalization, or commit ran in this prepare turn.
Oracle validation must rerun the default incremental logged build, the focused case=ctf_sigma diagnostic, and the unchanged default mother suite from ~/Projects. The focused hypotheses remain the 4.0E-6 component tolerance, valid physical CTF zeros, nonfatal unusable variance ranges with zero active samples, exact requested/effective ranges and sample counts, a zero pose tail beyond the short variance range, and equality of the unchanged PCG short-array fallback with explicit last-shell extension. The authoritative rsync -avn --delete --info=progress2 command is the final boundary of this prepare turn.

Final Oracle validation — 2026-08-27:

The independent gate passed with Phases 0 through 6 COMPLETE and Phase 7 READY FOR ORACLE VALIDATION. .codex/codex_exec_source_state.ps1 -Repository . -CheckFile codex_logs/pose_cont_20260826_144540_289/phase07/prepare-source-state.txt exited 0 and verified digest 837086283AC4FB5CBB3F349D27E0205949E5E9796F65A127006B6BF997B869C4, HEAD=7140ddc023f1c5fb93801a5130534ca816bd762a, and ORIGIN_MASTER=3e4a9da17c556e3c0c23cdc44945351dd7e04c47.
The exact synchronization command was rsync -av --delete --info=progress2 --exclude='.git/' --exclude='.codex/.local-history.git/' --exclude='build/' --exclude='*.o' --exclude='*.mod' --exclude='*.a' --exclude='*.so' ~/hael_SIMPLE/ hossainm7@fwl-c143206.ncifcrf.gov:~/Projects/hael_SIMPLE-rsync-test. It exited 0, transferred 82 files, and reported no deletion. find . -type f $ -name '*.pl' -o -name '*.sh' $ -exec sed -i 's/\r$//' {} + exited 0; the compile-helper shebang ended in LF byte 0a.
With module load gcc/15.2.0, the default incremental command cd ~/Projects/hael_SIMPLE-rsync-test && mkdir -p build && set -o pipefail && .codex/compile_debug.sh 2>&1 | tee build/build_debug.log exited 0. The conditional clean retry did not run. The compiler log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log.
From ~/Projects, simple_test_pose_cont_refinement case=ctf_sigma evidence_dir=/home/hossainm7/Projects/continuous_3D_phase7_focused_20260827_190240/focused exited 0 and wrote its PASS marker. The component maximum was 5.9604644775390625E-08, below the 4.0E-6 limit; physical-zero errors were 0; requested/effective ranges and active counts were (0:5,0:5,81), (1:5,1:5,80), (1:5,1:3,28), and (1:2,1:2,12); and every invalid-used/no-overlap case returned status 1 with zero active samples. The short-variance fallback row reported effective high shell 3, pose tail 0, PCG tail 8.0845206975936890E-01, and short-versus-explicit PCG error 0.
From a separate ~/Projects evidence package, the unchanged simple_test_pose_cont_refinement mother suite exited 0 with scheduled/run/passed/skipped/failed 5/5/5/0/0. Evidence is ~/Projects/continuous_3D_phase7_focused_20260827_190240 and ~/Projects/continuous_3D_phase7_regression_20260827_190311; both manifests record /home/hossainm7/Projects as the working directory and executable SHA-256 51d79db3b100c5074517d69527338981f3b7b7c806a55c563c819e655ad0b8b1.
Post-test local and Oracle checks exited 0. Neither source checkout contains a top-level validation/, continuous_3D_matrix_volumes_*, or Phase 7 evidence directory. No continuous_3D_matrix_volumes_* directory exists below ~/Projects; all runtime evidence is outside the source checkout. Source checks, synchronization, compilation, runtime completion, and AC-5 scientific acceptance are PASS.
Major implementation references are src/main/volume/simple_cartesian_pose_refiner.f90:41, src/main/volume/simple_cartesian_pose_refiner.f90:109, and src/main/volume/simple_cartesian_pose_refiner.f90:196; the focused independent diagnostic is production/tests/simple_pose_cont_refinement_ctf_sigma_test.f90:21, with bounded PCG fallback evidence at line 251 and explicit physical plane bounds at line 273; keyed dispatch is production/tests/simple_test_pose_cont_refinement.f90:210. The remaining limit is that Phase 7 validates the declared box-10 CTF/variance matrix; the complete multi-box and morphology matrix remains Phase 9 work.

Phase 8 — verify the independent forward hierarchy¶

Status: COMPLETE

Handoff boundary — updated 2026-08-30: Focused commit 8d619aaee contains the completed Phase 4 calibration amendment, Phase 5 BLAS accumulation oracle, Phase 6 LAPACK solve oracle, and the structurally separate slow gather required by the frozen forward contract. Oracle package ~/Projects/pose_cont_revalidation_20260830_231612 confirms the frozen Phase 4 marker and passes the focused Phase 5 and Phase 6 revalidations. The uncommitted Phase 8 source is deliberately incomplete. A prepare turn must replace its old box-10/box-16 acceptance use and superseded arbitrary-rotation projection comparison before any synchronization, compilation, or runtime test. Do not validate the existing source unchanged.

Phase 8 implementation handoff:

Preserve the existing analytic-object convention tests, full redundant disk, executed gather, structurally separate slow gather, raw component retention, and fail-after-artifact behavior.
Replace ACCEPTANCE_BOXES and build_acceptance_fixture in simple_pose_cont_refinement_forward_hierarchy_test.f90 with a Phase-8-only forward-holdout fixture constructor for frozen boxes 14 and 18. Use at least two deterministic asymmetric physical volumes per box. The constructor must not be callable from Phase 4 calibration.
Predeclare the holdout rotation matrices in source before the first Oracle run. Include identity for the convention control and at least three arbitrary rotations distinct from the Phase 4 calibration rotations. Do not change them after observing results.
Replace the current finite-projection comparison projection(original volume, rotation) versus DFT(original volume, rotated frequency). Resample one finite rotated object $X_R$, compare its line-sum/2-D FFT with the direct 3-D DFT of that same $X_R$ at $l=0$, and retain original-volume rotated-frequency disagreement, clipping fraction, interpolation error, support margin, and stencil switches as diagnostics only.
Apply the frozen families componentwise: analytic DFT family 4, executed DFT family 5, slow gather family 6, and matched finite projection family 7. Record box, volume variant, rotation, sample count, maximum absolute and scaled-relative errors, frozen limits, diagnostics, and pass state.
Run case=forward_hierarchy from ~/Projects into one new timestamped evidence directory. Only after it passes, run the unchanged default pose mother suite. A failure must retain all tables and stop before Phase 9; no tolerance, fixture, or rotation may be adjusted in place.

Fresh-holdout prepare implementation — 2026-08-30:

run_forward_hierarchy at production/tests/simple_pose_cont_refinement_forward_hierarchy_test.f90:64 now owns the fresh Phase 8 matrix. It uses frozen boxes 14 and 18, four predeclared rotations, and two Phase-8-only asymmetric volumes per box. The analytic convention cases run once per box. The physical-volume cases run for every box, variant, and rotation. The expected total is 80 named comparisons.
build_forward_holdout_fixture at line 232 and holdout_field at line 256 are private to the Phase 8 child module. They cannot be called by Phase 4 calibration. Their volume definitions, fixture identifiers, and rotations at line 654 are fixed before the first Oracle run. The three arbitrary rotations differ from all Phase 4 calibration rotations.
verify_volume_hierarchy at line 123 preserves the executed gather, the structurally separate slow gather, and the direct DFT over the full redundant disk. rotate_finite_volume at line 408 resamples one finite object $X_R$. finite_projection_fft at line 439 compares the line-sum/2-D FFT of that object with the direct 3-D DFT of the same $X_R$ at $l=0$. Original-volume disagreement, clipping fraction, analytic-field interpolation error, KB support margin, and stencil switches are diagnostic fields only.
write_forward_artifacts at line 546 writes the 80-row aggregate table, raw complex sample table, frozen-contract manifest, and fixture manifest before the final assertion. Each aggregate row records its family, box, volume variant, rotation, sample count, maximum errors, frozen limits, diagnostics, and pass state. A failed comparison therefore retains the complete evidence package and stops before Phase 9.
Keyed dispatch is production/tests/simple_test_pose_cont_refinement.f90:19,212. The default five-case mother schedule is unchanged. The focused hypothesis is that every fresh holdout comparison satisfies its frozen combined absolute-plus-relative family. The regression hypothesis is that the keyed addition does not change the existing default pose suite.
Applicable policies are doc/policies/KB_Interpolation_Policy.md for padded coordinates, normalized KB gather, and padf^3 scaling; doc/policies/reconstruct3D_pcg_policy.md for the full redundant disk, discrete envelope, and unchanged PCG-owner boundary; and doc/policies/refine3D_policy.md for particle-pose versus volume-domain ownership. No UI policy applies because Phase 8 adds no production caller or user-visible option.
Lightweight source checks are PASS. git diff --check exited 0. Both Phase 8 Fortran files have zero lines longer than 132 columns, zero conflict markers, and zero tab characters. Static checks find no calibration-fixture constructor, old acceptance-box constant, PCG reconstructor import, or neutral gather call in the fresh-holdout module. production/CMakeLists.txt remains unchanged during this prepare implementation at SHA-256 F850520E053180EA241C5B091D74C5358B87BFC118BA91E043BBA654059412EB.
Compilation, focused runtime completion, mother-suite runtime completion, and AC-6 scientific acceptance remain NEEDS MORE TESTING. The next Oracle turn must compile incrementally, run the focused case from ~/Projects into one new timestamped package, and run the unchanged mother suite only after the focused case passes. No fixture, rotation, tolerance, or comparison can change after this prepared dry run without returning Phase 8 to REWORK REQUIRED.
The exact approved rsync dry run is the final operation of this prepare turn. Its complete output and exit status remain in codex_logs/pose_cont_20260826_144540_289/phase08/prepare_20260830_233136_657.events.jsonl. No real synchronization, normalization, compilation, runtime test, scientific acceptance test, or commit occurs in this prepare turn.

Final Oracle validation — 2026-08-30:

The independent gate passed with Phases 0 through 7 COMPLETE and Phase 8 READY FOR ORACLE VALIDATION. .codex/codex_exec_source_state.ps1 -Repository . -CheckFile codex_logs/pose_cont_20260826_144540_289/phase08/prepare-source-state.txt exited 0 and verified digest EBD42CC645DD6C7A9E6E17415C4DC538F9A3E9BE646DC2DC096E4D4FDEA52492, HEAD=8d619aaee149ce131d4ce83940e125961f5e5640, and ORIGIN_MASTER=c2b419ad3a521588d152b8b43335b8488c905957.
The exact synchronization command was rsync -av --delete --info=progress2 --exclude='.git/' --exclude='.codex/.local-history.git/' --exclude='build/' --exclude='*.o' --exclude='*.mod' --exclude='*.a' --exclude='*.so' ~/hael_SIMPLE/ hossainm7@fwl-c143206.ncifcrf.gov:~/Projects/hael_SIMPLE-rsync-test. It exited 0, transferred 220 files, and reported no deletion. The transfer count includes current controller evidence that is outside the deterministic prepared-source digest. Remote normalization with find . -type f $ -name '*.pl' -o -name '*.sh' $ -exec sed -i 's/\r$//' {} + exited 0; .codex/compile_debug.sh retained #!/bin/bash and had zero carriage returns.
With module load gcc/15.2.0, the default incremental command cd ~/Projects/hael_SIMPLE-rsync-test && mkdir -p build && set -o pipefail && .codex/compile_debug.sh 2>&1 | tee build/build_debug.log exited 0 with GNU Fortran 15.2.0. The conditional clean retry did not run. The compiler log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log.
From /home/hossainm7/Projects, simple_test_pose_cont_refinement case=forward_hierarchy evidence_dir=/home/hossainm7/Projects/continuous_3D_phase8_forward_20260830_234914 exited 0 and wrote its PASS marker. Evidence is in ~/Projects/continuous_3D_phase8_forward_20260830_234914: command_manifest.tsv, executable.sha256, forward_hierarchy.log, forward_hierarchy.tsv, forward_hierarchy_components.tsv, forward_hierarchy_manifest.tsv, forward_holdout_fixtures.tsv, and forward_hierarchy_analysis.tsv.
The focused scientific analysis exited 0. All 80 aggregate rows passed: family counts were 32/16/16/16 for families 4 through 7; box counts were 40/40; variant counts were 32/24/24; every rotation had 20 rows; and the component table had 16,080 rows. Maximum absolute errors for families 4 through 7 were 1.626303258728E-19, 3.511552303816E-04, 5.269506286714E-09, and 2.470709852229E-09. Maximum scaled-relative errors were 8.147395520710E-16, 8.917885800089E-02, 5.318751461011E-07, and 1.073789430090E-06. Each row satisfied its frozen combined absolute-plus-relative gate. Diagnostic maxima were clipping fraction 3.330903790087E-01, original-volume error 3.257326775186E-03, interpolation error 1.946948203324E-01, and 4,800 total stencil switches; these values are not acceptance gates. An initial evidence-analysis command exited 1 because it used planned rather than actual artifact names; the corrected analysis above did not rerun the executable.
From /home/hossainm7/Projects, the unchanged simple_test_pose_cont_refinement mother suite exited 0 with scheduled/run/passed/skipped/failed 5/5/5/0/0. Evidence is ~/Projects/continuous_3D_phase8_regression_20260830_235047, including command_manifest.tsv, executable.sha256, mother_suite.log, and mother_suite_analysis.tsv.
Post-test checks exited 0. In both ~/Projects/hael_SIMPLE-rsync-test and ~/Projects/SIMPLE, top-level validation/ was absent and the counts of top-level continuous_3D_matrix_volumes_* and Phase 8 evidence directories were zero. Direct test -d, realpath, and stat checks verified that both Phase 8 evidence packages are directories below ~/Projects; no matrix-volume directory was generated. Source checks, synchronization, normalization, compilation, focused runtime completion, regression runtime completion, and AC-6 scientific acceptance are PASS.
Major implementation references are the focused runner at production/tests/simple_pose_cont_refinement_forward_hierarchy_test.f90:64, the physical hierarchy at line 123, the private holdout constructor and field at lines 232 and 256, the finite-volume rotation and matched projection at lines 408 and 439, artifact creation at line 546, and frozen rotations at line 654. Keyed dispatch is production/tests/simple_test_pose_cont_refinement.f90:19,212. The remaining limit is that Phase 8 verifies the frozen independent forward hierarchy only; the broader end-to-end matrix remains Phase 9 work.

Superseded Phase 8 attempts — historical evidence only: The records below explain why the final validation was necessary. Their embedded phase statuses are historical outcomes and do not override the machine-readable COMPLETE status above.

Approved recovery plan — 2026-08-28:

Complete and freeze the Phase 4 forward-only amendment before changing or rerunning Phase 8 acceptance.
Retain the 28-row box-$10^3$/box-$16^3$ result as diagnostic evidence. It cannot calibrate the amended tolerances or become fresh acceptance evidence.
Update the finite-projection hierarchy so its acceptance comparison uses the same rotated/resampled finite object on both paths. Preserve original-volume rotated-frequency agreement, clipping, interpolation, and support margin as separate diagnostics.
Run analytic, direct-DFT, executed-gather, slow-gather, and matched finite-projection comparisons over the full redundant disk on the fresh predeclared holdout boxes, volumes, and rotations.
Run the unchanged mother suite only after the focused forward hierarchy passes. Do not start Phase 9 until AC-6 passes under the amended frozen contract.

Prepare evidence — 2026-08-27:

Added the keyed case=forward_hierarchy acceptance diagnostic at production/tests/simple_pose_cont_refinement_forward_hierarchy_test.f90:35 and dispatched it from production/tests/simple_test_pose_cont_refinement.f90:212. The default five-case mother schedule is unchanged.
The analytic convention gate uses centered and off-center deltas, separated points, and a non-collinear unequal-amplitude point set. It compares closed-form values with a full voxel-loop normalized DFT for identity and arbitrary rotations over every point in the full redundant disk at boxes 10 and 16 in production/tests/simple_pose_cont_refinement_forward_hierarchy_test.f90:56,163. The explicit disk populations are 81 and 197, including both logical Nyquist endpoints.
The physical-volume gate constructs the executed immutable E^{-1}X reference, compares G(E^{-1}X) with a direct DFT of X, and separately compares the executed gather with a test-only slow packed/Friedel traversal at production/tests/simple_pose_cont_refinement_forward_hierarchy_test.f90:79,136. The slow traversal repeats the normalized polynomial KB weights, periodic wrapping, packing, Friedel conjugation, and padf^3 scaling without calling the executed stencil builder or neutral gather helper at src/main/volume/simple_cartesian_pose_refiner.f90:386. This preserves source independence while using the same immutable prepared reference.
The finite-box gate forms line-sum projections, uses a normalized two-dimensional FFT with the explicit 1/N factor, and compares the result with the direct three-dimensional DFT at production/tests/simple_pose_cont_refinement_forward_hierarchy_test.f90:256. Identity and arbitrary rotations are distinct observations; the arbitrary case records the zero-clipped trilinear sample fraction. Stencil-switch counts are recorded for the arbitrary gather instead of treating a switch as a derivative observation.
Every comparison uses its Phase 4 frozen family at production/tests/simple_pose_cont_refinement_forward_hierarchy_test.f90:340. The test writes forward_hierarchy.tsv and forward_hierarchy_manifest.tsv to the caller's explicit evidence_dir at production/tests/simple_pose_cont_refinement_forward_hierarchy_test.f90:364. No calibration fixture, threshold derivation, or evaluator-generated direct observation appears in this acceptance case.
Applicable policies are doc/policies/KB_Interpolation_Policy.md for padded coordinates, normalized KB gather, and padf^3 scaling; doc/policies/reconstruct3D_pcg_policy.md for the full-disk, discrete envelope, and unchanged PCG-owner boundary; and doc/policies/refine3D_policy.md for the particle-pose versus volume-domain separation. No UI policy applies because Phase 8 adds no production caller or user-visible option.
Lightweight source checks are PASS. git diff --check exited 0. The three edited Fortran files have zero lines longer than 132 columns, zero trailing-whitespace findings, zero conflict markers, and zero multiline-macro hazards. The new filename matches the existing simple_pose_cont_refinement_*.[fF]90 dependency glob. Static inspection finds no calibration-fixture call, no simple_reconstructor_pcg import, and no executed-stencil or neutral-gather call from the slow oracle. production/CMakeLists.txt remains unchanged at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4.
Oracle must create a timestamped evidence directory directly below ~/Projects, then run simple_test_pose_cont_refinement case=forward_hierarchy evidence_dir=<absolute-phase8-directory> from ~/Projects. The hypothesis is that all four frozen comparison families pass for both acceptance boxes over the full redundant disk, while clipping fractions and stencil switches remain explicit diagnostics. The complete simple_test_pose_cont_refinement mother suite then tests that the keyed diagnostic does not change the five scheduled pose regressions.
Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase08/prepare_20260827_190558_667.events.jsonl and its sibling prompt and stderr files. The exact approved rsync dry run is the final operation of this turn; its complete output and exit status remain in that JSONL record. No source or controller-input change is permitted after the dry run. No real synchronization, normalization, compilation, runtime test, scientific acceptance test, or commit occurs in this prepare turn.

First Oracle validation attempt — 2026-08-27:

The independent gate passed with Phases 0 through 7 COMPLETE and Phase 8 READY FOR ORACLE VALIDATION. The controller source-state check exited 0 and verified HEAD=e836bf020d8508219740bc6f254fbe5ef05999d8, 1512 files, and digest A3A4D2738920F95C24609ED80E0C89690179F24B003F2328547C1DCE6C993E6E. production/CMakeLists.txt remained unchanged at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4.
The exact approved rsync -av --delete --info=progress2 command exited 0, transferred 84 files to ~/Projects/hael_SIMPLE-rsync-test, and reported no deletion. An initial PowerShell normalization command failed locally with exit 1, and one direct SSH form stalled before command execution. The corrected one-argument UCRT64 invocation of find . -type f $ -name '*.pl' -o -name '*.sh' $ -exec sed -i 's/\r$//' {} + exited 0.
The first correctly delivered build command exited 126 before script execution because the earlier normalization wrapper had not changed the CRLF compile-helper shebang. After the corrected normalization, the default incremental module load gcc/15.2.0 and .codex/compile_debug.sh 2>&1 | tee build/build_debug.log command exited 0. It compiled simple_cartesian_pose_refiner.f90, the new forward-hierarchy module, and the keyed mother driver, then linked and installed simple_test_pose_cont_refinement. The conditional SIMPLE_CLEAN_BUILD=yes retry did not run. The compiler log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log.
Two pre-scientific runtime attempts are retained separately. The command in ~/Projects/continuous_3D_phase8_forward_20260827_192614 reached ~/Projects but exited 127 before test execution because the nested PATH variables expanded in the outer SSH shell. The corrected command in ~/Projects/continuous_3D_phase8_forward_20260827_192642 executed the stale pre-build binary and exited 1 because that binary did not contain case=forward_hierarchy. Neither attempt is scientific evidence for AC-6.
The current focused executable then ran from ~/Projects with evidence at ~/Projects/continuous_3D_phase8_forward_20260827_192839 and exited 1. The analytic DFT, executed DFT, and slow-gather comparisons reached the finite-projection gate, which stopped at production/tests/simple_pose_cont_refinement_forward_hierarchy_test.f90:127 with forward hierarchy comparison exceeded its frozen tolerance. The stopping path did not write forward_hierarchy.tsv or print the maximum error, family limits, comparison name, or clipping fraction. Runtime completion is FAIL; AC-6 scientific acceptance is NEEDS MORE TESTING. The unchanged mother suite did not run.
The smallest local rework now prints the failing comparison name, family, sample count, maximum absolute and scaled-relative errors, frozen absolute and relative limits, and clipping fraction before the stop at production/tests/simple_pose_cont_refinement_forward_hierarchy_test.f90:342 and line 362. It does not change a fixture, transform, tolerance, assertion, production algorithm, or frozen contract. Lightweight checks are PASS: git diff --check exits 0; the three Phase 8 Fortran files have zero lines longer than 132 columns and zero conflict markers; and production/CMakeLists.txt remains unchanged at the recorded SHA-256.
Post-test checks exited 0. Neither ~/Projects/hael_SIMPLE-rsync-test nor ~/Projects/SIMPLE contains a top-level validation/, continuous_3D_matrix_volumes_*, or Phase 8 evidence directory. The three Phase 8 evidence directories are directly below ~/Projects. Four earlier ~/Projects/continuous_3D_matrix_volumes_* directories remain from prior phases; Phase 8 created no new matrix directory and no runtime evidence below a source checkout.
This diagnostic source change invalidates the synchronized source and prepared fingerprint. Phase 8 is REWORK REQUIRED; no second synchronization, compilation, runtime test, mother suite, or commit is permitted in this turn. The safe next action is a new Phase 8 prepare turn with a new source fingerprint and authoritative rsync dry run. That turn must preserve every frozen tolerance and use the new failure record to diagnose the finite-projection comparison before another Oracle validation.

Rework prepare evidence — 2026-08-27:

The independent gate passed with Phases 0 through 7 COMPLETE and Phase 8 REWORK REQUIRED. Applicable policies remain doc/policies/KB_Interpolation_Policy.md for padded coordinates, normalized KB gathers, and padf^3; doc/policies/reconstruct3D_pcg_policy.md for the full redundant disk, discrete envelope, and unchanged PCG-owner boundary; and doc/policies/refine3D_policy.md for the particle-pose versus volume-domain ownership boundary. No UI policy applies.
The focused diagnostic now records all 28 declared comparisons before its final assertion at production/tests/simple_pose_cont_refinement_forward_hierarchy_test.f90:51. Each comparison stores its pass state at line 360; the compact log prints that state at line 414; and forward_hierarchy.tsv adds a machine-readable passed column at line 377. A failed metric still makes the executable fail after the table, manifest, and compact log are complete.
The rework does not change an analytic fixture, acceptance box, Fourier disk, rotation, prepared reference, comparison definition, frozen tolerance, production algorithm, or frozen contract. The executed gather remains at src/main/volume/simple_cartesian_pose_refiner.f90:357, and the structurally separate slow traversal remains at line 386. Keyed dispatch remains at production/tests/simple_test_pose_cont_refinement.f90:212; the five-case mother schedule is unchanged.
Lightweight source checks are PASS. git diff --check exited 0; the three Phase 8 Fortran files have zero lines longer than 132 columns, zero conflict markers, and zero multiline-macro hazards. Static checks find no calibration-fixture call and no simple_reconstructor_pcg import in the focused diagnostic. production/CMakeLists.txt remains unchanged at SHA-256 014480DFF49255399E1462CE37B3FD490CCECE6F8C72336B6A6B671AA97A60A4.
The next Oracle run must create one timestamped evidence package directly below ~/Projects, run simple_test_pose_cont_refinement case=forward_hierarchy evidence_dir=<absolute-phase8-directory> from ~/Projects, and retain the complete log, manifest, and 28-row table. The hypothesis is that the complete record will either satisfy every frozen family or identify the exact comparison, error, limit, clipping fraction, and stencil-switch count that needs a contract-consistent scientific decision. Run the unchanged mother suite only if the focused case passes. Compilation, runtime completion, and AC-6 acceptance remain NEEDS MORE TESTING in this prepare turn.
Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase08/prepare_20260827_193501_573.events.jsonl and its sibling prompt and stderr files. The exact approved rsync dry run is the final operation of this turn; its complete output and exit status remain in that JSONL record. No source or controller-input change is permitted after the dry run. No real synchronization, normalization, compilation, runtime test, scientific acceptance test, or commit occurs in this rework prepare turn.

Second Oracle validation attempt — 2026-08-27:

The independent gate passed with Phases 0 through 7 COMPLETE and Phase 8 READY FOR ORACLE VALIDATION. The prepared-state check exited 0 and verified HEAD=e836bf020d8508219740bc6f254fbe5ef05999d8, 1512 files, and digest B4444B3EEC6DDB9BD80F972FE4A06F6B867479F9FC7AEED6DB282BB00D8A1390.
The exact approved rsync -av --delete --info=progress2 command exited 0, transferred 82 files to ~/Projects/hael_SIMPLE-rsync-test, and reported no deletion. The five transfers beyond the reviewed 77-file dry run were current controller and prepared-state evidence. The approved line-ending normalization exited 0; the compile-helper shebang ended in LF byte 0a.
With module load gcc/15.2.0, the default incremental logged .codex/compile_debug.sh command exited 0. It compiled and linked the complete Phase 8 diagnostic and installed the Debug tree. The conditional clean retry did not run. The compiler log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log.
The focused command ran from ~/Projects and wrote its log, manifest, and complete 28-row comparison table to ~/Projects/continuous_3D_phase8_forward_20260827_194435. The executable SHA-256 was 0179747e22745c7252f70dc7b3f19c3248303f18b9aa4f8056958ac9e853c061. The command exited 1 after 25 comparisons passed and three arbitrary-rotation comparisons failed their frozen componentwise rules.
finite_projection_r2 failed for box 10 with maximum absolute error 3.1899879352969554E-03, maximum scaled-relative error 1.7953239260303799, and clipping fraction 0.329, against absolute and relative limits 1.0E-05 and 5.0E-02. For box 16 it failed with 1.8791978675879884E-03, 1.7268192905424458, and clipping fraction 0.27294921875 against the same limits. executed_dft_r2 failed for box 16 with maximum absolute error 1.6409070760202703E-04 and maximum scaled-relative error 1.9846476459230120E-01, against limits 1.0E-05 and 3.0E-02.
All 16 analytic-object comparisons passed. Both identity finite projections passed. All four independent slow-gather comparisons passed with maximum absolute error at most 6.841045E-09, including the arbitrary rotations with 76 and 192 recorded stencil switches. The failures therefore are scientific comparison results, not an incomplete runtime or a fast-versus-slow source-fidelity defect. The mother suite did not run because the frozen focused gate failed.
Phase 4 calibrated the executed-DFT and finite-projection families with four identity probes at boxes 8 and
The frozen Phase 8 gate applies those families over full disks at boxes 10 and 16 and an arbitrary rotation. The observed 27.3-32.9 percent finite-box clipping and the box-16 interpolation miss cannot be accepted by changing a tolerance, fixture, comparison, or gate after the result. No local source correction is justified by the frozen contract.
Post-test checks exited 0. Neither ~/Projects/hael_SIMPLE-rsync-test nor ~/Projects/SIMPLE contains a top-level validation/ or continuous_3D_matrix_volumes_* directory. No Phase 8 evidence directory exists below a source checkout, and no continuous_3D_matrix_volumes_* directory exists directly below ~/Projects.
Phase 8 is BLOCKED. Scientific ownership must choose one contract-level action: define a valid arbitrary- rotation finite-box comparison that separates the declared clipping/interpolation effects; require a new production interpolation/projection algorithm that satisfies the present frozen families; or return the contract above its approval boundary to IN REVIEW and recalibrate before any new acceptance observation. Do not start Phase 9, weaken a frozen gate, repeat unchanged validation, or make a failing-phase commit.

Implement AC-6 under Independent forward evidence and comparison contracts.

Tests and reason: use analytic deltas and point sets for convention checks; compare brute-force DFT with analytic values, executed $G(E^{-1}X)$ with direct DFT under the amended interpolation tolerance, the independent slow gather with the executed gather, and projection/FFT of $X_R$ with the three-dimensional DFT of that same $X_R$ under the amended finite-projection tolerance. Record original-volume rotated-frequency error, clipping, interpolation, support margin, and stencil switches as separate diagnostics.

Gate: AC-6 passes on fresh holdout boxes, volumes, and rotations over the full redundant disk, and each comparison is reported under its own amended frozen tolerance family without an inverse crime. The observed box-$10^3$/box-$16^3$ cases remain diagnostics.

Phase 9 — run the complete configuration and regression matrix¶

Status: COMPLETE

Oracle validation attempt 3 — 2026-08-31:

The independent gate passed with Phases 0 through 8 COMPLETE and Phase 9 READY FOR ORACLE VALIDATION. .codex/codex_exec_source_state.ps1 exited 0 and verified HEAD=26818001e0d3a6366fc89c471eae73defda9c815, 1,512 files, and digest 5D7F2F40C897CAC7D9F2FE028A0BB239C8A79A6420A7003DDB4434241D51958B against the reviewed prepare state. The local origin/master reference was 9695e1d365893efdd42a6bab87be28da770c71e5.
The approved rsync -av --delete --info=progress2 command exited 0, transferred 83 files, sent 1,165,575 bytes, received 8,206 bytes, and reported no deletion. The approved remote .pl/.sh line-ending normalization exited 0. With module load gcc/15.2.0, the default incremental logged .codex/compile_debug.sh command exited 0 and installed the Debug tree. The conditional clean retry did not run. The compiler log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log.
Every accepted runtime command changed to ~/Projects, verified and SHA-256 hashed its exact executable, kept the executable separate from its argument array, and wrote a manifest and status to a new timestamped directory directly below ~/Projects. The physical path reported by pwd -P is /usr/local/cache/mazhar/Projects because /home/hossainm7/Projects is a symlink to that directory. The pose executable SHA-256 was 985e49be685323ddbdb508807993af247e5607eead859e25d895b1b2cc62256d.
case=configuration_matrix exited 0 at ~/Projects/continuous_3D_phase9_configuration_matrix_20260831_092706_252085861. All 1,296 declared rows passed. The maximum exact objective, nonstationary objective, gradient norm, and independent slow-gather error were 9.1551045002523813E-17, 1.8107989702240634E-05, 5.6559335524945656E-04, and 1.2274658592878375E-08. Every row had LM status 1, two attempted steps, and two accepted steps; maximum rotation step, shift step, and stencil switches were 2.9133946403983715E-02, 1.0219846935161689E-01, and 120.
The pose mother suite exited 0 with five of five cases passed at ~/Projects/continuous_3D_phase9_pose_mother_20260831_092745_275612034. All retained keyed diagnostics exited 0 and reported PASS or EVIDENCE COMPLETE: fixed_reference, forward_path, matched_window, reference_bias, operator_contract, pose_capture_range, pose_capture_mechanism, tolerance_calibration, objective_normals, lm_transactions, ctf_sigma, and forward_hierarchy. The accepted quote-safe replacements for the four initial malformed manifests are under the forward_path_rerun2, matched_window_rerun2, reference_bias_rerun2, and operator_contract_rerun2 directories recorded in the aggregate results table below.
The capture-range rerun exited 0 at ~/Projects/continuous_3D_phase9_pose_capture_range_rerun_20260831_093600_283802280. Its 138 trials had zero integrity failures and 138 monotone traces; 137 trials accepted an improvement, and the exact-pose trial correctly reported finite no improvement. The mechanism case exited 0 for three volumes and five seed cases per volume at ~/Projects/continuous_3D_phase9_pose_capture_mechanism_20260831_093638_608351994.
The Cartesian mother exited 0 with two of two cases passed at ~/Projects/continuous_3D_phase9_cartesian_mother_20260831_093834_318179652. Its executable SHA-256 was fbd716047cb07b174b0fea30a1e0da90d1266131d99e638a0d9c2689524351e1. simple_test_exec test=pcg_recon and test=pcg_priors each exited 0 and reported normal stops at the pcg_recon_20260831_095547_975523090 and pcg_priors_20260831_095708_274698396 evidence directories.
The PCG mother executable SHA-256 was 46a3ad531cfe242e1b4c2cd9ef16d9602a54a0f8472d2f1194aa491b03971769. It exited 1 at ~/Projects/continuous_3D_phase9_pcg_mother_20260831_093910_581603048 with the exact frozen Phase 2 disposition: volume_fixture and volume_noise passed, only halfset_fsc failed, and best lambda was 10 for both halves. Raw PCG L2 errors were 6.612755E-01 and 6.608928E-01; gridding L2 errors were 6.518738E-01 and 6.388823E-01. This exact parity passes AC-12; the known absolute reconstruction-quality issue remains outside Phase 9 and is not weakened.
Infrastructure failures are retained and are not SIMPLE results. The first capture-range attempt exited 1 because its required evidence-directory variable was absent. A later forward_path evidence repair exited 1 before SIMPLE execution because the fresh shell lacked the GCC 15.2 runtime and used the wrong argument form. Four successful initial keyed runs had malformed manifest separators. Each affected scientific case was rerun in a new directory with the documented module, SIMPLE environment, exact arguments, executable hash, manifest, and status.
The aggregate review package is ~/Projects/continuous_3D_phase9_review_20260831_101729_565124385. Its phase9_results.tsv, scientific_summary.txt, infrastructure_attempts.tsv, path_checks.txt, and evidence_manifest.sha256 separate runtime, scientific, and infrastructure evidence. Post-test checks exited 0: neither ~/Projects/hael_SIMPLE-rsync-test nor the unused ~/Projects/SIMPLE checkout contains a top-level validation/, continuous_3D_matrix_volumes_*, or Phase 9 evidence directory. The current PCG matrix directory is ~/Projects/continuous_3D_matrix_volumes_20260831_094044954 with 29 top-level files. No Phase 9 process remains active.
Source checks, synchronization, normalization, compilation, runtime completion, and scientific review are PASS. AC-7, AC-8, AC-10, AC-11, and AC-12 pass without a result-driven metric, fixture, or gate change. Local controller evidence is codex_logs/pose_cont_20260826_144540_289/phase09/validate_20260831_091844_976.events.jsonl with its sibling prompt and stderr records. Phase 9 is COMPLETE.

Rework prepare after interrupted Oracle validation attempt 2 — 2026-08-31:

The independent gate passed with Phases 0 through 8 COMPLETE and Phase 9 REWORK REQUIRED. The applicable policies are doc/policies/KB_Interpolation_Policy.md for padded coordinates and normalized Kaiser-Bessel gathers, doc/policies/reconstruct3D_pcg_policy.md for reconstruction ownership and ordinary PCG, doc/policies/refine3D_policy.md for pose and volume ownership, doc/policies/phase_shift_ctf_policy.md for disabled, signed, and flipped CTF states, and doc/policies/sigma_calculation_policy.md for positive native-shell variance and bounded consumption. No UI policy applies.
The prepared-source state had to be renewed because the local origin/master reference moved to 9695e1d365893efdd42a6bab87be28da770c71e5 after attempt 2. No rebase, merge, checkout, reset, source correction, or controller-input edit was made. The Phase 9 implementation remains the 1,296-case configuration matrix at production/tests/simple_pose_cont_refinement_configuration_matrix_test.f90:38, with the corrected complex slow-gather value at the same file's line 175 and keyed dispatch at production/tests/simple_test_pose_cont_refinement.f90:215.
Lightweight source checks are PASS. Path-limited git diff --check exited 0; the Phase 9 sources have zero tab characters and zero conflict markers. The dispatch and slow-gather declarations are present. production/CMakeLists.txt remains unchanged at SHA-256 F850520E053180EA241C5B091D74C5358B87BFC118BA91E043BBA654059412EB.
Attempt 2 compilation is prior evidence only. The current prepare turn does not compile or run a SIMPLE executable. Runtime and scientific acceptance remain NEEDS MORE TESTING because the two pose-capture statuses, the PCG status, and the two unexecuted simple_test_exec cases do not yet have a complete, scientifically reviewed evidence package.
The next validation must invoke each retained test through an independently status-checked, quote-safe boundary. It must keep the executable path separate from its argument list, verify that the executable exists, hash that executable path before execution, quote each path and argument, use local and braced shell variables when a helper is necessary, and record the actual command exit status. A manifest or wrapper failure is infrastructure evidence, not a SIMPLE test result. Preserve attempt-2 directories and put each rerun in a new timestamped directory directly below ~/Projects.
The approved UCRT64 environment check and exact rsync -n dry run are the final external checks for this turn. The controller JSONL retains their complete output and exit status. No source or controller-input change is permitted after the dry run, and no real synchronization, normalization, compilation, runtime test, scientific acceptance test, or commit occurs.

Interrupted Oracle validation attempt 2 — 2026-08-31:

Phase 8 was already COMPLETE at focused commit 26818001e. Phase 9 synchronized and compiled, then launched the declared regression batch from ~/Projects. The batch did not reach a scientifically reviewable completion state and no Phase 9 commit was made.
configuration_matrix, the pose mother, fixed_reference, forward_path, matched_window, reference_bias, operator_contract, tolerance_calibration, objective_normals, lm_transactions, ctf_sigma, forward_hierarchy, and the Cartesian mother returned status 0. These runtime statuses remain provisional until the complete Phase 9 evidence package and manifests are repaired and reviewed.
pose_capture_range and pose_capture_mechanism returned status 1. Their logs were not retrieved before the connection failure, so their scientific meaning is NEEDS MORE TESTING, not an accepted regression failure.
The PCG mother returned its known status 1. Its best-lambda and both half-set error tables were not compared with the frozen Phase 2 disposition before the turn ended, so AC-12 remains NEEDS MORE TESTING.
simple_test_exec test=pcg_recon and simple_test_exec test=pcg_priors returned status 127 without running. The ad hoc shell helper passed unquoted manifest arguments and allowed its executable variable to be overwritten by test=.... Several evidence-directory labels were also lost through unbraced shell-variable expansion. These are validation-harness defects; they are not SIMPLE test results.
The final read-only log inspection failed with SSH status 255 because the Oracle hostname could not be resolved. The Codex websocket then disconnected before a final report, phase decision, evidence-location audit, or focused commit could be produced.
The saved Phase 9 prepared-source state is stale because the local origin/master reference moved from c2b419ad3a521588d152b8b43335b8488c905957 to 9695e1d365893efdd42a6bab87be28da770c71e5. Do not rebase during this phase. A fresh prepare turn must record the current source and Git refs, run a new exact rsync dry run, and then repeat Phase 9 validation.
The next validation must run each retained test through a quote-safe command boundary. Use distinct local shell variables, brace variable names adjacent to underscores, quote every path and argument, verify and hash the executable path before execution, and record each command's actual exit status. Do not use one mutable helper variable for both an executable path and its arguments. Preserve the incomplete attempt-2 directories as historical evidence; write all reruns to new timestamped directories directly below ~/Projects.

Rework prepare after Oracle validation attempt 1 — 2026-08-31:

The independent gate passed with Phases 0 through 8 COMPLETE and Phase 9 REWORK REQUIRED. The applicable policies remain doc/policies/KB_Interpolation_Policy.md, doc/policies/reconstruct3D_pcg_policy.md, doc/policies/refine3D_policy.md, doc/policies/phase_shift_ctf_policy.md, and doc/policies/sigma_calculation_policy.md for the same interpolation, PCG ownership, pose ownership, CTF, and positive-variance contracts recorded below. No UI policy applies.
Verified the validation-attempt correction at production/tests/simple_pose_cont_refinement_configuration_matrix_test.f90:175. The corrected complex(dp) declaration now matches the sample_fourier_slow_test output at src/main/volume/simple_cartesian_pose_refiner.f90:389. The single-precision production gather, derivative, phase, and observation are unchanged. No additional source change was required.
Lightweight source checks are PASS. Path-limited git diff --check exited 0; the Phase 9 matrix source has zero lines longer than 132 columns, zero tab characters, zero conflict markers, and zero multiline diagnostic-macro hazards. The keyed dispatch remains present, and production/CMakeLists.txt remains unchanged at SHA-256 F850520E053180EA241C5B091D74C5358B87BFC118BA91E043BBA654059412EB.
The declaration-only correction changes no module, procedure, or dependency symbol, so the Phase 9 generated code map and Fortran indexes remain current. Compilation and all runtime and scientific gates remain NEEDS MORE TESTING; prepare turns do not compile or execute SIMPLE.
The approved UCRT64 environment check and exact rsync -n dry run are the final external checks for this turn. The controller JSONL retains their complete output and exit status. No source or controller-input change is permitted after the dry run, and no real synchronization, normalization, compilation, runtime test, scientific acceptance test, or commit occurs.

Oracle validation attempt 1 — 2026-08-31:

The prepared-source fingerprint gate passed. Phases 0 through 8 were COMPLETE, Phase 9 was READY FOR ORACLE VALIDATION, and .codex/codex_exec_source_state.ps1 verified source digest 468669D7100E2C0766B19DBA32F2213D56C5581D72FC4FA82C2E55056E1D1B04 with exit status 0.
The approved real rsync -av --delete exited 0. It transferred 89 files and 5,542,303 bytes to ~/Projects/hael_SIMPLE-rsync-test, with no deletion. The five transfers added after the prepare dry run were the active Phase 9 controller records. The approved remote .pl/.sh line-ending normalization exited 0 after one local PowerShell quoting attempt failed before SSH execution.
The default incremental GCC 15.2.0 Debug compilation exited 2. The authoritative compiler log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log. GCC diagnosed a kind mismatch at the sample_slow_test call: the test supplied default complex, but the frozen slow gather returns complex(dp). A clean build cannot change this source-level mismatch, so the conditional clean retry was not used.
Corrected only the local Phase 9 test declaration so slow_value has complex(dp) at production/tests/simple_pose_cont_refinement_configuration_matrix_test.f90:175. This correction matches sample_fourier_slow_test in src/main/volume/simple_cartesian_pose_refiner.f90; the single-precision production gather value, derivative, phase, and observation remain unchanged.
No runtime test or scientific gate ran after the compilation failure. Compilation is FAIL; runtime and AC-7, AC-8, AC-10, AC-11, and AC-12 are NEEDS MORE TESTING. The safe next action is a new Phase 9 prepare turn, which must source-check this correction and review a new rsync dry run before a second validation transfer.

Prepare implementation — 2026-08-31:

The independent gate passed with Phases 0 through 8 COMPLETE and Phase 9 NOT STARTED. Applicable policies are doc/policies/KB_Interpolation_Policy.md for padded coordinates, normalized KB gather, and padf^3 scaling; doc/policies/reconstruct3D_pcg_policy.md for the full redundant disk, immutable ordinary-PCG numerical contract, and reconstruction-only ownership; doc/policies/refine3D_policy.md for particle-pose versus volume ownership; doc/policies/phase_shift_ctf_policy.md for signed, phase-flipped, and disabled CTF application with stored numerical phase; and doc/policies/sigma_calculation_policy.md for positive native-shell variance and bounded consumption. No UI policy applies because Phase 9 adds no command, option, or production caller.
Added the keyed case=configuration_matrix at production/tests/simple_pose_cont_refinement_configuration_matrix_test.f90:38 and dispatched it from production/tests/simple_test_pose_cont_refinement.f90:20,215. The established five-case mother schedule is unchanged. The filename matches the existing dependency glob at production/CMakeLists.txt:200; the protected build file remains unchanged.
The frozen matrix has boxes 10, 14, 16, and 18; three deterministic asymmetric physical volumes; all three rotation axes; both shift signs; exact and nonstationary pose evaluations; disabled, signed, and phase-flipped CTF modes; constant, varying, and short positive native-shell variance; and full-disk and interior Fourier ranges. It executes 1,296 declared combinations and writes one row per combination plus a dimension manifest. Fixture construction is at production/tests/simple_pose_cont_refinement_configuration_matrix_test.f90:133.
Each configuration prepares the production CTF/noise components, requires a finite exact-pose and nonstationary objective, applies the frozen exact-pose algebraic rule, and runs the production prepared LM path for up to two attempts. The accepted objective trace must be finite and monotone, and invalid-numerics status is prohibited (production/tests/simple_pose_cont_refinement_configuration_matrix_test.f90:286,302). The executed gather is also compared componentwise with the structurally separate slow gather under frozen family 6 for each box, morphology, and rotation axis at line 167.
The configuration case retains configuration_matrix.tsv and configuration_matrix_manifest.tsv before its final 1,296-row assertion (production/tests/simple_pose_cont_refinement_configuration_matrix_test.f90:322). The focused hypothesis is that no box, range, morphology, packing, pose sign, CTF mode, or variance extent changes the frozen prepared-objective, slow-gather, or LM transaction contracts.
Oracle validation must run from ~/Projects with each command writing to a new timestamped evidence package directly below ~/Projects. Run case=configuration_matrix, the default pose mother suite, and every retained keyed case: fixed_reference, forward_path, matched_window, reference_bias, operator_contract, pose_capture_range, pose_capture_mechanism, tolerance_calibration, objective_normals, lm_transactions, ctf_sigma, and forward_hierarchy. Also run simple_test_cartesian_fourier, simple_test_continuous_3D_pcg_reconstruction, simple_test_exec test=pcg_recon, and simple_test_exec test=pcg_priors. The known halfset_fsc absolute reconstruction failure must retain the exact Phase 2 scientific-owner disposition; any different PCG result is blocking.
Regenerated doc/code_overview/code_base_map.md and all six Fortran indexes. Both restricted MSYS2 Perl invocations failed before script execution with Win32 CreateFileMapping error 5; each exact elevated retry exited 0. The code map lists the new module at doc/code_overview/code_base_map.md:40.
Lightweight source checks are PASS. Path-limited git diff --check exited 0; both Phase 9 Fortran files have zero lines longer than 132 columns, zero tab characters, and zero conflict markers. Static ownership searches find the pose owner only in its defining production module and test sources, with no production caller or user-visible activation. production/CMakeLists.txt remains unchanged at SHA-256 F850520E053180EA241C5B091D74C5358B87BFC118BA91E043BBA654059412EB.
Compilation, runtime completion, AC-7, AC-8, AC-10, AC-11, and AC-12 scientific acceptance remain NEEDS MORE TESTING. The exact approved rsync dry run is the final operation of this prepare turn. Its complete output and exit status remain in the controller JSONL record. No source or controller-input change is permitted after the dry run. No real synchronization, normalization, compilation, runtime test, scientific acceptance test, or commit occurs in this prepare turn.

Repeat the essential Phase 5–8 checks over the fresh holdout boxes plus the retained box-$10^3$/box-$16^3$ diagnostics, two Fourier ranges, three deterministic asymmetric volumes, all rotation axes, both shift signs, exact and nonstationary poses, and the approved CTF/variance matrix. Re-run the complete mother suite and all retained keyed diagnostics.

Tests and reason: this phase detects hidden box, range, symmetry, morphology, packing, and configuration dependencies and rechecks ordinary PCG after every extraction and deletion is complete.

Gate: AC-7, AC-8, AC-10, AC-11, and AC-12 pass without result-driven metric or fixture changes.

Phase 10 — collect authoritative Oracle Linux evidence¶

Status: COMPLETE

Applicable policy review selected KB_INTERPOLATION_POLICY.md because the retained gather and derivative cases use the padded normalized KB contract; RECONSTRUCT3D_PCG_POLICY.md because AC-12 retains the PCG mother and both high-level PCG regression suites; REFINE3D_POLICY.md because pose and volume ownership must remain separate; PHASE_SHIFT_CTF_POLICY.md because the retained CTF matrix must preserve disabled, signed, and phase-flipped transfer semantics; and SIGMA_CALCULATION_POLICY.md because the variance matrix must use positive native-shell sigma values. No UI policy applies: this phase adds a test-only validation entry point and no public option.
production/tests/pose_cont_validation/run_oracle_validation.sh:16 creates one timestamped package directly below ~/Projects; snapshots the living note, pose owner, neutral Cartesian/envelope owners, PCG owner, all relevant oracle/test modules, and both validation-script sets at line 89; hashes the exact resolved executable before each invocation at line 141; runs every retained test independently from ~/Projects at lines 150 and 210; retains failures instead of truncating the schedule; copies newly generated matrix roots into the package; writes final analysis at line 246; and writes stable package checksums at line 266 while excluding the active console transcript. Its command manifests do not invoke pcg_pose_polish or a deleted pose-polisher strategy.
production/tests/pose_cont_validation/analyze_oracle_validation.py:13 declares the complete 18-command matrix. It checks independent exit status and completion markers, runs the retained pose-capture integrity analyzer, requires all machine-readable comparison and frozen-tolerance files, requires exactly 1,296 configuration rows at line 126, verifies source snapshot hashes at line 186, and accepts PCG-mother status 1 only when it reproduces the exact Phase 2 best lambda and decisive raw-L2 disposition at line 171. Any other PCG outcome fails Phase 10 rather than weakening AC-12.
production/tests/pose_cont_validation/README.md:3 documents the single entry point, stable working-directory and package boundaries, frozen known PCG disposition, and exact post-build invocation.
The test hypothesis is that all AC-1 through AC-12 numerical owners retain their frozen assertions across the complete focused/configuration matrix, the pose and neutral mother suites, and both high-level PCG regressions, and that the one known reconstruction-owner failure remains numerically identical to the Phase 2 control disposition.
Lightweight source evidence is PASS. Path-limited git diff --check exited 0; the Python analyzer AST check exited 0; the first restricted Bash parse and its post-correction repeat each stopped before script execution at the documented MSYS2 CreateFileMapping host boundary with wrapper status 256; each corresponding exact elevated retry exited 0. Python 3.6 grammar parsing and the frozen PCG-line parser smoke check also exited 0. The new files contain no tab characters or CRLF line endings. production/CMakeLists.txt remains unchanged.
Compilation, runtime completion, AC-9, the final AC-1 through AC-12 matrix, and package scientific acceptance remain NEEDS MORE TESTING. This prepare turn does not synchronize source, normalize remote files, compile, run a SIMPLE executable, or commit. The approved rsync attempts and their complete output and exit statuses are retained in the controller evidence.
The first attempted dry-run command was malformed at the PowerShell-to-Bash quoting boundary and exited 1 at local rsync usage parsing without a remote comparison. The corrected exact dry run exited 0, proposed 83 file transfers and no deletion, but included the unexpected agent-created production/tests/pose_cont_validation/__pycache__/analyze_oracle_validation.cpython-314.pyc. That cache was removed after review. This correction and the prior status update invalidated that dry run. Do not reuse its transfer review.
The corrective prepare turn repeated all lightweight checks without creating bytecode. Python 3.6 grammar parsing, git diff --check, the exact elevated Bash parse retry after the restricted CreateFileMapping host failure, the tab and CRLF scans, and the cache-artifact scan all passed. The protected production/CMakeLists.txt SHA-256 remains F850520E053180EA241C5B091D74C5358B87BFC118BA91E043BBA654059412EB. The authoritative fresh rsync dry run is the final operation of this prepare turn; its complete command, output, and exit status remain in the controller JSONL evidence and supersede the rejected transfer review above.

Oracle validation attempt 1 — 2026-08-31:

The independent phase-order gate passed, but the required prepared-source fingerprint check failed before synchronization. The prepared record has HEAD=397fad74faea53fc046b2e765cf4b62fa218aa27 and ORIGIN_MASTER=c75e33151f027aeb524210a2bc838209427ecd08; the current local HEAD is unchanged, but the current remote-tracking origin/master is 168b5f272b01e24a85a863394091c7f14dc8d353. The source-state checker exited 1 and classified the prepared state as stale.
No real rsync, remote line-ending normalization, compilation, runtime test, scientific acceptance test, or commit ran. Synchronization, compilation, runtime, AC-9, and the complete AC-1 through AC-12 matrix remain NEEDS MORE TESTING.
Start a new Phase 10 prepare turn. It must record the current Git identity, repeat the lightweight checks, and review a new exact rsync dry run against the source state that the next validation turn will use. Do not reuse the previous dry run or prepared fingerprint.

Rework prepare after Oracle validation attempt 1 — 2026-08-31:

The independent phase-order gate passed with Phases 0 through 9 COMPLETE and Phase 10 REWORK REQUIRED. The current Git identity is HEAD=397fad74faea53fc046b2e765cf4b62fa218aa27 and ORIGIN_MASTER=168b5f272b01e24a85a863394091c7f14dc8d353.
No source correction was necessary. Python 3.6 grammar parsing, path-limited git diff --check, tab, CRLF, and cache-artifact scans passed. The restricted Bash parser stopped before script execution at the documented MSYS2 CreateFileMapping host boundary; its one exact elevated retry exited 0. The protected production/CMakeLists.txt SHA-256 remains F850520E053180EA241C5B091D74C5358B87BFC118BA91E043BBA654059412EB.
The authoritative fresh rsync dry run is the final external operation of this prepare turn. Its complete command, output, and exit status remain in the controller JSONL evidence. It supersedes all earlier Phase 10 dry runs and is the only transfer review valid for the next validation turn.

Oracle validation evidence — 2026-08-31:

The independent phase-order and prepared-source checks exited 0. Phases 0 through 9 were COMPLETE, Phase 10 was READY FOR ORACLE VALIDATION, and the validated fingerprint was HEAD=397fad74faea53fc046b2e765cf4b62fa218aa27, ORIGIN_MASTER=168b5f272b01e24a85a863394091c7f14dc8d353, FILE_COUNT=1516, and SOURCE_DIGEST=7D340E54EBCEFD103F95595F0FBDB77E9A7D4787691C2F6882DD3F32F7D6032D.
The exact rsync -av --delete --info=progress2 command with exclusions for .git/, .codex/.local-history.git/, build/, *.o, *.mod, *.a, and *.so exited 0. It transferred 99 files, proposed no deletion, sent 7,233,044 bytes, received 11,960 bytes, and reported total size 150,898,657 bytes and speedup 20.83. The approved normalization command cd ~/Projects/hael_SIMPLE-rsync-test && find . -type f \$ -name '*.pl' -o -name '*.sh' \$ -exec sed -i 's/\\r$//' {} + exited 0.
After module load gcc/15.2.0, the exact incremental logged build used mkdir -p build, set -o pipefail, and .codex/compile_debug.sh 2>&1 | tee build/build_debug.log. It exited 0, completed the Debug install with GCC/GFortran 15.2.0, and did not use the conditional clean retry. The generated Git-hash step printed a non-fatal not a git repository warning because rsync excludes .git/; compilation, installation, and the pipeline status remained successful.
The first runtime launcher stopped before SSH or a SIMPLE invocation with exit 1 because its nested quote boundary was incomplete. It created no evidence directory and is classified as an infrastructure attempt, not a test result. The quote-safe retry loaded GCC 15.2.0, exported the documented SIMPLE environment, changed to ~/Projects, and invoked ~/Projects/hael_SIMPLE-rsync-test/production/tests/pose_cont_validation/run_oracle_validation.sh. It exited 0 and created ~/Projects/continuous_3D_pose_validation_20260831_112536.
The runner at production/tests/pose_cont_validation/run_oracle_validation.sh:150 independently resolved, checked, hashed, and invoked every executable from ~/Projects. All 17 expected-success commands exited 0: the 1,296-row configuration matrix; the pose mother; fixed-reference, forward-path, matched-window, reference-bias, operator-contract, capture-range, capture-mechanism, tolerance-calibration, objective-normal, LM-transaction, CTF/sigma, and forward-hierarchy cases; the neutral Cartesian mother; and the two high-level PCG suites. The pose-capture matrix had 138 trials and zero integrity failures. Mechanism evidence used three volumes and five seed cases per volume. Forward calibration used boxes 8 and 12, retained boxes 14 and 18 as unsampled holdouts, and retained factor 8.
The retained PCG mother exited 1 in its known halfset_fsc disposition. The best noisy lambda was 10 for both halves; PCG raw L2 errors were 0.6612755 and 0.6608928, and conventional-gridding raw L2 errors were 0.6518738 and 0.6388823. The analyzer at production/tests/pose_cont_validation/analyze_oracle_validation.py:171 accepted this exact Phase 2 control disposition and would reject any other result. The operator-level pcg_recon and pcg_priors regressions exited 0; representative gates include recovery correlation 0.97558, deapodized correlation 0.95269 versus 0.92741 without deapodization, cropped-kernel interior relative error 1.651648E-02, ML-kernel relative error 1.017238E-02, prior adjoint relative error 1.847703E-08, and priored reduction-route solution relative error 3.260160E-05.
Package analysis exited 0 and reported PASS for all required status rows, completion markers, machine-readable artifacts, the 1,296-row matrix, capture analysis, frozen forward amendment, source snapshot integrity, removed-route absence, PCG disposition, and runtime-parent check. A separate sha256sum -c MANIFEST.sha256 check exited 0. The package evidence is ~/Projects/continuous_3D_pose_validation_20260831_112536; the compiler log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log; and the matrix evidence root is ~/Projects/continuous_3D_matrix_volumes_20260831_113044100.
The required post-test path checks exited 0. ~/Projects resolves to /usr/local/cache/mazhar/Projects. The only source checkout used by Phase 10, ~/Projects/hael_SIMPLE-rsync-test, has no top-level validation/ directory and no top-level continuous_3D_matrix_volumes_* directory. The exact generated matrix directory is directly below ~/Projects; no A/B control checkout was used in this phase. The permitted compiler log is the only validation evidence below the source checkout.
Source checks, synchronization, normalization, compilation, runtime completion, package integrity, AC-9, and the complete AC-1 through AC-12 scientific matrix are PASS. The test-only runner and analyzer remain at production/tests/pose_cont_validation/run_oracle_validation.sh:16, production/tests/pose_cont_validation/analyze_oracle_validation.py:13, and production/tests/pose_cont_validation/README.md:3. They add no production caller, public option, or claim that the isolated pose refiner improves reconstruction quality. The unresolved absolute PCG-versus-gridding result remains the separate future-work item below.

After source review and lightweight checks, the user compiles on Oracle Linux and runs one validation entry point that continues through all independent focused cases and the complete mother suite while recording failures. Store logs, machine-readable comparisons, tolerance files, source snapshots, environment, configuration, statuses, and checksums in one timestamped directory under the requested ~/Projects parent.

The runner must snapshot this living note, the new pose and neutral owners, PCG owner, all oracle/test modules, and its own scripts. Its manifest must not require the deleted pose-polisher strategy or invoke pcg_pose_polish.

Tests and reason: authoritative compilation proves module integration; focused cases prove each numerical contract; the mother suite and PCG gates prove regression safety; package analysis proves results rather than process completion.

Gate: AC-9 and the complete AC-1 through AC-12 matrix pass, package integrity passes, and every required comparison is analyzed.

Phase 11 — handoff¶

Status: COMPLETE

Prepare handoff — 2026-08-31:

The independent phase gate exited 0: Phases 0 through 10 are COMPLETE, and Phase 11 entered from NOT STARTED. The handoff baseline is focused commit cb1a4dc6f8651af4b9da5f4811209104413e745a (Add authoritative continuous 3D pose validation). The branch contains the complete local phase sequence 016648550, 264248c73, b709b905b, 41928763f, 7140ddc02, e836bf020, 8d619aaee, 26818001e, 397fad74f, and cb1a4dc6f; no phase commit was pushed by this controller.
The handoff covers one isolated fixed-volume, five-parameter Cartesian pose refiner. cartesian_pose_refiner owns physical-volume preparation, shift-free CTF/sigma transfer, full-disk objective/Jacobian/normal terms, scaled damped LM proposals, bounds, accept/reject, and exact rollback in src/main/volume/simple_cartesian_pose_refiner.f90:56,197,633,945,1112. Neutral centered embedding/cropping, full-disk plane extraction, and packed KB value/value-gradient gathers remain in src/main/interp/simple_cartesian_fourier.f90:15,32,49,66,101. PCG keeps reconstruction accumulation, Gram/kernel, prior, preconditioner, and solve policy in src/main/volume/simple_reconstructor_pcg.f90; neither numerical owner imports the other.
Current source comments and generated navigation already describe this ownership. The !@descr records are at src/main/volume/simple_cartesian_pose_refiner.f90:1 and src/main/interp/simple_cartesian_fourier.f90:1. The generated code map records the neutral owner at doc/code_overview/code_base_map.md:410, the pose owner at line 667, the pose test matrix at lines 37–59, and its entry point at line 148. The generated API index records the neutral routines at doc/code_overview/fortran-indexes/api_index.md:2917 and the pose routines at lines 2922–2955. No source-comment or generated-map rewrite is needed in this phase because these current locations match the source and Git history.
The seven tolerance families are frozen, in order, as follows:

Family	Absolute tolerance	Relative tolerance
`algebraic`	`4.9353318740941177E-4`	`5.7686781070864920E-6`
`lm_system`	`2.0599365235796085E-7`	`2.0E-5`
`derivative`	`1.0E-8`	`5.0E-3`
`analytic_dft`	`1.0E-10`	`2.0E-5`
`executed_dft`	`6.1319031142573850E-4`	`3.0E-2`
`slow_gather`	`1.0E-7`	`2.0E-5`
`finite_projection`	`1.0E-5`	`5.0E-2`

The constants and safety factor 8 are in production/tests/simple_pose_cont_refinement_calibration_helpers.f90:9-20. Calibration boxes are 8 and 12. Boxes 10 and 16 remain observed diagnostics. Fresh acceptance holdouts are boxes 14 and 18. - The authoritative Phase 10 package is ~/Projects/continuous_3D_pose_validation_20260831_112536. It was generated from prepared source 397fad74faea53fc046b2e765cf4b62fa218aa27 plus the then-uncommitted Phase 10 validation package, whose complete snapshot is hashed inside the evidence. Package analysis and sha256sum -c MANIFEST.sha256 exited 0. The package contains 18 independently recorded commands: 17 expected-success commands exited 0, and the retained PCG mother exited its expected status 1. - Important authoritative results are: 1,296 configuration rows; 138 capture trials with zero integrity failures; three mechanism volumes and five seeds per volume; PCG best noisy lambda 10 for each half; PCG raw L2 errors 0.6612755 and 0.6608928; conventional raw L2 errors 0.6518738 and 0.6388823; pose-recovery correlation 0.97558; deapodized/non-deapodized correlations 0.95269/0.92741; cropped-kernel relative error 1.651648E-02; ML-kernel relative error 1.017238E-02; prior-adjoint relative error 1.847703E-08; and priored route-parity solution error 3.260160E-05. - Phase decisions are final for this development. Phase 2 established neutral Cartesian and envelope parity and classified the absolute PCG halfset-versus-gridding miss as unchanged from its control. Phase 3 moved pose numerics to the particle owner and removed the obsolete route. Phases 4–8 froze and verified tolerance, objective, LM transaction, CTF/sigma, and independent forward-hierarchy contracts. Phase 9 passed the complete configuration and retained regression matrix. Phase 10 produced and analyzed the authoritative Oracle package. No decision changed a frozen threshold after an acceptance observation. - Residual limits are explicit. The derivatives are local to one fixed KB stencil cell. The full redundant Fourier disk is retained. Capture evidence is a matched deterministic numerical experiment, not a real-data benefit claim. There is no UI key, production caller, persistence contract, distributed orchestration, standalone refine3D mode, or automatic activation. The known PCG halfset reconstruction result remains future work and cannot change a pose fixture, metric, or tolerance. Any production integration requires a new development record and matched real-data validation. - Applicable policies are KB_Interpolation_Policy.md for the executed normalized KB convention, reconstruct3D_pcg_policy.md for the unchanged reconstruction boundary and AC-12 disposition, refine3D_policy.md for particle/volume workflow ownership, phase_shift_ctf_policy.md for signed, disabled, and phase-flipped transfer behavior, and sigma_calculation_policy.md for positive native-shell variance. No UI policy applies because the handoff adds no public route. - Phase 11 validation must use the existing single entry point at production/tests/pose_cont_validation/run_oracle_validation.sh:1. Its hypothesis is reproducibility: the exact final handoff source must again pass all 18 independently status-checked commands, source-snapshot and manifest integrity, removed-route absence, the 1,296-row configuration gate, the frozen forward amendment, and the exact known PCG disposition. The package must be created directly below ~/Projects, every SIMPLE command must run from ~/Projects, and no runtime evidence may be created below the source checkout. This repeat does not prove production or real-data benefit. - Lightweight source checks are PASS. Path-limited git diff --check exited 0. Import-boundary checks found no pose-owner import in PCG, no PCG import in the pose owner, and no non-test caller of the pose owner. The removed pcg_pose_polish and simple_pcg_pose_polisher routes are absent outside the validation package's explicit negative checks. Current source-comment, code-map, and API-index lookups all passed. The only changed file is this living execution record. production/CMakeLists.txt remains unchanged at SHA-256 F850520E053180EA241C5B091D74C5358B87BFC118BA91E043BBA654059412EB. No compilation, runtime test, remote normalization, real transfer, or commit occurs in this prepare turn. The authoritative rsync dry-run command and complete output remain in the controller evidence; any later source or controller-input change invalidates that review.

Oracle validation evidence — 2026-08-31:

The independent phase-order gate exited 0: Phases 0 through 10 were COMPLETE, and Phase 11 was READY FOR ORACLE VALIDATION. The controller source-state checker also exited 0 and verified HEAD=cb1a4dc6f8651af4b9da5f4811209104413e745a, ORIGIN_MASTER=c5dae62b7ce4faeb320a6641126a5cc58dccce13, FILE_COUNT=1516, and SOURCE_DIGEST=5C3D69A2082C21661308A38068324BCDAC5C20D7F26A3FE08822B832EDE4FEBE.
The exact approved rsync -av --delete --info=progress2 command with the exclusions for .git/, .codex/.local-history.git/, build/, *.o, *.mod, *.a, and *.so exited 0. It transferred 82 files, deleted no path, sent 2,110,318 bytes, received 13,261 bytes, and reported total size 152,752,148 bytes and speedup 71.93. The five transfers beyond the reviewed 77-file dry run were active Phase 11 controller evidence created by this validation turn. The approved remote line-ending normalization exited 0 and changed only copied Perl and shell scripts.
After module load gcc/15.2.0, the exact default incremental logged build used mkdir -p build, set -o pipefail, and .codex/compile_debug.sh 2>&1 | tee build/build_debug.log. It exited 0, completed the Debug install with GCC/GFortran 15.2.0, and did not use the conditional clean retry. The generated Git-hash step printed the expected nonfatal warning because the synchronized checkout excludes .git/.
The first runtime launcher exited 1 before the runner or a SIMPLE binary started because PowerShell expanded the remote ${HOME} into a Windows path. It created no evidence directory and is an infrastructure attempt, not a test result. The quote-corrected launcher preserved the remote variables, changed to ~/Projects, invoked production/tests/pose_cont_validation/run_oracle_validation.sh, and exited 0. Its package is ~/Projects/continuous_3D_pose_validation_20260831_121306.
The runner independently resolved and hashed every executable and recorded all 18 commands with /usr/local/cache/mazhar/Projects as the working directory. The 17 expected-success commands exited 0: the 1,296-row configuration matrix; pose mother; fixed-reference, forward-path, matched-window, reference-bias, operator-contract, capture-range, capture-mechanism, tolerance-calibration, objective-normal, LM-transaction, CTF/sigma, and forward-hierarchy cases; neutral Cartesian mother; and the pcg_recon and pcg_priors regressions. Capture evidence retained 138 trials with zero integrity failures, three mechanism volumes, and five seeds per volume. Calibration retained boxes 8 and 12, unsampled holdouts 14 and 18, and safety factor 8.
The retained PCG mother exited its declared status 1. The analyzer accepted it only after it reproduced the frozen Phase 2 disposition: best noisy lambda 10 for each half, PCG raw L2 errors 0.6612755 and 0.6608928, conventional raw L2 errors 0.6518738 and 0.6388823, and the same scale-sensitive assertion. pcg_recon and pcg_priors exited 0. Representative retained values are recovery correlation 0.97558, deapodized/non-deapodized correlations 0.95269/0.92741, cropped-kernel relative error 1.651648E-02, ML-kernel relative error 1.017238E-02, prior-adjoint relative error 1.847703E-08, and priored route-parity solution relative error 3.260160E-05.
Package analysis exited 0 and reported PASS for every status, completion marker, required artifact, source snapshot, removed-route check, frozen forward amendment, 1,296-row count, capture analysis, exact PCG disposition, and runtime-parent check. A separate sha256sum -c MANIFEST.sha256 command exited 0. The compiler log is ~/Projects/hael_SIMPLE-rsync-test/build/build_debug.log; the generated matrix root is ~/Projects/continuous_3D_matrix_volumes_20260831_121755418.
The mandatory post-test path checks exited 0. ~/Projects resolves to /usr/local/cache/mazhar/Projects. The only source checkout used by Phase 11, ~/Projects/hael_SIMPLE-rsync-test, contains no top-level validation/ directory and no top-level continuous_3D_matrix_volumes_* directory. The compiler log is the only permitted validation evidence below the checkout; no A/B control checkout was used.
Source, synchronization, normalization, compilation, runtime completion, package integrity, and scientific acceptance are PASS. The isolated numerical component is reproducibly validated and remains separate from PCG reconstruction. It adds no UI key, production caller, persistence, distributed orchestration, standalone refine3D mode, automatic activation, or real-data benefit claim. The local fixed-cell derivative boundary and the known absolute PCG halfset-versus-gridding result remain explicit limits.

Record commands, package path, source commit, derived/frozen tolerances, metrics, phase decisions, and residual limitations below. Update relevant source comments and code maps with major file and routine locations.

Gate: the isolated numerical component is reproducibly validated and clearly distinguished from PCG reconstruction. No UI, production caller, standalone refine3D mode, or scientific-benefit claim is present; any such work requires a new development record.

Future work — investigate the PCG half-set reconstruction baseline¶

The deterministic halfset_fsc comparison fails identically in unchanged origin/master and the Phase 2 tree: at best lambda 10, PCG has higher raw L2 error than conventional gridding in both halves. Preserve this as a visible PCG-reconstruction issue for scientific handoff. A future assigned investigation should determine whether the behavior is a PCG implementation defect, a changed reconstruction baseline, or an assertion whose scientific premise no longer matches the executed operator. It should reproduce the complete lambda, residual, error, FSC, norm, and iteration trajectories from a clean current baseline before changing code or acceptance criteria. This investigation is outside continuous-pose implementation and must not change pose fixtures, metrics, tolerances, or phase acceptance.

Evidence and decision log¶

2026-08-25: completed research history was consolidated under completed/; replacement documents remained DRAFT.
2026-08-26: rebased commit f78d9dff3 preserved the reviewed parallel contract and plan before conversion to this single living record.
2026-08-26: tolerance calibration and the executed forward-model conventions were approved and consolidated into the contract; execution phases now reference those sections instead of duplicating them.
2026-08-26: the numerical ownership map was approved. It assigns the particle solve to simple_cartesian_pose_refiner, state-independent lattice work to neutral Cartesian Fourier utilities, and reconstruction policy to the unchanged PCG owner.
2026-08-26: the final-plan audit covered the newest upstream commit, relevant file history, live callers, production activation, test scheduling, validation runners, generated documentation, and local execution tooling. Upstream commit 77e90026b is unrelated to this work.
2026-08-26: the contract became FINAL (FROZEN), the execution plan became FINAL, and Phase 1 completed with AC-1 through AC-12 mapped to explicit phases and gates.
2026-08-26: the local persistent-session runner was updated to this living note and statically validated. It enforces Phases 2-11, separate prepare/validate turns, explicit Oracle approvals, post-turn phase gates, no prepare-turn commit, and exactly one focused local commit after a successful validate turn. No agent phase or external operation was run.
2026-08-26: the first attempted Phase 2 prepare launch stopped before session creation because Codex CLI rejected the simultaneous -s workspace-write and --approve-for-me options. The runner was aligned with the working RELION controller by retaining --approve-for-me and removing the conflicting explicit sandbox option. No source edit, rsync, compilation, runtime test, or phase-status change occurred; Phase 2 remains NOT STARTED.
2026-08-27: Phase 2 completed by scientific-owner decision after the matched A/B showed that neutral extraction preserved the decisive PCG reconstruction behavior. The unchanged control and Phase 2 arm both retain the same unresolved absolute halfset_fsc PCG-versus-gridding failure; that reconstruction issue is recorded separately and does not authorize a continuous-pose metric, fixture, or threshold change. Phase 3 will split and rename the tests under pose_cont_refinement, neutral Cartesian-Fourier, and explicit PCG-reconstruction owners.
2026-08-28: Phase 8's 25/28 result showed that the original identity/four-mode forward calibration did not cover the arbitrary-rotation full-disk acceptance domain. Scientific review reopened only executed_dft, slow_gather, and finite_projection; approved a matched finite-object projection contract and separate clipping/interpolation diagnostics; retained boxes 10 and 16 as observed diagnostics; and authorized Phase 5 BLAS and Phase 6 LAPACK reinforcement under their unchanged tolerances.
2026-08-28: The reopened Phase 4 source now proposes full-disk, four-rotation calibration over two asymmetric volumes at boxes 8 and 12, with matched finite-object projection comparison and separate clipping/interpolation diagnostics. Phase 5 adds a direct BLAS accumulation oracle, and Phase 6 adds a LAPACK DPOSV solve oracle. Static inspection passed; compilation, runtime, tolerance freezing, and fresh holdout acceptance remain pending. Phase 8 is the handoff boundary.
2026-08-30: Oracle package pose_cont_revalidation_20260830_231612 confirmed the frozen forward amendment and passed the BLAS and LAPACK revalidations with all three exit statuses equal to zero. Focused commit 8d619aaee records the Phase 4–6 implementation. Phase 8 is ready for rework on fresh boxes 14 and 18 under the explicit handoff above.

Implementation now resumes with the Phase 8 prepare turn. A failed gate stops later phases. The agent must implement the frozen fresh-holdout and matched finite-object contract before Oracle validation; Phase 9 remains prohibited until AC-6 passes.