From f0dc42a280e710e2423e7390b7a331b61f67de9c Mon Sep 17 00:00:00 2001
From: "KOKO\\Mimi" <kjkim2584@gmail.com>
Date: Tue, 22 Sep 2026 21:38:42 +0900
Subject: [PATCH] feat: implement consistent-mass HHT shell dynamics

---
 HANDOFF.md                                    |    2 +
 docs/hht-implicit-dynamics/ADR.md             |   10 +
 .../implementation-numerical-review.md        |   49 +
 docs/hht-implicit-dynamics/io-contract.md     |    2 +-
 .../numerical-controls.md                     |    2 +-
 .../physics-evaluation.md                     |   47 +
 .../fesa/analysis/dynamic_analysis_state.h    |  113 ++
 include/fesa/analysis/hht_dynamic_procedure.h |   29 +
 include/fesa/analysis/hht_time_integration.h  |   50 +
 include/fesa/analysis/newton_iteration_log.h  |   27 +
 include/fesa/analysis/prepared_analysis.h     |   17 +-
 .../fesa/elements/nonlinear_mitc4_inertia.h   |  106 ++
 include/fesa/elements/nonlinear_mitc4_shell.h |   17 +-
 .../io/hdf5/dynamic_hdf5_results_writer.h     |   20 +
 include/fesa/results/dynamic_results_writer.h |   28 +
 scripts/verification/compare_hht_dynamic.py   |  406 +++++++
 src/fesa/CMakeLists.txt                       |    7 +
 src/fesa/analysis/dynamic_analysis_state.cpp  |  406 +++++++
 src/fesa/analysis/hht_dynamic_algebra.cpp     |  732 ++++++++++++
 src/fesa/analysis/hht_dynamic_assembly.cpp    |  483 ++++++++
 src/fesa/analysis/hht_dynamic_internal.h      |  102 ++
 src/fesa/analysis/hht_dynamic_procedure.cpp   |  322 +++++
 src/fesa/analysis/hht_time_integration.cpp    |   97 ++
 src/fesa/analysis/newton_iteration_log.cpp    |   83 ++
 src/fesa/analysis/prepared_analysis.cpp       |   38 +-
 src/fesa/app/fesa_application.cpp             |   13 +-
 src/fesa/elements/nonlinear_mitc4_inertia.cpp |  871 ++++++++++++++
 src/fesa/elements/nonlinear_mitc4_shell.cpp   |  427 +++++--
 .../io/hdf5/dynamic_hdf5_results_writer.cpp   | 1017 ++++++++++++++++
 tests/CMakeLists.txt                          |    8 +
 tests/test_compare_hht_dynamic.py             |  302 +++++
 .../analysis/dynamic_analysis_state_test.cpp  |  305 +++++
 .../analysis/hht_dynamic_algebra_test.cpp     |  330 ++++++
 .../analysis/hht_dynamic_procedure_test.cpp   |  125 ++
 .../analysis/hht_energy_verification_test.cpp |  223 ++++
 .../hht_temporal_verification_test.cpp        |  507 ++++++++
 .../analysis/hht_time_integration_test.cpp    |   97 ++
 .../analysis/newton_iteration_log_test.cpp    |  150 +++
 .../elements/nonlinear_mitc4_inertia_test.cpp | 1051 +++++++++++++++++
 .../nonlinear_mitc4_shell_tangent_test.cpp    |  162 +++
 .../hdf5/dynamic_hdf5_results_writer_test.cpp |  636 ++++++++++
 41 files changed, 9294 insertions(+), 125 deletions(-)
 create mode 100644 docs/hht-implicit-dynamics/implementation-numerical-review.md
 create mode 100644 docs/hht-implicit-dynamics/physics-evaluation.md
 create mode 100644 include/fesa/analysis/dynamic_analysis_state.h
 create mode 100644 include/fesa/analysis/hht_dynamic_procedure.h
 create mode 100644 include/fesa/analysis/hht_time_integration.h
 create mode 100644 include/fesa/elements/nonlinear_mitc4_inertia.h
 create mode 100644 include/fesa/io/hdf5/dynamic_hdf5_results_writer.h
 create mode 100644 include/fesa/results/dynamic_results_writer.h
 create mode 100644 scripts/verification/compare_hht_dynamic.py
 create mode 100644 src/fesa/analysis/dynamic_analysis_state.cpp
 create mode 100644 src/fesa/analysis/hht_dynamic_algebra.cpp
 create mode 100644 src/fesa/analysis/hht_dynamic_assembly.cpp
 create mode 100644 src/fesa/analysis/hht_dynamic_internal.h
 create mode 100644 src/fesa/analysis/hht_dynamic_procedure.cpp
 create mode 100644 src/fesa/analysis/hht_time_integration.cpp
 create mode 100644 src/fesa/elements/nonlinear_mitc4_inertia.cpp
 create mode 100644 src/fesa/io/hdf5/dynamic_hdf5_results_writer.cpp
 create mode 100644 tests/test_compare_hht_dynamic.py
 create mode 100644 tests/unit/analysis/dynamic_analysis_state_test.cpp
 create mode 100644 tests/unit/analysis/hht_dynamic_algebra_test.cpp
 create mode 100644 tests/unit/analysis/hht_dynamic_procedure_test.cpp
 create mode 100644 tests/unit/analysis/hht_energy_verification_test.cpp
 create mode 100644 tests/unit/analysis/hht_temporal_verification_test.cpp
 create mode 100644 tests/unit/analysis/hht_time_integration_test.cpp
 create mode 100644 tests/unit/elements/nonlinear_mitc4_inertia_test.cpp
 create mode 100644 tests/unit/io/hdf5/dynamic_hdf5_results_writer_test.cpp

diff --git a/HANDOFF.md b/HANDOFF.md
index bf8b950..027ab1b 100644
--- a/HANDOFF.md
+++ b/HANDOFF.md
@@ -214,3 +214,5 @@ PowerShell helper의 `-B`는 named parameter로 잘못 bind될 수 있어 위 ar
 - 2026-09-22 初回記録: 本文のsnapshot作成。Reference16/100受理、最新Debug focused実行中。Comparator41testsのmain再実行PASSを確認。今後も作業を継続する。
 
 - 2026-09-22 후속 확인: 독립 physics reviewer가 `physics-evaluation.md` 초안을 작성했다. 최신 Debug focused는 68 tests 중67 PASS/1 C04a INCONCLUSIVE SKIP으로 종료했다. Main은 다음 명령에서 종료코드와 summary를 직접 확인한다. C08 및 최종 reference 검증은 계속 PENDING이다.
+
+- 2026-09-22 후속 작업: main이 Debug focused session81971 종료코드0을 직접 확인했다. 68 tests/67 PASS/1 INCONCLUSIVE SKIP, 총117.526s. Comparator41tests도 main 확인 완료. 구현 묶음을 로컬 커밋한 뒤 C08 파일을 등록한다. 신규 private test는 아직 이 Debug 실행에 포함되지 않았다.
diff --git a/docs/hht-implicit-dynamics/ADR.md b/docs/hht-implicit-dynamics/ADR.md
index 4a22476..7c56df2 100644
--- a/docs/hht-implicit-dynamics/ADR.md
+++ b/docs/hht-implicit-dynamics/ADR.md
@@ -78,3 +78,13 @@ Feature 범위·상태는 [PRD](PRD.md), 상세 acceptance intent는 [requiremen
 - 승인 근거: 사용자의 “I/O definition, implementation, physics evaluation gate 모두 진행하세요” 및 후속 “깃에 커밋 하면서 진행하세요”.
 - 결정: HHT-ADR-006의 검토된 physical a/auxiliary A 분리, 0+ full STEP 초기화, HHT-ADR-007의 consistent mass를 실제 구현 대상으로 채택한다. 공개 입력은 [I/O 계약](io-contract.md)의 단일 NLGEOM shell DIRECT·기본 계수·zero 초기조건/고정 BC·constant force CLOAD subset이다. 별도 dynamic state와 dynamic-only HDF5 schema v1을 추가하고 기존 static/eigen 계약은 보존한다.
 - 영향: [구현 계획](implementation-plan.md)에 따라 MSVC Debug build/CTest, 독립 수치·물리 검증과 지정 원본 reference 비교를 수행한다. 확인된 문서·검증된 구현 묶음을 현 branch에서 순차 커밋한다. 외부 solver 실행·reference 보정·push/release는 포함하지 않는다. 실패·미실행 검증을 통과로 표시하지 않는다.
+
+
+## HHT-ADR-010 — Newton 시작 형상과 영변형 산술
+
+- 상태: `accepted-implementation-detail`; reference 통과를 의미하지 않는다.
+- Owner: 메인 assistant; 독립 수치 검토는 numerical-review-agent.
+- 근거: 승인된 전체 구현 범위 안의 수치 시작값 선택. `.harness/build/hht-numerical/zero-trial-red.log`와 original reference 실행에서 먼저 실패를 재현했다.
+- 결정: 모든 increment의 Newton 초기 좌표를 `q_n`으로 둔다. Constant-A 외삽은 지정 DIRECT h=.1에서 최초 trial geometry를 무효화했으므로 N2의 시작값을 명시적으로 갱신한다. HHT predictor/rate/접선, alpha/beta/gamma, 고정 dt, Newton100 및 모든 tolerance는 유지한다. 유효한 시작점에서 나온 correction도 chart/geometry 밖이면 즉시 실패하며 retry·clamp·cutback은 없다.
+- 추가 수정: 초기 형상에서 차감한 큰 covariant metric 대신 `delta g`로 Green strain과 `F=I+delta g⊗Gdual`을 계산한다. 수학적으로 같은 식이며 영변형에서 생긴 artificial drilling force를 제거한다. 강성·정적 결과 영향은 기존 regression으로 확인한다.
+- 검증: decimal 좌표 영변형 exact-zero 회귀, finite/warped scalar drilling constraint·gradient·Hessian, 작은각 D3 threshold 검사가 통과했다. 상세 실행/물리 acceptance는 최종 implementation evidence에서 구분한다.
diff --git a/docs/hht-implicit-dynamics/implementation-numerical-review.md b/docs/hht-implicit-dynamics/implementation-numerical-review.md
new file mode 100644
index 0000000..c9a91ec
--- /dev/null
+++ b/docs/hht-implicit-dynamics/implementation-numerical-review.md
@@ -0,0 +1,49 @@
+# HHT 관성 구현 독립 수치 검토
+
+- Owner: `numerical-review-agent`; date: `2026-09-22`.
+- 상태: `source-delta-reviewed; runtime-verification-pending`. 수식/API 중간 검토이며 전체 구현 gate 통과 판정이 아니다.
+- 범위: [관성 API](../../include/fesa/elements/nonlinear_mitc4_inertia.h), [관성 구현](../../src/fesa/elements/nonlinear_mitc4_inertia.cpp), [관성 tests](../../tests/unit/elements/nonlinear_mitc4_inertia_test.cpp), [비선형 내력](../../src/fesa/elements/nonlinear_mitc4_shell.cpp)의 directional third-derivative, [초기화·null algebra](../../src/fesa/analysis/hht_dynamic_algebra.cpp), [동적 조립](../../src/fesa/analysis/hht_dynamic_assembly.cpp), [HHT procedure](../../src/fesa/analysis/hht_dynamic_procedure.cpp).
+- 기준: [정식화](formulation.md), [관성 상세](formulation-inertia.md), [N1–N7](numerical-controls.md), [C01–C12](verification-cases.md). Source/tests/상위 계약은 읽기 전용이다.
+
+## 첫 검토 findings
+
+아래는 작업 중 최초로 관찰한 내용이다. Owner 수정 뒤의 대조·실행 evidence는 별도로 갱신한다.
+
+| ID | 심각도·상태 | 관찰·수정과 필요한 검증 |
+| --- | --- | --- |
+| HHT-IMP-NR-001 | **P1; source corrected, execution pending** | `Inverse(JetMatrix)`의 cyclic minor에 이미 포함된 cofactor 부호를 다시 적용하던 오류가 제거됐다. 새 test가 독립 `Jl^-T`와 현재 null, finite rotation의 `M n=0`을 대조한다. 실행 evidence 확인 전이다. |
+| HHT-IMP-NR-002 | **P2; corrected, focused regression passed** | `convective_force=force-M*a` cancellation을 직접 `∫rho Hᵀ B_x[v,v]dV0` 누적으로 수정했다. 같은 q/v에서 a를 `1e15`배 변경해도 c가 동일한지 검사하는 test의 통과 로그를 확인했다. |
+| HHT-IMP-NR-003 | **P2; corrected, focused sweep passed** | 최초 raw mixed-unit direction/`1e-5` test를 D scaling/단위 direction, N5 `1e-6`·연속한 두 내부 sweep 점으로 수정했다. Position/velocity/acceleration partial 및 두 h의 dependent-rate effective inertia tangent, pure translation/rotation/mixed 방향과 해당 실행 통과를 확인했다. |
+| HHT-IMP-NR-004 | **미완료 coverage; 실행 대기** | 새 N4 guard는 analytic null의 20차원 직교 여공간에서 scaled symmetry/null, positive Cholesky와 `rcond_inf>=2^-32`를 검사한다. 물리 DOF를 numeric rank cutoff로 삭제하지 않는다. C05/C06의 finite rotation·warped/oracle·D3·단위변환 test와 실행 evidence는 owner 완료 후 확인한다. |
+| HHT-IMP-NR-005 | **P2; corrected, threshold regression passed** | 작은 각에서 기존 직접 삼각함수 D3의 cancellation 위험을 안정 series로 수정했다. `|phi|<.5`의 squared-norm 9차 coefficient recurrence와 최종 회전행렬 extras 복사를 대조했으며 작은각 경계 양쪽을 포함한 4개 C++ sweep의 통과를 확인했다. |
+| HHT-IMP-NR-006 | **P2; closed, exact scale restored** | 기존 `Σe |D²f_e[v,v]|`는 element 내부 coordinate-pair 상쇄를 잃어 N3와 달랐다. 수정본은 아래 exact scalar ψ Hessian을 global `(q_j,q_k)` identity로 합친 **뒤** `Σjk |ψ_qq,jk v_j v_k|`를 누적하고 algebra가 이를 소비한다. N3/[I/O 계약](io-contract.md) 의미와 일치한다. Finite/warped ψ·gradient·Hessian 독립 test 통과도 확인했다. |
+| HHT-IMP-NR-007 | **P2; source corrected, execution pending** | 최초 `BuildPhysicalSpace`에 없던 N4 `PᵀZ` 및 `[P Z]` Gram guard가 추가됐다. Nodal sparse block의 실제 free dimension과 global Frobenius 오차, normalized null Gram을 검사하며 `1e-12` 기준을 유지한다. 수정본 실행 evidence는 대기다. |
+| HHT-IMP-NR-008 | **수치 절차 변경; 문서 정합성 필요** | Reference의 큰 DIRECT step에서 constant-A 초기 추정이 geometry를 벗어나, Newton 시작 좌표를 `q_n`으로 변경했다. HHT predictor/종속 rates/endpoint 식은 그대로이며 cutback/retry도 없어 수식 변경은 아니다. 다만 N2가 기존 시작값을 명시하므로 새 deterministic 시작값과 실패 동작을 N2에 명시해야 한다. 기존 문구 상태로 계약 일치를 주장하지 않는다. |
+
+NR-001의 독립 scalar 반례: `phi=(.5,0,0)`, `d0=eZ`, Jl의 yz block은 `[[sin(.5)/.5,−(1−cos(.5))/.5],[(1−cos(.5))/.5,sin(.5)/.5]]`다. 관찰한 inverse 식을 적용하면 unit null의 yz 성분이 `(-.6816387600,.7316888689)`이고 `||B n||=||(Jl n)×d||=.4744471057`이다. Python 표준 산술로 실제 계산했다. 이는 zero rotation에서 숨는 부호 오류이며 같은 잘못된 n을 미분한 finite-difference test만으로는 검출되지 않는다.
+
+## 일치한 수식과 남은 대조
+
+최초 snapshot의 `H`, `B_x`, `C_x` 조립과 `I=∫rho Hᵀ(Ha+B_x[v,v])`, `DqI`, `DvI=2∫rho HᵀB_x[v,p]`, `M`의 표시된 index contraction은 정식화와 일치했다. `P/L` 및 `Pdot/Ldot`는 같은 현재 x와 물리적 acceleration을 사용하고 `Ldot=∫rho x×xddot`의 `v×v=0` 항등식과 맞는다. Referenced density/measure, 3³ mass quadrature, current geometry 검사와 fixed-global rate 의미도 대조했다. 이것은 runtime 통과 판정이 아니다.
+
+Internal Jet의 product 6항 및 Compose의 `f''' x_i x_v²+f''(2x_iv x_v+x_i x_vv)+f' x_ivv`를 독립 대조했다. Atan2의 bounded-ratio 미분은 quadrant 상수의 미분이 0인 점과 맞으며 기존 first/second reduction을 유지한다. 반환 `force_directional_second=D²f_int[v,v]`, `drilling_metric=Σkd gradγ⊗gradγ` 및 physical/drilling force·energy 분리는 정식화와 일치한다. 실제 procedure의 hidden-constraint 연결은 이 kernel 범위 밖이며 별도 검증이 필요하다.
+
+NR-005의 독립 scalar 검산은 `phi=(θ,0,0), d0=eZ`에 대해 `D³d_x[eX,eX,eZ]=cosθ/θ−2sinθ/θ²+2(1−cosθ)/θ³`와 안정 전개 `−θ/4+θ³/36−θ⁵/960+θ⁷/50400`를 Python binary64로 비교했다. `θ=1e-4`에서 각각 `−7.7441382018e-5`, `−2.4999999972e-5`, 대칭 상대오차 `0.512`이고 `θ=1e-4*(1+2^-10)`에서 `0.339`다. 이는 algebraic scalar cancellation의 재현이며 수정 전 C++ Jet 출력 자체를 실행했다고 주장하지 않는다. 관성 rotation kernel의 32항 matrix exponential series에는 같은 직접 뺄셈이 없다. `|phi|<pi`에서 그 D3 truncation tail의 exact-arithmetic 상계는 `pi^30/30!/(1−pi/31)<3.45e-18`이며 binary64 roundoff 검증은 별개다.
+
+NR-006의 최소 exact 구현 경로는 공개 moment-load가 0이고 동일 nodal initial director를 공유하는 현 범위에서 `κ_i=||Jl^-1d_i||`, `σ_i=1/κ_i`, `ψ_i=σ_i Σ_(e∋i)kd_e γ_ei`를 2차 미분하는 것이다. `δphi_i=n_i`는 `δtheta_i=σ_i d_i`를 만들어 모든 director와 element polar rotation을 고정하고 nodal R을 오른쪽 drilling 회전시킨다. 따라서 `Dγ_ej[n_i]=δij σ_i`, `n_iᵀf_phys=0`이다. σ는 현재 phi의 함수이므로 Hessian에서 동결하지 않는다. `Jl^-1d=Jr^-1d0=d0+.5 phi×d0+a(phi²)phi×(phi×d0)`로 σ를 안정 계산할 수 있다. 이 scalar ψ의 element-local Hessian을 source identity로 합친 뒤 `Σjk|ψ_i,qjqk||v_j||v_k|`를 계산하면 full energy D3 tensor 없이 N3 분모를 얻는다. 이는 승인 정식화의 항등식이며 scale 계약 변경이 아니다. 실제 code에서는 finite/warped 상태의 `nᵀf` 및 ψ gradient/Hessian과 독립 대조하고 수치 polar가 proper rotation으로 수렴하는 범위를 확인해야 한다.
+
+## 초기화·procedure delta와 실행 evidence
+
+`a_P=D P (Pᵀ DᵀM D P)^-1 PᵀDᵀ(F−f−c)` 뒤 `W^-1 ψ_q N W^-1` solve와 `N W^-1` 복원으로 null acceleration을 구하는 구현은 부호·단위와 맞는다. `ψ_q=DNᵀg+NᵀK`, raw hidden2의 `D²N[v,v]ᵀg+2DN[v]ᵀKv+NᵀD²f[v,v]+ψ_q a`도 일치한다. Null은 현재 `Jl^-1d`와 실제 free BC의 exact intersection으로 결정하며 작은 비영 constrained 성분을 버리지 않는다. Accepted null inventory 변경은 실패한다. Scaled physical mass factor와 W-scaled algebraic rcond 검사에는 epsilon mass/numeric rank deletion이 없다.
+
+Newmark의 q/v는 A를 사용하고 물리 a는 `(A+alpha*a_old)/(1+alpha)`로 회복한다. Effective tangent의 rate 계수, force/moment 별 uncancelled Newton scale, 네 correction gate, 100번째 correction 뒤 재평가, fixed DIRECT `n*h`, endpoint reaction 및 현재 arm/`Jl^-T` spatial moment balance를 대조했다. Constant STEP load의 work `F·q`와 `T+Uphys+Udrill−E0−W`는 현 하중 범위와 맞으며 energy 감소를 강제하지 않는다. 이것은 실제 moving-shell 시간 정확도 인증이 아니다.
+
+메인 실행 로그를 독립 열람했다. [focused.log](../../.harness/build/hht-numerical/focused.log)는 관성 8 tests와 일반 finite-rotation internal D3 sweep, HHT helper 3 tests의 통과를 보인다. 같은 실행 전체는 당시 mapper/writer 7 failures가 있어 전체 PASS가 아니다. `DynamicRotation.*`의 inverse/null/D3 oracle suite는 이 로그에 없어 별도 실행 확인이 필요하다. 당시 없었던 internal 작은각 threshold fixture는 아래 후속 로그에서 통과했다.
+
+[focused-procedure.log](../../.harness/build/hht-numerical/focused-procedure.log)는 algebra 7/8, all-fixed procedure, state/writer/log 통과와 총 37개 중 2개 실패를 보인다. Algebra 경계 fixture는 이후 `W=I`, `diag(1,2^-k)`로 binary-exact threshold를 검사하도록 고쳤으나 이 보고서 시점 재실행 evidence는 대기다. 나머지 실패는 mapper diagnostic fixture다. 기존 로그를 새 소스 전체 통과로 소급하지 않는다.
+
+후속 [focused-exact-constraint.log](../../.harness/build/hht-numerical/focused-exact-constraint.log)는 internal residual 7 tests의 통과를 보이며, NR-005의 작은각 4 fixtures와 NR-006의 finite/warped exact ψ·gradient·Hessian 검사를 포함한다. [zero-trial-red.log](../../.harness/build/hht-numerical/zero-trial-red.log)의 기존 영변형 spurious force 실패도 확인했다. 수정 `CovariantIncrement`의 `2E=G·δg+δg·G+δg·δg`, drilling `F=I+δg⊗Gdual`는 큰 기준값의 뺄셈을 피하는 동일 수식이다. `q=0`의 exact-zero 회복은 force clamp나 tolerance 완화가 아니다. 새 zero-trial test의 통과를 확인했다. Recovery·기존 정적 영향은 전체 회귀 검사 대상이다.
+
+C04a는 판정을 분리한다. 위 로그에서 finest binary64 full/reduced acceleration 차이 약 `3.079e-10`이 `1e-10`을 넘었지만 N7 해상도 약 `6.296e-10` 이하다. q/v/physical-a의 시간차수·오차/noise 검사와 coarse reduction은 별개다. N7에 따라 finest reduction은 **INCONCLUSIVE**로 남길 수 있으며 threshold를 바꾸지 않는다. [decimal80 독립 검산](../../.harness/build/hht-numerical/c04a-decimal-reduction.json)의 full 2×2/scalar recurrence 차이 `<=1.70e-73`은 수학적 reduction을 지지하지만 FESA binary64의 `1e-10` 통과를 대신하지 않는다. 새 test는 시간수렴/coarse gate와 finest `GTEST_SKIP`을 분리했으며 이 보고서에서는 새 바이너리 재실행을 아직 확인하지 않았다. C04a 전체를 무조건 PASS로 합치지 않는다.
+
+Build/CTest는 메인/구현 owner가 담당하며 reviewer가 별도 C++ 실행을 했다고 주장하지 않는다. 문서 `git diff --check`는 exit 0이다. NR-008 문서 정합성, 새 algebra/rotation oracle 실행, 실제 shell의 시간수렴·energy·moving-null·reference 검증이 남는다. 본 보고서는 전체 기능/물리 gate 통과 판정이 아니다.
diff --git a/docs/hht-implicit-dynamics/io-contract.md b/docs/hht-implicit-dynamics/io-contract.md
index d6c664b..bfc9911 100644
--- a/docs/hht-implicit-dynamics/io-contract.md
+++ b/docs/hht-implicit-dynamics/io-contract.md
@@ -122,7 +122,7 @@ Generalized force 계열 component_names=`F1,F2,F3,MPHI1,MPHI2,MPHI3`, units=`fo
 
 Energy의 W=F*ᵀ(qn-q0), defect=T+Uphys+Udrill-E0-W다. Initial physical energy E0는 frame0의 첫 세 성분 합이며 W0/defect0=0. A를 kinetic energy나 physical inertia에 쓰지 않는다. Algorithmic dissipation을 physical damping energy로 이름 붙이지 않는다. Raw momentum/hidden diagnostics는 위 internal frame의 필수 evidence이며 이번 persistent schema에는 별도 필수 dataset을 추가하지 않는다. HDF5에서 계산할 수 없는 상세 검증은 실행 보고서가 internal evidence를 기록한다.
 
-`/diagnostics`는 기존 diagnostic compound의 severity/code/source_file/source_line/keyword/entity_identity/message와 정렬을 재사용한다. Writer는 전체 frames/node/element inventory, dtype/rank/component/attrs/time/finite/constraint, complete final frame를 검사하고 write/flush/close/reopen/self-check 후 원자 replace한다. 기존 final file은 실패 시 보존한다. Live log의 이미 flush된 prefix는 rollback하지 않는다. No-op warning이 있어도 필수 dataset을 생략할 수 없다.
+`/diagnostics`는 기존 diagnostic의 의미·dtype·정렬을 재사용하되 dynamic compound field 이름을 severity/code/source_file/source_line/keyword/entity_identity/message로 명시한다. 기존 static writer의 file/line 이름은 이 dynamic schema에 적용하지 않는다. Writer는 전체 frames/node/element inventory, dtype/rank/component/attrs/time/finite/constraint, complete final frame를 검사하고 write/flush/close/reopen/self-check 후 원자 replace한다. 기존 final file은 실패 시 보존한다. Live log의 이미 flush된 prefix는 rollback하지 않는다. No-op warning이 있어도 필수 dataset을 생략할 수 없다.
 
 ## 4. 진단과 비교 binding
 
diff --git a/docs/hht-implicit-dynamics/numerical-controls.md b/docs/hht-implicit-dynamics/numerical-controls.md
index 889610c..f35de16 100644
--- a/docs/hht-implicit-dynamics/numerical-controls.md
+++ b/docs/hht-implicit-dynamics/numerical-controls.md
@@ -29,7 +29,7 @@
 
 모든 적용 가능한 gate의 **AND**다. a와 A의 서로 다른 chain-rule 계수를 반영한다. h-based rate gate는 증가량의 운동학 일관성을 검사하며 physical acceleration의 시간 정확도를 인증하지 않는다. 해당 정확도는 N7의 독립 검증으로 확인한다.
 
-Newton 초기 추정은 constant-acceleration `q_trial=q_p+beta h² A_n`으로 둔다. 이는 Newton 시작값이며 시간 scheme 변경이 아니다. 모든 trial에서 고정 q/v/a/A 성분은 exact 0이다. Residual이 이미 통과하는 초기 추정은 correction=0으로 명시하여 동일 gate를 평가한다. 그 외에는 `Keff`를 매회 새로 조립하고 correction을 수정 없이 적용한 후 residual을 다시 검사한다. Initial guess가 chart/geometry 밖이면 실패이며 clamp·line search·cutback으로 바꾸지 않는다.
+Newton 초기 추정은 직전 accepted geometry `q_trial=q_n`으로 둔다([HHT-ADR-010](ADR.md)). `q_p`, `v_p` 및 물리 a/보조 A의 관계는 정식화 그대로 유지한다. 이는 Newton 시작값이며 시간 scheme 변경이 아니다. 모든 trial에서 고정 q/v/a/A 성분은 exact 0이다. Residual이 이미 통과하는 초기 추정은 correction=0으로 명시하여 동일 gate를 평가한다. 그 외에는 `Keff`를 매회 새로 조립하고 correction을 수정 없이 적용한 후 residual을 다시 검사한다. Initial guess가 chart/geometry 밖이면 실패이며 clamp·line search·cutback으로 바꾸지 않는다.
 
 최대 **100개의 Newton correction**을 허용한다. 100번째 correction 뒤의 candidate가 모든 gate를 만족하면 통과, 아니면 실패하며 101번째 solve는 없다. 기존 정적 100회/no-cutback 제한을 동일 실패 상한으로 채택한 것이고, 동적 문제가 100회 안에 수렴한다는 보장은 아니다. Backend success나 작은 correction 하나만으로 성공하지 않는다. Singular/invalid/nonfinite/linear backward-error failure는 즉시 실패다.
 
diff --git a/docs/hht-implicit-dynamics/physics-evaluation.md b/docs/hht-implicit-dynamics/physics-evaluation.md
new file mode 100644
index 0000000..bcc6b30
--- /dev/null
+++ b/docs/hht-implicit-dynamics/physics-evaluation.md
@@ -0,0 +1,47 @@
+# HHT 동해석 물리 평가
+
+- Owner: `physics-evaluation-agent`; 검토일: `2026-09-22`.
+- 판정: **PENDING — 실제 shell C08 및 완료된 원본 reference/HDF5 evidence 대기**. 제한된 oscillator·관성 kernel 결과는 물리적으로 일관되지만 전체 physics gate 통과를 뜻하지 않는다.
+- 적용 계약: [정식화](formulation.md), [관성 상세](formulation-inertia.md), [N1–N7](numerical-controls.md), [C01–C12](verification-cases.md), [reference mapping](reference-model.md), [I/O](io-contract.md). [독립 구현 수치 검토](implementation-numerical-review.md)와 구분한다.
+
+## 우선순위별 findings
+
+| ID | 상태 | 근거·영향·후속 owner |
+| --- | --- | --- |
+| HHT-PHY-001 | **필수 evidence 미완료** | C08a의 독립 volume forcing/전체 shell 좌표 시간수렴과 C08b의 자유 변형 shell 에너지·운동량·hidden defect 결과가 아직 없다. C01–C07과 작은 reference 변위로 유한회전 shell DAE의 물리적 적절성을 대신 입증할 수 없다. 구현 owner의 C08 결과를 검토해야 한다. |
+| HHT-PHY-002 | **필수 reference 대기** | 원본 계산의 부분 Newton 로그만 존재한다. 완료된 101-frame 공식 HDF5와 C12 202-family 비교 결과를 아직 검토하지 못했다. 부분 accepted increment는 원본 전체 해석·평형·비교 통과가 아니다. |
+| HHT-PHY-003 | **Debug 후속 실행 확인** | 기존 `focused-optimized.log`는 42 PASS/1 SKIP/1 FAIL이었다. 후속 `focused-debug-complete.log`는 68개 중 67 PASS/1 SKIP이며 `LargeDirectStepStartsFromAcceptedGeometry`도 PASS다. 이전 로그를 소급해 통과로 바꾸지 않는다. 구성된 전체 CTest 결과와는 구별한다. |
+| HHT-PHY-004 | **C04a finest reduction INCONCLUSIVE** | Binary64 full/reduced physical acceleration 차이 `3.0790209097630861e-10`은 기존 `1e-10`보다 크고 N7 산술/solve 해상도 `6.2961354117696263e-10`보다 작다. 시간수렴 통과와 구별한다. Decimal80 최대 차이 `1.6934145088608964e-73`은 수학적 reduction 근거이며 FESA binary64 통과 증거가 아니다. |
+
+## 확인한 물리 근거
+
+실행 주체는 구현 owner다. Reviewer는 아래 로그와 원본 CSV를 읽고 표시된 수치로 독립 계산했으며 C++ solver를 별도 재실행하지 않았다. 단위는 일관된 입력 단위계다.
+
+| 검사 | 관찰·계산 | 해석과 한계 |
+| --- | --- | --- |
+| C01/C03/C04a/C04b 시간수렴 | `focused-stable-kernel.log`의 `h=1/128→1/256` 전체 시점 최대오차로 `log2(e_h/e_h2)`를 재계산: q/v/a 각각 C01 `1.99978/1.99931/1.99978`, C03 `1.99994/1.99768/1.99944`, C04a `1.99993/1.99746/1.99992`, C04b `1.99968/1.99982/2.00237`. C03 naive q order `0.899645` | Smooth variable mass와 moving-null 제한 모델에서 승인 확장의 약 2차 수렴 및 잘못된 질량 확대의 구별을 지지한다. Shell의 증명은 아니다. |
+| C04b hidden defects | Finest `max|q·v|=6.72614e-10`, `max|q·a+v²|=3.16003e-6`; 이전 두 grid에서 각각 감소 | C04b `1e-6/1e-4` 이내. Position-level 평형만으로 rate consistency를 주장하지 않는 계약과 맞는다. |
+| C07 alpha=0 | `max|E−E0|/E0=1.14353e-13`, 한계 `1e-10` | 선형 무감쇠 평균가속도 한계의 에너지 보존 지지. |
+| C07 기본 alpha | 최대 energy defect `2.72922e-5`, 종단 signed defect `−2.45134e-5`, displacement error `0.0016895`, phase error `−0.00185687` | 관측된 소산·위상 변화는 algorithmic 효과다. 물리 damping이나 비선형 매-step 단조 감소로 해석하지 않는다. |
+| C07 spectrum | `omega*h=10/100/1000`의 spectral radius `0.913168/0.904853/0.904763`; 해석적 limit `.95/1.05=0.9047619048` | 기본 음수 alpha의 고주파 소산 방향과 한계에 일치. 마지막 finite frequency와 limit의 exact equality를 요구하지 않는다. |
+| C07 관성 반력 | `SupportReactionUsesPhysicalAccelerationAndCoupling` PASS. 계약 모델에서 constrained acceleration=0이어도 `R2=M21*a1=.5*a1` | Support-on-structure 부호와 physical endpoint 반력의 근거다. `A` 또는 weighted constrained residual을 반력으로 대체할 수 없다. |
+| C05/C06 관성·회전 | Optimized 로그에서 관성 8 tests, 회전 4 tests PASS: rectangle 질량/null, warped 독립 volume energy/power, 단위·global-frame 변환, finite-rotation inverse/null, 독립 D3 anchors, 누락 mutation 검출 | Current consistent mass, 양의 물리 질량과 무질량 drill, 관성 power의 국소 근거다. Test 이름의 PASS를 전역 shell 운동량·시간수렴 통과로 확대하지 않는다. |
+| 대수 초기화·rigid limits | Algebra 8 tests와 all-fixed procedure PASS. Internal zero-trial 및 rigid translation nullspace/symmetry PASS | 초기 mass-null 가속도 결합, admissible null rank, 영변형 spurious force 방지의 제한 근거다. Free translating shell 전체 이력과 C11 반복 실행 coverage는 별도 확인 대상이다. |
+
+## 원본 모델과 coverage
+
+원본 INP는 729 nodes/676 elements의 평판, 외곽 104 nodes의 6 DOF 고정, 중심 node `2`의 global force `(-100000,-100000,-100000)`이다. 입력 수치로 총 질량은 `rho*area*t=2700*100*.5=135000` mass units다. `E=2.1e11`, `nu=.3`, `rho=2700`, 두께 `.5`를 SI로 단정하지 않는다.
+
+원본 CSV 909행을 직접 집계했다. `max|U1|=max|U2|=2.31251943e-6`, `max|U3|=4.91895989e-5` length units, 따라서 `max|U3|/t=9.83791978e-5`다. 모든 표본 U는 0 이하이고 중심의 U1=U2로, 적용 하중 방향 및 x/y 교환 대칭과 일관된다. 최대 회전 성분은 `6.88441514e-6 rad`다. 이는 외부 reference 자체의 관찰이며 FESA 응답 검증이 아니다. 동역학에서 개별 자유도의 가속도·반력·변위 부호를 하중 부호만으로 일률 강제하지 않는다.
+
+Reference는 중심 주변 9 nodes만 제공한다. [계약](reference-model.md)에 기록된 `dt/T1≈7.4567`과 위 작은 회전 때문에 transient phase 정확도·전판 모드·큰 회전 관성·stress/V/A/반력/에너지에는 coverage가 없다. 외부 일치는 Abaqus 내부 요소·질량·시간적분 동등성의 근거가 아니다.
+
+완료 HDF5에서는 기존 N2/N6에 따라 `I+f_int−F`, constrained selector 반력, `Σ(F+R)−Pdot`, current-arm spatial moment 평형을 확인해야 한다. `T/Uphys/Udrill`의 비음성·규모, `W=F·(q−q0)`, energy defect 정의, constrained exact zero, 물리 strain/stress 회복과 대칭도 확인 대상이다. `Udrill`을 물리 stress에 합치거나 `A`를 물리 관성/운동에너지에 쓰면 안 된다. 현재 이 전판 결과는 미검토 상태다.
+
+## 열람 evidence와 잔여 위험
+
+- [stable kernel 로그](../../.harness/build/hht-numerical/focused-stable-kernel.log), [exact-constraint 로그](../../.harness/build/hht-numerical/focused-exact-constraint.log), [optimized 로그](../../.harness/build/hht-numerical/focused-optimized.log), [Debug 후속 로그](../../.harness/build/hht-numerical/focused-debug-complete.log).
+- [C04a Decimal80](../../.harness/build/hht-numerical/c04a-decimal-reduction.json).
+- [원본 INP](../../reference/shellNL-dyn-meshfine/shellNL-dyn-meshfine.inp), [원본 CSV](<../../reference/shellNL-dyn-meshfine/shellNL-dyn-meshfine displacements.csv>), [진행 중 reference 로그](../../reference/shellNL-dyn-meshfine/shellNL-dyn-meshfine_log.txt): 초기 검토 snapshot은 increment 8 accepted까지이며 이후 실행 완료를 뜻하지 않는다.
+
+잔여 위험은 실제 shell의 유한회전 DAE 정확도, nonlinear energy/momentum 수렴, 전판 물리 평형·recovery 및 필수 reference 미완료다. C09–C11의 전체 실패 보존/결정론/rigid-motion coverage와 구성된 build/CTest도 해당 실행 보고서에서 확인해야 한다. 기존 기준을 완화하거나 새 acceptance gate를 만들지 않았다. 본 문서는 release 승인 문서가 아니다.
diff --git a/include/fesa/analysis/dynamic_analysis_state.h b/include/fesa/analysis/dynamic_analysis_state.h
new file mode 100644
index 0000000..317f3d3
--- /dev/null
+++ b/include/fesa/analysis/dynamic_analysis_state.h
@@ -0,0 +1,113 @@
+#ifndef FESA_ANALYSIS_DYNAMIC_ANALYSIS_STATE_H_
+#define FESA_ANALYSIS_DYNAMIC_ANALYSIS_STATE_H_
+
+#include <array>
+#include <cstdint>
+#include <vector>
+
+#include "fesa/core/source_identity.h"
+#include "fesa/core/status.h"
+#include "fesa/fem/dof_manager.h"
+#include "fesa/math/vector.h"
+#include "fesa/model/domain.h"
+#include "fesa/results/result_records.h"
+
+namespace fesa {
+
+/// @brief Stores one accepted endpoint of an HHT dynamic step.
+struct DynamicAcceptedFrameState {
+  std::uint32_t frame_index = 0U;
+  std::uint32_t increment_index = 0U;
+  std::uint32_t iteration_count = 0U;
+  double time = 0.0;
+  bool is_initial = false;
+  std::vector<EntityIndex> nodal_internal_order;
+  std::vector<SourceEntityId> nodal_source_ids;
+  Vector generalized_coordinates{0U};
+  Vector velocity{0U};
+  Vector acceleration{0U};
+  Vector algorithmic_acceleration{0U};
+  std::vector<std::array<std::array<double, 3>, 3>> nodal_triad;
+  std::vector<std::array<double, 3>> nodal_director;
+  Vector angular_velocity{0U};
+  Vector angular_acceleration{0U};
+  Vector inertia_force{0U};
+  Vector internal_force{0U};
+  Vector external_force{0U};
+  Vector residual{0U};
+  Vector reaction{0U};
+  Vector residual_scale{0U};
+  std::vector<ShellResultRow> shell_results;
+  double kinetic_energy = 0.0;
+  double physical_strain_energy = 0.0;
+  double drilling_energy = 0.0;
+  double external_work = 0.0;
+  double energy_defect = 0.0;
+  std::array<double, 6> global_equilibrium{};
+  std::array<double, 3> linear_momentum{};
+  std::array<double, 3> angular_momentum{};
+  std::array<double, 3> linear_momentum_rate{};
+  std::array<double, 3> angular_momentum_rate{};
+  std::array<double, 2> free_residual_metrics{};
+  Vector hidden_constraint{0U};
+  Vector hidden_velocity_defect{0U};
+  Vector hidden_acceleration_defect{0U};
+  Vector hidden_constraint_scale{0U};
+  Vector hidden_velocity_defect_scale{0U};
+  Vector hidden_acceleration_defect_scale{0U};
+};
+
+/// @brief Owns accepted HHT frame history and the current committed endpoint.
+class DynamicAnalysisState {
+ public:
+  /// @brief Creates an uninitialized state that cannot be written or committed.
+  DynamicAnalysisState() = default;
+
+  /// @brief Validates the immutable dynamic inventory and schedule.
+  /// @return A state ready to accept the required frame zero.
+  static Result<DynamicAnalysisState> Create(const Domain& domain,
+                                             const DofManager& dofs);
+
+  /// @brief Returns an independent copy of the committed frame.
+  /// @pre At least one frame has been committed.
+  Result<DynamicAcceptedFrameState> BeginTrialFromCommitted() const;
+
+  /// @brief Atomically accepts one complete finite dynamic frame.
+  Status CommitAcceptedFrame(const DynamicAcceptedFrameState& frame);
+
+  /// @brief Discards caller-owned trial data without mutating this state.
+  void DiscardTrial() noexcept;
+
+  /// @brief Returns accepted frames in frame-index order.
+  const std::vector<DynamicAcceptedFrameState>& AcceptedFrames() const noexcept;
+
+  /// @brief Returns the current committed frame.
+  /// @pre At least one frame has been committed.
+  const DynamicAcceptedFrameState& CommittedState() const;
+
+  /// @brief Reports whether Create has validated this state inventory.
+  bool IsInitialized() const noexcept;
+
+ private:
+  DynamicAnalysisState(std::size_t full_dof_count,
+                       std::uint32_t increment_count, double initial_increment,
+                       std::vector<EntityIndex> shell_element_order,
+                       std::vector<std::size_t> constrained_dofs,
+                       std::vector<SourceEntityId> nodal_source_ids,
+                       std::vector<ShellNodeInitialFrame> initial_frames);
+
+  std::size_t full_dof_count_ = 0U;
+  std::uint32_t increment_count_ = 0U;
+  double initial_increment_ = 0.0;
+  std::vector<EntityIndex> shell_element_order_;
+  std::vector<std::size_t> constrained_dofs_;
+  std::vector<SourceEntityId> nodal_source_ids_;
+  std::vector<ShellNodeInitialFrame> initial_frames_;
+  std::vector<DynamicAcceptedFrameState> accepted_frames_;
+  std::size_t hidden_constraint_count_ = 0U;
+  bool initialized_ = false;
+};
+
+}  // namespace fesa
+
+#endif  // FESA_ANALYSIS_DYNAMIC_ANALYSIS_STATE_H_
diff --git a/include/fesa/analysis/hht_dynamic_procedure.h b/include/fesa/analysis/hht_dynamic_procedure.h
new file mode 100644
index 0000000..c10404f
--- /dev/null
+++ b/include/fesa/analysis/hht_dynamic_procedure.h
@@ -0,0 +1,29 @@
+#ifndef FESA_ANALYSIS_HHT_DYNAMIC_PROCEDURE_H_
+#define FESA_ANALYSIS_HHT_DYNAMIC_PROCEDURE_H_
+
+#include "fesa/analysis/prepared_analysis.h"
+
+namespace fesa {
+class LinearSolver;
+class ParallelFor;
+class TangentSolver;
+
+/// @brief Executes endpoint-equilibrium HHT with consistent shell inertia.
+class HhtDynamicProcedureExecutor {
+ public:
+  /// @brief Retains caller-owned deterministic execution and solve adapters.
+  HhtDynamicProcedureExecutor(const ParallelFor& parallel_for,
+                              LinearSolver& positive_solver,
+                              TangentSolver& tangent_solver);
+
+  /// @brief Returns complete accepted history without opening result output.
+  Result<DynamicExecutionResult> Execute(const Domain& domain,
+                                         NewtonIterationLogWriter& log) const;
+
+ private:
+  const ParallelFor& parallel_for_;
+  LinearSolver& positive_solver_;
+  TangentSolver& tangent_solver_;
+};
+}  // namespace fesa
+#endif  // FESA_ANALYSIS_HHT_DYNAMIC_PROCEDURE_H_
diff --git a/include/fesa/analysis/hht_time_integration.h b/include/fesa/analysis/hht_time_integration.h
new file mode 100644
index 0000000..0892051
--- /dev/null
+++ b/include/fesa/analysis/hht_time_integration.h
@@ -0,0 +1,50 @@
+#ifndef FESA_ANALYSIS_HHT_TIME_INTEGRATION_H_
+#define FESA_ANALYSIS_HHT_TIME_INTEGRATION_H_
+
+#include "fesa/core/status.h"
+#include "fesa/math/vector.h"
+
+namespace fesa {
+
+/// @brief Stores the coupled original negative-alpha HHT coefficients.
+struct HhtParameters {
+  double alpha;
+  double beta;
+  double gamma;
+};
+
+/// @brief Stores the displacement and velocity Newmark predictors.
+struct HhtPredictor {
+  Vector coordinates;
+  Vector velocity;
+};
+
+/// @brief Separates physical chart rates from the auxiliary acceleration.
+struct HhtRates {
+  Vector velocity;
+  Vector acceleration;
+  Vector algorithmic_acceleration;
+};
+
+/// @brief Builds coupled coefficients for alpha in [-1/3, 0].
+/// @note The public INP subset uses only alpha=-0.05.
+Result<HhtParameters> MakeHhtParameters(double alpha);
+
+/// @brief Predicts q and v using the old auxiliary acceleration.
+/// @param time_increment Finite positive duration in input time units.
+Result<HhtPredictor> PredictHht(const Vector& coordinates,
+                              const Vector& velocity,
+                              const Vector& algorithmic_acceleration,
+                              double time_increment,
+                              const HhtParameters& parameters);
+
+/// @brief Recovers physical and auxiliary rates from one trial coordinate.
+/// @param old_acceleration Physical endpoint acceleration at the old time.
+Result<HhtRates> EvaluateHhtRates(const Vector& coordinates,
+                                const HhtPredictor& predictor,
+                                const Vector& old_acceleration,
+                                double time_increment,
+                                const HhtParameters& parameters);
+
+}  // namespace fesa
+#endif  // FESA_ANALYSIS_HHT_TIME_INTEGRATION_H_
diff --git a/include/fesa/analysis/newton_iteration_log.h b/include/fesa/analysis/newton_iteration_log.h
index 6c2b9c4..e2de1da 100644
--- a/include/fesa/analysis/newton_iteration_log.h
+++ b/include/fesa/analysis/newton_iteration_log.h
@@ -1,6 +1,7 @@
 #ifndef FESA_ANALYSIS_NEWTON_ITERATION_LOG_H_
 #define FESA_ANALYSIS_NEWTON_ITERATION_LOG_H_
 
+#include <array>
 #include <cstdint>
 #include <filesystem>
 #include <fstream>
@@ -49,6 +50,27 @@ struct NewtonIterationLogRecord {
   bool combined_passed;
 };
 
+/// @brief Carries two-channel HHT endpoint convergence evidence.
+/// @note Array entries are translation and rotation channels, respectively.
+/// Corrections are dimensionless N2 metrics; rate corrections already include
+/// h or h squared. Residual numerator and scale retain force/moment units.
+struct DynamicNewtonIterationLogRecord {
+  std::uint32_t increment_index = 0U;
+  std::uint32_t iteration_index = 0U;
+  double time = 0.0;
+  std::string stage;
+  std::string outcome;
+  std::string failure_code;
+  std::array<double, 2U> residual_numerator{};
+  std::array<double, 2U> residual_scale{};
+  std::array<double, 2U> coordinate_correction{};
+  std::array<double, 2U> velocity_correction{};
+  std::array<double, 2U> acceleration_correction{};
+  std::array<double, 2U> algorithmic_correction{};
+  bool residual_pass = false;
+  bool correction_pass = false;
+};
+
 /// @brief Writes deterministic, line-oriented Newton iteration diagnostics.
 /// @note A write, flush, or close failure permanently prevents a successful
 /// log lifecycle for this writer instance.
@@ -66,6 +88,11 @@ class NewtonIterationLogWriter {
   /// failure with code `log-output-failure`.
   Status Write(const NewtonIterationLogRecord& record);
 
+  /// @brief Writes one complete HHT record using schema `hht-log-v1`.
+  /// @return Success after the complete line is written; invalid numeric
+  /// evidence or stream failure permanently fails this writer instance.
+  Status Write(const DynamicNewtonIterationLogRecord& record);
+
   /// @brief Flushes every complete record written so far to the log.
   /// @return Success after the stream flush, otherwise an output failure with
   /// code `log-output-failure`.
diff --git a/include/fesa/analysis/prepared_analysis.h b/include/fesa/analysis/prepared_analysis.h
index b2a24d7..e623fde 100644
--- a/include/fesa/analysis/prepared_analysis.h
+++ b/include/fesa/analysis/prepared_analysis.h
@@ -6,6 +6,7 @@
 #include <vector>
 
 #include "fesa/analysis/analysis_state.h"
+#include "fesa/analysis/dynamic_analysis_state.h"
 #include "fesa/analysis/eigen_analysis_state.h"
 #include "fesa/analysis/nonlinear_analysis_state.h"
 #include "fesa/core/diagnostic.h"
@@ -21,6 +22,8 @@ class NewtonIterationLogWriter;
 class NonlinearResultsWriter;
 class NonlinearStaticProcedureExecutor;
 class ResultsWriter;
+class HhtDynamicProcedureExecutor;
+class DynamicResultsWriter;
 struct DerivedOutputPaths;
 
 /// @brief Owns one parsed and semantically mapped analysis input.
@@ -49,9 +52,15 @@ struct NonlinearStaticExecutionResult {
   std::vector<Diagnostic> diagnostics;
 };
 
+/// @brief Stores a complete HHT history before atomic result finalization.
+struct DynamicExecutionResult {
+  DynamicAnalysisState state;
+  std::vector<Diagnostic> diagnostics;
+};
+
 using PreparedAnalysisOutcome =
     std::variant<LinearStaticExecutionResult, NonlinearStaticExecutionResult,
-                 EigenAnalysisState>;
+                 EigenAnalysisState, DynamicExecutionResult>;
 
 /// @brief Selects the approved procedure from a prepared Domain.
 /// @pre The executors and log outlive this call.
@@ -60,7 +69,8 @@ Result<PreparedAnalysisOutcome> ExecutePreparedAnalysis(
     const Domain& domain, LinearStaticProcedureExecutor& linear_executor,
     NonlinearStaticProcedureExecutor& nonlinear_executor,
     const LinearFrequencyProcedureExecutor& frequency_executor,
-    NewtonIterationLogWriter& log);
+    NewtonIterationLogWriter& log,
+    const HhtDynamicProcedureExecutor* dynamic_executor = nullptr);
 
 /// @brief Writes an already computed outcome to its authoritative result file.
 /// @pre The Newton log has closed successfully before this function is called.
@@ -69,7 +79,8 @@ Status FinalizePreparedAnalysisResult(
     const DerivedOutputPaths& paths, const Domain& domain,
     const PreparedAnalysisOutcome& outcome,
     const std::vector<Diagnostic>& diagnostics, ResultsWriter& linear_writer,
-    NonlinearResultsWriter& nonlinear_writer, EigenResultsWriter& eigen_writer);
+    NonlinearResultsWriter& nonlinear_writer, EigenResultsWriter& eigen_writer,
+    DynamicResultsWriter* dynamic_writer = nullptr);
 
 }  // namespace fesa
 
diff --git a/include/fesa/elements/nonlinear_mitc4_inertia.h b/include/fesa/elements/nonlinear_mitc4_inertia.h
new file mode 100644
index 0000000..2ff33ea
--- /dev/null
+++ b/include/fesa/elements/nonlinear_mitc4_inertia.h
@@ -0,0 +1,106 @@
+#ifndef FESA_ELEMENTS_NONLINEAR_MITC4_INERTIA_H_
+#define FESA_ELEMENTS_NONLINEAR_MITC4_INERTIA_H_
+
+#include <array>
+#include <string>
+
+#include "fesa/core/status.h"
+#include "fesa/elements/nonlinear_mitc4_shell.h"
+#include "fesa/math/matrix.h"
+#include "fesa/math/vector.h"
+#include "fesa/math/vector3.h"
+#include "fesa/model/model_types.h"
+
+namespace fesa {
+
+/// @brief Stores exact physical rotation-rate and drilling-null quantities.
+struct DynamicRotationKinematics {
+  Vector3 director;
+  Vector3 drill_null;
+  Matrix null_gradient{3U, 3U};
+  /// @brief Stores D2 drill_null[velocity, velocity], without Dn[a].
+  Vector3 null_directional_second;
+  Vector3 angular_velocity;
+  Vector3 angular_acceleration;
+  /// @brief Stores director derivatives in fixed-global chart directions.
+  std::array<Vector3, 3> director_first;
+  std::array<std::array<Vector3, 3>, 3> director_second;
+  std::array<std::array<std::array<Vector3, 3>, 3>, 3> director_third;
+};
+
+/// @brief Evaluates exact finite-rotation rates and the unit drilling null.
+/// @param phi Fixed-global principal-chart rotation coordinate.
+/// @param initial_director Unit director at zero rotation.
+/// @param velocity Fixed-chart rotation-coordinate rate.
+/// @param acceleration Fixed-chart rotation-coordinate acceleration.
+/// @return Finite director/rates/null derivatives or a structured failure.
+[[nodiscard]] Result<DynamicRotationKinematics> EvaluateDynamicRotation(
+    const Vector3& phi, const Vector3& initial_director,
+    const Vector3& velocity, const Vector3& acceleration);
+
+/// @brief Stores the consistent kinetic-inertia quantities at one trial.
+struct NonlinearMitc4InertiaEvaluation {
+  Matrix mass;
+  Matrix position_tangent;
+  Matrix velocity_tangent;
+  Vector force;
+  Vector convective_force;
+  double kinetic_energy;
+  Vector3 momentum;
+  Vector3 angular_momentum;
+  Vector3 momentum_rate;
+  Vector3 angular_momentum_rate;
+  /// @brief Stores uncancelled quadrature norm sums for balance checks.
+  double momentum_rate_scale = 0.0;
+  double angular_momentum_rate_scale = 0.0;
+};
+
+/// @brief Evaluates finite-rotation consistent inertia for one MITC4 shell.
+/// @note This object owns immutable reference geometry only, never analysis
+/// trial state.
+class NonlinearMitc4Inertia {
+ public:
+  /// @brief Creates a checked consistent kinetic-mass evaluator.
+  /// @param nodes Four non-owning nodes in source order.
+  /// @param initial_frames Fixed proper node frames in source order.
+  /// @param section Centered shell section with positive thickness.
+  /// @param material Shell material used to retain the nonlinear-shell input
+  /// contract.
+  /// @param density Reference mass density, strictly positive and finite.
+  /// @return A checked immutable evaluator or a structured model failure.
+  static Result<NonlinearMitc4Inertia> Create(
+      std::array<const Node*, 4> nodes,
+      std::array<ShellNodeInitialFrame, 4> initial_frames,
+      const ShellSection& section, const LinearElasticMaterial& material,
+      double density);
+
+  /// @brief Evaluates physical consistent inertia at a complete trial.
+  /// @param trial Fixed-global translation and rotation coordinates.
+  /// @param velocity24 Fixed-chart generalized physical velocity.
+  /// @param physical_acceleration24 Fixed-chart generalized physical
+  /// acceleration.
+  /// @return Current mass, inertia force and exact partial tangents, or a
+  /// fail-closed diagnostic.
+  [[nodiscard]] Result<NonlinearMitc4InertiaEvaluation> Evaluate(
+      const NonlinearMitc4TrialDofs& trial, const Vector& velocity24,
+      const Vector& physical_acceleration24) const;
+
+ private:
+  NonlinearMitc4Inertia(std::array<Vector3, 4> coordinates,
+                        std::array<Matrix, 4> initial_frames,
+                        std::array<Vector3, 4> initial_directors,
+                        double thickness, double density,
+                        SourceLocation source_location, std::string identity);
+
+  std::array<Vector3, 4> coordinates_;
+  std::array<Matrix, 4> initial_frames_;
+  std::array<Vector3, 4> initial_directors_;
+  double thickness_;
+  double density_;
+  SourceLocation source_location_;
+  std::string identity_;
+};
+
+}  // namespace fesa
+
+#endif  // FESA_ELEMENTS_NONLINEAR_MITC4_INERTIA_H_
diff --git a/include/fesa/elements/nonlinear_mitc4_shell.h b/include/fesa/elements/nonlinear_mitc4_shell.h
index bab0476..6fe99ab 100644
--- a/include/fesa/elements/nonlinear_mitc4_shell.h
+++ b/include/fesa/elements/nonlinear_mitc4_shell.h
@@ -43,6 +43,16 @@ struct NonlinearMitc4InternalEquilibrium {
   Vector internal_force;
   NonlinearMitc4Recovery recovery;
   double physical_strain_energy;
+  Vector physical_force{0U};
+  Vector drilling_force{0U};
+  Matrix drilling_tangent{0U, 0U};
+  Matrix drilling_metric{0U, 0U};
+  double drilling_energy = 0.0;
+  Vector force_directional_second{0U};
+  Vector drilling_constraint{0U};
+  Matrix drilling_constraint_gradient{0U, 0U};
+  std::array<Matrix, 4> drilling_constraint_hessian{
+      Matrix{0U, 0U}, Matrix{0U, 0U}, Matrix{0U, 0U}, Matrix{0U, 0U}};
 };
 
 class NonlinearMitc4Shell;
@@ -50,11 +60,13 @@ class NonlinearMitc4Shell;
 /// @brief Evaluates the internal residual and tangent at one complete trial.
 /// @param element Immutable nonlinear MITC4 reference evaluator.
 /// @param trial Complete global translation and rotation trial coordinates.
+/// @param coordinate_direction Optional 24-vector for D2(f_int)[v,v].
 /// @return Internal force, consistent tangent and physical recovery, or
 /// failure.
 /// @note External load vectors and their tangents are intentionally excluded.
 Result<NonlinearMitc4InternalEquilibrium> EvaluateInternalResidualAndTangent(
-    const NonlinearMitc4Shell& element, const NonlinearMitc4TrialDofs& trial);
+    const NonlinearMitc4Shell& element, const NonlinearMitc4TrialDofs& trial,
+    const Vector* coordinate_direction = nullptr);
 
 /// @brief Evaluates fixed-reference Total Lagrangian MITC4 kinematics.
 /// @note This class owns no mutable trial or accepted analysis state.
@@ -94,7 +106,8 @@ class NonlinearMitc4Shell {
 
   friend Result<NonlinearMitc4InternalEquilibrium>
   EvaluateInternalResidualAndTangent(const NonlinearMitc4Shell& element,
-                                     const NonlinearMitc4TrialDofs& trial);
+                                     const NonlinearMitc4TrialDofs& trial,
+                                     const Vector* coordinate_direction);
 
   std::array<Vector3, 4> coordinates_;
   std::array<Matrix, 4> initial_frames_;
diff --git a/include/fesa/io/hdf5/dynamic_hdf5_results_writer.h b/include/fesa/io/hdf5/dynamic_hdf5_results_writer.h
new file mode 100644
index 0000000..0c04478
--- /dev/null
+++ b/include/fesa/io/hdf5/dynamic_hdf5_results_writer.h
@@ -0,0 +1,20 @@
+#ifndef FESA_IO_HDF5_DYNAMIC_HDF5_RESULTS_WRITER_H_
+#define FESA_IO_HDF5_DYNAMIC_HDF5_RESULTS_WRITER_H_
+
+#include "fesa/results/dynamic_results_writer.h"
+
+namespace fesa {
+
+/// @brief Writes schema-v1 HHT dynamic HDF5 results with atomic finalization.
+class DynamicHdf5ResultsWriter final : public DynamicResultsWriter {
+ public:
+  /// @brief Writes a validated dynamic result file and preserves a prior final
+  /// file on failure.
+  Status Write(const std::filesystem::path& output_path, const Domain& domain,
+               const DynamicAnalysisState& state,
+               const std::vector<Diagnostic>& diagnostics) override;
+};
+
+}  // namespace fesa
+
+#endif  // FESA_IO_HDF5_DYNAMIC_HDF5_RESULTS_WRITER_H_
diff --git a/include/fesa/results/dynamic_results_writer.h b/include/fesa/results/dynamic_results_writer.h
new file mode 100644
index 0000000..07c603d
--- /dev/null
+++ b/include/fesa/results/dynamic_results_writer.h
@@ -0,0 +1,28 @@
+#ifndef FESA_RESULTS_DYNAMIC_RESULTS_WRITER_H_
+#define FESA_RESULTS_DYNAMIC_RESULTS_WRITER_H_
+
+#include <filesystem>
+#include <vector>
+
+#include "fesa/analysis/dynamic_analysis_state.h"
+#include "fesa/core/diagnostic.h"
+#include "fesa/core/status.h"
+
+namespace fesa {
+
+class Domain;
+
+/// @brief Writes complete HHT dynamic results to their official output file.
+class DynamicResultsWriter {
+ public:
+  virtual ~DynamicResultsWriter() = default;
+
+  /// @brief Persists every accepted dynamic frame and diagnostic atomically.
+  virtual Status Write(const std::filesystem::path& output_path,
+                       const Domain& domain, const DynamicAnalysisState& state,
+                       const std::vector<Diagnostic>& diagnostics) = 0;
+};
+
+}  // namespace fesa
+
+#endif  // FESA_RESULTS_DYNAMIC_RESULTS_WRITER_H_
diff --git a/scripts/verification/compare_hht_dynamic.py b/scripts/verification/compare_hht_dynamic.py
new file mode 100644
index 0000000..93b948e
--- /dev/null
+++ b/scripts/verification/compare_hht_dynamic.py
@@ -0,0 +1,406 @@
+"""Compare the approved 101-frame HHT reference without modifying artifacts.
+
+Run with ``uv run --with h5py python -B scripts/verification/compare_hht_dynamic.py``.
+Only the documented displacement/rotation reference quantities are compared;
+this is not an independent validation of inertia, energy, or convergence.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+from decimal import Decimal, InvalidOperation
+import hashlib
+import json
+import math
+from pathlib import Path
+import re
+from typing import Any
+
+import h5py
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[2]
+CASE = "shellNL-dyn-meshfine"
+REFERENCE_DIRECTORY = ROOT / "reference" / CASE
+NODE_LABELS = (2, 21, 22, 69, 70, 165, 309, 442, 586)
+INSTANCE = "PART-1-1"
+STEP = "Step-1"
+NODE_COUNT = 729
+FRAME_COUNT = 101
+INCREMENT = 0.1
+COMPONENTS = ("U-U1", "U-U2", "U-U3", "UR-UR1", "UR-UR2", "UR-UR3")
+CSV_COLUMNS = ("Frame", "Part Instance Name", "Node Label", *COMPONENTS)
+FRAME_PATTERN = re.compile(
+    r"Increment\s+(\d+):\s*Step Time\s*=\s*"
+    r"([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)"
+)
+POLICY = {
+    "policy_id": "common-reference-tolerance",
+    "near_zero_ratio": 0.01,
+    "relative_tolerance": 0.05,
+    "relative_rms_tolerance": 0.01,
+}
+
+
+class ComparisonError(ValueError):
+    """An identity/schema/finite failure that must precede tolerance evaluation."""
+
+    def __init__(self, code: str, message: str):
+        super().__init__(message)
+        self.code = code
+
+
+def require(condition: bool, code: str, message: str) -> None:
+    if not condition:
+        raise ComparisonError(code, message)
+
+
+def positive_label(text: str) -> int:
+    require(bool(re.fullmatch(r"\d+", text)), "invalid-node-label", repr(text))
+    label = int(text)
+    require(0 < label <= 2**63 - 1, "invalid-node-label", repr(text))
+    return label
+
+
+def canonical_instance(text: str) -> str:
+    return text.translate(str.maketrans("abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
+
+
+def input_inventory(path: Path) -> tuple[dict[int, tuple[float, ...]], str]:
+    """Read identity and schedule authority from this specific approved INP."""
+    raw = path.read_bytes()
+    nodes: dict[int, tuple[float, ...]] = {}
+    parts: list[str] = []
+    instances: list[tuple[str, str]] = []
+    steps: list[dict[str, str]] = []
+    dynamic_rows: list[tuple[float, float]] = []
+    keyword = ""
+    in_part = False
+    for line_number, line in enumerate(raw.decode("utf-8-sig").splitlines(), 1):
+        text = line.strip()
+        if not text or text.startswith("**"):
+            continue
+        fields = [field.strip() for field in text.split(",")]
+        if text.startswith("*"):
+            keyword = fields[0].upper()
+            parameters = dict(
+                (name.upper(), value.strip())
+                for field in fields[1:] if "=" in field
+                for name, value in [field.split("=", 1)]
+            )
+            if keyword == "*PART":
+                in_part = True
+                parts.append(canonical_instance(parameters.get("NAME", "")))
+            elif keyword == "*END PART":
+                in_part = False
+            elif keyword == "*INSTANCE":
+                instances.append((canonical_instance(parameters.get("NAME", "")),
+                                  canonical_instance(parameters.get("PART", ""))))
+            elif keyword == "*STEP":
+                steps.append(parameters)
+            elif keyword == "*DYNAMIC":
+                require([field.upper() for field in fields] == ["*DYNAMIC", "DIRECT"],
+                        "wrong-input-procedure", f"line {line_number}")
+            continue
+        if keyword == "*NODE":
+            require(in_part and len(fields) == 4, "invalid-input-node", f"line {line_number}")
+            label = positive_label(fields[0])
+            require(label not in nodes, "duplicate-input-node", str(label))
+            coordinates = tuple(float(value) for value in fields[1:])
+            require(all(math.isfinite(value) for value in coordinates),
+                    "nonfinite-input-node", str(label))
+            nodes[label] = coordinates
+        elif keyword == "*DYNAMIC":
+            if fields[-1] == "":
+                fields.pop()
+            require(len(fields) == 2, "wrong-input-schedule", f"line {line_number}")
+            dynamic_rows.append((float(fields[0]), float(fields[1])))
+    require(parts == ["PART-1"] and instances == [(INSTANCE, "PART-1")],
+            "wrong-input-instance", "Expected the original single identity instance.")
+    require(len(nodes) == NODE_COUNT and set(NODE_LABELS) <= nodes.keys(),
+            "wrong-input-node-inventory", f"Expected {NODE_COUNT} source nodes.")
+    require(len(steps) == 1 and steps[0].get("NAME") == STEP
+            and steps[0].get("NLGEOM", "").upper() == "YES"
+            and steps[0].get("INC") == "1000", "wrong-input-step", str(steps))
+    require(dynamic_rows == [(INCREMENT, 10.0)], "wrong-input-schedule", str(dynamic_rows))
+    value = 14695981039346656037
+    for byte in raw:
+        value = ((value ^ byte) * 1099511628211) & (2**64 - 1)
+    return nodes, f"fnv1a64:{value:016x}"
+
+
+def read_reference(path: Path) -> dict[tuple[int, int], tuple[float, ...]]:
+    rows: dict[tuple[int, int], tuple[float, ...]] = {}
+    with path.open(encoding="utf-8-sig", newline="") as stream:
+        reader = csv.reader(stream)
+        header = [field.strip() for field in next(reader, [])]
+        require(len(header) == len(set(header)), "duplicate-reference-column", str(header))
+        require(set(CSV_COLUMNS) <= set(header), "missing-reference-column", str(header))
+        for line_number, fields in enumerate(reader, 2):
+            if not fields or all(not field.strip() for field in fields):
+                continue
+            require(len(fields) == len(header), "invalid-reference-row", f"line {line_number}")
+            row = dict(zip(header, (field.strip() for field in fields)))
+            match = FRAME_PATTERN.fullmatch(row["Frame"])
+            require(match is not None, "invalid-reference-frame", f"line {line_number}")
+            increment = int(match.group(1))
+            time = Decimal(match.group(2))
+            require(time.is_finite() and time == Decimal(increment) / Decimal(10),
+                    "wrong-reference-time", f"line {line_number}: {row['Frame']}")
+            require(canonical_instance(row["Part Instance Name"]) == INSTANCE,
+                    "wrong-reference-instance", f"line {line_number}")
+            label = positive_label(row["Node Label"])
+            key = (increment, label)
+            require(key not in rows, "duplicate-reference-row", str(key))
+            values = tuple(float(row[component]) for component in COMPONENTS)
+            require(all(math.isfinite(value) for value in values),
+                    "nonfinite-reference-value", str(key))
+            rows[key] = values
+    expected = {(frame, label) for frame in range(FRAME_COUNT) for label in NODE_LABELS}
+    require(rows.keys() == expected, "reference-row-inventory",
+            f"missing={sorted(expected - rows.keys())}; extra={sorted(rows.keys() - expected)}")
+    return rows
+
+
+def text_value(value: Any) -> str:
+    return value.decode("utf-8") if isinstance(value, bytes) else str(value)
+
+
+def string_attribute(obj: Any, name: str, expected: str | None = None) -> str:
+    require(name in obj.attrs, "missing-hdf5-attribute", f"{obj.name}@{name}")
+    attribute = obj.attrs.get_id(name)
+    string = h5py.check_string_dtype(attribute.dtype)
+    require(attribute.shape == () and string is not None and string.length is None
+            and string.encoding == "utf-8", "wrong-hdf5-attribute-type", f"{obj.name}@{name}")
+    value = text_value(obj.attrs[name])
+    require(bool(value) and (expected is None or value == expected),
+            "wrong-hdf5-attribute-value", f"{obj.name}@{name}: {value!r}")
+    return value
+
+
+def numeric_attribute(obj: Any, name: str, dtype: str, expected: int | float) -> None:
+    require(name in obj.attrs, "missing-hdf5-attribute", f"{obj.name}@{name}")
+    attribute = obj.attrs.get_id(name)
+    require(attribute.shape == () and attribute.dtype == np.dtype(dtype),
+            "wrong-hdf5-attribute-type", f"{obj.name}@{name}")
+    value = obj.attrs[name]
+    require(math.isfinite(value) and value == expected, "wrong-hdf5-attribute-value",
+            f"{obj.name}@{name}: {value!r}")
+
+
+def dataset(file: h5py.File, path: str, shape: tuple[int, ...]) -> h5py.Dataset:
+    require(path in file and isinstance(file[path], h5py.Dataset), "missing-hdf5-dataset", path)
+    result = file[path]
+    require(result.shape == shape and result.chunks is None and result.compression is None,
+            "wrong-hdf5-dataset-layout", path)
+    return result
+
+
+def read_results(path: Path, nodes: dict[int, tuple[float, ...]],
+                 content_identity: str) -> tuple[list[np.ndarray], dict[str, Any]]:
+    """Precheck every result node/frame/component, then project by source key."""
+    projected: list[np.ndarray] = []
+    with h5py.File(path, "r") as file:
+        require("metadata" in file and isinstance(file["metadata"], h5py.Group),
+                "missing-hdf5-metadata", "/metadata")
+        metadata = file["metadata"]
+        for name, expected in {
+            "feature_id": "hht-implicit-dynamics", "analysis_procedure": "hht-implicit-dynamics",
+            "mass_formulation": "consistent-kinetic", "internal_formulation": "FESA-MITC4-total-lagrangian",
+            "initial_state": "zero-q-v-step-load-0+",
+            "acceleration_convention": "physical-endpoint-and-auxiliary-separated",
+            "source_step_name": STEP, "step_name": STEP, "unit_system_label": "consistent-input-units",
+        }.items():
+            string_attribute(metadata, name, expected)
+        string_attribute(metadata, "solver_version")
+        source_identity = string_attribute(metadata, "source_input_identity")
+        require(source_identity.endswith(";content_identity=" + content_identity),
+                "wrong-input-content-identity", source_identity)
+        for name, dtype, value in (
+            ("schema_version", "<u8", 1), ("increment_count", "<u8", 100),
+            ("maximum_increments", "<u8", 1000), ("alpha", "<f8", -0.05),
+            ("beta", "<f8", 0.275625), ("gamma", "<f8", 0.55),
+            ("initial_increment", "<f8", INCREMENT), ("time_period", "<f8", 10.0),
+        ):
+            numeric_attribute(metadata, name, dtype, value)
+        table = dataset(file, "model/nodes", (NODE_COUNT,))
+        require(table.dtype.names == ("internal_node_id", "instance_name", "source_label", "coordinates"),
+                "wrong-node-schema", str(table.dtype))
+        require(table.dtype["internal_node_id"] == np.dtype("<u8")
+                and table.dtype["coordinates"] == np.dtype(("<f8", (3,))),
+                "wrong-node-schema", str(table.dtype))
+        for name in ("instance_name", "source_label"):
+            string = h5py.check_string_dtype(table.dtype[name])
+            require(string is not None and string.length is None and string.encoding == "utf-8",
+                    "wrong-node-schema", name)
+        node_indices: dict[int, int] = {}
+        for index, node in enumerate(table[:]):
+            require(int(node["internal_node_id"]) == index, "wrong-internal-node-identity", str(index))
+            instance = canonical_instance(text_value(node["instance_name"]))
+            label = positive_label(text_value(node["source_label"]))
+            require(instance == INSTANCE, "wrong-result-instance", instance)
+            require(label not in node_indices, "duplicate-result-node", str(label))
+            require(label in nodes, "extra-result-node", str(label))
+            require(np.isfinite(node["coordinates"]).all(), "nonfinite-result-node", str(label))
+            require(tuple(node["coordinates"]) == nodes[label], "wrong-result-coordinate", str(label))
+            node_indices[label] = index
+        require(node_indices.keys() == nodes.keys(), "result-node-inventory", "Source node inventories differ.")
+        require("steps" in file and isinstance(file["steps"], h5py.Group)
+                and set(file["steps"]) == {STEP}, "wrong-result-step", "Expected one accepted step.")
+        accepted = dataset(file, f"steps/{STEP}/accepted_frames", (FRAME_COUNT,))
+        expected_fields = (("frame_index", "<u8"), ("increment_index", "<u8"),
+                           ("time", "<f8"), ("iteration_count", "<u8"), ("is_initial", "u1"))
+        require(accepted.dtype.names == tuple(name for name, _ in expected_fields)
+                and all(accepted.dtype[name] == np.dtype(dtype) for name, dtype in expected_fields),
+                "wrong-frame-table-schema", str(accepted.dtype))
+        frame_path = f"steps/{STEP}/frames"
+        require(frame_path in file and isinstance(file[frame_path], h5py.Group)
+                and set(file[frame_path]) == {str(i) for i in range(FRAME_COUNT)},
+                "result-frame-inventory", "Missing, extra, or noncanonical frame group.")
+        selection = [node_indices[label] for label in NODE_LABELS]
+        for frame, row in enumerate(accepted[:]):
+            scheduled_time = float(frame) * INCREMENT
+            require(int(row["frame_index"]) == frame and int(row["increment_index"]) == frame
+                    and math.isfinite(row["time"]) and float(row["time"]) == scheduled_time
+                    and int(row["is_initial"]) == int(frame == 0)
+                    and 0 <= int(row["iteration_count"]) <= 100
+                    and (frame != 0 or (int(row["iteration_count"]) == 0 and not np.signbit(row["time"]))),
+                    "wrong-result-frame-time", str(frame))
+            displacement = dataset(file, f"{frame_path}/{frame}/nodal/displacement", (NODE_COUNT, 6))
+            require(displacement.dtype == np.dtype("<f8"), "wrong-displacement-type", str(frame))
+            for name, value in {
+                "component_names": "UX,UY,UZ,URX,URY,URZ",
+                "component_unit_dimensions": "length,length,length,1,1,1",
+                "coordinate_system": "global-cartesian", "location": "nodal",
+                "step_name": STEP, "source_step_name": STEP,
+                "rotation_representation": "total-rotation-vector-chart",
+                "quantity_semantics": "global-translation-and-total-rotation-vector",
+            }.items():
+                string_attribute(displacement, name, value)
+            for name, dtype, value in (
+                ("schema_version", "<u8", 1), ("frame_index", "<u8", frame),
+                ("increment_index", "<u8", frame), ("time", "<f8", scheduled_time),
+                ("is_initial", "u1", int(frame == 0)),
+            ):
+                numeric_attribute(displacement, name, dtype, value)
+            values = displacement[:]
+            require(np.isfinite(values).all(), "nonfinite-result-value", str(frame))
+            if frame == 0:
+                require((values == 0.0).all(), "nonzero-initial-displacement", "Frame zero must have q0=0.")
+            projected.append(values[selection])
+    return projected, {"source_input_identity": source_identity, "source_node_count": NODE_COUNT,
+                       "accepted_frame_count": FRAME_COUNT, "checked_result_scalars": NODE_COUNT * FRAME_COUNT * 6,
+                       "projected_node_labels": list(NODE_LABELS)}
+
+
+def evaluate_family(increment: int, quantity: str, result: list[float],
+                    reference: list[float]) -> dict[str, Any]:
+    """Apply the common policy exactly, including zero-scale and family RMS."""
+    require(len(result) == len(reference) and len(result) > 0, "scalar-inventory", quantity)
+    require(all(math.isfinite(value) for value in (*result, *reference)),
+            "nonfinite-comparison-value", quantity)
+    scale = max(abs(value) for value in reference)
+    band = POLICY["near_zero_ratio"] * scale
+    rows = []
+    error_norm = 0.0
+    for index, (actual, expected) in enumerate(zip(result, reference)):
+        error = abs(actual - expected)
+        require(math.isfinite(error), "nonfinite-comparison-value", quantity)
+        error_norm = math.hypot(error_norm, error)
+        require(math.isfinite(error_norm), "nonfinite-comparison-value", quantity)
+        relative_error = None
+        if scale == 0.0:
+            branch, threshold, passed = "zero-scale-exact", 0.0, error == 0.0
+        elif abs(expected) <= band:
+            branch, threshold, passed = "near-zero", band, error <= band
+        else:
+            branch = "relative"
+            threshold = POLICY["relative_tolerance"] * abs(expected)
+            relative_error = error / abs(expected)
+            require(math.isfinite(relative_error), "nonfinite-comparison-value", quantity)
+            passed = relative_error <= POLICY["relative_tolerance"]
+        rows.append({"instance": INSTANCE, "node_label": NODE_LABELS[index // 3],
+                     "component": f"{quantity}{index % 3 + 1}", "fesa_value": actual,
+                     "reference_value": expected, "absolute_error": error,
+                     "relative_error": relative_error, "branch": branch,
+                     "threshold": threshold, "passed": passed})
+    rows_passed = all(row["passed"] for row in rows)
+    rms = error_norm / math.sqrt(len(rows)) / scale if scale else None
+    require(rms is None or math.isfinite(rms), "nonfinite-comparison-value", quantity)
+    rms_passed = rows_passed if scale == 0.0 else rms <= POLICY["relative_rms_tolerance"]
+    return {"identity": f"{quantity}-global:{STEP}:increment-{increment}", "case": CASE,
+            "step": STEP, "increment": increment, "hdf5_time": float(increment) * INCREMENT,
+            "reference_decimal_time": str(Decimal(increment) / Decimal(10)),
+            "quantity": quantity, "components": [f"{quantity}{i}" for i in (1, 2, 3)],
+            "unit_dimension": "length" if quantity == "U" else "rad",
+            "coordinate_system": "global-cartesian" if quantity == "U" else "fixed-initial-global-total-rotation-vector",
+            "impact": "blocking" if quantity == "U" else "warning-only", "row_count": len(rows),
+            "reference_scale": scale, "near_zero_band": band, "rows": rows,
+            "rows_passed": rows_passed, "relative_rms": rms, "rms_passed": rms_passed,
+            "diagnostic_code": "zero-reference-scale-nonzero-error" if scale == 0.0 and not rows_passed else None,
+            "passed": rows_passed and rms_passed}
+
+
+def compare(input_path: Path, reference_path: Path, results_path: Path) -> dict[str, Any]:
+    report: dict[str, Any] = {
+        "schema": "hht-reference-comparison-v1", "case": CASE, "policy": dict(POLICY),
+        "identities": {}, "precheck": {"passed": False}, "families": [],
+        "blocking_failures": [], "warnings": [], "blocking_passed": False, "verdict": "failed",
+    }
+    try:
+        for name, path in (("input", input_path), ("reference", reference_path), ("results", results_path)):
+            report["identities"][name] = {"path": str(path.absolute())}
+            with path.open("rb") as stream:
+                report["identities"][name]["sha256"] = hashlib.file_digest(stream, "sha256").hexdigest()
+        nodes, content_identity = input_inventory(input_path)
+        reference = read_reference(reference_path)
+        result, evidence = read_results(results_path, nodes, content_identity)
+        families = []
+        for frame in range(FRAME_COUNT):
+            for quantity, first in (("U", 0), ("UR", 3)):
+                actual = [float(value) for row in result[frame] for value in row[first:first + 3]]
+                expected = [value for label in NODE_LABELS for value in reference[(frame, label)][first:first + 3]]
+                families.append(evaluate_family(frame, quantity, actual, expected))
+        report["precheck"] = {"passed": True, "reference_row_count": len(reference),
+                              "reference_frame_count": FRAME_COUNT, **evidence}
+        report["families"] = families
+        for family in families:
+            if family["passed"]:
+                continue
+            if family["impact"] == "blocking":
+                report["blocking_failures"].append(family["identity"])
+            else:
+                if not family["rows_passed"]:
+                    report["warnings"].append({"family": family["identity"], "code": "row-tolerance-failure"})
+                if not family["rms_passed"]:
+                    report["warnings"].append({"family": family["identity"], "code": "relative-rms-failure"})
+        report["blocking_passed"] = not report["blocking_failures"]
+        report["verdict"] = "passed" if report["blocking_passed"] else "failed"
+    except (ComparisonError, OSError, ValueError, InvalidOperation, UnicodeError) as error:
+        report["precheck"] = {"passed": False, "code": getattr(error, "code", "invalid-comparison-input"),
+                              "message": str(error)}
+    return report
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--input", type=Path, default=REFERENCE_DIRECTORY / f"{CASE}.inp")
+    parser.add_argument("--reference", type=Path, default=REFERENCE_DIRECTORY / f"{CASE} displacements.csv")
+    parser.add_argument("--results", type=Path)
+    parser.add_argument("--report", type=Path, required=True)
+    args = parser.parse_args()
+    results = args.results or args.input.with_name(args.input.stem + "_results.h5")
+    if args.report.resolve() in {args.input.resolve(), args.reference.resolve(), results.resolve()}:
+        parser.error("The report path must not overwrite an input, reference, or solver result.")
+    report = compare(args.input, args.reference, results)
+    args.report.parent.mkdir(parents=True, exist_ok=True)
+    args.report.write_text(json.dumps(report, indent=2, sort_keys=True, allow_nan=False) + "\n", encoding="utf-8")
+    print(json.dumps({"verdict": report["verdict"], "precheck": report["precheck"],
+                      "blocking_failure_count": len(report["blocking_failures"]),
+                      "warning_count": len(report["warnings"]), "report": str(args.report)}, allow_nan=False))
+    return 2 if not report["precheck"]["passed"] else (0 if report["blocking_passed"] else 1)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/src/fesa/CMakeLists.txt b/src/fesa/CMakeLists.txt
index f96b4ab..06fc1e0 100644
--- a/src/fesa/CMakeLists.txt
+++ b/src/fesa/CMakeLists.txt
@@ -3,7 +3,12 @@ add_library(
     STATIC
     analysis/analysis_model.cpp
     analysis/analysis_state.cpp
+    analysis/dynamic_analysis_state.cpp
     analysis/eigen_reduction.cpp
+    analysis/hht_time_integration.cpp
+    analysis/hht_dynamic_algebra.cpp
+    analysis/hht_dynamic_assembly.cpp
+    analysis/hht_dynamic_procedure.cpp
     analysis/linear_frequency_procedure.cpp
     analysis/linear_static_analysis.cpp
     analysis/linear_static_procedure.cpp
@@ -29,6 +34,7 @@ add_library(
     elements/finite_rotation.cpp
     elements/mitc4_shell.cpp
     elements/nonlinear_mitc4_shell.cpp
+    elements/nonlinear_mitc4_inertia.cpp
     fem/dof_manager.cpp
     io/abaqus/domain_builder.cpp
     io/abaqus/domain_mapping_context.cpp
@@ -39,6 +45,7 @@ add_library(
     io/abaqus/surface_definition_mapper.cpp
     io/abaqus/topology_mapper.cpp
     io/hdf5/hdf5_atomic_file.cpp
+    io/hdf5/dynamic_hdf5_results_writer.cpp
     io/hdf5/hdf5_model_writer.cpp
     io/hdf5/nonlinear_hdf5_results_writer.cpp
     io/hdf5/hdf5_primitives.cpp
diff --git a/src/fesa/analysis/dynamic_analysis_state.cpp b/src/fesa/analysis/dynamic_analysis_state.cpp
new file mode 100644
index 0000000..605456b
--- /dev/null
+++ b/src/fesa/analysis/dynamic_analysis_state.cpp
@@ -0,0 +1,406 @@
+#include "fesa/analysis/dynamic_analysis_state.h"
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+#include "fesa/elements/element_definition.h"
+#include "fesa/elements/finite_rotation.h"
+
+namespace fesa {
+namespace {
+
+constexpr std::size_t kDofsPerNode = 6U;
+constexpr std::size_t kAngularDofsPerNode = 3U;
+constexpr std::size_t kShellLocationsPerElement = 4U;
+constexpr std::uint32_t kMaximumNewtonIterations = 100U;
+
+/// @brief Reports a rejected state without changing committed history.
+Status Failure(const FailureCategory category, const std::string& message) {
+  return Status::Failure(category, {{Severity::kError,
+                                     "dynamic-invalid-state",
+                                     {},
+                                     "DYNAMIC_ANALYSIS_STATE",
+                                     {},
+                                     message}});
+}
+
+/// @brief Compares canonical and raw source identity exactly.
+bool SameId(const SourceEntityId& left, const SourceEntityId& right) {
+  return left.instance_name == right.instance_name &&
+         left.source_label == right.source_label &&
+         left.source_label_text == right.source_label_text;
+}
+
+/// @brief Checks all components of one fixed-size physical record.
+template <std::size_t Size>
+bool IsFinite(const std::array<double, Size>& values) {
+  return std::all_of(values.begin(), values.end(),
+                     [](double value) { return std::isfinite(value); });
+}
+
+/// @brief Checks every vector component before state acceptance.
+bool IsFinite(const Vector& values) {
+  for (std::size_t index = 0U; index < values.Size(); ++index) {
+    if (!std::isfinite(values[index])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/// @brief Checks all physical recovery quantities for finite values.
+bool IsFinite(const ShellResultRow& row) {
+  if (!IsFinite(row.natural_coordinates) || !IsFinite(row.generalized_strain) ||
+      !IsFinite(row.section_resultant)) {
+    return false;
+  }
+  for (const auto& axis : row.local_frame) {
+    if (!IsFinite(axis)) {
+      return false;
+    }
+  }
+  return std::all_of(row.stress.begin(), row.stress.end(),
+                     [](const ShellSectionStressRow& stress) {
+                       return std::isfinite(stress.zeta) &&
+                              IsFinite(stress.components);
+                     });
+}
+
+/// @brief Collects stable Domain indices for recovery identity.
+std::vector<EntityIndex> ShellElementOrder(const Domain& domain) {
+  std::vector<EntityIndex> order;
+  for (std::size_t index = 0U; index < domain.Elements().Size(); ++index) {
+    if (domain.Elements()[index].Kind() == ElementDefinitionKind::kMitc4Shell) {
+      order.push_back(static_cast<EntityIndex>(index));
+    }
+  }
+  return order;
+}
+
+/// @brief Requires complete ordered Gauss and section-position rows.
+Status ValidateShellRows(const DynamicAcceptedFrameState& frame,
+                         const std::vector<EntityIndex>& shell_order) {
+  if (shell_order.size() > (std::numeric_limits<std::size_t>::max)() /
+                               kShellLocationsPerElement ||
+      frame.shell_results.size() !=
+          shell_order.size() * kShellLocationsPerElement) {
+    return Failure(FailureCategory::kSolver,
+                   "Shell recovery inventory does not match the Domain.");
+  }
+  constexpr std::array<ShellMidsurfaceLocation, kShellLocationsPerElement>
+      kLocations{ShellMidsurfaceLocation::kGp1, ShellMidsurfaceLocation::kGp2,
+                 ShellMidsurfaceLocation::kGp3, ShellMidsurfaceLocation::kGp4};
+  constexpr std::array<ShellSectionPosition, 3U> kPositions{
+      ShellSectionPosition::kBottom, ShellSectionPosition::kMiddle,
+      ShellSectionPosition::kTop};
+  constexpr std::array<double, 3U> kZeta{-1.0, 0.0, 1.0};
+  const double gauss = 1.0 / std::sqrt(3.0);
+  const std::array<std::array<double, 2U>, 4U> natural{
+      std::array<double, 2U>{-gauss, -gauss},
+      {gauss, -gauss},
+      {gauss, gauss},
+      {-gauss, gauss}};
+  for (std::size_t element = 0U; element < shell_order.size(); ++element) {
+    for (std::size_t point = 0U; point < kShellLocationsPerElement; ++point) {
+      const auto& row =
+          frame.shell_results[element * kShellLocationsPerElement + point];
+      if (row.element != shell_order[element] ||
+          row.location != kLocations[point] ||
+          row.natural_coordinates != natural[point] || !IsFinite(row)) {
+        return Failure(FailureCategory::kSolver,
+                       "Shell recovery rows have invalid identity or values.");
+      }
+      for (std::size_t position = 0U; position < kPositions.size();
+           ++position) {
+        if (row.stress[position].position != kPositions[position] ||
+            row.stress[position].zeta != kZeta[position]) {
+          return Failure(FailureCategory::kSolver,
+                         "Shell stress rows have invalid section identity.");
+        }
+      }
+    }
+  }
+  return Status::Ok();
+}
+
+}  // namespace
+
+Result<DynamicAnalysisState> DynamicAnalysisState::Create(
+    const Domain& domain, const DofManager& dofs) {
+  const DynamicStepDefinition* const dynamic = domain.Dynamic();
+  const std::size_t node_count = domain.Nodes().size();
+  if (dynamic == nullptr || dynamic->increment_count == 0U ||
+      !std::isfinite(dynamic->initial_increment) ||
+      !std::isfinite(dynamic->time_period) ||
+      dynamic->initial_increment <= 0.0 ||
+      dynamic->increment_count > dynamic->maximum_increments ||
+      !std::isfinite(dynamic->alpha) || dynamic->alpha < -1.0 / 3.0 ||
+      dynamic->alpha > 0.0 ||
+      dynamic->beta != 0.25 * (1.0 - dynamic->alpha) * (1.0 - dynamic->alpha) ||
+      dynamic->gamma != 0.5 - dynamic->alpha || dynamic->time_period <= 0.0 ||
+      static_cast<double>(dynamic->increment_count) *
+              dynamic->initial_increment !=
+          dynamic->time_period ||
+      node_count == 0U || domain.ShellElements().Empty() ||
+      domain.Elements().Size() != domain.ShellElements().Size() ||
+      domain.ShellNodeInitialFrames().size() != node_count ||
+      node_count > (std::numeric_limits<std::size_t>::max)() / kDofsPerNode ||
+      dofs.FullDofCount() != node_count * kDofsPerNode ||
+      !dofs.ValidateInvariants().IsOk()) {
+    return Result<DynamicAnalysisState>::Failure(
+        Failure(FailureCategory::kModel,
+                "Dynamic schedule and full-DOF inventory must be valid."));
+  }
+  for (std::size_t index = 0U; index < dofs.PrescribedValues().Size();
+       ++index) {
+    if (dofs.PrescribedValues()[index] != 0.0) {
+      return Result<DynamicAnalysisState>::Failure(
+          Failure(FailureCategory::kModel,
+                  "Dynamic prescribed components must be exactly zero."));
+    }
+  }
+  std::vector<SourceEntityId> source_ids;
+  source_ids.reserve(node_count);
+  for (const Node& node : domain.Nodes()) {
+    source_ids.push_back(node.source_id);
+  }
+  return Result<DynamicAnalysisState>::Success(DynamicAnalysisState{
+      dofs.FullDofCount(), dynamic->increment_count, dynamic->initial_increment,
+      ShellElementOrder(domain), dofs.ConstrainedDofs(), std::move(source_ids),
+      domain.ShellNodeInitialFrames()});
+}
+
+Result<DynamicAcceptedFrameState>
+DynamicAnalysisState::BeginTrialFromCommitted() const {
+  if (accepted_frames_.empty()) {
+    return Result<DynamicAcceptedFrameState>::Failure(
+        Failure(FailureCategory::kSolver,
+                "A dynamic trial requires an accepted frame zero."));
+  }
+  return Result<DynamicAcceptedFrameState>::Success(accepted_frames_.back());
+}
+
+Status DynamicAnalysisState::CommitAcceptedFrame(
+    const DynamicAcceptedFrameState& frame) {
+  if (!initialized_) {
+    return Failure(FailureCategory::kSolver,
+                   "A default dynamic state cannot accept frames.");
+  }
+  const std::size_t expected_frame = accepted_frames_.size();
+  if (expected_frame > (std::numeric_limits<std::uint32_t>::max)() ||
+      frame.frame_index != expected_frame ||
+      frame.increment_index != expected_frame ||
+      frame.increment_index > increment_count_ || !std::isfinite(frame.time) ||
+      frame.time !=
+          static_cast<double>(frame.increment_index) * initial_increment_ ||
+      frame.is_initial != (frame.frame_index == 0U) ||
+      (frame.is_initial && frame.iteration_count != 0U) ||
+      frame.iteration_count > kMaximumNewtonIterations ||
+      (frame.is_initial && std::signbit(frame.time))) {
+    return Failure(FailureCategory::kSolver,
+                   "Frame schedule or iteration identity is invalid.");
+  }
+  if (!accepted_frames_.empty() && frame.time <= accepted_frames_.back().time) {
+    return Failure(FailureCategory::kSolver,
+                   "Accepted dynamic frame times must strictly increase.");
+  }
+  const std::size_t node_count = nodal_source_ids_.size();
+  if (frame.nodal_internal_order.size() != node_count ||
+      frame.nodal_source_ids.size() != node_count ||
+      frame.nodal_triad.size() != node_count ||
+      frame.nodal_director.size() != node_count) {
+    return Failure(FailureCategory::kSolver,
+                   "Frame node inventory does not match the Domain.");
+  }
+  for (std::size_t node = 0U; node < node_count; ++node) {
+    if (frame.nodal_internal_order[node] != node ||
+        !SameId(frame.nodal_source_ids[node], nodal_source_ids_[node]) ||
+        !IsFinite(frame.nodal_triad[node][0U]) ||
+        !IsFinite(frame.nodal_triad[node][1U]) ||
+        !IsFinite(frame.nodal_triad[node][2U]) ||
+        !IsFinite(frame.nodal_director[node])) {
+      return Failure(FailureCategory::kSolver,
+                     "Frame nodal identity or orientation is invalid.");
+    }
+  }
+  const std::array<const Vector*, 10U> full_vectors{
+      &frame.generalized_coordinates,
+      &frame.velocity,
+      &frame.acceleration,
+      &frame.algorithmic_acceleration,
+      &frame.inertia_force,
+      &frame.internal_force,
+      &frame.external_force,
+      &frame.residual,
+      &frame.reaction,
+      &frame.residual_scale};
+  for (const Vector* values : full_vectors) {
+    if (values->Size() != full_dof_count_ || !IsFinite(*values)) {
+      return Failure(FailureCategory::kSolver,
+                     "Frame generalized vector inventory is invalid.");
+    }
+  }
+  // N5 preserves the existing chart and 1e-12 orientation consistency checks.
+  for (std::size_t node = 0U; node < node_count; ++node) {
+    Matrix initial{3U, 3U};
+    for (std::size_t component = 0U; component < 3U; ++component) {
+      initial(component, 0U) = initial_frames_[node].tangent_a[component];
+      initial(component, 1U) = initial_frames_[node].tangent_b[component];
+      initial(component, 2U) = initial_frames_[node].director[component];
+    }
+    const std::size_t offset = node * kDofsPerNode;
+    const Vector3 phi{frame.generalized_coordinates[offset + 3U],
+                      frame.generalized_coordinates[offset + 4U],
+                      frame.generalized_coordinates[offset + 5U]};
+    const auto rotation = MakeFiniteRotationState(phi, initial);
+    if (!rotation.HasValue()) {
+      return Failure(FailureCategory::kSolver,
+                     "Frame rotation is outside the valid initial chart.");
+    }
+    for (std::size_t axis = 0U; axis < 3U; ++axis) {
+      for (std::size_t component = 0U; component < 3U; ++component) {
+        if (std::abs(frame.nodal_triad[node][axis][component] -
+                     rotation.Value().q(component, axis)) > 1.0e-12) {
+          return Failure(FailureCategory::kSolver,
+                         "Frame triad does not match its rotation coordinate.");
+        }
+      }
+      if (std::abs(frame.nodal_director[node][axis] -
+                   rotation.Value().q(axis, 2U)) > 1.0e-12) {
+        return Failure(
+            FailureCategory::kSolver,
+            "Frame director does not match its rotation coordinate.");
+      }
+    }
+  }
+  const std::array<const Vector*, 6U> hidden_vectors{
+      &frame.hidden_constraint,
+      &frame.hidden_velocity_defect,
+      &frame.hidden_acceleration_defect,
+      &frame.hidden_constraint_scale,
+      &frame.hidden_velocity_defect_scale,
+      &frame.hidden_acceleration_defect_scale};
+  for (const Vector* values : hidden_vectors) {
+    if (values->Size() != frame.hidden_constraint.Size() ||
+        !IsFinite(*values)) {
+      return Failure(FailureCategory::kSolver,
+                     "Frame hidden-constraint evidence has invalid size.");
+    }
+  }
+  if ((!accepted_frames_.empty() &&
+       frame.hidden_constraint.Size() != hidden_constraint_count_) ||
+      frame.angular_velocity.Size() != node_count * kAngularDofsPerNode ||
+      frame.angular_acceleration.Size() != node_count * kAngularDofsPerNode ||
+      !IsFinite(frame.angular_velocity) ||
+      !IsFinite(frame.angular_acceleration) ||
+      !std::isfinite(frame.kinetic_energy) ||
+      !std::isfinite(frame.physical_strain_energy) ||
+      !std::isfinite(frame.drilling_energy) ||
+      !std::isfinite(frame.external_work) ||
+      !std::isfinite(frame.energy_defect) ||
+      !IsFinite(frame.global_equilibrium) || !IsFinite(frame.linear_momentum) ||
+      !IsFinite(frame.angular_momentum) ||
+      !IsFinite(frame.linear_momentum_rate) ||
+      !IsFinite(frame.angular_momentum_rate) ||
+      !IsFinite(frame.free_residual_metrics)) {
+    return Failure(FailureCategory::kSolver,
+                   "Frame physical evidence is nonfinite or has invalid size.");
+  }
+  for (const std::size_t dof : constrained_dofs_) {
+    if (frame.generalized_coordinates[dof] != 0.0 ||
+        frame.velocity[dof] != 0.0 || frame.acceleration[dof] != 0.0 ||
+        frame.algorithmic_acceleration[dof] != 0.0) {
+      return Failure(FailureCategory::kSolver,
+                     "Fixed boundary components must remain exactly zero.");
+    }
+  }
+  for (const Vector* scales :
+       {&frame.hidden_constraint_scale, &frame.hidden_velocity_defect_scale,
+        &frame.hidden_acceleration_defect_scale}) {
+    for (std::size_t index = 0U; index < scales->Size(); ++index) {
+      if ((*scales)[index] < 0.0) {
+        return Failure(FailureCategory::kSolver,
+                       "Hidden evidence scales must be nonnegative.");
+      }
+    }
+  }
+  if (frame.free_residual_metrics[0U] < 0.0 ||
+      frame.free_residual_metrics[1U] < 0.0 ||
+      (frame.is_initial &&
+       (frame.external_work != 0.0 || frame.energy_defect != 0.0))) {
+    return Failure(FailureCategory::kSolver,
+                   "Frame metric or initial energy evidence is invalid.");
+  }
+  std::size_t constraint = 0U;
+  for (std::size_t dof = 0U; dof < full_dof_count_; ++dof) {
+    const bool constrained = constraint < constrained_dofs_.size() &&
+                             constrained_dofs_[constraint] == dof;
+    if (constrained) ++constraint;
+    if (frame.residual[dof] != frame.inertia_force[dof] +
+                                   frame.internal_force[dof] -
+                                   frame.external_force[dof] ||
+        frame.reaction[dof] != (constrained ? frame.residual[dof] : 0.0) ||
+        frame.residual_scale[dof] < 0.0 ||
+        (!accepted_frames_.empty() &&
+         frame.external_force[dof] !=
+             accepted_frames_.front().external_force[dof]) ||
+        (frame.is_initial &&
+         (frame.generalized_coordinates[dof] != 0.0 ||
+          frame.velocity[dof] != 0.0 ||
+          frame.acceleration[dof] != frame.algorithmic_acceleration[dof]))) {
+      return Failure(
+          FailureCategory::kSolver,
+          "Frame force, reaction, or initial-state identity is invalid.");
+    }
+  }
+  const Status shell_status = ValidateShellRows(frame, shell_element_order_);
+  if (!shell_status.IsOk()) {
+    return shell_status;
+  }
+  const std::size_t hidden_constraint_count = frame.hidden_constraint.Size();
+  // Copy insertion preserves the previous vector when allocation/copy fails.
+  accepted_frames_.push_back(frame);
+  hidden_constraint_count_ = hidden_constraint_count;
+  return Status::Ok();
+}
+
+void DynamicAnalysisState::DiscardTrial() noexcept {}
+
+const std::vector<DynamicAcceptedFrameState>&
+DynamicAnalysisState::AcceptedFrames() const noexcept {
+  return accepted_frames_;
+}
+
+const DynamicAcceptedFrameState& DynamicAnalysisState::CommittedState() const {
+  if (accepted_frames_.empty()) {
+    throw std::logic_error{
+        "Committed dynamic state is unavailable before frame zero."};
+  }
+  return accepted_frames_.back();
+}
+
+bool DynamicAnalysisState::IsInitialized() const noexcept {
+  return initialized_;
+}
+
+DynamicAnalysisState::DynamicAnalysisState(
+    const std::size_t full_dof_count, const std::uint32_t increment_count,
+    const double initial_increment,
+    std::vector<EntityIndex> shell_element_order,
+    std::vector<std::size_t> constrained_dofs,
+    std::vector<SourceEntityId> nodal_source_ids,
+    std::vector<ShellNodeInitialFrame> initial_frames)
+    : full_dof_count_{full_dof_count},
+      increment_count_{increment_count},
+      initial_increment_{initial_increment},
+      shell_element_order_{std::move(shell_element_order)},
+      constrained_dofs_{std::move(constrained_dofs)},
+      nodal_source_ids_{std::move(nodal_source_ids)},
+      initial_frames_{std::move(initial_frames)},
+      initialized_{true} {}
+
+}  // namespace fesa
diff --git a/src/fesa/analysis/hht_dynamic_algebra.cpp b/src/fesa/analysis/hht_dynamic_algebra.cpp
new file mode 100644
index 0000000..de0f0d4
--- /dev/null
+++ b/src/fesa/analysis/hht_dynamic_algebra.cpp
@@ -0,0 +1,732 @@
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <iomanip>
+#include <limits>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "analysis/hht_dynamic_internal.h"
+#include "fesa/math/matrix.h"
+#include "fesa/solvers/linear/linear_solver.h"
+#include "fesa/solvers/linear/tangent_solver.h"
+
+namespace fesa {
+namespace hht_internal {
+namespace {
+
+/// @brief Attaches a fail-closed dynamic diagnostic to the source model.
+Status Failure(const Domain& domain, const std::string& code,
+               const std::string& message) {
+  return Status::Failure(FailureCategory::kSolver, {{Severity::kError,
+                                                     code,
+                                                     {domain.SourcePath(), 0U},
+                                                     "*DYNAMIC",
+                                                     {},
+                                                     message}});
+}
+
+/// @brief Reads one structural entry, including an implicit exact zero.
+double Entry(const SparseMatrix& matrix, const std::size_t row,
+             const std::size_t column) {
+  const auto first = matrix.ColumnIndices().begin() +
+                     static_cast<std::ptrdiff_t>(matrix.RowOffsets()[row]);
+  const auto last = matrix.ColumnIndices().begin() +
+                    static_cast<std::ptrdiff_t>(matrix.RowOffsets()[row + 1U]);
+  const auto found = std::lower_bound(first, last, column);
+  return found != last && *found == column
+             ? matrix.Values()[static_cast<std::size_t>(
+                   found - matrix.ColumnIndices().begin())]
+             : 0.0;
+}
+
+/// @brief Applies the fixed translation length scale by full-space row.
+double Scale(const std::size_t full_dof, const double length) {
+  return full_dof % 6U < 3U ? length : 1.0;
+}
+
+/// @brief Checks a dimensionless ratio without inventing a zero-scale floor.
+bool Within(const double value, const double scale, const double tolerance) {
+  return std::isfinite(value) && std::isfinite(scale) && scale >= 0.0 &&
+         (scale == 0.0 ? value == 0.0 : std::abs(value) / scale <= tolerance);
+}
+
+/// @brief Verifies dimensions and finite values before algebraic contractions.
+Status Validate(const Domain& domain, const DofManager& dofs,
+                const DynamicAssembly& assembly, const double length) {
+  const std::size_t count = dofs.FullDofCount();
+  if (!std::isfinite(length) || !(length > 0.0) || count % 6U != 0U ||
+      assembly.rotations.size() != count / 6U) {
+    return Failure(domain, "dynamic-invalid-algebra-state",
+                   "Dynamic algebra requires complete rotations and a positive "
+                   "reference length.");
+  }
+  for (const Vector* vector :
+       {&assembly.frame.velocity, &assembly.frame.acceleration,
+        &assembly.frame.internal_force, &assembly.frame.external_force,
+        &assembly.frame.inertia_force, &assembly.frame.residual_scale,
+        &assembly.force_directional_second,
+        &assembly.force_directional_second_scale}) {
+    if (vector->Size() != count) {
+      return Failure(
+          domain, "dynamic-invalid-algebra-state",
+          "Dynamic algebra vectors must match the full equation space.");
+    }
+    for (std::size_t i = 0; i < count; ++i) {
+      if (!std::isfinite((*vector)[i])) {
+        return Failure(domain, "dynamic-invalid-algebra-state",
+                       "Dynamic algebra vectors must remain finite.");
+      }
+    }
+  }
+  for (const Vector* vector :
+       {&assembly.hidden_second, &assembly.hidden_second_scale}) {
+    if (vector->Size() != assembly.rotations.size()) {
+      return Failure(
+          domain, "dynamic-invalid-algebra-state",
+          "Exact scalar hidden Hessian evidence must cover every node.");
+    }
+    for (std::size_t i = 0; i < vector->Size(); ++i) {
+      if (!std::isfinite((*vector)[i]) ||
+          (vector == &assembly.hidden_second_scale && (*vector)[i] < 0.0)) {
+        return Failure(domain, "dynamic-invalid-algebra-state",
+                       "Scalar hidden Hessian evidence must be finite with "
+                       "nonnegative scale.");
+      }
+    }
+  }
+  for (const SparseMatrix* matrix : {&assembly.mass, &assembly.internal_tangent,
+                                     &assembly.drilling_metric}) {
+    if (matrix->Rows() != count || matrix->Columns() != count ||
+        !matrix->Validate().IsOk()) {
+      return Failure(
+          domain, "dynamic-invalid-algebra-state",
+          "Dynamic algebra operators must match the full equation space.");
+    }
+  }
+  for (const auto& rotation : assembly.rotations) {
+    if (!rotation.drill_null.IsFinite() ||
+        !(std::abs(rotation.drill_null.Dot(rotation.drill_null) - 1.0) <=
+          1.0e-12)) {
+      return Failure(
+          domain, "dynamic-invalid-analytic-null",
+          "Every analytic drilling null must remain finite and unit length.");
+    }
+  }
+  return Status::Ok();
+}
+
+using BasisRow = std::vector<std::pair<std::size_t, double>>;
+
+/// @brief Holds sparse nodal physical-complement columns and their mass.
+struct PhysicalSpace {
+  std::vector<BasisRow> rows;
+  SparseMatrix mass;
+};
+
+/// @brief Checks a nonempty nodal physical block without removing small pivots.
+Status CheckLocalMass(const Domain& domain, const SparseMatrix& matrix,
+                      const std::size_t begin, const std::size_t end) {
+  if (begin == end) return Status::Ok();
+  const std::size_t size = end - begin;
+  std::array<std::array<double, 6>, 6> block{};
+  std::array<std::array<double, 6>, 6> lower{};
+  double scale = 0.0;
+  for (std::size_t i = 0; i < size; ++i) {
+    for (std::size_t j = 0; j < size; ++j) {
+      block[i][j] = Entry(matrix, begin + i, begin + j);
+      scale = std::max(scale, std::abs(block[i][j]));
+    }
+  }
+  if (!std::isfinite(scale) || !(scale > 0.0)) {
+    return Failure(domain, "dynamic-positive-mass",
+                   "A nonempty physical mass block has no positive scale.");
+  }
+  double norm = 0.0;
+  for (std::size_t i = 0; i < size; ++i) {
+    double sum = 0.0;
+    for (std::size_t j = 0; j < size; ++j) {
+      block[i][j] /= scale;
+      sum += std::abs(block[i][j]);
+    }
+    norm = std::max(norm, sum);
+    for (std::size_t j = 0; j <= i; ++j) {
+      double value = block[i][j];
+      for (std::size_t k = 0; k < j; ++k) value -= lower[i][k] * lower[j][k];
+      if (!std::isfinite(value) || (i == j && !(value > 0.0))) {
+        return Failure(
+            domain, "dynamic-positive-mass",
+            "Physical mass requires strictly positive Cholesky pivots.");
+      }
+      lower[i][j] = i == j ? std::sqrt(value) : value / lower[j][j];
+    }
+  }
+  std::array<double, 6> sums{};
+  for (std::size_t column = 0; column < size; ++column) {
+    std::array<double, 6> solution{};
+    for (std::size_t i = 0; i < size; ++i) {
+      double value = i == column ? 1.0 : 0.0;
+      for (std::size_t k = 0; k < i; ++k) value -= lower[i][k] * solution[k];
+      solution[i] = value / lower[i][i];
+    }
+    for (std::size_t reverse = size; reverse > 0U; --reverse) {
+      const std::size_t i = reverse - 1U;
+      double value = solution[i];
+      for (std::size_t k = i + 1U; k < size; ++k)
+        value -= lower[k][i] * solution[k];
+      solution[i] = value / lower[i][i];
+      sums[i] += std::abs(solution[i]);
+    }
+  }
+  const double inverse_norm = *std::max_element(sums.begin(), sums.end());
+  const double rcond = 1.0 / norm / inverse_norm;
+  if (!std::isfinite(inverse_norm) || !std::isfinite(rcond) ||
+      !(rcond >= std::ldexp(1.0, -32))) {
+    return Failure(
+        domain, "dynamic-positive-mass-conditioning",
+        "A nodal free physical block reciprocal condition is below 2^-32.");
+  }
+  return Status::Ok();
+}
+
+/// @brief Builds the actual free-space analytic complement, without rank cuts.
+Result<PhysicalSpace> BuildPhysicalSpace(
+    const Domain& domain, const DofManager& dofs,
+    const DynamicAssembly& assembly, const double length,
+    const std::vector<std::size_t>& null_nodes, LinearSolver& solver) {
+  const auto scaled = ScaledFree(assembly.mass, dofs, length);
+  if (!scaled.HasValue())
+    return Result<PhysicalSpace>::Failure(scaled.GetStatus());
+  const SparseMatrix& mass = scaled.Value();
+  double mass_scale = 0.0;
+  for (const double entry : mass.Values())
+    mass_scale = std::max(mass_scale, std::abs(entry));
+  const std::size_t no_null = std::numeric_limits<std::size_t>::max();
+  std::vector<std::size_t> node_null(assembly.rotations.size(), no_null);
+  for (std::size_t i = 0; i < null_nodes.size(); ++i)
+    node_null[null_nodes[i]] = i;
+  double mass_norm = 0.0;
+  double symmetry_error = 0.0;
+  double null_error = 0.0;
+  if (mass_scale > 0.0) {
+    for (std::size_t row = 0; row < mass.Rows(); ++row) {
+      std::vector<double> action(null_nodes.size(), 0.0);
+      for (std::size_t index = mass.RowOffsets()[row];
+           index < mass.RowOffsets()[row + 1U]; ++index) {
+        const std::size_t column = mass.ColumnIndices()[index];
+        const double entry = mass.Values()[index] / mass_scale;
+        mass_norm = std::hypot(mass_norm, entry);
+        symmetry_error = std::hypot(
+            symmetry_error, entry - Entry(mass, column, row) / mass_scale);
+        const std::size_t full = dofs.FreeDofs()[column];
+        if (full % 6U >= 3U && node_null[full / 6U] != no_null) {
+          action[node_null[full / 6U]] +=
+              entry * assembly.rotations[full / 6U].drill_null[full % 6U - 3U];
+        }
+      }
+      for (const double value : action)
+        null_error = std::hypot(null_error, value);
+    }
+  }
+  if ((mass_norm > 0.0 && symmetry_error / mass_norm > 1.0e-12) ||
+      (!null_nodes.empty() && mass_norm > 0.0 &&
+       null_error / mass_norm /
+               std::sqrt(static_cast<double>(null_nodes.size())) >
+           1.0e-12)) {
+    return Result<PhysicalSpace>::Failure(
+        Failure(domain, "dynamic-invalid-mass-null",
+                "Scaled free mass symmetry or analytic null action failed."));
+  }
+  std::vector<BasisRow> rows(dofs.FullDofCount());
+  std::vector<std::size_t> node_starts;
+  std::size_t dimension = 0U;
+  for (std::size_t node = 0; node < assembly.rotations.size(); ++node) {
+    node_starts.push_back(dimension);
+    for (std::size_t component = 0; component < 3; ++component) {
+      if (dofs.FreeEquation(6U * node + component).has_value()) {
+        rows[6U * node + component].push_back({dimension++, 1.0});
+      }
+    }
+    std::vector<std::size_t> free_rotations;
+    for (std::size_t component = 0; component < 3; ++component) {
+      if (dofs.FreeEquation(6U * node + 3U + component).has_value()) {
+        free_rotations.push_back(component);
+      }
+    }
+    if (node_null[node] == no_null) {
+      for (const std::size_t component : free_rotations) {
+        rows[6U * node + 3U + component].push_back({dimension++, 1.0});
+      }
+      continue;
+    }
+    const Vector3 n = assembly.rotations[node].drill_null;
+    std::stable_sort(free_rotations.begin(), free_rotations.end(),
+                     [&](const std::size_t a, const std::size_t b) {
+                       return std::abs(n[a]) < std::abs(n[b]);
+                     });
+    std::vector<Vector3> basis;
+    for (std::size_t column = 0; column + 1U < free_rotations.size();
+         ++column) {
+      std::array<double, 3> axis{};
+      axis[free_rotations[column]] = 1.0;
+      Vector3 tangent = Vector3{axis} - n[free_rotations[column]] * n;
+      for (const Vector3& previous : basis)
+        tangent = tangent - tangent.Dot(previous) * previous;
+      const double norm = tangent.Norm();
+      if (!std::isfinite(norm) || !(norm > 0.0)) {
+        return Result<PhysicalSpace>::Failure(Failure(
+            domain, "dynamic-invalid-analytic-null",
+            "The free physical complement lost its analytic dimension."));
+      }
+      tangent = tangent / norm;
+      basis.push_back(tangent);
+      for (const std::size_t component : free_rotations) {
+        rows[6U * node + 3U + component].push_back(
+            {dimension, tangent[component]});
+      }
+      ++dimension;
+    }
+  }
+  std::vector<CooContribution> entries;
+  node_starts.push_back(dimension);
+  double complement_gram_error = 0.0;
+  double null_gram_error = 0.0;
+  double cross_gram_error = 0.0;
+  for (std::size_t node = 0; node < assembly.rotations.size(); ++node) {
+    const std::size_t first = node_starts[node];
+    const std::size_t last = node_starts[node + 1U];
+    std::size_t free_count = 0U;
+    for (std::size_t c = 0; c < 6; ++c) {
+      if (dofs.FreeEquation(6U * node + c).has_value()) ++free_count;
+    }
+    const bool has_null = node_null[node] != no_null;
+    if (last - first + (has_null ? 1U : 0U) != free_count) {
+      return Result<PhysicalSpace>::Failure(Failure(
+          domain, "dynamic-invalid-analytic-null",
+          "The free physical and null bases do not span the free space."));
+    }
+    for (std::size_t a = first; a < last; ++a) {
+      for (std::size_t b = first; b < last; ++b) {
+        double gram = a == b ? -1.0 : 0.0;
+        for (std::size_t c = 0; c < 6; ++c) {
+          double pa = 0.0;
+          double pb = 0.0;
+          for (const auto& entry : rows[6U * node + c]) {
+            if (entry.first == a) pa = entry.second;
+            if (entry.first == b) pb = entry.second;
+          }
+          gram += pa * pb;
+        }
+        complement_gram_error = std::hypot(complement_gram_error, gram);
+      }
+      if (has_null) {
+        double gram = 0.0;
+        for (std::size_t c = 0; c < 3; ++c) {
+          for (const auto& entry : rows[6U * node + 3U + c]) {
+            if (entry.first == a)
+              gram += entry.second * assembly.rotations[node].drill_null[c];
+          }
+        }
+        cross_gram_error = std::hypot(cross_gram_error, gram);
+      }
+    }
+    if (has_null)
+      null_gram_error =
+          std::hypot(null_gram_error, assembly.rotations[node].drill_null.Dot(
+                                          assembly.rotations[node].drill_null) -
+                                          1.0);
+  }
+  const double full_gram_error = std::hypot(
+      complement_gram_error,
+      std::hypot(null_gram_error, std::sqrt(2.0) * cross_gram_error));
+  if (!(cross_gram_error <= 1.0e-12) || !(full_gram_error <= 1.0e-12) ||
+      (!null_nodes.empty() &&
+       !(null_gram_error / std::sqrt(static_cast<double>(null_nodes.size())) <=
+         1.0e-12))) {
+    return Result<PhysicalSpace>::Failure(Failure(
+        domain, "dynamic-invalid-analytic-null",
+        "The scaled physical and analytic null Gram identities failed."));
+  }
+  for (std::size_t i = 0; i < dimension; ++i)
+    entries.push_back({i, i, 0.0, 0U, entries.size()});
+  for (std::size_t row = 0; row < mass.Rows(); ++row) {
+    const auto& left = rows[dofs.FreeDofs()[row]];
+    for (std::size_t index = mass.RowOffsets()[row];
+         index < mass.RowOffsets()[row + 1U]; ++index) {
+      const auto& right = rows[dofs.FreeDofs()[mass.ColumnIndices()[index]]];
+      for (const auto& a : left) {
+        for (const auto& b : right) {
+          entries.push_back({a.first, b.first,
+                             a.second * mass.Values()[index] * b.second, 0U,
+                             entries.size()});
+        }
+      }
+    }
+  }
+  auto block = MakeSparse(dimension, dimension, std::move(entries));
+  if (!block.HasValue())
+    return Result<PhysicalSpace>::Failure(block.GetStatus());
+  for (std::size_t node = 0; node < assembly.rotations.size(); ++node) {
+    const Status local = CheckLocalMass(
+        domain, block.Value(), node_starts[node], node_starts[node + 1U]);
+    if (!local.IsOk()) return Result<PhysicalSpace>::Failure(local);
+  }
+  if (dimension > 0U) {
+    const Status factor = solver.Factorize(block.Value());
+    if (!factor.IsOk()) return Result<PhysicalSpace>::Failure(factor);
+  }
+  return Result<PhysicalSpace>::Success(
+      {std::move(rows), std::move(block.Value())});
+}
+
+/// @brief Builds psi_q from the current unit-null derivatives and force
+/// Hessian.
+Result<SparseMatrix> ConstraintGradient(const DynamicAssembly& assembly,
+                                        const std::vector<std::size_t>& nodes) {
+  std::vector<CooContribution> entries;
+  const auto& stiffness = assembly.internal_tangent;
+  for (std::size_t row = 0; row < nodes.size(); ++row) {
+    const std::size_t node = nodes[row];
+    const auto& rotation = assembly.rotations[node];
+    for (std::size_t c = 0; c < 3; ++c) {
+      const std::size_t full = 6U * node + 3U + c;
+      const double g = assembly.frame.internal_force[full] -
+                       assembly.frame.external_force[full];
+      for (std::size_t d = 0; d < 3; ++d) {
+        entries.push_back({row, 6U * node + 3U + d,
+                           rotation.null_gradient(c, d) * g, 0U,
+                           entries.size()});
+      }
+      for (std::size_t index = stiffness.RowOffsets()[full];
+           index < stiffness.RowOffsets()[full + 1U]; ++index) {
+        entries.push_back({row, stiffness.ColumnIndices()[index],
+                           rotation.drill_null[c] * stiffness.Values()[index],
+                           0U, entries.size()});
+      }
+    }
+  }
+  return MakeSparse(nodes.size(), stiffness.Columns(), std::move(entries));
+}
+
+/// @brief Stores W-scaled regularity with exact inverse-action infinity norms.
+struct Regularity {
+  SparseMatrix matrix;
+  Vector weights;
+};
+
+/// @brief Factors W^-1 psi_q N W^-1 and checks the prescribed condition bound.
+Result<Regularity> CheckRegularity(const Domain& domain,
+                                   const DynamicAssembly& assembly,
+                                   const std::vector<std::size_t>& nodes,
+                                   const SparseMatrix& gradient,
+                                   TangentSolver& solver) {
+  const std::size_t no_null = std::numeric_limits<std::size_t>::max();
+  std::vector<std::size_t> node_null(assembly.rotations.size(), no_null);
+  Vector weights{nodes.size()};
+  for (std::size_t i = 0; i < nodes.size(); ++i) {
+    node_null[nodes[i]] = i;
+    const auto& n = assembly.rotations[nodes[i]].drill_null;
+    double stiffness = 0.0;
+    for (std::size_t a = 0; a < 3; ++a) {
+      for (std::size_t b = 0; b < 3; ++b) {
+        stiffness += n[a] *
+                     Entry(assembly.drilling_metric, 6U * nodes[i] + 3U + a,
+                           6U * nodes[i] + 3U + b) *
+                     n[b];
+      }
+    }
+    if (!std::isfinite(stiffness) || !(stiffness > 0.0)) {
+      return Result<Regularity>::Failure(
+          Failure(domain, "dynamic-algebraic-regularity",
+                  "Every admissible drill null requires positive finite "
+                  "drilling metric."));
+    }
+    weights[i] = std::sqrt(stiffness);
+  }
+  std::vector<CooContribution> entries;
+  for (std::size_t row = 0; row < nodes.size(); ++row) {
+    entries.push_back({row, row, 0.0, 0U, entries.size()});
+    for (std::size_t index = gradient.RowOffsets()[row];
+         index < gradient.RowOffsets()[row + 1U]; ++index) {
+      const std::size_t full = gradient.ColumnIndices()[index];
+      if (full % 6U >= 3U && node_null[full / 6U] != no_null) {
+        const std::size_t column = node_null[full / 6U];
+        entries.push_back(
+            {row, column,
+             gradient.Values()[index] *
+                 assembly.rotations[full / 6U].drill_null[full % 6U - 3U] /
+                 weights[row] / weights[column],
+             0U, entries.size()});
+      }
+    }
+  }
+  auto matrix = MakeSparse(nodes.size(), nodes.size(), std::move(entries));
+  if (!matrix.HasValue())
+    return Result<Regularity>::Failure(matrix.GetStatus());
+  if (nodes.empty())
+    return Result<Regularity>::Success(
+        {std::move(matrix.Value()), std::move(weights)});
+  const Status factor = solver.FactorizeFresh(matrix.Value());
+  if (!factor.IsOk()) return Result<Regularity>::Failure(factor);
+  double norm = 0.0;
+  for (std::size_t row = 0; row < nodes.size(); ++row) {
+    double sum = 0.0;
+    for (std::size_t index = matrix.Value().RowOffsets()[row];
+         index < matrix.Value().RowOffsets()[row + 1U]; ++index)
+      sum += std::abs(matrix.Value().Values()[index]);
+    norm = std::max(norm, sum);
+  }
+  Vector inverse_sums{nodes.size()};
+  // Columns are discarded after their absolute row sums are accumulated;
+  // a global dense inverse is never retained.
+  for (std::size_t column = 0; column < nodes.size(); ++column) {
+    Vector rhs{nodes.size()};
+    rhs[column] = 1.0;
+    Vector solution{nodes.size()};
+    const Status solved = solver.SolveCorrection(rhs, solution);
+    if (!solved.IsOk()) return Result<Regularity>::Failure(solved);
+    const Status checked = CheckLinearSolve(matrix.Value(), rhs, solution);
+    if (!checked.IsOk()) return Result<Regularity>::Failure(checked);
+    for (std::size_t row = 0; row < nodes.size(); ++row)
+      inverse_sums[row] += std::abs(solution[row]);
+  }
+  double inverse_norm = 0.0;
+  for (std::size_t row = 0; row < nodes.size(); ++row)
+    inverse_norm = std::max(inverse_norm, inverse_sums[row]);
+  const double condition = 1.0 / norm / inverse_norm;
+  if (!std::isfinite(norm) || !std::isfinite(inverse_norm) ||
+      !std::isfinite(condition) || !(condition >= std::ldexp(1.0, -32))) {
+    std::ostringstream message;
+    message << std::setprecision(17)
+            << "Scaled null regularity reciprocal infinity condition "
+            << condition << " is below 2^-32; norm=" << norm
+            << ", inverse-action norm=" << inverse_norm << ".";
+    return Result<Regularity>::Failure(
+        Failure(domain, "dynamic-algebraic-conditioning", message.str()));
+  }
+  return Result<Regularity>::Success(
+      {std::move(matrix.Value()), std::move(weights)});
+}
+
+/// @brief Recovers raw hidden equations and uncancelled derivative term scales.
+Status HiddenEvidence(const Domain& domain, const DynamicAssembly& assembly,
+                      const std::vector<std::size_t>& nodes,
+                      const SparseMatrix& gradient,
+                      DynamicAcceptedFrameState* frame,
+                      const bool require_acceleration) {
+  Vector psi{nodes.size()};
+  Vector psi_scale{nodes.size()};
+  Vector velocity_defect = gradient.Multiply(frame->velocity);
+  Vector acceleration_defect = gradient.Multiply(frame->acceleration);
+  Vector velocity_scale{nodes.size()};
+  Vector acceleration_scale{nodes.size()};
+  for (std::size_t row = 0; row < nodes.size(); ++row) {
+    const std::size_t node = nodes[row];
+    const auto& rotation = assembly.rotations[node];
+    for (std::size_t index = gradient.RowOffsets()[row];
+         index < gradient.RowOffsets()[row + 1U]; ++index) {
+      const std::size_t column = gradient.ColumnIndices()[index];
+      velocity_scale[row] +=
+          std::abs(gradient.Values()[index] * frame->velocity[column]);
+      acceleration_scale[row] +=
+          std::abs(gradient.Values()[index] * frame->acceleration[column]);
+    }
+    for (std::size_t c = 0; c < 3; ++c) {
+      const std::size_t full = 6U * node + 3U + c;
+      const double g =
+          frame->internal_force[full] - frame->external_force[full];
+      const double n = rotation.drill_null[c];
+      psi[row] += n * g;
+      psi_scale[row] += std::abs(n) * frame->residual_scale[full];
+    }
+    acceleration_defect[row] += assembly.hidden_second[node];
+    acceleration_scale[row] += assembly.hidden_second_scale[node];
+    if (!Within(psi[row], psi_scale[row], 1.0e-10) ||
+        (frame->is_initial &&
+         !Within(velocity_defect[row], velocity_scale[row], 1.0e-10)) ||
+        (frame->is_initial && require_acceleration &&
+         !Within(acceleration_defect[row], acceleration_scale[row], 1.0e-10)) ||
+        !std::isfinite(velocity_defect[row]) ||
+        !std::isfinite(acceleration_defect[row]) ||
+        !std::isfinite(velocity_scale[row]) ||
+        !std::isfinite(acceleration_scale[row])) {
+      std::ostringstream message;
+      message << std::setprecision(17)
+              << "Dynamic null consistency failed at node "
+              << domain.Nodes()[node].source_id.instance_name << ":"
+              << domain.Nodes()[node].source_id.source_label_text
+              << "; psi=" << psi[row] << ", psi_scale=" << psi_scale[row]
+              << ", velocity=" << velocity_defect[row]
+              << ", velocity_scale=" << velocity_scale[row]
+              << ", acceleration=" << acceleration_defect[row]
+              << ", acceleration_scale=" << acceleration_scale[row]
+              << ", initial=" << frame->is_initial
+              << ", enforce_acceleration=" << require_acceleration << ".";
+      return Failure(domain, "dynamic-hidden-constraint", message.str());
+    }
+  }
+  frame->hidden_constraint = std::move(psi);
+  frame->hidden_constraint_scale = std::move(psi_scale);
+  frame->hidden_velocity_defect = std::move(velocity_defect);
+  frame->hidden_velocity_defect_scale = std::move(velocity_scale);
+  frame->hidden_acceleration_defect = std::move(acceleration_defect);
+  frame->hidden_acceleration_defect_scale = std::move(acceleration_scale);
+  return Status::Ok();
+}
+
+}  // namespace
+
+std::vector<std::size_t> NullNodes(
+    const DofManager& dofs,
+    const std::vector<DynamicRotationKinematics>& rotations) {
+  std::vector<std::size_t> nodes;
+  for (std::size_t node = 0; node < rotations.size(); ++node) {
+    bool admissible = true;
+    for (std::size_t component = 0; component < 3; ++component) {
+      if (!dofs.FreeEquation(6U * node + 3U + component).has_value() &&
+          rotations[node].drill_null[component] != 0.0)
+        admissible = false;
+    }
+    if (admissible) nodes.push_back(node);
+  }
+  return nodes;
+}
+
+Result<Vector> InitializeAcceleration(const Domain& domain,
+                                      const DofManager& dofs,
+                                      const DynamicAssembly& initial,
+                                      const double length,
+                                      LinearSolver& positive_solver,
+                                      TangentSolver& tangent_solver) {
+  const Status valid = Validate(domain, dofs, initial, length);
+  if (!valid.IsOk()) return Result<Vector>::Failure(valid);
+  const auto nodes = NullNodes(dofs, initial.rotations);
+  auto physical =
+      BuildPhysicalSpace(domain, dofs, initial, length, nodes, positive_solver);
+  if (!physical.HasValue())
+    return Result<Vector>::Failure(physical.GetStatus());
+  auto gradient = ConstraintGradient(initial, nodes);
+  if (!gradient.HasValue())
+    return Result<Vector>::Failure(gradient.GetStatus());
+  auto regularity =
+      CheckRegularity(domain, initial, nodes, gradient.Value(), tangent_solver);
+  if (!regularity.HasValue())
+    return Result<Vector>::Failure(regularity.GetStatus());
+  DynamicAcceptedFrameState candidate = initial.frame;
+  candidate.is_initial = true;
+  candidate.acceleration = Vector{dofs.FullDofCount()};
+  const Status consistent = HiddenEvidence(domain, initial, nodes,
+                                           gradient.Value(), &candidate, false);
+  if (!consistent.IsOk()) return Result<Vector>::Failure(consistent);
+  Vector rhs{physical.Value().mass.Rows()};
+  // The initialization evaluation has zero acceleration, so I(q,v,0)=c(q,v).
+  for (std::size_t full = 0; full < dofs.FullDofCount(); ++full) {
+    if (initial.frame.acceleration[full] != 0.0) {
+      return Result<Vector>::Failure(Failure(
+          domain, "dynamic-invalid-initial-acceleration",
+          "Initial inertia must be evaluated at zero unknown acceleration."));
+    }
+    const double force = initial.frame.external_force[full] -
+                         initial.frame.internal_force[full] -
+                         initial.frame.inertia_force[full];
+    for (const auto& entry : physical.Value().rows[full]) {
+      rhs[entry.first] += entry.second * Scale(full, length) * force;
+    }
+  }
+  Vector solution{rhs.Size()};
+  if (rhs.Size() > 0U) {
+    const Status solved = positive_solver.Solve(rhs, solution);
+    if (!solved.IsOk()) return Result<Vector>::Failure(solved);
+    const Status checked =
+        CheckLinearSolve(physical.Value().mass, rhs, solution);
+    if (!checked.IsOk()) return Result<Vector>::Failure(checked);
+  }
+  for (std::size_t full = 0; full < dofs.FullDofCount(); ++full) {
+    for (const auto& entry : physical.Value().rows[full]) {
+      candidate.acceleration[full] +=
+          Scale(full, length) * entry.second * solution[entry.first];
+    }
+  }
+  const Status physical_hidden = HiddenEvidence(
+      domain, initial, nodes, gradient.Value(), &candidate, false);
+  if (!physical_hidden.IsOk()) return Result<Vector>::Failure(physical_hidden);
+  if (!nodes.empty()) {
+    Vector null_rhs{nodes.size()};
+    for (std::size_t row = 0; row < nodes.size(); ++row) {
+      null_rhs[row] = -candidate.hidden_acceleration_defect[row] /
+                      regularity.Value().weights[row];
+    }
+    Vector correction{nodes.size()};
+    const Status solved = tangent_solver.SolveCorrection(null_rhs, correction);
+    if (!solved.IsOk()) return Result<Vector>::Failure(solved);
+    const Status checked =
+        CheckLinearSolve(regularity.Value().matrix, null_rhs, correction);
+    if (!checked.IsOk()) return Result<Vector>::Failure(checked);
+    for (std::size_t i = 0; i < nodes.size(); ++i) {
+      for (std::size_t c = 0; c < 3; ++c) {
+        candidate.acceleration[6U * nodes[i] + 3U + c] +=
+            initial.rotations[nodes[i]].drill_null[c] * correction[i] /
+            regularity.Value().weights[i];
+      }
+    }
+  }
+  const Status hidden = HiddenEvidence(domain, initial, nodes, gradient.Value(),
+                                       &candidate, true);
+  if (!hidden.IsOk()) return Result<Vector>::Failure(hidden);
+  const Vector ma = initial.mass.Multiply(candidate.acceleration);
+  for (const std::size_t full : dofs.FreeDofs()) {
+    const double residual = ma[full] + initial.frame.inertia_force[full] +
+                            initial.frame.internal_force[full] -
+                            initial.frame.external_force[full];
+    double scale = std::abs(initial.frame.inertia_force[full]) +
+                   std::abs(initial.frame.internal_force[full]) +
+                   std::abs(initial.frame.external_force[full]);
+    for (std::size_t index = initial.mass.RowOffsets()[full];
+         index < initial.mass.RowOffsets()[full + 1U]; ++index) {
+      scale +=
+          std::abs(initial.mass.Values()[index] *
+                   candidate.acceleration[initial.mass.ColumnIndices()[index]]);
+    }
+    if (!Within(residual, scale, 1.0e-10)) {
+      return Result<Vector>::Failure(Failure(
+          domain, "dynamic-initial-equilibrium",
+          "Initial physical acceleration failed the complete free equation."));
+    }
+  }
+  return Result<Vector>::Success(std::move(candidate.acceleration));
+}
+
+Status CompleteConstraintEvidence(
+    const Domain& domain, const DofManager& dofs,
+    const DynamicAssembly& assembly, const double length,
+    const std::vector<std::size_t>& initial_null_nodes,
+    LinearSolver& positive_solver, TangentSolver& tangent_solver,
+    DynamicAcceptedFrameState* frame) {
+  const Status valid = Validate(domain, dofs, assembly, length);
+  if (!valid.IsOk()) return valid;
+  const auto nodes = NullNodes(dofs, assembly.rotations);
+  if (nodes != initial_null_nodes) {
+    return Failure(domain, "dynamic-mass-null-rank-change",
+                   "The admissible analytic drilling-null inventory changed.");
+  }
+  const auto physical = BuildPhysicalSpace(domain, dofs, assembly, length,
+                                           nodes, positive_solver);
+  if (!physical.HasValue()) return physical.GetStatus();
+  const auto gradient = ConstraintGradient(assembly, nodes);
+  if (!gradient.HasValue()) return gradient.GetStatus();
+  const auto regularity = CheckRegularity(domain, assembly, nodes,
+                                          gradient.Value(), tangent_solver);
+  if (!regularity.HasValue()) return regularity.GetStatus();
+  DynamicAcceptedFrameState candidate = *frame;
+  const Status hidden = HiddenEvidence(domain, assembly, nodes,
+                                       gradient.Value(), &candidate, true);
+  if (!hidden.IsOk()) return hidden;
+  *frame = std::move(candidate);
+  return Status::Ok();
+}
+
+}  // namespace hht_internal
+}  // namespace fesa
diff --git a/src/fesa/analysis/hht_dynamic_assembly.cpp b/src/fesa/analysis/hht_dynamic_assembly.cpp
new file mode 100644
index 0000000..76ad3a4
--- /dev/null
+++ b/src/fesa/analysis/hht_dynamic_assembly.cpp
@@ -0,0 +1,483 @@
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <map>
+#include <optional>
+#include <string>
+#include <utility>
+
+#include "analysis/hht_dynamic_internal.h"
+#include "fesa/assembly/parallel_for.h"
+#include "fesa/elements/finite_rotation.h"
+#include "fesa/loads/load.h"
+#include "fesa/model/source_target_resolver.h"
+
+namespace fesa::hht_internal {
+namespace {
+
+/// @brief Reports a dynamic assembly or equilibrium failure.
+Status Failure(const std::string& message) {
+  return Status::Failure(FailureCategory::kSolver, {{Severity::kError,
+                                                     "dynamic-invalid-state",
+                                                     {},
+                                                     "DYNAMIC",
+                                                     {},
+                                                     message}});
+}
+
+/// @brief Uses exact zero semantics for a dimensionally consistent ratio.
+double Ratio(const double numerator, const double denominator) {
+  return denominator > 0.0  ? numerator / denominator
+         : numerator == 0.0 ? 0.0
+                            : (std::numeric_limits<double>::infinity)();
+}
+
+/// @brief Gathers one source-node Cartesian component triple.
+Vector3 Triple(const Vector& vector, const std::size_t first) {
+  return {vector[first], vector[first + 1U], vector[first + 2U]};
+}
+
+/// @brief Computes one matrix-vector spatial transform.
+Vector3 Transform(const Matrix& matrix, const Vector3& vector) {
+  return {matrix(0U, 0U) * vector[0U] + matrix(0U, 1U) * vector[1U] +
+              matrix(0U, 2U) * vector[2U],
+          matrix(1U, 0U) * vector[0U] + matrix(1U, 1U) * vector[1U] +
+              matrix(1U, 2U) * vector[2U],
+          matrix(2U, 0U) * vector[0U] + matrix(2U, 1U) * vector[1U] +
+              matrix(2U, 2U) * vector[2U]};
+}
+
+/// @brief Gathers a local 24-vector in the DOF-owner scatter order.
+Vector Gather(const Vector& full, const RuntimeShell& shell) {
+  Vector local(24U);
+  for (std::size_t i = 0U; i < 24U; ++i) local[i] = full[shell.scatter[i]];
+  return local;
+}
+
+}  // namespace
+
+Result<std::vector<RuntimeShell>> BuildRuntimeShells(const Domain& domain,
+                                                     const DofManager& dofs) {
+  std::vector<RuntimeShell> shells;
+  for (std::size_t index = 0U; index < domain.Elements().Size(); ++index) {
+    const auto* definition =
+        dynamic_cast<const Mitc4ShellDefinition*>(&domain.Elements()[index]);
+    if (definition == nullptr ||
+        definition->section_index >= domain.Properties().Size() ||
+        definition->material_index >= domain.Materials().Size()) {
+      return Result<std::vector<RuntimeShell>>::Failure(
+          Failure("HHT requires valid MITC4 shell definitions."));
+    }
+    const auto* section = dynamic_cast<const ShellSection*>(
+        &domain.Properties()[definition->section_index]);
+    const auto* material = dynamic_cast<const LinearElasticMaterial*>(
+        &domain.Materials()[definition->material_index]);
+    if (section == nullptr || material == nullptr) {
+      return Result<std::vector<RuntimeShell>>::Failure(
+          Failure("HHT requires homogeneous elastic shell properties."));
+    }
+    double density = 0.0;
+    for (const auto& record : domain.Densities()) {
+      if (record.material_index == definition->material_index)
+        density = record.rho;
+    }
+    std::array<const Node*, 4> nodes{};
+    std::array<ShellNodeInitialFrame, 4> frames{};
+    for (std::size_t local = 0U; local < 4U; ++local) {
+      const auto node = definition->node_indices[local];
+      if (node >= domain.Nodes().size() ||
+          node >= domain.ShellNodeInitialFrames().size()) {
+        return Result<std::vector<RuntimeShell>>::Failure(
+            Failure("A dynamic shell node has no initial frame."));
+      }
+      nodes[local] = &domain.Nodes()[node];
+      frames[local] = domain.ShellNodeInitialFrames()[node];
+    }
+    auto internal =
+        NonlinearMitc4Shell::Create(nodes, frames, *section, *material);
+    if (!internal.HasValue())
+      return Result<std::vector<RuntimeShell>>::Failure(internal.GetStatus());
+    auto inertia = NonlinearMitc4Inertia::Create(nodes, frames, *section,
+                                                 *material, density);
+    if (!inertia.HasValue())
+      return Result<std::vector<RuntimeShell>>::Failure(inertia.GetStatus());
+    shells.push_back({static_cast<EntityIndex>(index),
+                      dofs.ShellElementScatter(static_cast<EntityIndex>(index)),
+                      std::move(internal.Value()), std::move(inertia.Value())});
+  }
+  return Result<std::vector<RuntimeShell>>::Success(std::move(shells));
+}
+
+Result<double> ReferenceLength(const Domain& domain) {
+  double length = 0.0;
+  for (std::size_t i = 0U; i < domain.ShellElements().Size(); ++i) {
+    const auto& element = domain.ShellElements()[i];
+    for (std::size_t node = 0U; node < 4U; ++node) {
+      const Vector3 a(domain.Nodes()[element.node_indices[node]].coordinates);
+      const Vector3 b(
+          domain.Nodes()[element.node_indices[(node + 1U) % 4U]].coordinates);
+      length = (std::max)(length, (a - b).Norm());
+    }
+  }
+  if (!std::isfinite(length) || length <= 0.0)
+    return Result<double>::Failure(
+        Failure("The dynamic reference length must be positive."));
+  return Result<double>::Success(length);
+}
+
+Result<std::array<Vector, 2>> AssembleLoads(const Domain& domain,
+                                            const DofManager& dofs) {
+  const auto index = SourceTargetIndex::FromDomain(domain);
+  const SourceTargetResolver resolver(index);
+  const LoadContext context{domain, dofs, resolver};
+  std::array<Vector, 2> result{Vector(dofs.FullDofCount()),
+                               Vector(dofs.FullDofCount())};
+  for (const auto& load : domain.Steps()[0U].Loads()) {
+    const auto contributions = load.get().ComputeContributions(context);
+    if (!contributions.HasValue())
+      return Result<std::array<Vector, 2>>::Failure(contributions.GetStatus());
+    for (const auto& entry : contributions.Value()) {
+      result[0U][entry.full_dof_index] += entry.value;
+      result[1U][entry.full_dof_index] += std::abs(entry.value);
+      if (!std::isfinite(result[0U][entry.full_dof_index]) ||
+          !std::isfinite(result[1U][entry.full_dof_index]))
+        return Result<std::array<Vector, 2>>::Failure(
+            Failure("Dynamic load reduction overflowed."));
+    }
+  }
+  return Result<std::array<Vector, 2>>::Success(std::move(result));
+}
+
+Result<SparseMatrix> MakeSparse(const std::size_t rows,
+                                const std::size_t columns,
+                                std::vector<CooContribution> contributions) {
+  std::vector<std::vector<std::size_t>> row_columns(rows);
+  for (const auto& entry : contributions) {
+    if (entry.row >= rows || entry.column >= columns)
+      return Result<SparseMatrix>::Failure(
+          Failure("Projected sparse index is invalid."));
+    row_columns[entry.row].push_back(entry.column);
+  }
+  SparsePattern pattern;
+  pattern.row_offsets.push_back(0U);
+  for (auto& row : row_columns) {
+    std::sort(row.begin(), row.end());
+    row.erase(std::unique(row.begin(), row.end()), row.end());
+    pattern.column_indices.insert(pattern.column_indices.end(), row.begin(),
+                                  row.end());
+    pattern.row_offsets.push_back(pattern.column_indices.size());
+  }
+  return SparseMatrix::FromCoo(rows, columns, std::move(contributions),
+                               pattern);
+}
+
+Result<SparseMatrix> ScaledFree(const SparseMatrix& matrix,
+                                const DofManager& dofs, const double length) {
+  std::vector<CooContribution> entries;
+  for (std::size_t i = 0U; i < dofs.FreeDofCount(); ++i) {
+    const auto row = dofs.FreeDofs()[i];
+    for (auto offset = matrix.RowOffsets()[row];
+         offset < matrix.RowOffsets()[row + 1U]; ++offset) {
+      const auto column = matrix.ColumnIndices()[offset];
+      const auto free_column = dofs.FreeEquation(column);
+      if (free_column.has_value()) {
+        const double factor =
+            (row % 6U < 3U ? length : 1.0) * (column % 6U < 3U ? length : 1.0);
+        entries.push_back(
+            {i, *free_column, factor * matrix.Values()[offset], row, offset});
+      }
+    }
+  }
+  return MakeSparse(dofs.FreeDofCount(), dofs.FreeDofCount(),
+                    std::move(entries));
+}
+
+Status CheckLinearSolve(const SparseMatrix& matrix, const Vector& rhs,
+                        const Vector& solution) {
+  if (matrix.Rows() != rhs.Size() || matrix.Columns() != solution.Size())
+    return Failure("Dynamic linear solve dimensions differ.");
+  double numerator = 0.0;
+  double denominator = 0.0;
+  for (std::size_t row = 0U; row < matrix.Rows(); ++row) {
+    double residual = -rhs[row];
+    double scale = std::abs(rhs[row]);
+    for (auto offset = matrix.RowOffsets()[row];
+         offset < matrix.RowOffsets()[row + 1U]; ++offset) {
+      const double term =
+          matrix.Values()[offset] * solution[matrix.ColumnIndices()[offset]];
+      residual += term;
+      scale += std::abs(term);
+    }
+    if (!std::isfinite(residual) || !std::isfinite(scale))
+      return Failure("Dynamic linear solve returned nonfinite data.");
+    numerator = (std::max)(numerator, std::abs(residual));
+    denominator = (std::max)(denominator, scale);
+  }
+  if (Ratio(numerator, denominator) > 1e-12) {
+    return Status::Failure(FailureCategory::kSolver,
+                           {{Severity::kError,
+                             "dynamic-linear-solve",
+                             {},
+                             "DYNAMIC",
+                             {},
+                             "Dynamic linear backward error exceeds 1e-12."}});
+  }
+  return Status::Ok();
+}
+
+Result<DynamicAssembly> EvaluateAssembly(
+    const Domain& domain, const DofManager& dofs,
+    const std::vector<RuntimeShell>& shells, DynamicAcceptedFrameState frame,
+    const Vector& load_scale, const double time_increment,
+    const HhtParameters& parameters, const ParallelFor& parallel_for,
+    const bool directional_third) {
+  const std::size_t count = dofs.FullDofCount();
+  for (const auto* values : std::array<const Vector*, 6>{
+           &frame.generalized_coordinates, &frame.velocity, &frame.acceleration,
+           &frame.algorithmic_acceleration, &frame.external_force,
+           &load_scale}) {
+    if (values->Size() != count)
+      return Result<DynamicAssembly>::Failure(
+          Failure("Dynamic trial vector size is invalid."));
+    for (std::size_t i = 0U; i < count; ++i)
+      if (!std::isfinite((*values)[i]))
+        return Result<DynamicAssembly>::Failure(
+            Failure("Dynamic trial contains nonfinite values."));
+  }
+  frame.nodal_internal_order.clear();
+  frame.nodal_source_ids.clear();
+  frame.nodal_triad.clear();
+  frame.nodal_director.clear();
+  frame.angular_velocity = Vector(3U * domain.Nodes().size());
+  frame.angular_acceleration = Vector(3U * domain.Nodes().size());
+  std::vector<DynamicRotationKinematics> rotations;
+  for (std::size_t node = 0U; node < domain.Nodes().size(); ++node) {
+    const auto phi = Triple(frame.generalized_coordinates, 6U * node + 3U);
+    const auto& baseline = domain.ShellNodeInitialFrames()[node];
+    auto rotation = EvaluateDynamicRotation(
+        phi, Vector3(baseline.director), Triple(frame.velocity, 6U * node + 3U),
+        Triple(frame.acceleration, 6U * node + 3U));
+    if (!rotation.HasValue())
+      return Result<DynamicAssembly>::Failure(rotation.GetStatus());
+    const Matrix r = ExpSkew(phi);
+    frame.nodal_internal_order.push_back(static_cast<EntityIndex>(node));
+    frame.nodal_source_ids.push_back(domain.Nodes()[node].source_id);
+    frame.nodal_director.push_back(rotation.Value().director.Components());
+    frame.nodal_triad.push_back(
+        {Transform(r, Vector3(baseline.tangent_a)).Components(),
+         Transform(r, Vector3(baseline.tangent_b)).Components(),
+         rotation.Value().director.Components()});
+    for (std::size_t c = 0U; c < 3U; ++c) {
+      frame.angular_velocity[3U * node + c] =
+          rotation.Value().angular_velocity[c];
+      frame.angular_acceleration[3U * node + c] =
+          rotation.Value().angular_acceleration[c];
+    }
+    rotations.push_back(std::move(rotation.Value()));
+  }
+  std::vector<std::optional<NonlinearMitc4InternalEquilibrium>> internal(
+      shells.size());
+  std::vector<std::optional<NonlinearMitc4InertiaEvaluation>> inertia(
+      shells.size());
+  std::vector<std::optional<Status>> failures(shells.size());
+  parallel_for.Execute(shells.size(), [&](const std::size_t e) {
+    const auto q = Gather(frame.generalized_coordinates, shells[e]);
+    const auto v = Gather(frame.velocity, shells[e]);
+    const auto a = Gather(frame.acceleration, shells[e]);
+    NonlinearMitc4TrialDofs trial{};
+    for (std::size_t node = 0U; node < 4U; ++node) {
+      trial.displacement[node] = Triple(q, 6U * node);
+      trial.rotation_vector[node] = Triple(q, 6U * node + 3U);
+    }
+    auto f = EvaluateInternalResidualAndTangent(
+        shells[e].internal, trial, directional_third ? &v : nullptr);
+    if (!f.HasValue()) {
+      failures[e] = f.GetStatus();
+      return;
+    }
+    auto m = shells[e].inertia.Evaluate(trial, v, a);
+    if (!m.HasValue()) {
+      failures[e] = m.GetStatus();
+      return;
+    }
+    internal[e] = std::move(f.Value());
+    inertia[e] = std::move(m.Value());
+  });
+  frame.inertia_force = Vector(count);
+  frame.internal_force = Vector(count);
+  frame.residual = Vector(count);
+  frame.reaction = Vector(count);
+  frame.residual_scale = load_scale;
+  frame.shell_results.clear();
+  frame.kinetic_energy = frame.physical_strain_energy = frame.drilling_energy =
+      0.0;
+  frame.linear_momentum = {};
+  frame.angular_momentum = {};
+  frame.linear_momentum_rate = {};
+  frame.angular_momentum_rate = {};
+  std::vector<std::map<std::pair<std::size_t, std::size_t>, double>>
+      constraint_hessians(domain.Nodes().size());
+  Vector third(count);
+  Vector third_scale(count);
+  std::array<std::vector<CooContribution>, 4> entries;
+  for (auto& values : entries) values.reserve(shells.size() * 24U * 24U);
+  double momentum_scale = 0.0;
+  double angular_scale = 0.0;
+  const double a_coefficient =
+      1.0 / ((1.0 + parameters.alpha) * parameters.beta * time_increment *
+             time_increment);
+  const double v_coefficient =
+      parameters.gamma / (parameters.beta * time_increment);
+  for (std::size_t e = 0U; e < shells.size(); ++e) {
+    if (failures[e].has_value())
+      return Result<DynamicAssembly>::Failure(*failures[e]);
+    const auto& f = *internal[e];
+    const auto& m = *inertia[e];
+    if (directional_third) {
+      for (std::size_t local = 0U; local < 4U; ++local) {
+        auto& hessian = constraint_hessians[shells[e].scatter[6U * local] / 6U];
+        for (std::size_t i = 0U; i < 24U; ++i)
+          for (std::size_t j = 0U; j < 24U; ++j) {
+            hessian[{shells[e].scatter[i], shells[e].scatter[j]}] +=
+                f.drilling_constraint_hessian[local](i, j);
+          }
+      }
+    }
+    const auto a = Gather(frame.acceleration, shells[e]);
+    for (std::size_t row = 0U; row < 24U; ++row) {
+      const auto global = shells[e].scatter[row];
+      frame.internal_force[global] += f.internal_force[row];
+      frame.inertia_force[global] += m.force[row];
+      third[global] += f.force_directional_second[row];
+      third_scale[global] += std::abs(f.force_directional_second[row]);
+      frame.residual_scale[global] += std::abs(m.convective_force[row]) +
+                                      std::abs(f.physical_force[row]) +
+                                      std::abs(f.drilling_force[row]);
+      for (std::size_t column = 0U; column < 24U; ++column) {
+        frame.residual_scale[global] +=
+            std::abs(m.mass(row, column) * a[column]);
+        const std::array<double, 4> values{
+            m.mass(row, column), f.internal_tangent(row, column),
+            f.internal_tangent(row, column) + m.position_tangent(row, column) +
+                v_coefficient * m.velocity_tangent(row, column) +
+                a_coefficient * m.mass(row, column),
+            f.drilling_metric(row, column)};
+        for (std::size_t k = 0U; k < 4U; ++k)
+          entries[k].push_back({global, shells[e].scatter[column], values[k], e,
+                                row * 24U + column});
+      }
+    }
+    for (const auto& point : f.recovery.gauss_points) {
+      frame.shell_results.push_back(
+          {shells[e].element_index,
+           point.location,
+           point.natural_coordinates,
+           {point.local_frame.e1, point.local_frame.e2, point.local_frame.e3},
+           point.generalized_strain,
+           point.section_resultant,
+           point.stress});
+    }
+    frame.kinetic_energy += m.kinetic_energy;
+    frame.physical_strain_energy += f.physical_strain_energy;
+    frame.drilling_energy += f.drilling_energy;
+    momentum_scale += m.momentum_rate_scale;
+    angular_scale += m.angular_momentum_rate_scale;
+    for (std::size_t c = 0U; c < 3U; ++c) {
+      frame.linear_momentum[c] += m.momentum[c];
+      frame.angular_momentum[c] += m.angular_momentum[c];
+      frame.linear_momentum_rate[c] += m.momentum_rate[c];
+      frame.angular_momentum_rate[c] += m.angular_momentum_rate[c];
+    }
+  }
+  for (std::size_t i = 0U; i < count; ++i) {
+    frame.residual[i] = frame.inertia_force[i] + frame.internal_force[i] -
+                        frame.external_force[i];
+    if (!std::isfinite(frame.residual[i]) ||
+        !std::isfinite(frame.residual_scale[i]) || !std::isfinite(third[i]) ||
+        !std::isfinite(third_scale[i])) {
+      return Result<DynamicAssembly>::Failure(
+          Failure("Dynamic force reduction overflowed."));
+    }
+  }
+  for (const auto i : dofs.ConstrainedDofs())
+    frame.reaction[i] = frame.residual[i];
+  std::array<double, 2> residual_norm{};
+  std::array<double, 2> scale_norm{};
+  for (const auto i : dofs.FreeDofs()) {
+    const auto channel = i % 6U < 3U ? 0U : 1U;
+    residual_norm[channel] =
+        (std::max)(residual_norm[channel], std::abs(frame.residual[i]));
+    scale_norm[channel] =
+        (std::max)(scale_norm[channel], frame.residual_scale[i]);
+  }
+  for (std::size_t c = 0U; c < 2U; ++c)
+    frame.free_residual_metrics[c] = Ratio(residual_norm[c], scale_norm[c]);
+  auto mass = SparseMatrix::FromCoo(count, count, std::move(entries[0U]),
+                                    dofs.GetSparsePattern());
+  auto stiffness = SparseMatrix::FromCoo(count, count, std::move(entries[1U]),
+                                         dofs.GetSparsePattern());
+  auto effective = SparseMatrix::FromCoo(count, count, std::move(entries[2U]),
+                                         dofs.GetSparsePattern());
+  auto metric = SparseMatrix::FromCoo(count, count, std::move(entries[3U]),
+                                      dofs.GetSparsePattern());
+  for (const auto* result : {&mass, &stiffness, &effective, &metric})
+    if (!result->HasValue())
+      return Result<DynamicAssembly>::Failure(result->GetStatus());
+  Vector hidden_second(domain.Nodes().size());
+  Vector hidden_second_scale(domain.Nodes().size());
+  for (std::size_t node = 0U; node < constraint_hessians.size(); ++node) {
+    for (const auto& entry : constraint_hessians[node]) {
+      const double term = entry.second * frame.velocity[entry.first.first] *
+                          frame.velocity[entry.first.second];
+      hidden_second[node] += term;
+      hidden_second_scale[node] += std::abs(term);
+    }
+  }
+  return Result<DynamicAssembly>::Success(
+      {std::move(frame), std::move(mass.Value()), std::move(stiffness.Value()),
+       std::move(effective.Value()), std::move(metric.Value()),
+       std::move(third), std::move(third_scale), std::move(rotations),
+       momentum_scale, angular_scale, std::move(hidden_second),
+       std::move(hidden_second_scale)});
+}
+
+Status CompleteEquilibrium(const Domain& domain, const DofManager& dofs,
+                           const DynamicAssembly& assembly,
+                           DynamicAcceptedFrameState* frame) {
+  static_cast<void>(dofs);
+  Vector3 total_force;
+  Vector3 total_moment;
+  double force_scale = assembly.momentum_rate_scale;
+  double moment_scale = assembly.angular_momentum_rate_scale;
+  for (std::size_t node = 0U; node < domain.Nodes().size(); ++node) {
+    const auto first = 6U * node;
+    const Vector3 arm = Vector3(domain.Nodes()[node].coordinates) +
+                        Triple(frame->generalized_coordinates, first);
+    const Matrix transform = InverseTransposeLeftJacobianSO3(
+        Triple(frame->generalized_coordinates, first + 3U));
+    for (const Vector* values : {&frame->external_force, &frame->reaction}) {
+      const Vector3 force = Triple(*values, first);
+      const Vector3 moment = Transform(transform, Triple(*values, first + 3U));
+      total_force = total_force + force;
+      total_moment = total_moment + arm.Cross(force) + moment;
+      force_scale += force.Norm();
+      moment_scale += arm.Cross(force).Norm() + moment.Norm();
+    }
+  }
+  const Vector3 force_error =
+      total_force - Vector3(frame->linear_momentum_rate);
+  const Vector3 moment_error =
+      total_moment - Vector3(frame->angular_momentum_rate);
+  for (std::size_t c = 0U; c < 3U; ++c) {
+    frame->global_equilibrium[c] = force_error[c];
+    frame->global_equilibrium[3U + c] = moment_error[c];
+  }
+  if (!force_error.IsFinite() || !moment_error.IsFinite() ||
+      !std::isfinite(force_scale) || !std::isfinite(moment_scale) ||
+      Ratio(force_error.Norm(), force_scale) > 1e-8 ||
+      Ratio(moment_error.Norm(), moment_scale) > 1e-8)
+    return Failure("Dynamic physical force or moment balance exceeds 1e-8.");
+  return Status::Ok();
+}
+
+}  // namespace fesa::hht_internal
diff --git a/src/fesa/analysis/hht_dynamic_internal.h b/src/fesa/analysis/hht_dynamic_internal.h
new file mode 100644
index 0000000..8f3967c
--- /dev/null
+++ b/src/fesa/analysis/hht_dynamic_internal.h
@@ -0,0 +1,102 @@
+#ifndef FESA_ANALYSIS_HHT_DYNAMIC_INTERNAL_H_
+#define FESA_ANALYSIS_HHT_DYNAMIC_INTERNAL_H_
+
+#include <array>
+#include <vector>
+
+#include "fesa/analysis/dynamic_analysis_state.h"
+#include "fesa/analysis/hht_time_integration.h"
+#include "fesa/elements/nonlinear_mitc4_inertia.h"
+#include "fesa/elements/nonlinear_mitc4_shell.h"
+#include "fesa/math/sparse_matrix.h"
+
+namespace fesa {
+class LinearSolver;
+class ParallelFor;
+class TangentSolver;
+namespace hht_internal {
+
+/// @brief Keeps immutable local evaluators with the DOF-owner scatter.
+struct RuntimeShell {
+  EntityIndex element_index;
+  std::array<std::size_t, 24> scatter;
+  NonlinearMitc4Shell internal;
+  NonlinearMitc4Inertia inertia;
+};
+
+/// @brief Stores a complete trial with independently assembled operators.
+struct DynamicAssembly {
+  DynamicAcceptedFrameState frame;
+  SparseMatrix mass;
+  SparseMatrix internal_tangent;
+  SparseMatrix effective_tangent;
+  SparseMatrix drilling_metric;
+  Vector force_directional_second;
+  Vector force_directional_second_scale;
+  std::vector<DynamicRotationKinematics> rotations;
+  double momentum_rate_scale;
+  double angular_momentum_rate_scale;
+  Vector hidden_second{0U};
+  Vector hidden_second_scale{0U};
+};
+
+/// @brief Builds checked shell evaluators in stable source order.
+Result<std::vector<RuntimeShell>> BuildRuntimeShells(const Domain& domain,
+                                                     const DofManager& dofs);
+
+/// @brief Returns the maximum initial active-element edge length.
+Result<double> ReferenceLength(const Domain& domain);
+
+/// @brief Assembles dead loads and their uncancelled absolute row scales.
+Result<std::array<Vector, 2>> AssembleLoads(const Domain& domain,
+                                            const DofManager& dofs);
+
+/// @brief Evaluates current kinetic and internal quantities without commit.
+Result<DynamicAssembly> EvaluateAssembly(
+    const Domain& domain, const DofManager& dofs,
+    const std::vector<RuntimeShell>& shells, DynamicAcceptedFrameState frame,
+    const Vector& load_scale, double time_increment,
+    const HhtParameters& parameters, const ParallelFor& parallel_for,
+    bool directional_third);
+
+/// @brief Builds deterministic CSR structure from an ordered local list.
+Result<SparseMatrix> MakeSparse(std::size_t rows, std::size_t columns,
+                                std::vector<CooContribution> contributions);
+
+/// @brief Builds the scaled free-space operator D^T K D.
+Result<SparseMatrix> ScaledFree(const SparseMatrix& matrix,
+                                const DofManager& dofs, double length);
+
+/// @brief Checks normwise backward error in the supplied equation space.
+Status CheckLinearSolve(const SparseMatrix& matrix, const Vector& rhs,
+                        const Vector& solution);
+
+/// @brief Finds analytic admissible node null directions without rank cuts.
+std::vector<std::size_t> NullNodes(
+    const DofManager& dofs,
+    const std::vector<DynamicRotationKinematics>& rotations);
+
+/// @brief Solves the positive-mass and differentiated-null initial equations.
+Result<Vector> InitializeAcceleration(const Domain& domain,
+                                      const DofManager& dofs,
+                                      const DynamicAssembly& initial,
+                                      double length,
+                                      LinearSolver& positive_solver,
+                                      TangentSolver& tangent_solver);
+
+/// @brief Checks mass/regularity and recovers all exact hidden defects.
+Status CompleteConstraintEvidence(
+    const Domain& domain, const DofManager& dofs,
+    const DynamicAssembly& assembly, double length,
+    const std::vector<std::size_t>& initial_null_nodes,
+    LinearSolver& positive_solver, TangentSolver& tangent_solver,
+    DynamicAcceptedFrameState* frame);
+
+/// @brief Recovers physical support balance using volume momentum rates.
+Status CompleteEquilibrium(const Domain& domain, const DofManager& dofs,
+                           const DynamicAssembly& assembly,
+                           DynamicAcceptedFrameState* frame);
+
+}  // namespace hht_internal
+}  // namespace fesa
+#endif  // FESA_ANALYSIS_HHT_DYNAMIC_INTERNAL_H_
diff --git a/src/fesa/analysis/hht_dynamic_procedure.cpp b/src/fesa/analysis/hht_dynamic_procedure.cpp
new file mode 100644
index 0000000..cc77024
--- /dev/null
+++ b/src/fesa/analysis/hht_dynamic_procedure.cpp
@@ -0,0 +1,322 @@
+#include "fesa/analysis/hht_dynamic_procedure.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <string>
+#include <utility>
+
+#include "analysis/hht_dynamic_internal.h"
+#include "fesa/analysis/analysis_model.h"
+#include "fesa/analysis/newton_iteration_log.h"
+#include "fesa/solvers/linear/tangent_solver.h"
+
+namespace fesa {
+namespace {
+using namespace hht_internal;
+
+/// @brief Creates one procedure-owned diagnostic with the source step.
+Status Failure(const Domain& domain, const std::string& code,
+               const std::string& message) {
+  return Status::Failure(
+      FailureCategory::kSolver,
+      {{Severity::kError, code, domain.Dynamic()->dynamic_location, "DYNAMIC",
+        domain.Dynamic()->source_step_name_raw, message}});
+}
+
+/// @brief Checks one update against its uncancelled, dimensionally equal terms.
+bool UpdateEqual(const double left, const std::initializer_list<double> terms) {
+  double right = 0.0;
+  double scale = 0.0;
+  for (const double term : terms) {
+    right += term;
+    scale += std::abs(term);
+  }
+  const double defect = std::abs(left - right);
+  return std::isfinite(defect) && std::isfinite(scale) &&
+         (scale == 0.0 ? defect == 0.0 : defect / scale <= 1e-12);
+}
+
+/// @brief Verifies both absolute and increment forms before accepting history.
+Status CheckUpdates(const Domain& domain, const DynamicAcceptedFrameState& old,
+                    const DynamicAcceptedFrameState& frame,
+                    const HhtPredictor& predictor, const HhtParameters& p,
+                    const double h) {
+  for (std::size_t i = 0U; i < frame.generalized_coordinates.Size(); ++i) {
+    const double increment =
+        frame.generalized_coordinates[i] - old.generalized_coordinates[i];
+    const double old_term =
+        h * h * (0.5 - p.beta) * old.algorithmic_acceleration[i];
+    const double new_term = h * h * p.beta * frame.algorithmic_acceleration[i];
+    if (!UpdateEqual(frame.generalized_coordinates[i],
+                     {old.generalized_coordinates[i], h * old.velocity[i],
+                      old_term, new_term}) ||
+        !UpdateEqual(increment, {h * old.velocity[i], old_term, new_term}) ||
+        !UpdateEqual(
+            frame.generalized_coordinates[i] - predictor.coordinates[i],
+            {new_term}) ||
+        !UpdateEqual(frame.velocity[i],
+                     {old.velocity[i],
+                      h * (1 - p.gamma) * old.algorithmic_acceleration[i],
+                      h * p.gamma * frame.algorithmic_acceleration[i]}) ||
+        !UpdateEqual(frame.algorithmic_acceleration[i],
+                     {(1 + p.alpha) * frame.acceleration[i],
+                      -p.alpha * old.acceleration[i]})) {
+      return Failure(
+          domain, "dynamic-update-inconsistency",
+          "HHT endpoint update or resolved increment exceeds 1e-12.");
+    }
+  }
+  return Status::Ok();
+}
+
+/// @brief Fills the raw channel evidence without hiding a zero denominator.
+void ResidualRecord(const DofManager& dofs,
+                    const DynamicAcceptedFrameState& frame,
+                    DynamicNewtonIterationLogRecord* record) {
+  record->residual_numerator = {};
+  record->residual_scale = {};
+  for (const auto full : dofs.FreeDofs()) {
+    const auto c = full % 6U < 3U ? 0U : 1U;
+    record->residual_numerator[c] = (std::max)(record->residual_numerator[c],
+                                               std::abs(frame.residual[full]));
+    record->residual_scale[c] =
+        (std::max)(record->residual_scale[c], frame.residual_scale[full]);
+  }
+  record->residual_pass = frame.free_residual_metrics[0U] <= 1e-10 &&
+                          frame.free_residual_metrics[1U] <= 1e-10;
+}
+
+/// @brief Forms the four coordinate/rate correction checks in scaled units.
+void CorrectionRecord(const Vector& correction, const DofManager& dofs,
+                      const double length, const HhtParameters& p,
+                      DynamicNewtonIterationLogRecord* record) {
+  record->coordinate_correction = {};
+  for (const auto full : dofs.FreeDofs()) {
+    const auto c = full % 6U < 3U ? 0U : 1U;
+    record->coordinate_correction[c] =
+        (std::max)(record->coordinate_correction[c],
+                   std::abs(correction[full]) / (c == 0U ? length : 1.0));
+  }
+  record->correction_pass = true;
+  for (std::size_t c = 0; c < 2U; ++c) {
+    const double dq = record->coordinate_correction[c];
+    record->velocity_correction[c] = p.gamma / p.beta * dq;
+    record->acceleration_correction[c] = dq / ((1 + p.alpha) * p.beta);
+    record->algorithmic_correction[c] = dq / p.beta;
+    for (const auto* channel :
+         {&record->coordinate_correction, &record->velocity_correction,
+          &record->acceleration_correction, &record->algorithmic_correction})
+      record->correction_pass =
+          record->correction_pass && (*channel)[c] <= 1e-10;
+  }
+}
+}  // namespace
+
+HhtDynamicProcedureExecutor::HhtDynamicProcedureExecutor(
+    const ParallelFor& parallel_for, LinearSolver& positive_solver,
+    TangentSolver& tangent_solver)
+    : parallel_for_(parallel_for),
+      positive_solver_(positive_solver),
+      tangent_solver_(tangent_solver) {}
+
+Result<DynamicExecutionResult> HhtDynamicProcedureExecutor::Execute(
+    const Domain& domain, NewtonIterationLogWriter& log) const {
+  if (domain.Dynamic() == nullptr) {
+    return Result<DynamicExecutionResult>::Failure(Status::Failure(
+        FailureCategory::kModel, {{Severity::kError,
+                                   "invalid-dynamic-step",
+                                   {},
+                                   "DYNAMIC",
+                                   {},
+                                   "HHT requires exactly one dynamic step."}}));
+  }
+  auto model = AnalysisModel::Create(domain);
+  if (!model.HasValue())
+    return Result<DynamicExecutionResult>::Failure(model.GetStatus());
+  auto dofs_result = DofManager::Create(model.Value());
+  if (!dofs_result.HasValue())
+    return Result<DynamicExecutionResult>::Failure(dofs_result.GetStatus());
+  const auto& dofs = dofs_result.Value();
+  auto state_result = DynamicAnalysisState::Create(domain, dofs);
+  if (!state_result.HasValue())
+    return Result<DynamicExecutionResult>::Failure(state_result.GetStatus());
+  auto state = std::move(state_result.Value());
+  auto shells = BuildRuntimeShells(domain, dofs);
+  if (!shells.HasValue())
+    return Result<DynamicExecutionResult>::Failure(shells.GetStatus());
+  auto length_result = ReferenceLength(domain);
+  if (!length_result.HasValue())
+    return Result<DynamicExecutionResult>::Failure(length_result.GetStatus());
+  const double length = length_result.Value();
+  auto loads = AssembleLoads(domain, dofs);
+  if (!loads.HasValue())
+    return Result<DynamicExecutionResult>::Failure(loads.GetStatus());
+  auto parameters = MakeHhtParameters(domain.Dynamic()->alpha);
+  if (!parameters.HasValue())
+    return Result<DynamicExecutionResult>::Failure(parameters.GetStatus());
+  const auto p = parameters.Value();
+  const double h = domain.Dynamic()->initial_increment;
+  DynamicAcceptedFrameState frame{};
+  frame.is_initial = true;
+  for (auto* vector : {&frame.generalized_coordinates, &frame.velocity,
+                       &frame.acceleration, &frame.algorithmic_acceleration})
+    *vector = Vector(dofs.FullDofCount());
+  frame.external_force = loads.Value()[0U];
+  auto initial = EvaluateAssembly(domain, dofs, shells.Value(), frame,
+                                  loads.Value()[1U], h, p, parallel_for_, true);
+  if (!initial.HasValue())
+    return Result<DynamicExecutionResult>::Failure(initial.GetStatus());
+  const auto null_nodes = NullNodes(dofs, initial.Value().rotations);
+  auto acceleration = InitializeAcceleration(
+      domain, dofs, initial.Value(), length, positive_solver_, tangent_solver_);
+  if (!acceleration.HasValue())
+    return Result<DynamicExecutionResult>::Failure(acceleration.GetStatus());
+  frame.acceleration = acceleration.Value();
+  frame.algorithmic_acceleration = acceleration.Value();
+  initial = EvaluateAssembly(domain, dofs, shells.Value(), frame,
+                             loads.Value()[1U], h, p, parallel_for_, true);
+  if (!initial.HasValue())
+    return Result<DynamicExecutionResult>::Failure(initial.GetStatus());
+  frame = initial.Value().frame;
+  Status status = CompleteConstraintEvidence(
+      domain, dofs, initial.Value(), length, null_nodes, positive_solver_,
+      tangent_solver_, &frame);
+  if (!status.IsOk()) return Result<DynamicExecutionResult>::Failure(status);
+  status = CompleteEquilibrium(domain, dofs, initial.Value(), &frame);
+  if (!status.IsOk()) return Result<DynamicExecutionResult>::Failure(status);
+  const double initial_energy = frame.kinetic_energy +
+                                frame.physical_strain_energy +
+                                frame.drilling_energy;
+  status = state.CommitAcceptedFrame(frame);
+  if (!status.IsOk()) return Result<DynamicExecutionResult>::Failure(status);
+  DynamicNewtonIterationLogRecord record{};
+  record.stage = "accepted";
+  record.outcome = "initial";
+  record.correction_pass = true;
+  ResidualRecord(dofs, frame, &record);
+  status = log.Write(record);
+  if (status.IsOk()) status = log.Flush();
+  if (!status.IsOk()) return Result<DynamicExecutionResult>::Failure(status);
+  for (std::uint32_t increment = 1U;
+       increment <= domain.Dynamic()->increment_count; ++increment) {
+    const auto& old = state.CommittedState();
+    auto predictor = PredictHht(old.generalized_coordinates, old.velocity,
+                                old.algorithmic_acceleration, h, p);
+    if (!predictor.HasValue())
+      return Result<DynamicExecutionResult>::Failure(predictor.GetStatus());
+    frame = old;
+    frame.is_initial = false;
+    frame.frame_index = increment;
+    frame.increment_index = increment;
+    frame.time = static_cast<double>(increment) * h;
+    // A large DIRECT step may put a kinematic predictor outside the shell
+    // chart before Newton starts. The last accepted geometry is a valid
+    // initial iterate; q_p still defines the unchanged HHT rate equations.
+    frame.generalized_coordinates = old.generalized_coordinates;
+    record = {};
+    record.increment_index = increment;
+    record.time = frame.time;
+    record.correction_pass = true;
+    bool accepted = false;
+    for (std::uint32_t iteration = 0U; iteration <= 100U; ++iteration) {
+      record.iteration_index = iteration;
+      record.stage = "evaluation";
+      record.outcome = "candidate";
+      auto fail = [&](const Status& failure) -> Result<DynamicExecutionResult> {
+        record.stage = "failed";
+        record.outcome = "failed";
+        record.failure_code = failure.Diagnostics().empty()
+                                  ? "dynamic-solver-failure"
+                                  : failure.Diagnostics().front().code;
+        const Status written = log.Write(record);
+        return Result<DynamicExecutionResult>::Failure(
+            written.IsOk() ? failure : written);
+      };
+      auto rates = EvaluateHhtRates(frame.generalized_coordinates,
+                                    predictor.Value(), old.acceleration, h, p);
+      if (!rates.HasValue()) return fail(rates.GetStatus());
+      frame.velocity = std::move(rates.Value().velocity);
+      frame.acceleration = std::move(rates.Value().acceleration);
+      frame.algorithmic_acceleration =
+          std::move(rates.Value().algorithmic_acceleration);
+      frame.iteration_count = iteration;
+      auto assembly =
+          EvaluateAssembly(domain, dofs, shells.Value(), frame,
+                           loads.Value()[1U], h, p, parallel_for_, false);
+      if (!assembly.HasValue()) return fail(assembly.GetStatus());
+      frame = assembly.Value().frame;
+      ResidualRecord(dofs, frame, &record);
+      if (record.residual_pass && record.correction_pass) {
+        assembly =
+            EvaluateAssembly(domain, dofs, shells.Value(), frame,
+                             loads.Value()[1U], h, p, parallel_for_, true);
+        if (!assembly.HasValue()) return fail(assembly.GetStatus());
+        frame = assembly.Value().frame;
+        status = CompleteConstraintEvidence(
+            domain, dofs, assembly.Value(), length, null_nodes,
+            positive_solver_, tangent_solver_, &frame);
+        if (!status.IsOk()) return fail(status);
+        status = CompleteEquilibrium(domain, dofs, assembly.Value(), &frame);
+        if (!status.IsOk()) return fail(status);
+        status = CheckUpdates(domain, old, frame, predictor.Value(), p, h);
+        if (!status.IsOk()) return fail(status);
+        frame.external_work = 0.0;
+        for (std::size_t i = 0; i < dofs.FullDofCount(); ++i)
+          frame.external_work +=
+              frame.external_force[i] * frame.generalized_coordinates[i];
+        frame.energy_defect =
+            frame.kinetic_energy + frame.physical_strain_energy +
+            frame.drilling_energy - initial_energy - frame.external_work;
+        status = state.CommitAcceptedFrame(frame);
+        if (!status.IsOk()) return fail(status);
+        record.stage = "accepted";
+        record.outcome = "accepted";
+        status = log.Write(record);
+        if (status.IsOk()) status = log.Flush();
+        if (!status.IsOk())
+          return Result<DynamicExecutionResult>::Failure(status);
+        accepted = true;
+        break;
+      }
+      if (iteration == 100U)
+        return fail(Failure(domain, "dynamic-nonconvergence",
+                            "HHT exhausted 100 corrections without satisfying "
+                            "every endpoint check."));
+      status = log.Write(record);
+      if (!status.IsOk())
+        return Result<DynamicExecutionResult>::Failure(status);
+      auto tangent =
+          ScaledFree(assembly.Value().effective_tangent, dofs, length);
+      if (!tangent.HasValue()) return fail(tangent.GetStatus());
+      Vector rhs(dofs.FreeDofCount());
+      Vector solution(dofs.FreeDofCount());
+      Vector correction(dofs.FullDofCount());
+      for (std::size_t i = 0; i < dofs.FreeDofCount(); ++i) {
+        const auto full = dofs.FreeDofs()[i];
+        rhs[i] = -frame.residual[full] * (full % 6U < 3U ? length : 1.0);
+      }
+      if (dofs.FreeDofCount() > 0U) {
+        status = tangent_solver_.FactorizeFresh(tangent.Value());
+        if (!status.IsOk()) return fail(status);
+        status = tangent_solver_.SolveCorrection(rhs, solution);
+        if (!status.IsOk()) return fail(status);
+        status = CheckLinearSolve(tangent.Value(), rhs, solution);
+        if (!status.IsOk()) return fail(status);
+      }
+      for (std::size_t i = 0; i < dofs.FreeDofCount(); ++i) {
+        const auto full = dofs.FreeDofs()[i];
+        correction[full] = solution[i] * (full % 6U < 3U ? length : 1.0);
+        frame.generalized_coordinates[full] += correction[full];
+      }
+      CorrectionRecord(correction, dofs, length, p, &record);
+    }
+    if (!accepted)
+      return Result<DynamicExecutionResult>::Failure(
+          Failure(domain, "dynamic-nonconvergence",
+                  "Dynamic increment was not accepted."));
+  }
+  return Result<DynamicExecutionResult>::Success(
+      {std::move(state), domain.Warnings()});
+}
+}  // namespace fesa
diff --git a/src/fesa/analysis/hht_time_integration.cpp b/src/fesa/analysis/hht_time_integration.cpp
new file mode 100644
index 0000000..6992522
--- /dev/null
+++ b/src/fesa/analysis/hht_time_integration.cpp
@@ -0,0 +1,97 @@
+#include "fesa/analysis/hht_time_integration.h"
+
+#include <cmath>
+#include <utility>
+
+namespace fesa {
+namespace {
+
+/// @brief Reports invalid or unrepresentable HHT kinematics.
+Status Failure() {
+  return Status::Failure(
+      FailureCategory::kSolver,
+      {{Severity::kError, "dynamic-invalid-state", {}, "DYNAMIC", {},
+        "HHT requires finite compatible rates, positive time, and coupled "
+        "coefficients in the supported range."}});
+}
+
+/// @brief Validates the coupled coefficient and time denominators.
+bool Valid(const double h, const HhtParameters& p) {
+  return std::isfinite(h) && h > 0.0 && std::isfinite(h * h) &&
+         h * h > 0.0 && std::isfinite(p.alpha) &&
+         p.alpha >= -1.0 / 3.0 && p.alpha <= 0.0 &&
+         p.beta == 0.25 * (1.0 - p.alpha) * (1.0 - p.alpha) &&
+         p.gamma == 0.5 - p.alpha && p.beta * h * h > 0.0;
+}
+
+}  // namespace
+
+Result<HhtParameters> MakeHhtParameters(const double alpha) {
+  if (!std::isfinite(alpha) || alpha < -1.0 / 3.0 || alpha > 0.0) {
+    return Result<HhtParameters>::Failure(Failure());
+  }
+  return Result<HhtParameters>::Success(
+      {alpha, 0.25 * (1.0 - alpha) * (1.0 - alpha), 0.5 - alpha});
+}
+
+Result<HhtPredictor> PredictHht(const Vector& coordinates,
+                              const Vector& velocity,
+                              const Vector& algorithmic_acceleration,
+                              const double time_increment,
+                              const HhtParameters& parameters) {
+  if (!Valid(time_increment, parameters) ||
+      coordinates.Size() != velocity.Size() ||
+      coordinates.Size() != algorithmic_acceleration.Size()) {
+    return Result<HhtPredictor>::Failure(Failure());
+  }
+  HhtPredictor predictor{Vector(coordinates.Size()), Vector(coordinates.Size())};
+  for (std::size_t i = 0U; i < coordinates.Size(); ++i) {
+    predictor.coordinates[i] =
+        coordinates[i] + time_increment * velocity[i] +
+        time_increment * time_increment * (0.5 - parameters.beta) *
+            algorithmic_acceleration[i];
+    predictor.velocity[i] =
+        velocity[i] + time_increment * (1.0 - parameters.gamma) *
+                          algorithmic_acceleration[i];
+    if (!std::isfinite(predictor.coordinates[i]) ||
+        !std::isfinite(predictor.velocity[i])) {
+      return Result<HhtPredictor>::Failure(Failure());
+    }
+  }
+  return Result<HhtPredictor>::Success(std::move(predictor));
+}
+
+Result<HhtRates> EvaluateHhtRates(const Vector& coordinates,
+                                const HhtPredictor& predictor,
+                                const Vector& old_acceleration,
+                                const double time_increment,
+                                const HhtParameters& parameters) {
+  if (!Valid(time_increment, parameters) ||
+      coordinates.Size() != predictor.coordinates.Size() ||
+      coordinates.Size() != predictor.velocity.Size() ||
+      coordinates.Size() != old_acceleration.Size()) {
+    return Result<HhtRates>::Failure(Failure());
+  }
+  HhtRates rates{Vector(coordinates.Size()), Vector(coordinates.Size()),
+                 Vector(coordinates.Size())};
+  for (std::size_t i = 0U; i < coordinates.Size(); ++i) {
+    const double increment = coordinates[i] - predictor.coordinates[i];
+    rates.algorithmic_acceleration[i] =
+        increment / (parameters.beta * time_increment * time_increment);
+    rates.velocity[i] = predictor.velocity[i] +
+                        parameters.gamma * increment /
+                            (parameters.beta * time_increment);
+    rates.acceleration[i] =
+        (rates.algorithmic_acceleration[i] +
+         parameters.alpha * old_acceleration[i]) /
+        (1.0 + parameters.alpha);
+    if (!std::isfinite(rates.algorithmic_acceleration[i]) ||
+        !std::isfinite(rates.acceleration[i]) ||
+        !std::isfinite(rates.velocity[i])) {
+      return Result<HhtRates>::Failure(Failure());
+    }
+  }
+  return Result<HhtRates>::Success(std::move(rates));
+}
+
+}  // namespace fesa
diff --git a/src/fesa/analysis/newton_iteration_log.cpp b/src/fesa/analysis/newton_iteration_log.cpp
index 9c96ee7..32fb67f 100644
--- a/src/fesa/analysis/newton_iteration_log.cpp
+++ b/src/fesa/analysis/newton_iteration_log.cpp
@@ -258,6 +258,68 @@ Result<std::string> SerializeRecord(const NewtonIterationLogRecord& record,
   return Result<std::string>::Success(std::move(line));
 }
 
+/// @brief Serializes dynamic evidence without static load-factor semantics.
+Result<std::string> SerializeRecord(
+    const DynamicNewtonIterationLogRecord& record,
+    const std::filesystem::path& log_path) {
+  const auto time = FormatFiniteNumber(record.time, log_path);
+  if (!time.HasValue()) return Result<std::string>::Failure(time.GetStatus());
+  if (record.time < 0.0 || record.stage.empty() || record.outcome.empty()) {
+    return Result<std::string>::Failure(LogOutputFailure(
+        log_path,
+        "A dynamic Newton log requires nonnegative time, stage, and outcome."));
+  }
+  std::vector<std::string> fields;
+  fields.reserve(24U);
+  AppendField(&fields, "record", "dynamic-newton-iteration");
+  AppendField(&fields, "schema", "hht-log-v1");
+  AppendField(&fields, "increment", std::to_string(record.increment_index));
+  AppendField(&fields, "time", time.Value());
+  AppendField(&fields, "iteration", std::to_string(record.iteration_index));
+  AppendField(&fields, "stage", EscapeText(record.stage));
+  const std::array<const char*, 2U> channels{"u", "phi"};
+  for (std::size_t channel = 0U; channel < channels.size(); ++channel) {
+    const std::string suffix{channels[channel]};
+    const std::array<std::pair<std::string, double>, 6U> metrics{{
+        {"residual_" + suffix + "_numerator",
+         record.residual_numerator[channel]},
+        {"residual_" + suffix + "_scale", record.residual_scale[channel]},
+        {"coordinate_correction_" + suffix,
+         record.coordinate_correction[channel]},
+        {"velocity_correction_" + suffix, record.velocity_correction[channel]},
+        {"acceleration_correction_" + suffix,
+         record.acceleration_correction[channel]},
+        {"algorithmic_correction_" + suffix,
+         record.algorithmic_correction[channel]},
+    }};
+    for (const auto& metric : metrics) {
+      const auto formatted = FormatFiniteNumber(metric.second, log_path);
+      if (!formatted.HasValue()) {
+        return Result<std::string>::Failure(formatted.GetStatus());
+      }
+      if (metric.second < 0.0) {
+        return Result<std::string>::Failure(LogOutputFailure(
+            log_path, "A dynamic Newton log norm or scale is negative."));
+      }
+      AppendField(&fields, metric.first, formatted.Value());
+    }
+    AppendField(
+        &fields, "residual_" + suffix + "_branch",
+        record.residual_scale[channel] == 0.0 ? "zero-scale" : "relative");
+  }
+  AppendField(&fields, "residual_pass", record.residual_pass ? "1" : "0");
+  AppendField(&fields, "correction_pass", record.correction_pass ? "1" : "0");
+  AppendField(&fields, "outcome", EscapeText(record.outcome));
+  AppendField(&fields, "failure_code", EscapeText(record.failure_code));
+  std::string line;
+  for (std::size_t index = 0U; index < fields.size(); ++index) {
+    if (index != 0U) line += '\t';
+    line += fields[index];
+  }
+  line += '\n';
+  return Result<std::string>::Success(std::move(line));
+}
+
 }  // namespace
 
 Status NewtonIterationLogWriter::Open(const std::filesystem::path& log_path) {
@@ -296,6 +358,27 @@ Status NewtonIterationLogWriter::Write(const NewtonIterationLogRecord& record) {
   return Status::Ok();
 }
 
+Status NewtonIterationLogWriter::Write(
+    const DynamicNewtonIterationLogRecord& record) {
+  if (state_ != State::kOpen) {
+    state_ = State::kFailed;
+    return LogOutputFailure(log_path_, "The Newton log writer is not open.");
+  }
+  const auto line = SerializeRecord(record, log_path_);
+  if (!line.HasValue()) {
+    state_ = State::kFailed;
+    return line.GetStatus();
+  }
+  stream_.write(line.Value().data(),
+                static_cast<std::streamsize>(line.Value().size()));
+  if (!stream_) {
+    state_ = State::kFailed;
+    return LogOutputFailure(log_path_,
+                            "The dynamic Newton log record could not write.");
+  }
+  return Status::Ok();
+}
+
 Status NewtonIterationLogWriter::Flush() {
   if (state_ != State::kOpen) {
     state_ = State::kFailed;
diff --git a/src/fesa/analysis/prepared_analysis.cpp b/src/fesa/analysis/prepared_analysis.cpp
index c1ee97f..597e10a 100644
--- a/src/fesa/analysis/prepared_analysis.cpp
+++ b/src/fesa/analysis/prepared_analysis.cpp
@@ -2,6 +2,7 @@
 
 #include <utility>
 
+#include "fesa/analysis/hht_dynamic_procedure.h"
 #include "fesa/analysis/linear_frequency_procedure.h"
 #include "fesa/analysis/linear_static_procedure.h"
 #include "fesa/analysis/newton_iteration_log.h"
@@ -9,6 +10,7 @@
 #include "fesa/app/output_paths.h"
 #include "fesa/io/abaqus/domain_mapper.h"
 #include "fesa/io/abaqus/input_reader.h"
+#include "fesa/results/dynamic_results_writer.h"
 #include "fesa/results/eigen_results_writer.h"
 #include "fesa/results/nonlinear_results_writer.h"
 #include "fesa/results/results_writer.h"
@@ -37,7 +39,8 @@ Result<PreparedAnalysisOutcome> ExecutePreparedAnalysis(
     const Domain& domain, LinearStaticProcedureExecutor& linear_executor,
     NonlinearStaticProcedureExecutor& nonlinear_executor,
     const LinearFrequencyProcedureExecutor& frequency_executor,
-    NewtonIterationLogWriter& log) {
+    NewtonIterationLogWriter& log,
+    const HhtDynamicProcedureExecutor* dynamic_executor) {
   if (domain.Steps().Size() != 1U) {
     return Result<PreparedAnalysisOutcome>::Failure(Status::Failure(
         FailureCategory::kInput,
@@ -49,6 +52,22 @@ Result<PreparedAnalysisOutcome> ExecutePreparedAnalysis(
           "Prepared analysis requires exactly one analysis step."}}));
   }
 
+  if (domain.Dynamic() != nullptr) {
+    if (dynamic_executor == nullptr)
+      return Result<PreparedAnalysisOutcome>::Failure(
+          Status::Failure(FailureCategory::kSolver,
+                          {{Severity::kError,
+                            "missing-dynamic-executor",
+                            {},
+                            "DYNAMIC",
+                            {},
+                            "Dynamic execution adapter is required."}}));
+    auto dynamic = dynamic_executor->Execute(domain, log);
+    if (!dynamic.HasValue())
+      return Result<PreparedAnalysisOutcome>::Failure(dynamic.GetStatus());
+    return Result<PreparedAnalysisOutcome>::Success(
+        PreparedAnalysisOutcome{std::move(dynamic.Value())});
+  }
   if (domain.Steps()[0U].IsFrequency()) {
     auto eigen = frequency_executor.Execute(domain);
     if (!eigen.HasValue()) {
@@ -80,8 +99,21 @@ Status FinalizePreparedAnalysisResult(
     const DerivedOutputPaths& paths, const Domain& domain,
     const PreparedAnalysisOutcome& outcome,
     const std::vector<Diagnostic>& diagnostics, ResultsWriter& linear_writer,
-    NonlinearResultsWriter& nonlinear_writer,
-    EigenResultsWriter& eigen_writer) {
+    NonlinearResultsWriter& nonlinear_writer, EigenResultsWriter& eigen_writer,
+    DynamicResultsWriter* dynamic_writer) {
+  if (std::holds_alternative<DynamicExecutionResult>(outcome)) {
+    if (dynamic_writer == nullptr)
+      return Status::Failure(FailureCategory::kOutput,
+                             {{Severity::kError,
+                               "missing-dynamic-writer",
+                               {},
+                               "DYNAMIC",
+                               {},
+                               "Dynamic result writer is required."}});
+    return dynamic_writer->Write(
+        paths.results_path, domain,
+        std::get<DynamicExecutionResult>(outcome).state, diagnostics);
+  }
   if (std::holds_alternative<EigenAnalysisState>(outcome)) {
     return eigen_writer.Write(paths.results_path, domain,
                               std::get<EigenAnalysisState>(outcome),
diff --git a/src/fesa/app/fesa_application.cpp b/src/fesa/app/fesa_application.cpp
index 1e54035..c80204a 100644
--- a/src/fesa/app/fesa_application.cpp
+++ b/src/fesa/app/fesa_application.cpp
@@ -5,6 +5,7 @@
 #include <string>
 #include <vector>
 
+#include "fesa/analysis/hht_dynamic_procedure.h"
 #include "fesa/analysis/linear_frequency_procedure.h"
 #include "fesa/analysis/linear_static_procedure.h"
 #include "fesa/analysis/newton_iteration_log.h"
@@ -13,6 +14,7 @@
 #include "fesa/app/output_paths.h"
 #include "fesa/assembly/parallel_for.h"
 #include "fesa/core/diagnostic.h"
+#include "fesa/io/hdf5/dynamic_hdf5_results_writer.h"
 #include "fesa/io/hdf5/eigen_hdf5_results_writer.h"
 #include "fesa/io/hdf5/hdf5_results_writer.h"
 #include "fesa/io/hdf5/nonlinear_hdf5_results_writer.h"
@@ -84,6 +86,7 @@ int FesaApplication::Run(const std::vector<std::string>& arguments) {
   Hdf5ResultsWriter linear_writer;
   NonlinearHdf5ResultsWriter nonlinear_writer;
   EigenHdf5ResultsWriter eigen_writer;
+  DynamicHdf5ResultsWriter dynamic_writer;
   NewtonIterationLogWriter log;
 
   Status status = log.Open(paths.Value().log_path);
@@ -101,9 +104,11 @@ int FesaApplication::Run(const std::vector<std::string>& arguments) {
     NonlinearStaticProcedureExecutor nonlinear_executor(parallel_for,
                                                         tangent_solver);
     const LinearFrequencyProcedureExecutor frequency_executor;
-    Result<PreparedAnalysisOutcome> outcome =
-        ExecutePreparedAnalysis(prepared.Value().domain, linear_executor,
-                                nonlinear_executor, frequency_executor, log);
+    const HhtDynamicProcedureExecutor dynamic_executor(
+        parallel_for, linear_solver, tangent_solver);
+    Result<PreparedAnalysisOutcome> outcome = ExecutePreparedAnalysis(
+        prepared.Value().domain, linear_executor, nonlinear_executor,
+        frequency_executor, log, &dynamic_executor);
     if (!outcome.HasValue()) {
       status = outcome.GetStatus();
     } else {
@@ -115,7 +120,7 @@ int FesaApplication::Run(const std::vector<std::string>& arguments) {
       status = FinalizePreparedAnalysisResult(
           paths.Value(), prepared.Value().domain, outcome.Value(),
           prepared.Value().diagnostics, linear_writer, nonlinear_writer,
-          eigen_writer);
+          eigen_writer, &dynamic_writer);
       if (status.IsOk()) {
         return kSuccessExitCode;
       }
diff --git a/src/fesa/elements/nonlinear_mitc4_inertia.cpp b/src/fesa/elements/nonlinear_mitc4_inertia.cpp
new file mode 100644
index 0000000..9024e15
--- /dev/null
+++ b/src/fesa/elements/nonlinear_mitc4_inertia.cpp
@@ -0,0 +1,871 @@
+#include "fesa/elements/nonlinear_mitc4_inertia.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <limits>
+#include <string>
+#include <utility>
+
+#include "fesa/elements/finite_rotation.h"
+
+namespace fesa {
+namespace {
+
+constexpr std::size_t kNodes = 4U;
+constexpr std::size_t kDofs = 24U;
+const std::array<double, 3> kGauss{-std::sqrt(3.0 / 5.0), 0.0,
+                                   std::sqrt(3.0 / 5.0)};
+constexpr std::array<double, 3> kWeights{5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0};
+
+template <class T>
+Result<T> Failure(const std::string& code, const SourceLocation& location,
+                  const std::string& identity, std::string message) {
+  return Result<T>::Failure(Status::Failure(
+      FailureCategory::kModel, {{Severity::kError, code, location, "*ELEMENT",
+                                 identity, std::move(message)}}));
+}
+
+std::string Identity(const std::array<const Node*, kNodes>& nodes) {
+  std::string identity;
+  for (const Node* node : nodes) {
+    if (!identity.empty()) {
+      identity += "-";
+    }
+    identity += node == nullptr ? "?" : node->source_id.source_label_text;
+  }
+  return identity;
+}
+
+Matrix FrameMatrix(const ShellNodeInitialFrame& frame) {
+  Matrix result{3U, 3U};
+  for (std::size_t row = 0U; row < 3U; ++row) {
+    result(row, 0U) = frame.tangent_a[row];
+    result(row, 1U) = frame.tangent_b[row];
+    result(row, 2U) = frame.director[row];
+  }
+  return result;
+}
+
+bool IsFinite(const Matrix& matrix) {
+  for (std::size_t row = 0U; row < matrix.Rows(); ++row) {
+    for (std::size_t column = 0U; column < matrix.Columns(); ++column) {
+      if (!std::isfinite(matrix(row, column))) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool IsFinite(const Vector& vector) {
+  for (std::size_t index = 0U; index < vector.Size(); ++index) {
+    if (!std::isfinite(vector[index])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/// @brief Carries all derivatives through order three in one nodal rotation.
+struct Jet {
+  double value{};
+  std::array<double, 3> d{};
+  std::array<std::array<double, 3>, 3> dd{};
+  std::array<std::array<std::array<double, 3>, 3>, 3> ddd{};
+};
+
+Jet Constant(const double value) { return Jet{value, {}, {}, {}}; }
+
+Jet Variable(const double value, const std::size_t component) {
+  Jet result = Constant(value);
+  result.d[component] = 1.0;
+  return result;
+}
+
+Jet operator+(const Jet& left, const Jet& right) {
+  Jet result{};
+  result.value = left.value + right.value;
+  for (std::size_t i = 0U; i < 3U; ++i) {
+    result.d[i] = left.d[i] + right.d[i];
+    for (std::size_t j = 0U; j < 3U; ++j) {
+      result.dd[i][j] = left.dd[i][j] + right.dd[i][j];
+      for (std::size_t k = 0U; k < 3U; ++k) {
+        result.ddd[i][j][k] = left.ddd[i][j][k] + right.ddd[i][j][k];
+      }
+    }
+  }
+  return result;
+}
+
+Jet operator-(const Jet& left, const Jet& right) {
+  Jet result{};
+  result.value = left.value - right.value;
+  for (std::size_t i = 0U; i < 3U; ++i) {
+    result.d[i] = left.d[i] - right.d[i];
+    for (std::size_t j = 0U; j < 3U; ++j) {
+      result.dd[i][j] = left.dd[i][j] - right.dd[i][j];
+      for (std::size_t k = 0U; k < 3U; ++k) {
+        result.ddd[i][j][k] = left.ddd[i][j][k] - right.ddd[i][j][k];
+      }
+    }
+  }
+  return result;
+}
+
+Jet operator*(const Jet& left, const Jet& right) {
+  Jet result{};
+  result.value = left.value * right.value;
+  for (std::size_t i = 0U; i < 3U; ++i) {
+    result.d[i] = left.d[i] * right.value + left.value * right.d[i];
+    for (std::size_t j = 0U; j < 3U; ++j) {
+      result.dd[i][j] = left.dd[i][j] * right.value + left.d[i] * right.d[j] +
+                        left.d[j] * right.d[i] + left.value * right.dd[i][j];
+      for (std::size_t k = 0U; k < 3U; ++k) {
+        result.ddd[i][j][k] =
+            left.ddd[i][j][k] * right.value + left.dd[i][j] * right.d[k] +
+            left.dd[i][k] * right.d[j] + left.dd[j][k] * right.d[i] +
+            left.d[i] * right.dd[j][k] + left.d[j] * right.dd[i][k] +
+            left.d[k] * right.dd[i][j] + left.value * right.ddd[i][j][k];
+      }
+    }
+  }
+  return result;
+}
+
+Jet Reciprocal(const Jet& value) {
+  Jet result{};
+  result.value = 1.0 / value.value;
+  const double squared = result.value * result.value;
+  const double cubed = squared * result.value;
+  const double fourth = cubed * result.value;
+  for (std::size_t i = 0U; i < 3U; ++i) {
+    result.d[i] = -value.d[i] * squared;
+    for (std::size_t j = 0U; j < 3U; ++j) {
+      result.dd[i][j] =
+          2.0 * value.d[i] * value.d[j] * cubed - value.dd[i][j] * squared;
+      for (std::size_t k = 0U; k < 3U; ++k) {
+        result.ddd[i][j][k] =
+            -6.0 * value.d[i] * value.d[j] * value.d[k] * fourth +
+            2.0 *
+                (value.dd[i][j] * value.d[k] + value.dd[i][k] * value.d[j] +
+                 value.dd[j][k] * value.d[i]) *
+                cubed -
+            value.ddd[i][j][k] * squared;
+      }
+    }
+  }
+  return result;
+}
+
+Jet InverseSqrt(const Jet& value) {
+  Jet result{};
+  result.value = 1.0 / std::sqrt(value.value);
+  const double cubed = result.value * result.value * result.value;
+  const double fifth = cubed * result.value * result.value;
+  const double seventh = fifth * result.value * result.value;
+  for (std::size_t i = 0U; i < 3U; ++i) {
+    result.d[i] = -0.5 * cubed * value.d[i];
+    for (std::size_t j = 0U; j < 3U; ++j) {
+      result.dd[i][j] =
+          0.75 * fifth * value.d[i] * value.d[j] - 0.5 * cubed * value.dd[i][j];
+      for (std::size_t k = 0U; k < 3U; ++k) {
+        result.ddd[i][j][k] =
+            -1.875 * seventh * value.d[i] * value.d[j] * value.d[k] +
+            0.75 * fifth *
+                (value.dd[i][j] * value.d[k] + value.dd[i][k] * value.d[j] +
+                 value.dd[j][k] * value.d[i]) -
+            0.5 * cubed * value.ddd[i][j][k];
+      }
+    }
+  }
+  return result;
+}
+
+Jet Scale(const double scalar, const Jet& value) {
+  return Constant(scalar) * value;
+}
+
+using JetVector = std::array<Jet, 3>;
+using JetMatrix = std::array<std::array<Jet, 3>, 3>;
+
+JetVector Multiply(const JetMatrix& matrix, const JetVector& vector) {
+  JetVector result{Constant(0.0), Constant(0.0), Constant(0.0)};
+  for (std::size_t row = 0U; row < 3U; ++row) {
+    for (std::size_t column = 0U; column < 3U; ++column) {
+      result[row] = result[row] + matrix[row][column] * vector[column];
+    }
+  }
+  return result;
+}
+
+JetMatrix Multiply(const JetMatrix& left, const JetMatrix& right) {
+  JetMatrix result{};
+  for (std::size_t row = 0U; row < 3U; ++row) {
+    for (std::size_t column = 0U; column < 3U; ++column) {
+      result[row][column] = Constant(0.0);
+      for (std::size_t index = 0U; index < 3U; ++index) {
+        result[row][column] =
+            result[row][column] + left[row][index] * right[index][column];
+      }
+    }
+  }
+  return result;
+}
+
+JetMatrix IdentityMatrix() {
+  JetMatrix result{};
+  for (std::size_t index = 0U; index < 3U; ++index) {
+    result[index][index] = Constant(1.0);
+  }
+  return result;
+}
+
+JetMatrix Skew(const JetVector& value) {
+  JetMatrix result{};
+  result[0U][1U] = Scale(-1.0, value[2U]);
+  result[0U][2U] = value[1U];
+  result[1U][0U] = value[2U];
+  result[1U][2U] = Scale(-1.0, value[0U]);
+  result[2U][0U] = Scale(-1.0, value[1U]);
+  result[2U][1U] = value[0U];
+  return result;
+}
+
+Jet Dot(const JetVector& left, const JetVector& right) {
+  Jet result = Constant(0.0);
+  for (std::size_t component = 0U; component < 3U; ++component) {
+    result = result + left[component] * right[component];
+  }
+  return result;
+}
+
+JetMatrix Inverse(const JetMatrix& matrix) {
+  JetMatrix cofactor{};
+  for (std::size_t row = 0U; row < 3U; ++row) {
+    for (std::size_t column = 0U; column < 3U; ++column) {
+      const std::size_t a = (row + 1U) % 3U;
+      const std::size_t b = (row + 2U) % 3U;
+      const std::size_t c = (column + 1U) % 3U;
+      const std::size_t d = (column + 2U) % 3U;
+      cofactor[row][column] =
+          matrix[a][c] * matrix[b][d] - matrix[a][d] * matrix[b][c];
+      // Cyclic minor ordering already includes the cofactor sign.
+    }
+  }
+  Jet determinant = Constant(0.0);
+  for (std::size_t column = 0U; column < 3U; ++column) {
+    determinant = determinant + matrix[0U][column] * cofactor[0U][column];
+  }
+  const Jet inverse_determinant = Reciprocal(determinant);
+  JetMatrix result{};
+  for (std::size_t row = 0U; row < 3U; ++row) {
+    for (std::size_t column = 0U; column < 3U; ++column) {
+      result[row][column] = cofactor[column][row] * inverse_determinant;
+    }
+  }
+  return result;
+}
+
+JetMatrix LeftJacobian(const JetVector& phi) {
+  const JetMatrix skew = Skew(phi);
+  JetMatrix result = IdentityMatrix();
+  JetMatrix term = IdentityMatrix();
+  double factorial = 1.0;
+  for (std::size_t order = 1U; order <= 32U; ++order) {
+    term = Multiply(term, skew);
+    factorial *= static_cast<double>(order + 1U);
+    for (std::size_t row = 0U; row < 3U; ++row) {
+      for (std::size_t column = 0U; column < 3U; ++column) {
+        result[row][column] =
+            result[row][column] + Scale(1.0 / factorial, term[row][column]);
+      }
+    }
+  }
+  return result;
+}
+
+/// @brief Uses a converged exponential series so D1/D2/D3 share one analytic
+/// map.
+JetMatrix ExpSkew(const JetVector& phi) {
+  const JetMatrix skew = Skew(phi);
+  JetMatrix result = IdentityMatrix();
+  JetMatrix term = IdentityMatrix();
+  double factorial = 1.0;
+  for (std::size_t order = 1U; order <= 32U; ++order) {
+    term = Multiply(term, skew);
+    factorial *= static_cast<double>(order);
+    for (std::size_t row = 0U; row < 3U; ++row) {
+      for (std::size_t column = 0U; column < 3U; ++column) {
+        result[row][column] =
+            result[row][column] + Scale(1.0 / factorial, term[row][column]);
+      }
+    }
+  }
+  return result;
+}
+
+double Determinant(const Vector3& a, const Vector3& b, const Vector3& c) {
+  return a.Dot(b.Cross(c));
+}
+
+/// @brief Checks the scaled physical twenty-dimensional mass without a rank
+/// cut.
+Status CheckPhysicalMass(const Matrix& mass,
+                         const std::array<Vector3, kNodes>& nulls,
+                         const double length, const SourceLocation& location,
+                         const std::string& identity) {
+  const auto fail = [&](const std::string& code, const std::string& message) {
+    return Status::Failure(
+        FailureCategory::kModel,
+        {{Severity::kError, code, location, "*ELEMENT", identity, message}});
+  };
+  constexpr std::size_t kPhysical = 20U;
+  Matrix scaled{kDofs, kDofs};
+  double scale = 0.0;
+  for (std::size_t row = 0U; row < kDofs; ++row) {
+    for (std::size_t column = 0U; column < kDofs; ++column) {
+      scaled(row, column) = mass(row, column) * (row % 6U < 3U ? length : 1.0) *
+                            (column % 6U < 3U ? length : 1.0);
+      if (mass(row, column) != 0.0 && scaled(row, column) == 0.0) {
+        return fail("invalid-nonlinear-inertia-positive-mass",
+                    "Physical mass scaling underflowed a nonzero entry.");
+      }
+      scale = std::max(scale, std::abs(scaled(row, column)));
+    }
+  }
+  if (!IsFinite(scaled) || !std::isfinite(scale) || !(scale > 0.0)) {
+    return fail("invalid-nonlinear-inertia-positive-mass",
+                "Scaled physical mass must have a finite positive scale.");
+  }
+  // Scaling by a positive entry preserves conditioning and avoids density
+  // overflow in the Cholesky and inverse-action norms.
+  for (std::size_t row = 0U; row < kDofs; ++row) {
+    for (std::size_t column = 0U; column < kDofs; ++column) {
+      scaled(row, column) /= scale;
+    }
+  }
+  Matrix complement{kDofs, kPhysical};
+  for (std::size_t node = 0U; node < kNodes; ++node) {
+    const Vector3& normal = nulls[node];
+    std::array<std::size_t, 3> axes{0U, 1U, 2U};
+    std::stable_sort(axes.begin(), axes.end(),
+                     [&](const std::size_t a, const std::size_t b) {
+                       return std::abs(normal[a]) < std::abs(normal[b]);
+                     });
+    std::array<Vector3, 2> tangent{};
+    for (std::size_t column = 0U; column < 2U; ++column) {
+      std::array<double, 3> axis{};
+      axis[axes[column]] = 1.0;
+      Vector3 direction{axis};
+      direction = direction - direction.Dot(normal) * normal;
+      for (std::size_t previous = 0U; previous < column; ++previous) {
+        direction =
+            direction - direction.Dot(tangent[previous]) * tangent[previous];
+      }
+      const double norm = direction.Norm();
+      if (!std::isfinite(norm) || !(norm > 0.0)) {
+        return fail("invalid-nonlinear-inertia-null",
+                    "The analytic physical complement must remain finite.");
+      }
+      tangent[column] = direction / norm;
+    }
+    for (std::size_t row = 0U; row < 3U; ++row) {
+      complement(6U * node + row, 5U * node + row) = 1.0;
+      for (std::size_t column = 0U; column < 2U; ++column) {
+        complement(6U * node + 3U + row, 5U * node + 3U + column) =
+            tangent[column][row];
+      }
+    }
+  }
+  double mass_norm = 0.0;
+  double symmetry_norm = 0.0;
+  double null_action_norm = 0.0;
+  for (std::size_t row = 0U; row < kDofs; ++row) {
+    for (std::size_t column = 0U; column < kDofs; ++column) {
+      mass_norm = std::hypot(mass_norm, scaled(row, column));
+      symmetry_norm =
+          std::hypot(symmetry_norm, scaled(row, column) - scaled(column, row));
+    }
+    for (std::size_t node = 0U; node < kNodes; ++node) {
+      double action = 0.0;
+      for (std::size_t component = 0U; component < 3U; ++component) {
+        action +=
+            scaled(row, 6U * node + 3U + component) * nulls[node][component];
+      }
+      null_action_norm = std::hypot(null_action_norm, action);
+    }
+  }
+  double gram_error = 0.0;
+  double orthogonality_error = 0.0;
+  for (std::size_t row = 0U; row < kPhysical; ++row) {
+    for (std::size_t column = 0U; column < kPhysical; ++column) {
+      double entry = row == column ? -1.0 : 0.0;
+      for (std::size_t inner = 0U; inner < kDofs; ++inner) {
+        entry += complement(inner, row) * complement(inner, column);
+      }
+      gram_error = std::hypot(gram_error, entry);
+    }
+    for (std::size_t node = 0U; node < kNodes; ++node) {
+      double entry = 0.0;
+      for (std::size_t component = 0U; component < 3U; ++component) {
+        entry += complement(6U * node + 3U + component, row) *
+                 nulls[node][component];
+      }
+      orthogonality_error = std::hypot(orthogonality_error, entry);
+    }
+  }
+  double null_gram_error = 0.0;
+  for (const Vector3& normal : nulls) {
+    null_gram_error = std::hypot(null_gram_error, normal.Dot(normal) - 1.0);
+  }
+  const double full_gram_error = std::hypot(
+      gram_error,
+      std::hypot(null_gram_error, std::sqrt(2.0) * orthogonality_error));
+  if (!(symmetry_norm / mass_norm <= 1.0e-12) ||
+      !(null_action_norm / mass_norm / 2.0 <= 1.0e-12) ||
+      !(full_gram_error <= 1.0e-12)) {
+    return fail("invalid-nonlinear-inertia-null",
+                "Scaled mass symmetry and analytic null identities failed.");
+  }
+  Matrix block{kPhysical, kPhysical};
+  Matrix mass_complement{kDofs, kPhysical};
+  for (std::size_t row = 0U; row < kDofs; ++row) {
+    for (std::size_t column = 0U; column < kPhysical; ++column) {
+      for (std::size_t inner = 0U; inner < kDofs; ++inner) {
+        mass_complement(row, column) +=
+            scaled(row, inner) * complement(inner, column);
+      }
+    }
+  }
+  double block_norm = 0.0;
+  for (std::size_t row = 0U; row < kPhysical; ++row) {
+    double row_sum = 0.0;
+    for (std::size_t column = 0U; column < kPhysical; ++column) {
+      for (std::size_t inner = 0U; inner < kDofs; ++inner) {
+        block(row, column) +=
+            complement(inner, row) * mass_complement(inner, column);
+      }
+      row_sum += std::abs(block(row, column));
+    }
+    block_norm = std::max(block_norm, row_sum);
+  }
+  Matrix lower{kPhysical, kPhysical};
+  for (std::size_t row = 0U; row < kPhysical; ++row) {
+    for (std::size_t column = 0U; column <= row; ++column) {
+      double entry = block(row, column);
+      for (std::size_t inner = 0U; inner < column; ++inner) {
+        entry -= lower(row, inner) * lower(column, inner);
+      }
+      if (!std::isfinite(entry) || (row == column && !(entry > 0.0))) {
+        return fail(
+            "invalid-nonlinear-inertia-positive-mass",
+            "Physical mass requires strictly positive Cholesky pivots.");
+      }
+      lower(row, column) =
+          row == column ? std::sqrt(entry) : entry / lower(column, column);
+    }
+  }
+  std::array<double, kPhysical> inverse_row_sums{};
+  double reconstruction_error = 0.0;
+  double block_frobenius = 0.0;
+  for (std::size_t row = 0U; row < kPhysical; ++row) {
+    for (std::size_t column = 0U; column < kPhysical; ++column) {
+      double reconstructed = 0.0;
+      for (std::size_t inner = 0U; inner <= std::min(row, column); ++inner) {
+        reconstructed += lower(row, inner) * lower(column, inner);
+      }
+      reconstruction_error =
+          std::hypot(reconstruction_error, reconstructed - block(row, column));
+      block_frobenius = std::hypot(block_frobenius, block(row, column));
+    }
+  }
+  if (!(reconstruction_error / block_frobenius <= 1.0e-12)) {
+    return fail("invalid-nonlinear-inertia-positive-mass",
+                "Physical mass Cholesky reconstruction failed.");
+  }
+  for (std::size_t column = 0U; column < kPhysical; ++column) {
+    std::array<double, kPhysical> solution{};
+    for (std::size_t row = 0U; row < kPhysical; ++row) {
+      double rhs = row == column ? 1.0 : 0.0;
+      for (std::size_t inner = 0U; inner < row; ++inner) {
+        rhs -= lower(row, inner) * solution[inner];
+      }
+      solution[row] = rhs / lower(row, row);
+    }
+    for (std::size_t reverse = kPhysical; reverse > 0U; --reverse) {
+      const std::size_t row = reverse - 1U;
+      double rhs = solution[row];
+      for (std::size_t inner = row + 1U; inner < kPhysical; ++inner) {
+        rhs -= lower(inner, row) * solution[inner];
+      }
+      solution[row] = rhs / lower(row, row);
+      inverse_row_sums[row] += std::abs(solution[row]);
+    }
+  }
+  const double inverse_norm =
+      *std::max_element(inverse_row_sums.begin(), inverse_row_sums.end());
+  const double reciprocal_condition = 1.0 / block_norm / inverse_norm;
+  if (!std::isfinite(inverse_norm) || !std::isfinite(reciprocal_condition) ||
+      !(reciprocal_condition >= std::ldexp(1.0, -32))) {
+    return fail("ill-conditioned-nonlinear-inertia-positive-mass",
+                "Physical mass reciprocal infinity condition is below 2^-32.");
+  }
+  return Status::Ok();
+}
+
+}  // namespace
+
+Result<DynamicRotationKinematics> EvaluateDynamicRotation(
+    const Vector3& phi_value, const Vector3& initial_director,
+    const Vector3& velocity, const Vector3& acceleration) {
+  if (!phi_value.IsFinite() || !initial_director.IsFinite() ||
+      !velocity.IsFinite() || !acceleration.IsFinite() ||
+      !(std::abs(initial_director.Norm() - 1.0) <= 1.0e-12) ||
+      !(std::acos(-1.0) - phi_value.Norm() >
+        std::sqrt(std::numeric_limits<double>::epsilon()))) {
+    return Failure<DynamicRotationKinematics>(
+        "invalid-dynamic-rotation", {{}, 0U}, "DYNAMIC_ROTATION",
+        "Dynamic rotation requires finite principal coordinates and a unit "
+        "initial director.");
+  }
+  JetVector phi{};
+  for (std::size_t component = 0U; component < 3U; ++component) {
+    phi[component] = Variable(phi_value[component], component);
+  }
+  const JetVector initial{Constant(initial_director.X()),
+                          Constant(initial_director.Y()),
+                          Constant(initial_director.Z())};
+  const JetVector director_jet = Multiply(ExpSkew(phi), initial);
+  const JetMatrix left_jacobian = LeftJacobian(phi);
+  JetVector null_jet = Multiply(Inverse(left_jacobian), director_jet);
+  const Jet null_norm_squared = Dot(null_jet, null_jet);
+  if (!std::isfinite(null_norm_squared.value) ||
+      !(null_norm_squared.value > 0.0)) {
+    return Failure<DynamicRotationKinematics>(
+        "invalid-dynamic-rotation", {{}, 0U}, "DYNAMIC_ROTATION",
+        "Dynamic rotation produced a nonpositive drilling-null norm.");
+  }
+  const Jet inverse_norm = InverseSqrt(null_norm_squared);
+  for (Jet& component : null_jet) {
+    component = component * inverse_norm;
+  }
+  std::array<double, 3> directional_second{};
+  std::array<double, 3> angular_velocity{};
+  std::array<double, 3> angular_acceleration{};
+  Matrix gradient{3U, 3U};
+  for (std::size_t row = 0U; row < 3U; ++row) {
+    for (std::size_t column = 0U; column < 3U; ++column) {
+      gradient(row, column) = null_jet[row].d[column];
+    }
+  }
+  for (std::size_t row = 0U; row < 3U; ++row) {
+    double second = 0.0;
+    double omega = 0.0;
+    double omega_dot = 0.0;
+    for (std::size_t column = 0U; column < 3U; ++column) {
+      omega += left_jacobian[row][column].value * velocity[column];
+      omega_dot += left_jacobian[row][column].value * acceleration[column];
+      for (std::size_t other = 0U; other < 3U; ++other) {
+        second += null_jet[row].dd[column][other] * velocity[column] *
+                  velocity[other];
+        omega_dot += left_jacobian[row][column].d[other] * velocity[other] *
+                     velocity[column];
+      }
+    }
+    directional_second[row] = second;
+    angular_velocity[row] = omega;
+    angular_acceleration[row] = omega_dot;
+  }
+  const Vector3 director{director_jet[0U].value, director_jet[1U].value,
+                         director_jet[2U].value};
+  const Vector3 drill_null{null_jet[0U].value, null_jet[1U].value,
+                           null_jet[2U].value};
+  const Vector3 directional_second_value{directional_second};
+  const Vector3 angular_velocity_value{angular_velocity};
+  const Vector3 angular_acceleration_value{angular_acceleration};
+  if (!director.IsFinite() || !drill_null.IsFinite() ||
+      !directional_second_value.IsFinite() ||
+      !angular_velocity_value.IsFinite() ||
+      !angular_acceleration_value.IsFinite() || !IsFinite(gradient)) {
+    return Failure<DynamicRotationKinematics>(
+        "invalid-dynamic-rotation", {{}, 0U}, "DYNAMIC_ROTATION",
+        "Dynamic rotation evaluation must remain finite.");
+  }
+  DynamicRotationKinematics result{director,
+                                   drill_null,
+                                   std::move(gradient),
+                                   directional_second_value,
+                                   angular_velocity_value,
+                                   angular_acceleration_value,
+                                   {},
+                                   {},
+                                   {}};
+  for (std::size_t i = 0U; i < 3U; ++i) {
+    result.director_first[i] = {director_jet[0].d[i], director_jet[1].d[i],
+                                director_jet[2].d[i]};
+    for (std::size_t j = 0U; j < 3U; ++j) {
+      result.director_second[i][j] = {director_jet[0].dd[i][j],
+                                      director_jet[1].dd[i][j],
+                                      director_jet[2].dd[i][j]};
+      for (std::size_t k = 0U; k < 3U; ++k) {
+        result.director_third[i][j][k] = {director_jet[0].ddd[i][j][k],
+                                          director_jet[1].ddd[i][j][k],
+                                          director_jet[2].ddd[i][j][k]};
+      }
+    }
+  }
+  return Result<DynamicRotationKinematics>::Success(std::move(result));
+}
+
+NonlinearMitc4Inertia::NonlinearMitc4Inertia(
+    std::array<Vector3, 4> coordinates, std::array<Matrix, 4> initial_frames,
+    std::array<Vector3, 4> initial_directors, const double thickness,
+    const double density, SourceLocation source_location, std::string identity)
+    : coordinates_(std::move(coordinates)),
+      initial_frames_(std::move(initial_frames)),
+      initial_directors_(std::move(initial_directors)),
+      thickness_(thickness),
+      density_(density),
+      source_location_(std::move(source_location)),
+      identity_(std::move(identity)) {}
+
+Result<NonlinearMitc4Inertia> NonlinearMitc4Inertia::Create(
+    std::array<const Node*, 4> nodes,
+    std::array<ShellNodeInitialFrame, 4> initial_frames,
+    const ShellSection& section, const LinearElasticMaterial& material,
+    const double density) {
+  const std::string identity = Identity(nodes);
+  if (!std::isfinite(density) || !(density > 0.0)) {
+    return Failure<NonlinearMitc4Inertia>(
+        "invalid-nonlinear-inertia-density", section.location, identity,
+        "Nonlinear MITC4 inertia requires a finite positive density.");
+  }
+  const auto shell =
+      NonlinearMitc4Shell::Create(nodes, initial_frames, section, material);
+  if (!shell.HasValue()) {
+    return Result<NonlinearMitc4Inertia>::Failure(shell.GetStatus());
+  }
+  std::array<Vector3, kNodes> coordinates{};
+  std::array<Matrix, kNodes> frames{Matrix{3U, 3U}, Matrix{3U, 3U},
+                                    Matrix{3U, 3U}, Matrix{3U, 3U}};
+  std::array<Vector3, kNodes> directors{};
+  for (std::size_t node = 0U; node < kNodes; ++node) {
+    coordinates[node] = Vector3{nodes[node]->coordinates};
+    frames[node] = FrameMatrix(initial_frames[node]);
+    directors[node] = Vector3{initial_frames[node].director};
+  }
+  NonlinearMitc4Inertia inertia{
+      coordinates, std::move(frames),   directors, section.thickness,
+      density,     nodes[0U]->location, identity};
+  const auto initial = inertia.Evaluate({}, Vector{kDofs}, Vector{kDofs});
+  if (!initial.HasValue()) {
+    return Result<NonlinearMitc4Inertia>::Failure(initial.GetStatus());
+  }
+  return Result<NonlinearMitc4Inertia>::Success(std::move(inertia));
+}
+
+Result<NonlinearMitc4InertiaEvaluation> NonlinearMitc4Inertia::Evaluate(
+    const NonlinearMitc4TrialDofs& trial, const Vector& velocity,
+    const Vector& acceleration) const {
+  if (velocity.Size() != kDofs || acceleration.Size() != kDofs ||
+      !IsFinite(velocity) || !IsFinite(acceleration)) {
+    return Failure<NonlinearMitc4InertiaEvaluation>(
+        "invalid-nonlinear-inertia-rate", source_location_, identity_,
+        "Nonlinear MITC4 inertia requires 24 finite rates.");
+  }
+  std::array<DynamicRotationKinematics, kNodes> rotations{};
+  std::array<Vector3, kNodes> nulls{};
+  double length = 0.0;
+  for (std::size_t node = 0U; node < kNodes; ++node) {
+    length = std::max(
+        length,
+        (coordinates_[(node + 1U) % kNodes] - coordinates_[node]).Norm());
+    if (!trial.displacement[node].IsFinite() ||
+        !MakeFiniteRotationState(trial.rotation_vector[node],
+                                 initial_frames_[node])
+             .HasValue()) {
+      return Failure<NonlinearMitc4InertiaEvaluation>(
+          "invalid-nonlinear-inertia-trial", source_location_, identity_,
+          "Nonlinear MITC4 inertia trial must be in the principal chart.");
+    }
+    const auto rotation = EvaluateDynamicRotation(
+        trial.rotation_vector[node], initial_directors_[node], {}, {});
+    if (!rotation.HasValue()) {
+      return Result<NonlinearMitc4InertiaEvaluation>::Failure(
+          rotation.GetStatus());
+    }
+    rotations[node] = rotation.Value();
+    nulls[node] = rotation.Value().drill_null;
+    for (std::size_t previous = 0U; previous < node; ++previous) {
+      if (!(rotations[node].director.Dot(rotations[previous].director) >
+            -1.0 + 1.0e-8)) {
+        return Failure<NonlinearMitc4InertiaEvaluation>(
+            "invalid-nonlinear-inertia-director", source_location_, identity_,
+            "Nonlinear MITC4 inertia trial directors must not be opposed.");
+      }
+    }
+  }
+  if (!std::isfinite(length) || !(length > 0.0)) {
+    return Failure<NonlinearMitc4InertiaEvaluation>(
+        "invalid-nonlinear-inertia-geometry", source_location_, identity_,
+        "Nonlinear MITC4 inertia requires a finite positive initial edge.");
+  }
+
+  NonlinearMitc4InertiaEvaluation result{Matrix{kDofs, kDofs},
+                                         Matrix{kDofs, kDofs},
+                                         Matrix{kDofs, kDofs},
+                                         Vector{kDofs},
+                                         Vector{kDofs},
+                                         0.0,
+                                         {},
+                                         {},
+                                         {},
+                                         {}};
+  for (std::size_t xi = 0U; xi < kGauss.size(); ++xi) {
+    for (std::size_t eta = 0U; eta < kGauss.size(); ++eta) {
+      const Mitc4ShapeFunctions shape =
+          Mitc4Shell::ShapeFunctions(kGauss[xi], kGauss[eta]);
+      for (std::size_t zeta = 0U; zeta < kGauss.size(); ++zeta) {
+        const double z = 0.5 * thickness_ * kGauss[zeta];
+        const double weight = kWeights[xi] * kWeights[eta] * kWeights[zeta];
+        Vector3 ref_xi{};
+        Vector3 ref_eta{};
+        Vector3 ref_zeta{};
+        Vector3 current_xi{};
+        Vector3 current_eta{};
+        Vector3 current_zeta{};
+        Vector3 position{};
+        Vector3 velocity_point{};
+        Vector3 acceleration_point{};
+        Vector3 convective_point{};
+        std::array<Vector3, kDofs> h{};
+        std::array<Vector3, kDofs> velocity_derivative{};
+        std::array<Vector3, kDofs> position_derivative{};
+        for (std::size_t node = 0U; node < kNodes; ++node) {
+          const std::size_t base = 6U * node;
+          const auto& rotation = rotations[node];
+          const Vector3 reference =
+              coordinates_[node] + z * initial_directors_[node];
+          const Vector3 current = coordinates_[node] +
+                                  trial.displacement[node] +
+                                  z * rotation.director;
+          ref_xi = ref_xi + shape.xi_derivatives[node] * reference;
+          ref_eta = ref_eta + shape.eta_derivatives[node] * reference;
+          ref_zeta = ref_zeta + 0.5 * thickness_ * shape.values[node] *
+                                    initial_directors_[node];
+          current_xi = current_xi + shape.xi_derivatives[node] * current;
+          current_eta = current_eta + shape.eta_derivatives[node] * current;
+          current_zeta = current_zeta + 0.5 * thickness_ * shape.values[node] *
+                                            rotation.director;
+          position = position + shape.values[node] * current;
+          for (std::size_t component = 0U; component < 3U; ++component) {
+            std::array<double, 3> translation{};
+            translation[component] = shape.values[node];
+            h[base + component] = Vector3{translation};
+            h[base + 3U + component] =
+                z * shape.values[node] * rotation.director_first[component];
+            for (std::size_t other = 0U; other < 3U; ++other) {
+              const Vector3 second = z * shape.values[node] *
+                                     rotation.director_second[component][other];
+              convective_point =
+                  convective_point + second * velocity[base + 3U + component] *
+                                         velocity[base + 3U + other];
+              velocity_derivative[base + 3U + component] =
+                  velocity_derivative[base + 3U + component] +
+                  2.0 * second * velocity[base + 3U + other];
+              position_derivative[base + 3U + component] =
+                  position_derivative[base + 3U + component] +
+                  second * acceleration[base + 3U + other];
+              for (std::size_t third = 0U; third < 3U; ++third) {
+                position_derivative[base + 3U + component] =
+                    position_derivative[base + 3U + component] +
+                    z * shape.values[node] *
+                        rotation.director_third[component][other][third] *
+                        velocity[base + 3U + other] *
+                        velocity[base + 3U + third];
+              }
+            }
+          }
+        }
+        const double jacobian = Determinant(ref_xi, ref_eta, ref_zeta);
+        const double current_jacobian =
+            Determinant(current_xi, current_eta, current_zeta);
+        if (!std::isfinite(jacobian) || !(jacobian > 0.0) ||
+            !std::isfinite(current_jacobian) || !(current_jacobian > 0.0)) {
+          return Failure<NonlinearMitc4InertiaEvaluation>(
+              "invalid-nonlinear-inertia-geometry", source_location_, identity_,
+              "Inertia requires positive reference and current mass-point "
+              "Jacobians.");
+        }
+        for (std::size_t row = 0U; row < kDofs; ++row) {
+          velocity_point = velocity_point + h[row] * velocity[row];
+          acceleration_point = acceleration_point + h[row] * acceleration[row];
+        }
+        acceleration_point = acceleration_point + convective_point;
+        const double scale = density_ * weight * jacobian;
+        if (!std::isfinite(scale) || !(scale > 0.0)) {
+          return Failure<NonlinearMitc4InertiaEvaluation>(
+              "invalid-nonlinear-inertia-positive-mass", source_location_,
+              identity_,
+              "Mass-point integration weight must be finite and positive.");
+        }
+        result.kinetic_energy +=
+            0.5 * scale * velocity_point.Dot(velocity_point);
+        result.momentum = result.momentum + scale * velocity_point;
+        result.momentum_rate =
+            result.momentum_rate + scale * acceleration_point;
+        result.angular_momentum =
+            result.angular_momentum + scale * position.Cross(velocity_point);
+        result.angular_momentum_rate =
+            result.angular_momentum_rate +
+            scale * position.Cross(acceleration_point);
+        result.momentum_rate_scale += scale * acceleration_point.Norm();
+        result.angular_momentum_rate_scale +=
+            scale * position.Cross(acceleration_point).Norm();
+        for (std::size_t row = 0U; row < kDofs; ++row) {
+          result.force[row] += scale * h[row].Dot(acceleration_point);
+          // Keep c independent of a; subtracting M*a destroys small c values.
+          result.convective_force[row] += scale * h[row].Dot(convective_point);
+          for (std::size_t column = 0U; column < kDofs; ++column) {
+            result.mass(row, column) += scale * h[row].Dot(h[column]);
+            result.velocity_tangent(row, column) +=
+                scale * h[row].Dot(velocity_derivative[column]);
+            double position_entry = h[row].Dot(position_derivative[column]);
+            if (row / 6U == column / 6U && row % 6U >= 3U &&
+                column % 6U >= 3U) {
+              const std::size_t node = row / 6U;
+              position_entry +=
+                  z * shape.values[node] *
+                  rotations[node]
+                      .director_second[row % 6U - 3U][column % 6U - 3U]
+                      .Dot(acceleration_point);
+            }
+            result.position_tangent(row, column) += scale * position_entry;
+          }
+        }
+      }
+    }
+  }
+  if (!IsFinite(result.mass) || !IsFinite(result.position_tangent) ||
+      !IsFinite(result.velocity_tangent) || !IsFinite(result.force) ||
+      !IsFinite(result.convective_force) ||
+      !std::isfinite(result.kinetic_energy) || !result.momentum.IsFinite() ||
+      !result.angular_momentum.IsFinite() || !result.momentum_rate.IsFinite() ||
+      !result.angular_momentum_rate.IsFinite() ||
+      !std::isfinite(result.momentum_rate_scale) ||
+      !std::isfinite(result.angular_momentum_rate_scale)) {
+    return Failure<NonlinearMitc4InertiaEvaluation>(
+        "invalid-nonlinear-inertia-evaluation", source_location_, identity_,
+        "Nonlinear MITC4 inertia evaluation must remain finite.");
+  }
+  const Status physical_mass = CheckPhysicalMass(result.mass, nulls, length,
+                                                 source_location_, identity_);
+  if (!physical_mass.IsOk()) {
+    return Result<NonlinearMitc4InertiaEvaluation>::Failure(physical_mass);
+  }
+  return Result<NonlinearMitc4InertiaEvaluation>::Success(std::move(result));
+}
+
+}  // namespace fesa
diff --git a/src/fesa/elements/nonlinear_mitc4_shell.cpp b/src/fesa/elements/nonlinear_mitc4_shell.cpp
index 48d117a..a0917ea 100644
--- a/src/fesa/elements/nonlinear_mitc4_shell.cpp
+++ b/src/fesa/elements/nonlinear_mitc4_shell.cpp
@@ -42,9 +42,8 @@ template <class T>
 Result<T> Failure(const std::string& code, const SourceLocation& location,
                   const std::string& identity, std::string message) {
   return Result<T>::Failure(Status::Failure(
-      FailureCategory::kModel,
-      {{Severity::kError, code, location, "*ELEMENT", identity,
-        std::move(message)}}));
+      FailureCategory::kModel, {{Severity::kError, code, location, "*ELEMENT",
+                                 identity, std::move(message)}}));
 }
 
 /// @brief Builds the stable source label concatenation used by diagnostics.
@@ -134,8 +133,7 @@ bool MakeLocalFrame(const Vector3& midsurface_xi, const Vector3& midsurface_eta,
   }
   const Vector3 e1_candidate = midsurface_xi - midsurface_xi.Dot(e3) * e3;
   const double e1_norm = e1_candidate.Norm();
-  if (!e1_candidate.IsFinite() || !std::isfinite(e1_norm) ||
-      !(e1_norm > 0.0)) {
+  if (!e1_candidate.IsFinite() || !std::isfinite(e1_norm) || !(e1_norm > 0.0)) {
     return false;
   }
   const Vector3 e1 = e1_candidate / e1_norm;
@@ -155,8 +153,7 @@ bool EvaluateGeometry(const std::array<Vector3, kNodeCount>& coordinates,
                       const double thickness, const double xi, const double eta,
                       const double zeta, Geometry& geometry) {
   const Mitc4ShapeFunctions shape = Mitc4Shell::ShapeFunctions(xi, eta);
-  const Vector3 reference_xi =
-      DerivativeSum(shape.xi_derivatives, coordinates);
+  const Vector3 reference_xi = DerivativeSum(shape.xi_derivatives, coordinates);
   const Vector3 reference_eta =
       DerivativeSum(shape.eta_derivatives, coordinates);
   const Vector3 initial_director_xi =
@@ -218,11 +215,10 @@ Tensor DirectStrain(const Geometry& geometry) {
   Tensor strain{};
   for (std::size_t row = 0U; row < 3U; ++row) {
     for (std::size_t column = 0U; column < 3U; ++column) {
-      strain[row][column] =
-          0.5 * (geometry.current_covariant[row].Dot(
-                     geometry.current_covariant[column]) -
-                 geometry.reference_covariant[row].Dot(
-                     geometry.reference_covariant[column]));
+      strain[row][column] = 0.5 * (geometry.current_covariant[row].Dot(
+                                       geometry.current_covariant[column]) -
+                                   geometry.reference_covariant[row].Dot(
+                                       geometry.reference_covariant[column]));
     }
   }
   strain[2U][2U] = 0.0;
@@ -278,17 +274,17 @@ EngineeringStress Stress(const EngineeringStrain& strain, const double youngs,
   const double shear = kShearCorrection * youngs / (2.0 * (1.0 + poisson));
   return {factor * (strain[0U] + poisson * strain[1U]),
           factor * (poisson * strain[0U] + strain[1U]),
-          factor * (1.0 - poisson) * 0.5 * strain[2U],
-          shear * strain[3U], shear * strain[4U]};
+          factor * (1.0 - poisson) * 0.5 * strain[2U], shear * strain[3U],
+          shear * strain[4U]};
 }
 
 /// @brief Evaluates direct strain at one mandatory edge-midpoint tying point.
-bool EvaluateTyingSample(const std::array<Vector3, kNodeCount>& coordinates,
-                         const std::array<Vector3, kNodeCount>& initial_directors,
-                         const std::array<Vector3, kNodeCount>& directors,
-                         const NonlinearMitc4TrialDofs& trial,
-                         const double thickness, const double xi,
-                         const double eta, Tensor& strain) {
+bool EvaluateTyingSample(
+    const std::array<Vector3, kNodeCount>& coordinates,
+    const std::array<Vector3, kNodeCount>& initial_directors,
+    const std::array<Vector3, kNodeCount>& directors,
+    const NonlinearMitc4TrialDofs& trial, const double thickness,
+    const double xi, const double eta, Tensor& strain) {
   Geometry geometry{};
   if (!EvaluateGeometry(coordinates, initial_directors, directors, trial,
                         thickness, xi, eta, 0.0, geometry)) {
@@ -314,12 +310,13 @@ bool EvaluatePoint(const std::array<Vector3, kNodeCount>& coordinates,
   Tensor covariant = DirectStrain(point.geometry);
   const Mitc4TyingWeights weights = Mitc4Shell::TyingWeights(xi, eta);
   covariant[0U][2U] = weights.xi_zeta[0U] * tying_samples[0U][0U][2U] +
-                       weights.xi_zeta[1U] * tying_samples[1U][0U][2U];
+                      weights.xi_zeta[1U] * tying_samples[1U][0U][2U];
   covariant[2U][0U] = covariant[0U][2U];
   covariant[1U][2U] = weights.eta_zeta[0U] * tying_samples[2U][1U][2U] +
-                       weights.eta_zeta[1U] * tying_samples[3U][1U][2U];
+                      weights.eta_zeta[1U] * tying_samples[3U][1U][2U];
   covariant[2U][1U] = covariant[1U][2U];
-  const Tensor cartesian = CartesianStrain(covariant, point.geometry.reciprocal);
+  const Tensor cartesian =
+      CartesianStrain(covariant, point.geometry.reciprocal);
   point.strain = LocalEngineering(cartesian, point.geometry.local_frame);
   point.stress = Stress(point.strain, youngs, poisson);
   return IsFinite(covariant) && IsFinite(cartesian) && IsFinite(point.strain) &&
@@ -372,6 +369,10 @@ struct Jet {
   double value{};
   std::array<double, kGlobalDofCount> first{};
   Hessian second;
+  double directional_first{};
+  double directional_second{};
+  std::array<double, kGlobalDofCount> mixed_first{};
+  std::array<double, kGlobalDofCount> mixed_second{};
 };
 
 using JetVector3 = std::array<Jet, 3>;
@@ -386,9 +387,11 @@ Jet Constant(const double value) {
 }
 
 /// @brief Returns one independent global trial coordinate.
-Jet Variable(const double value, const std::size_t index) {
+Jet Variable(const double value, const std::size_t index,
+             const double direction = 0.0) {
   Jet result = Constant(value);
   result.first[index] = 1.0;
+  result.directional_first = direction;
   return result;
 }
 
@@ -396,8 +399,15 @@ Jet Variable(const double value, const std::size_t index) {
 Jet operator+(const Jet& left, const Jet& right) {
   Jet result{};
   result.value = left.value + right.value;
+  result.directional_first = left.directional_first + right.directional_first;
+  result.directional_second =
+      left.directional_second + right.directional_second;
   for (std::size_t index = 0U; index < kGlobalDofCount; ++index) {
     result.first[index] = left.first[index] + right.first[index];
+    result.mixed_first[index] =
+        left.mixed_first[index] + right.mixed_first[index];
+    result.mixed_second[index] =
+        left.mixed_second[index] + right.mixed_second[index];
   }
   for (std::size_t index = 0U; index < kHessianSize; ++index) {
     result.second[index] = left.second[index] + right.second[index];
@@ -409,8 +419,15 @@ Jet operator+(const Jet& left, const Jet& right) {
 Jet operator-(const Jet& left, const Jet& right) {
   Jet result{};
   result.value = left.value - right.value;
+  result.directional_first = left.directional_first - right.directional_first;
+  result.directional_second =
+      left.directional_second - right.directional_second;
   for (std::size_t index = 0U; index < kGlobalDofCount; ++index) {
     result.first[index] = left.first[index] - right.first[index];
+    result.mixed_first[index] =
+        left.mixed_first[index] - right.mixed_first[index];
+    result.mixed_second[index] =
+        left.mixed_second[index] - right.mixed_second[index];
   }
   for (std::size_t index = 0U; index < kHessianSize; ++index) {
     result.second[index] = left.second[index] - right.second[index];
@@ -422,9 +439,26 @@ Jet operator-(const Jet& left, const Jet& right) {
 Jet operator*(const Jet& left, const Jet& right) {
   Jet result{};
   result.value = left.value * right.value;
+  result.directional_first = left.directional_first * right.value +
+                             left.value * right.directional_first;
+  result.directional_second =
+      left.directional_second * right.value +
+      2.0 * left.directional_first * right.directional_first +
+      left.value * right.directional_second;
   for (std::size_t index = 0U; index < kGlobalDofCount; ++index) {
     result.first[index] =
         left.first[index] * right.value + left.value * right.first[index];
+    result.mixed_first[index] = left.mixed_first[index] * right.value +
+                                left.first[index] * right.directional_first +
+                                left.directional_first * right.first[index] +
+                                left.value * right.mixed_first[index];
+    result.mixed_second[index] =
+        left.mixed_second[index] * right.value +
+        2.0 * left.mixed_first[index] * right.directional_first +
+        left.first[index] * right.directional_second +
+        left.directional_second * right.first[index] +
+        2.0 * left.directional_first * right.mixed_first[index] +
+        left.value * right.mixed_second[index];
   }
   for (std::size_t row = 0U; row < kGlobalDofCount; ++row) {
     for (std::size_t column = 0U; column < kGlobalDofCount; ++column) {
@@ -442,8 +476,12 @@ Jet operator*(const Jet& left, const Jet& right) {
 Jet operator*(const double scalar, const Jet& value) {
   Jet result{};
   result.value = scalar * value.value;
+  result.directional_first = scalar * value.directional_first;
+  result.directional_second = scalar * value.directional_second;
   for (std::size_t index = 0U; index < kGlobalDofCount; ++index) {
     result.first[index] = scalar * value.first[index];
+    result.mixed_first[index] = scalar * value.mixed_first[index];
+    result.mixed_second[index] = scalar * value.mixed_second[index];
   }
   for (std::size_t index = 0U; index < kHessianSize; ++index) {
     result.second[index] = scalar * value.second[index];
@@ -456,11 +494,24 @@ Jet operator*(const Jet& value, const double scalar) { return scalar * value; }
 
 /// @brief Applies a scalar unary function through its first two derivatives.
 Jet Compose(const Jet& input, const double value, const double first,
-            const double second) {
+            const double second, const double third) {
   Jet result{};
   result.value = value;
+  result.directional_first = first * input.directional_first;
+  result.directional_second =
+      second * input.directional_first * input.directional_first +
+      first * input.directional_second;
   for (std::size_t index = 0U; index < kGlobalDofCount; ++index) {
     result.first[index] = first * input.first[index];
+    result.mixed_first[index] =
+        second * input.first[index] * input.directional_first +
+        first * input.mixed_first[index];
+    result.mixed_second[index] =
+        third * input.first[index] * input.directional_first *
+            input.directional_first +
+        second * (2.0 * input.mixed_first[index] * input.directional_first +
+                  input.first[index] * input.directional_second) +
+        first * input.mixed_second[index];
   }
   for (std::size_t row = 0U; row < kGlobalDofCount; ++row) {
     for (std::size_t column = 0U; column < kGlobalDofCount; ++column) {
@@ -476,7 +527,8 @@ Jet Compose(const Jet& input, const double value, const double first,
 Jet Reciprocal(const Jet& value) {
   const double inverse = 1.0 / value.value;
   return Compose(value, inverse, -inverse * inverse,
-                 2.0 * inverse * inverse * inverse);
+                 2.0 * inverse * inverse * inverse,
+                 -6.0 * inverse * inverse * inverse * inverse);
 }
 
 /// @brief Divides two second-order trial-coordinate quantities.
@@ -487,19 +539,20 @@ Jet operator/(const Jet& left, const Jet& right) {
 /// @brief Computes the analytic square root variation.
 Jet Sqrt(const Jet& value) {
   const double root = std::sqrt(value.value);
-  return Compose(value, root, 0.5 / root, -0.25 / (root * root * root));
+  return Compose(value, root, 0.5 / root, -0.25 / (root * root * root),
+                 0.375 / (root * root * root * root * root));
 }
 
 /// @brief Computes the analytic sine variation.
 Jet Sin(const Jet& value) {
   return Compose(value, std::sin(value.value), std::cos(value.value),
-                 -std::sin(value.value));
+                 -std::sin(value.value), -std::cos(value.value));
 }
 
 /// @brief Computes the analytic cosine variation.
 Jet Cos(const Jet& value) {
   return Compose(value, std::cos(value.value), -std::sin(value.value),
-                 -std::cos(value.value));
+                 -std::cos(value.value), std::sin(value.value));
 }
 
 /// @brief Computes the two-argument angle and its analytic first/second map.
@@ -529,15 +582,40 @@ Jet Atan2(const Jet& y, const Jet& x) {
                              derivative_xx * x.first[row] * x.first[column];
     }
   }
+  // Use a bounded ratio for the directional third derivative only. Retain
+  // the established value/gradient/Hessian reduction above for static runs.
+  const bool use_x = std::abs(x.value) >= std::abs(y.value);
+  const Jet ratio = use_x ? y / x : x / y;
+  const double denominator = 1.0 + ratio.value * ratio.value;
+  const Jet angle = Compose(ratio, std::atan(ratio.value), 1.0 / denominator,
+                            -2.0 * ratio.value / (denominator * denominator),
+                            (6.0 * ratio.value * ratio.value - 2.0) /
+                                (denominator * denominator * denominator));
+  const double sign = use_x ? 1.0 : -1.0;
+  result.directional_first = sign * angle.directional_first;
+  result.directional_second = sign * angle.directional_second;
+  for (std::size_t i = 0U; i < kGlobalDofCount; ++i) {
+    result.mixed_first[i] = sign * angle.mixed_first[i];
+    result.mixed_second[i] = sign * angle.mixed_second[i];
+  }
   return result;
 }
 
 /// @brief Checks every coefficient in an automatic-differentiation quantity.
 bool IsFinite(const Jet& value) {
-  if (!std::isfinite(value.value)) {
+  if (!std::isfinite(value.value) || !std::isfinite(value.directional_first) ||
+      !std::isfinite(value.directional_second)) {
     return false;
   }
-  return std::all_of(value.first.begin(), value.first.end(),
+  return std::all_of(value.mixed_first.begin(), value.mixed_first.end(),
+                     [](const double coefficient) {
+                       return std::isfinite(coefficient);
+                     }) &&
+         std::all_of(value.mixed_second.begin(), value.mixed_second.end(),
+                     [](const double coefficient) {
+                       return std::isfinite(coefficient);
+                     }) &&
+         std::all_of(value.first.begin(), value.first.end(),
                      [](const double coefficient) {
                        return std::isfinite(coefficient);
                      }) &&
@@ -728,8 +806,39 @@ JetMatrix3 ExpSkew(const JetVector3& rotation) {
         (Constant(1.0) - Cos(norm)) / squared_norm;
   }
   const JetMatrix3 skew = Skew(rotation);
-  return Add(Add(Identity(), Scale(sine_over_norm, skew)),
-             Scale(one_minus_cosine_over_norm_squared, Multiply(skew, skew)));
+  JetMatrix3 result =
+      Add(Add(Identity(), Scale(sine_over_norm, skew)),
+          Scale(one_minus_cosine_over_norm_squared, Multiply(skew, skew)));
+  if (squared_norm.value < 0.25) {
+    // Third derivatives amplify cancellation in 1-cos(theta). Preserve the
+    // established static coefficients and use a stable series for the new
+    // directional derivatives of the complete rotation tensor.
+    Jet sine_series = Constant(1.0);
+    Jet cosine_series = Constant(0.5);
+    Jet power = Constant(1.0);
+    double sine_coefficient = 1.0;
+    double cosine_coefficient = 0.5;
+    for (unsigned int k = 1U; k <= 9U; ++k) {
+      power = power * squared_norm;
+      sine_coefficient /= -static_cast<double>((2U * k) * (2U * k + 1U));
+      cosine_coefficient /= -static_cast<double>((2U * k + 1U) * (2U * k + 2U));
+      sine_series = sine_series + sine_coefficient * power;
+      cosine_series = cosine_series + cosine_coefficient * power;
+    }
+    const JetMatrix3 stable = Add(Add(Identity(), Scale(sine_series, skew)),
+                                  Scale(cosine_series, Multiply(skew, skew)));
+    for (std::size_t row = 0U; row < 3U; ++row) {
+      for (std::size_t column = 0U; column < 3U; ++column) {
+        result[row][column].directional_first =
+            stable[row][column].directional_first;
+        result[row][column].directional_second =
+            stable[row][column].directional_second;
+        result[row][column].mixed_first = stable[row][column].mixed_first;
+        result[row][column].mixed_second = stable[row][column].mixed_second;
+      }
+    }
+  }
+  return result;
 }
 
 /// @brief Stores the complete Jet-valued global element trial coordinates.
@@ -741,14 +850,18 @@ struct JetTrial {
 
 /// @brief Lifts one validated nonlinear trial into independent Jet variables.
 JetTrial MakeJetTrial(const NonlinearMitc4TrialDofs& trial,
-                      const std::array<Matrix, kNodeCount>& initial_frames) {
+                      const std::array<Matrix, kNodeCount>& initial_frames,
+                      const Vector* direction) {
   JetTrial result{};
   for (std::size_t node = 0U; node < kNodeCount; ++node) {
     for (std::size_t component = 0U; component < 3U; ++component) {
-      result.displacement[node][component] =
-          Variable(trial.displacement[node][component], 6U * node + component);
+      result.displacement[node][component] = Variable(
+          trial.displacement[node][component], 6U * node + component,
+          direction == nullptr ? 0.0 : (*direction)[6U * node + component]);
       result.rotation[node][component] = Variable(
-          trial.rotation_vector[node][component], 6U * node + 3U + component);
+          trial.rotation_vector[node][component], 6U * node + 3U + component,
+          direction == nullptr ? 0.0
+                               : (*direction)[6U * node + 3U + component]);
     }
     JetMatrix3 frame{};
     for (std::size_t row = 0U; row < 3U; ++row) {
@@ -764,52 +877,42 @@ JetTrial MakeJetTrial(const NonlinearMitc4TrialDofs& trial,
   return result;
 }
 
-/// @brief Forms one current covariant basis from the exact trial variables.
-std::array<JetVector3, 3> CurrentCovariant(
-    const std::array<Vector3, kNodeCount>& coordinates, const JetTrial& trial,
-    const double thickness, const double xi, const double eta,
-    const double zeta) {
-  const Mitc4ShapeFunctions shape = Mitc4Shell::ShapeFunctions(xi, eta);
-  JetVector3 displacement_xi{};
-  JetVector3 displacement_eta{};
-  JetVector3 director{};
-  JetVector3 director_xi{};
-  JetVector3 director_eta{};
-  Vector3 reference_xi{};
-  Vector3 reference_eta{};
+/// @brief Forms covariant increments directly, preserving exact zero motion.
+std::array<JetVector3, 3> CovariantIncrement(
+    const std::array<Vector3, kNodeCount>& initial_directors,
+    const JetTrial& trial, const double thickness, const double xi,
+    const double eta, const double zeta) {
+  const auto shape = Mitc4Shell::ShapeFunctions(xi, eta);
+  std::array<JetVector3, 3> increment{};
   for (std::size_t node = 0U; node < kNodeCount; ++node) {
-    reference_xi =
-        reference_xi + shape.xi_derivatives[node] * coordinates[node];
-    reference_eta =
-        reference_eta + shape.eta_derivatives[node] * coordinates[node];
-    displacement_xi = Add(displacement_xi, Scale(shape.xi_derivatives[node],
-                                                 trial.displacement[node]));
-    displacement_eta = Add(displacement_eta, Scale(shape.eta_derivatives[node],
-                                                   trial.displacement[node]));
-    director = Add(director, Scale(shape.values[node], trial.director[node]));
-    director_xi = Add(director_xi,
-                      Scale(shape.xi_derivatives[node], trial.director[node]));
-    director_eta = Add(
-        director_eta, Scale(shape.eta_derivatives[node], trial.director[node]));
+    const auto displacement =
+        Subtract(trial.displacement[node], trial.displacement[0U]);
+    const auto director =
+        Subtract(trial.director[node], ConstantVector(initial_directors[node]));
+    const auto layer =
+        Add(displacement, Scale(0.5 * thickness * zeta, director));
+    increment[0U] =
+        Add(increment[0U], Scale(shape.xi_derivatives[node], layer));
+    increment[1U] =
+        Add(increment[1U], Scale(shape.eta_derivatives[node], layer));
+    increment[2U] = Add(increment[2U],
+                        Scale(0.5 * thickness * shape.values[node], director));
   }
-  const double half_thickness = 0.5 * thickness;
-  return {Add(Add(ConstantVector(reference_xi), displacement_xi),
-              Scale(half_thickness * zeta, director_xi)),
-          Add(Add(ConstantVector(reference_eta), displacement_eta),
-              Scale(half_thickness * zeta, director_eta)),
-          Scale(half_thickness, director)};
+  return increment;
 }
 
 /// @brief Forms the direct covariant Green--Lagrange strain tensor.
-JetTensor DirectStrain(const std::array<JetVector3, 3>& current,
+JetTensor DirectStrain(const std::array<JetVector3, 3>& increment,
                        const Geometry& reference) {
   JetTensor result{};
   for (std::size_t row = 0U; row < 3U; ++row) {
     for (std::size_t column = 0U; column < 3U; ++column) {
       result[row][column] =
-          0.5 * (Dot(current[row], current[column]) -
-                 Constant(reference.reference_covariant[row].Dot(
-                     reference.reference_covariant[column])));
+          0.5 * (Dot(ConstantVector(reference.reference_covariant[row]),
+                     increment[column]) +
+                 Dot(increment[row],
+                     ConstantVector(reference.reference_covariant[column])) +
+                 Dot(increment[row], increment[column]));
     }
   }
   result[2U][2U] = Constant(0.0);
@@ -867,9 +970,9 @@ Jet PhysicalEnergy(const std::array<Vector3, kNodeCount>& coordinates,
       return {};
     }
     tying[point] =
-        DirectStrain(CurrentCovariant(coordinates, trial, thickness,
-                                      tying_locations[point][0U],
-                                      tying_locations[point][1U], 0.0),
+        DirectStrain(CovariantIncrement(initial_directors, trial, thickness,
+                                        tying_locations[point][0U],
+                                        tying_locations[point][1U], 0.0),
                      reference);
   }
 
@@ -892,8 +995,8 @@ Jet PhysicalEnergy(const std::array<Vector3, kNodeCount>& coordinates,
         return {};
       }
       JetTensor covariant =
-          DirectStrain(CurrentCovariant(coordinates, trial, thickness,
-                                        surface[0U], surface[1U], zeta),
+          DirectStrain(CovariantIncrement(initial_directors, trial, thickness,
+                                          surface[0U], surface[1U], zeta),
                        reference);
       const Mitc4TyingWeights weights =
           Mitc4Shell::TyingWeights(surface[0U], surface[1U]);
@@ -940,11 +1043,41 @@ JetMatrix3 PolarRotation(const JetMatrix3& deformation) {
   return result;
 }
 
+/// @brief Returns the speed of physical spin for a unit chart null vector.
+Jet DrillSpinRate(const JetVector3& phi, const Vector3& director) {
+  const Jet square = Dot(phi, phi);
+  Jet coefficient{};
+  if (square.value < 0.25) {
+    constexpr std::array<double, 9> series{1.0 / 12.0,
+                                           1.0 / 720.0,
+                                           1.0 / 30240.0,
+                                           1.0 / 1209600.0,
+                                           1.0 / 47900160.0,
+                                           691.0 / 1307674368000.0,
+                                           1.0 / 74724249600.0,
+                                           3617.0 / 10670622842880000.0,
+                                           43867.0 / 5109094217170944000.0};
+    coefficient = Constant(series.back());
+    for (std::size_t i = series.size() - 1U; i > 0U; --i)
+      coefficient = Constant(series[i - 1U]) + square * coefficient;
+  } else {
+    const Jet half = 0.5 * Sqrt(square);
+    coefficient = (Constant(1.0) - half * Cos(half) * Reciprocal(Sin(half))) *
+                  Reciprocal(square);
+  }
+  const auto d0 = ConstantVector(director);
+  const auto cross = Cross(phi, d0);
+  const auto inverse_action =
+      Add(Add(d0, Scale(0.5, cross)), Scale(coefficient, Cross(phi, cross)));
+  return Reciprocal(Sqrt(Dot(inverse_action, inverse_action)));
+}
+
 /// @brief Evaluates the objective numerical drilling potential and variations.
 Jet DrillingEnergy(const std::array<Vector3, kNodeCount>& coordinates,
                    const std::array<Vector3, kNodeCount>& initial_directors,
                    const JetTrial& trial, const double thickness,
-                   const double drilling_stiffness, bool& valid) {
+                   const double drilling_stiffness, bool& valid, Matrix* metric,
+                   std::array<Jet, 4>* constraints) {
   const NonlinearMitc4TrialDofs reference_trial{};
   Geometry reference{};
   if (!EvaluateGeometry(coordinates, initial_directors, initial_directors,
@@ -953,8 +1086,8 @@ Jet DrillingEnergy(const std::array<Vector3, kNodeCount>& coordinates,
     return {};
   }
   const auto current =
-      CurrentCovariant(coordinates, trial, thickness, 0.0, 0.0, 0.0);
-  JetMatrix3 deformation{};
+      CovariantIncrement(initial_directors, trial, thickness, 0.0, 0.0, 0.0);
+  JetMatrix3 deformation = Identity();
   for (std::size_t row = 0U; row < 3U; ++row) {
     for (std::size_t column = 0U; column < 3U; ++column) {
       for (std::size_t alpha = 0U; alpha < 3U; ++alpha) {
@@ -991,7 +1124,19 @@ Jet DrillingEnergy(const std::array<Vector3, kNodeCount>& coordinates,
     const Jet cosine =
         0.5 * (twist[0U][0U] + twist[1U][1U] + twist[2U][2U] - Constant(1.0));
     const Jet gamma = Atan2(sine, cosine);
+    if (constraints != nullptr) {
+      // n^T grad(Uphys)=0 and Dgamma_j[n_i]=delta_ij/||Jl^-1 d||.
+      (*constraints)[node] =
+          drilling_stiffness *
+          DrillSpinRate(trial.rotation[node], initial_directors[node]) * gamma;
+    }
     energy = energy + 0.5 * drilling_stiffness * gamma * gamma;
+    for (std::size_t row = 0U; row < kGlobalDofCount; ++row) {
+      for (std::size_t column = 0U; column < kGlobalDofCount; ++column) {
+        (*metric)(row, column) +=
+            drilling_stiffness * gamma.first[row] * gamma.first[column];
+      }
+    }
   }
   if (!IsFinite(energy)) {
     valid = false;
@@ -1040,13 +1185,15 @@ Result<NonlinearMitc4Shell> NonlinearMitc4Shell::Create(
     for (std::size_t previous = 0U; previous < node; ++previous) {
       if (coordinates[node] == coordinates[previous]) {
         return Failure<NonlinearMitc4Shell>(
-            "invalid-nonlinear-shell-geometry", nodes[node]->location,
-            identity, "Nonlinear MITC4 nodes must have distinct coordinates.");
+            "invalid-nonlinear-shell-geometry", nodes[node]->location, identity,
+            "Nonlinear MITC4 nodes must have distinct coordinates.");
       }
-      if (initial_frames[node].node_index == initial_frames[previous].node_index) {
+      if (initial_frames[node].node_index ==
+          initial_frames[previous].node_index) {
         return Failure<NonlinearMitc4Shell>(
             "invalid-nonlinear-shell-frame", nodes[node]->location, identity,
-            "Nonlinear MITC4 initial frames must identify four distinct nodes.");
+            "Nonlinear MITC4 initial frames must identify four distinct "
+            "nodes.");
       }
     }
   }
@@ -1089,7 +1236,8 @@ Result<NonlinearMitc4Shell> NonlinearMitc4Shell::Create(
                   })) {
     return Failure<NonlinearMitc4Shell>(
         "invalid-nonlinear-shell-frame", nodes[0U]->location, identity,
-        "Nonlinear MITC4 initial directors must follow the source positive face.");
+        "Nonlinear MITC4 initial directors must follow the source positive "
+        "face.");
   }
 
   if (!std::isfinite(section.thickness) || !(section.thickness > 0.0)) {
@@ -1125,14 +1273,14 @@ Result<NonlinearMitc4Shell> NonlinearMitc4Shell::Create(
   }
 
   NonlinearMitc4Shell shell{coordinates,
-                             std::move(frames),
-                             directors,
-                             section.thickness,
-                             material.youngs_modulus,
-                             material.poisson_ratio,
-                             linear_stiffness.Value().drilling_stiffness,
-                             nodes[0U]->location,
-                             identity};
+                            std::move(frames),
+                            directors,
+                            section.thickness,
+                            material.youngs_modulus,
+                            material.poisson_ratio,
+                            linear_stiffness.Value().drilling_stiffness,
+                            nodes[0U]->location,
+                            identity};
   const auto reference = shell.EvaluateKinematics(NonlinearMitc4TrialDofs{});
   if (!reference.HasValue()) {
     return Result<NonlinearMitc4Shell>::Failure(reference.GetStatus());
@@ -1150,12 +1298,13 @@ Result<NonlinearMitc4Recovery> NonlinearMitc4Shell::EvaluateKinematics(
           "invalid-nonlinear-shell-trial", source_location_, identity_,
           "Nonlinear MITC4 trial displacements and rotations must be finite.");
     }
-    const auto state =
-        MakeFiniteRotationState(trial.rotation_vector[node], initial_frames_[node]);
+    const auto state = MakeFiniteRotationState(trial.rotation_vector[node],
+                                               initial_frames_[node]);
     if (!state.HasValue()) {
       return Failure<NonlinearMitc4Recovery>(
           "invalid-nonlinear-shell-rotation", source_location_, identity_,
-          "Nonlinear MITC4 trial rotations must remain in the principal chart.");
+          "Nonlinear MITC4 trial rotations must remain in the principal "
+          "chart.");
     }
     directors[node] = state.Value().director;
   }
@@ -1185,10 +1334,12 @@ Result<NonlinearMitc4Recovery> NonlinearMitc4Shell::EvaluateKinematics(
   for (std::size_t point = 0U; point < tying_locations.size(); ++point) {
     if (!EvaluateTyingSample(coordinates_, initial_directors_, directors, trial,
                              thickness_, tying_locations[point][0U],
-                             tying_locations[point][1U], tying_samples[point])) {
+                             tying_locations[point][1U],
+                             tying_samples[point])) {
       return Failure<NonlinearMitc4Recovery>(
           "invalid-nonlinear-shell-geometry", source_location_, identity_,
-          "Nonlinear MITC4 tying-point reference or trial geometry is invalid.");
+          "Nonlinear MITC4 tying-point reference or trial geometry is "
+          "invalid.");
     }
   }
 
@@ -1198,8 +1349,7 @@ Result<NonlinearMitc4Recovery> NonlinearMitc4Shell::EvaluateKinematics(
       ShellMidsurfaceLocation::kGp3, ShellMidsurfaceLocation::kGp4};
   const std::array<std::array<double, 2>, 4> surface_points{
       std::array<double, 2>{-gauss, -gauss},
-      std::array<double, 2>{gauss, -gauss},
-      std::array<double, 2>{gauss, gauss},
+      std::array<double, 2>{gauss, -gauss}, std::array<double, 2>{gauss, gauss},
       std::array<double, 2>{-gauss, gauss}};
   constexpr std::array<double, 2> thickness_gauss{-1.0, 1.0};
   constexpr std::array<double, 3> stress_zeta{-1.0, 0.0, 1.0};
@@ -1236,12 +1386,12 @@ Result<NonlinearMitc4Recovery> NonlinearMitc4Shell::EvaluateKinematics(
       for (std::size_t component = 0U; component < 3U; ++component) {
         row.generalized_strain[component] += 0.5 * point.strain[component];
         row.generalized_strain[3U + component] +=
-            3.0 * thickness_sign * gauss * point.strain[component] /
-            thickness_;
+            3.0 * thickness_sign * gauss * point.strain[component] / thickness_;
         row.section_resultant[component] +=
             0.5 * thickness_ * point.stress[component];
-        row.section_resultant[3U + component] +=
-            0.25 * thickness_ * thickness_sign * gauss * point.stress[component];
+        row.section_resultant[3U + component] += 0.25 * thickness_ *
+                                                 thickness_sign * gauss *
+                                                 point.stress[component];
       }
       for (std::size_t component = 0U; component < 2U; ++component) {
         row.generalized_strain[6U + component] +=
@@ -1269,9 +1419,10 @@ Result<NonlinearMitc4Recovery> NonlinearMitc4Shell::EvaluateKinematics(
             "invalid-nonlinear-shell-geometry", source_location_, identity_,
             "Nonlinear MITC4 section-position recovery geometry is invalid.");
       }
-      row.stress[position] = {stress_position[position], stress_zeta[position],
-                              {point.stress[0U], point.stress[1U],
-                               point.stress[2U]}};
+      row.stress[position] = {
+          stress_position[position],
+          stress_zeta[position],
+          {point.stress[0U], point.stress[1U], point.stress[2U]}};
     }
   }
 
@@ -1289,7 +1440,22 @@ Result<NonlinearMitc4Recovery> NonlinearMitc4Shell::RecoverState(
 }
 
 Result<NonlinearMitc4InternalEquilibrium> EvaluateInternalResidualAndTangent(
-    const NonlinearMitc4Shell& element, const NonlinearMitc4TrialDofs& trial) {
+    const NonlinearMitc4Shell& element, const NonlinearMitc4TrialDofs& trial,
+    const Vector* coordinate_direction) {
+  if (coordinate_direction != nullptr) {
+    if (coordinate_direction->Size() != kGlobalDofCount) {
+      return Failure<NonlinearMitc4InternalEquilibrium>(
+          "invalid-nonlinear-shell-equilibrium", element.source_location_,
+          element.identity_, "The directional derivative requires 24 DOFs.");
+    }
+    for (std::size_t i = 0U; i < kGlobalDofCount; ++i) {
+      if (!std::isfinite((*coordinate_direction)[i])) {
+        return Failure<NonlinearMitc4InternalEquilibrium>(
+            "invalid-nonlinear-shell-equilibrium", element.source_location_,
+            element.identity_, "The directional derivative must be finite.");
+      }
+    }
+  }
   const auto recovery = element.EvaluateKinematics(trial);
   if (!recovery.HasValue()) {
     return Result<NonlinearMitc4InternalEquilibrium>::Failure(
@@ -1297,14 +1463,18 @@ Result<NonlinearMitc4InternalEquilibrium> EvaluateInternalResidualAndTangent(
   }
 
   bool valid = true;
-  const JetTrial jet_trial = MakeJetTrial(trial, element.initial_frames_);
+  const JetTrial jet_trial =
+      MakeJetTrial(trial, element.initial_frames_, coordinate_direction);
   const Jet physical =
       PhysicalEnergy(element.coordinates_, element.initial_directors_,
                      jet_trial, element.thickness_, element.youngs_modulus_,
                      element.poisson_ratio_, valid);
+  Matrix drilling_metric{kGlobalDofCount, kGlobalDofCount};
+  std::array<Jet, 4> constraints{};
   const Jet drilling = DrillingEnergy(
       element.coordinates_, element.initial_directors_, jet_trial,
-      element.thickness_, element.drilling_stiffness_, valid);
+      element.thickness_, element.drilling_stiffness_, valid, &drilling_metric,
+      coordinate_direction != nullptr ? &constraints : nullptr);
   const Jet internal_energy = physical + drilling;
   if (!valid || !IsFinite(internal_energy)) {
     return Failure<NonlinearMitc4InternalEquilibrium>(
@@ -1344,8 +1514,43 @@ Result<NonlinearMitc4InternalEquilibrium> EvaluateInternalResidualAndTangent(
       std::move(internal_residual), std::move(internal_tangent),
       Vector{kGlobalDofCount}, recovery.Value(),
       recovery.Value().physical_strain_energy};
+  if (coordinate_direction != nullptr) {
+    equilibrium.drilling_constraint = Vector{4U};
+    equilibrium.drilling_constraint_gradient = Matrix{4U, kGlobalDofCount};
+    for (std::size_t node = 0U; node < 4U; ++node) {
+      if (!IsFinite(constraints[node]))
+        return Failure<NonlinearMitc4InternalEquilibrium>(
+            "invalid-nonlinear-shell-equilibrium", element.source_location_,
+            element.identity_,
+            "Drilling constraint derivatives must remain finite.");
+      equilibrium.drilling_constraint[node] = constraints[node].value;
+      equilibrium.drilling_constraint_hessian[node] =
+          Matrix{kGlobalDofCount, kGlobalDofCount};
+      for (std::size_t i = 0U; i < kGlobalDofCount; ++i) {
+        equilibrium.drilling_constraint_gradient(node, i) =
+            constraints[node].first[i];
+        for (std::size_t j = 0U; j < kGlobalDofCount; ++j)
+          equilibrium.drilling_constraint_hessian[node](i, j) =
+              constraints[node].second[i * kGlobalDofCount + j];
+      }
+    }
+  }
+  equilibrium.physical_force = Vector{kGlobalDofCount};
+  equilibrium.drilling_force = Vector{kGlobalDofCount};
+  equilibrium.drilling_tangent = Matrix{kGlobalDofCount, kGlobalDofCount};
+  equilibrium.drilling_metric = std::move(drilling_metric);
+  equilibrium.drilling_energy = drilling.value;
+  equilibrium.force_directional_second = Vector{kGlobalDofCount};
   for (std::size_t index = 0U; index < kGlobalDofCount; ++index) {
     equilibrium.internal_force[index] = equilibrium.internal_residual[index];
+    equilibrium.physical_force[index] = physical.first[index];
+    equilibrium.drilling_force[index] = drilling.first[index];
+    equilibrium.force_directional_second[index] =
+        internal_energy.mixed_second[index];
+    for (std::size_t column = 0U; column < kGlobalDofCount; ++column) {
+      equilibrium.drilling_tangent(index, column) =
+          drilling.second[index * kGlobalDofCount + column];
+    }
   }
   return Result<NonlinearMitc4InternalEquilibrium>::Success(
       std::move(equilibrium));
diff --git a/src/fesa/io/hdf5/dynamic_hdf5_results_writer.cpp b/src/fesa/io/hdf5/dynamic_hdf5_results_writer.cpp
new file mode 100644
index 0000000..aa8db8a
--- /dev/null
+++ b/src/fesa/io/hdf5/dynamic_hdf5_results_writer.cpp
@@ -0,0 +1,1017 @@
+#include "fesa/io/hdf5/dynamic_hdf5_results_writer.h"
+
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <exception>
+#include <filesystem>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "fesa/analysis/analysis_model.h"
+#include "fesa/build_info.h"
+#include "fesa/core/diagnostic.h"
+#include "fesa/elements/finite_rotation.h"
+#include "fesa/fem/dof_manager.h"
+#include "io/hdf5/hdf5_atomic_file.h"
+#include "io/hdf5/hdf5_model_writer.h"
+#include "io/hdf5/hdf5_primitives.h"
+#include "io/hdf5/hdf5_raii.h"
+
+namespace fesa {
+namespace {
+
+using hdf5_internal::Hdf5Failure;
+using hdf5_internal::Hdf5Handle;
+
+struct AcceptedFrameRow {
+  std::uint64_t frame_index;
+  std::uint64_t increment_index;
+  double time;
+  std::uint64_t iteration_count;
+  std::uint8_t is_initial;
+};
+
+struct DiagnosticRow {
+  const char* severity;
+  const char* code;
+  const char* file;
+  std::uint64_t line;
+  const char* keyword;
+  const char* entity_identity;
+  const char* message;
+};
+
+struct DensityRow {
+  std::uint64_t internal_material_id;
+  double rho;
+};
+
+/// @brief Rejects a candidate before its final path can be replaced.
+void Check(const bool condition, const char* message) {
+  if (!condition) throw Hdf5Failure{message};
+}
+
+/// @brief Checks scalar type, rank and value of one numeric attribute.
+template <typename Value>
+void CheckAttribute(const hid_t object, const char* name, const hid_t file_type,
+                    const hid_t memory_type, const Value expected) {
+  Hdf5Handle attribute{
+      hdf5_internal::RequireHdf5Id(H5Aopen(object, name, H5P_DEFAULT),
+                                   "Missing numeric attribute."),
+      H5Aclose};
+  Hdf5Handle type{H5Aget_type(attribute.Get()), H5Tclose};
+  Hdf5Handle space{H5Aget_space(attribute.Get()), H5Sclose};
+  Check(H5Tequal(type.Get(), file_type) > 0 &&
+            H5Sget_simple_extent_type(space.Get()) == H5S_SCALAR,
+        "Invalid numeric attribute schema.");
+  Value actual{};
+  hdf5_internal::RequireHdf5(H5Aread(attribute.Get(), memory_type, &actual),
+                             "Unable to read numeric attribute.");
+  Check(actual == expected, "Numeric attribute value mismatch.");
+}
+
+/// @brief Checks UTF-8 variable-length scalar attribute storage and value.
+void CheckString(const hid_t object, const char* name,
+                 const std::string& expected) {
+  Hdf5Handle attribute{
+      hdf5_internal::RequireHdf5Id(H5Aopen(object, name, H5P_DEFAULT),
+                                   "Missing string attribute."),
+      H5Aclose};
+  Hdf5Handle type{H5Aget_type(attribute.Get()), H5Tclose};
+  Hdf5Handle space{H5Aget_space(attribute.Get()), H5Sclose};
+  Check(H5Tget_class(type.Get()) == H5T_STRING &&
+            H5Tis_variable_str(type.Get()) > 0 &&
+            H5Tget_cset(type.Get()) == H5T_CSET_UTF8 &&
+            H5Sget_simple_extent_type(space.Get()) == H5S_SCALAR,
+        "Invalid string attribute schema.");
+  char* actual = nullptr;
+  hdf5_internal::RequireHdf5(H5Aread(attribute.Get(), type.Get(), &actual),
+                             "Unable to read string attribute.");
+  const bool equal = actual != nullptr && expected == actual;
+  (void)H5free_memory(actual);
+  Check(equal, "String attribute value mismatch.");
+}
+
+/// @brief Opens one mandatory contiguous, uncompressed dataset of exact shape.
+Hdf5Handle OpenDataset(const hid_t file, const std::string& path,
+                       const std::vector<hsize_t>& dimensions) {
+  Hdf5Handle dataset{
+      hdf5_internal::RequireHdf5Id(H5Dopen2(file, path.c_str(), H5P_DEFAULT),
+                                   "Missing dynamic dataset."),
+      H5Dclose};
+  Hdf5Handle space{H5Dget_space(dataset.Get()), H5Sclose};
+  Check(H5Sget_simple_extent_ndims(space.Get()) ==
+            static_cast<int>(dimensions.size()),
+        "Dataset rank mismatch.");
+  std::vector<hsize_t> actual(dimensions.size());
+  hdf5_internal::RequireHdf5(
+      H5Sget_simple_extent_dims(space.Get(), actual.data(), nullptr),
+      "Unable to read dataset dimensions.");
+  Check(actual == dimensions, "Dataset shape mismatch.");
+  Hdf5Handle properties{H5Dget_create_plist(dataset.Get()), H5Pclose};
+  Check(H5Pget_layout(properties.Get()) == H5D_CONTIGUOUS &&
+            H5Pget_nfilters(properties.Get()) == 0,
+        "Dataset must be contiguous and uncompressed.");
+  return dataset;
+}
+
+/// @brief Compares binary64 readback to the complete finite accepted values.
+Hdf5Handle CheckDoubles(const hid_t file, const std::string& path,
+                        const std::vector<hsize_t>& dimensions,
+                        const std::vector<double>& expected) {
+  auto dataset = OpenDataset(file, path, dimensions);
+  Hdf5Handle type{H5Dget_type(dataset.Get()), H5Tclose};
+  Check(H5Tequal(type.Get(), H5T_IEEE_F64LE) > 0,
+        "Dataset must use little-endian binary64.");
+  std::vector<double> actual(expected.size());
+  hdf5_internal::RequireHdf5(H5Dread(dataset.Get(), H5T_NATIVE_DOUBLE, H5S_ALL,
+                                     H5S_ALL, H5P_DEFAULT, actual.data()),
+                             "Unable to read dynamic values.");
+  for (std::size_t index = 0U; index < actual.size(); ++index) {
+    Check(std::isfinite(actual[index]) && actual[index] == expected[index],
+          "Dataset value mismatch or nonfinite value.");
+  }
+  return dataset;
+}
+
+/// @brief Validates ordered compound members without accepting extra fields.
+void CheckMembers(const hid_t dataset, const std::vector<std::string>& names) {
+  Hdf5Handle type{H5Dget_type(dataset), H5Tclose};
+  Check(H5Tget_class(type.Get()) == H5T_COMPOUND &&
+            H5Tget_nmembers(type.Get()) == static_cast<int>(names.size()),
+        "Compound field inventory mismatch.");
+  for (std::size_t index = 0U; index < names.size(); ++index) {
+    char* name = H5Tget_member_name(type.Get(), static_cast<unsigned>(index));
+    const bool equal = name != nullptr && names[index] == name;
+    (void)H5free_memory(name);
+    Check(equal, "Compound field order mismatch.");
+  }
+}
+
+/// @brief Compares one fixed-width compound column with its source inventory.
+template <typename Value>
+void CheckColumn(const hid_t dataset, const char* name, const hid_t file_type,
+                 const hid_t memory_type, const std::vector<Value>& expected) {
+  Hdf5Handle type{H5Dget_type(dataset), H5Tclose};
+  const int index = H5Tget_member_index(type.Get(), name);
+  Check(index >= 0, "Missing compound column.");
+  Hdf5Handle member{
+      H5Tget_member_type(type.Get(), static_cast<unsigned>(index)), H5Tclose};
+  Check(H5Tequal(member.Get(), file_type) > 0,
+        "Compound column dtype mismatch.");
+  Hdf5Handle memory{H5Tcreate(H5T_COMPOUND, sizeof(Value)), H5Tclose};
+  hdf5_internal::RequireHdf5(H5Tinsert(memory.Get(), name, 0U, memory_type),
+                             "Unable to create readback column type.");
+  std::vector<Value> actual(expected.size());
+  if (!actual.empty()) {
+    hdf5_internal::RequireHdf5(H5Dread(dataset, memory.Get(), H5S_ALL, H5S_ALL,
+                                       H5P_DEFAULT, actual.data()),
+                               "Unable to read compound column.");
+  }
+  Check(actual == expected, "Compound column value mismatch.");
+}
+
+/// @brief Compares and reclaims a UTF-8 variable-length compound column.
+void CheckStringColumn(const hid_t dataset, const char* name,
+                       const std::vector<std::string>& expected) {
+  Hdf5Handle type{H5Dget_type(dataset), H5Tclose};
+  const int index = H5Tget_member_index(type.Get(), name);
+  Check(index >= 0, "Missing compound string column.");
+  Hdf5Handle member{
+      H5Tget_member_type(type.Get(), static_cast<unsigned>(index)), H5Tclose};
+  Check(H5Tget_class(member.Get()) == H5T_STRING &&
+            H5Tis_variable_str(member.Get()) > 0 &&
+            H5Tget_cset(member.Get()) == H5T_CSET_UTF8,
+        "Invalid compound string dtype.");
+  Hdf5Handle memory{H5Tcreate(H5T_COMPOUND, sizeof(char*)), H5Tclose};
+  hdf5_internal::RequireHdf5(H5Tinsert(memory.Get(), name, 0U, member.Get()),
+                             "Unable to create readback string type.");
+  std::vector<char*> actual(expected.size(), nullptr);
+  if (actual.empty()) return;
+  hdf5_internal::RequireHdf5(H5Dread(dataset, memory.Get(), H5S_ALL, H5S_ALL,
+                                     H5P_DEFAULT, actual.data()),
+                             "Unable to read compound strings.");
+  bool equal = true;
+  for (std::size_t row = 0U; row < actual.size(); ++row) {
+    equal = equal && actual[row] != nullptr && expected[row] == actual[row];
+  }
+  Hdf5Handle space{H5Dget_space(dataset), H5Sclose};
+  hdf5_internal::RequireHdf5(
+      H5Dvlen_reclaim(memory.Get(), space.Get(), H5P_DEFAULT, actual.data()),
+      "Unable to reclaim compound strings.");
+  Check(equal, "Compound string value mismatch.");
+}
+
+/// @brief Writes the stable material-index density table.
+void WriteDensity(const hid_t file, const Domain& domain) {
+  std::vector<DensityRow> rows;
+  for (const auto& density : domain.Densities()) {
+    rows.push_back({density.material_index, density.rho});
+  }
+  Hdf5Handle type{H5Tcreate(H5T_COMPOUND, sizeof(DensityRow)), H5Tclose};
+  hdf5_internal::RequireHdf5(
+      H5Tinsert(type.Get(), "internal_material_id",
+                HOFFSET(DensityRow, internal_material_id), H5T_STD_U64LE),
+      "Unable to define density identity.");
+  hdf5_internal::RequireHdf5(
+      H5Tinsert(type.Get(), "rho", HOFFSET(DensityRow, rho), H5T_IEEE_F64LE),
+      "Unable to define density value.");
+  (void)hdf5_internal::WriteCompoundDataset(file, "/model/material_density",
+                                            rows.size(), type.Get(), type.Get(),
+                                            rows.data());
+}
+
+/// @brief Reports an output failure without exposing backend exceptions.
+Status Failure(const char* code, const std::string& message) {
+  return hdf5_internal::OutputFailure(code, message);
+}
+
+/// @brief Copies one nonempty full-space vector in node-major order.
+std::vector<double> Values(const Vector& values) {
+  return std::vector<double>{values.Data(), values.Data() + values.Size()};
+}
+
+/// @brief Removes inherited metadata before applying the dynamic schema.
+void DeleteAttribute(const hid_t object, const char* name) {
+  if (H5Aexists(object, name) > 0) {
+    hdf5_internal::RequireHdf5(H5Adelete(object, name),
+                               "Unable to replace metadata attribute.");
+  }
+}
+
+/// @brief Writes the dynamic procedure identity and fixed time schedule.
+void WriteMetadata(const hid_t file, const Domain& domain) {
+  Hdf5Handle metadata{
+      hdf5_internal::RequireHdf5Id(H5Gopen2(file, "/metadata", H5P_DEFAULT),
+                                   "The model metadata group is missing."),
+      H5Gclose};
+  for (const char* name :
+       {"feature_id", "analysis_procedure", "schema_version",
+        "mass_formulation", "internal_formulation", "initial_state",
+        "acceleration_convention", "step_name", "source_step_name",
+        "unit_system_label", "coordinate_convention", "integration_rule",
+        "frame_index"}) {
+    DeleteAttribute(metadata.Get(), name);
+  }
+  const DynamicStepDefinition* const step = domain.Dynamic();
+  hdf5_internal::WriteStringAttribute(metadata.Get(), "feature_id",
+                                      "hht-implicit-dynamics");
+  hdf5_internal::WriteStringAttribute(metadata.Get(), "analysis_procedure",
+                                      "hht-implicit-dynamics");
+  hdf5_internal::WriteUint64Attribute(metadata.Get(), "schema_version", 1U);
+  hdf5_internal::WriteStringAttribute(metadata.Get(), "mass_formulation",
+                                      "consistent-kinetic");
+  hdf5_internal::WriteStringAttribute(metadata.Get(), "internal_formulation",
+                                      "FESA-MITC4-total-lagrangian");
+  hdf5_internal::WriteStringAttribute(metadata.Get(), "initial_state",
+                                      "zero-q-v-step-load-0+");
+  hdf5_internal::WriteStringAttribute(
+      metadata.Get(), "acceleration_convention",
+      "physical-endpoint-and-auxiliary-separated");
+  hdf5_internal::WriteStringAttribute(metadata.Get(), "source_step_name",
+                                      step->source_step_name_raw);
+  hdf5_internal::WriteStringAttribute(metadata.Get(), "step_name", "Step-1");
+  hdf5_internal::WriteStringAttribute(metadata.Get(), "unit_system_label",
+                                      "consistent-input-units");
+  hdf5_internal::WriteDoubleAttribute(metadata.Get(), "alpha", step->alpha);
+  hdf5_internal::WriteDoubleAttribute(metadata.Get(), "beta", step->beta);
+  hdf5_internal::WriteDoubleAttribute(metadata.Get(), "gamma", step->gamma);
+  hdf5_internal::WriteDoubleAttribute(metadata.Get(), "initial_increment",
+                                      step->initial_increment);
+  hdf5_internal::WriteDoubleAttribute(metadata.Get(), "time_period",
+                                      step->time_period);
+  hdf5_internal::WriteUint64Attribute(metadata.Get(), "increment_count",
+                                      step->increment_count);
+  hdf5_internal::WriteUint64Attribute(metadata.Get(), "maximum_increments",
+                                      step->maximum_increments);
+  (void)domain;
+}
+
+/// @brief Records exact accepted endpoint identity on a result dataset.
+void WriteFrameAttributes(const hid_t dataset,
+                          const DynamicAcceptedFrameState& frame) {
+  hdf5_internal::WriteUint64Attribute(dataset, "schema_version", 1U);
+  hdf5_internal::WriteStringAttribute(dataset, "step_name", "Step-1");
+  hdf5_internal::WriteUint64Attribute(dataset, "frame_index",
+                                      frame.frame_index);
+  hdf5_internal::WriteUint64Attribute(dataset, "increment_index",
+                                      frame.increment_index);
+  hdf5_internal::WriteDoubleAttribute(dataset, "time", frame.time);
+  hdf5_internal::WriteUint8Attribute(dataset, "is_initial",
+                                     frame.is_initial ? 1U : 0U);
+}
+
+/// @brief Writes or validates a result against the explicit schema plan.
+void ProcessDataset(const hid_t file, const std::string& path,
+                    const std::vector<hsize_t>& dimensions,
+                    const std::vector<double>& values, const char* names,
+                    const char* units, const char* coordinates,
+                    const char* location,
+                    const DynamicAcceptedFrameState& frame,
+                    const std::string& source_step, const bool readback) {
+  Hdf5Handle dataset =
+      readback ? CheckDoubles(file, path, dimensions, values)
+               : hdf5_internal::WriteDoubleValues(file, path, dimensions,
+                                                  values.data(), values.size());
+  const auto string_attribute = [&](const char* name,
+                                    const std::string& value) {
+    if (readback)
+      CheckString(dataset.Get(), name, value);
+    else
+      hdf5_internal::WriteStringAttribute(dataset.Get(), name, value);
+  };
+  string_attribute("component_names", names);
+  string_attribute("component_unit_dimensions", units);
+  string_attribute("coordinate_system", coordinates);
+  string_attribute("location", location);
+  string_attribute("source_step_name", source_step);
+  if (readback) {
+    CheckAttribute(dataset.Get(), "schema_version", H5T_STD_U64LE,
+                   H5T_NATIVE_UINT64, std::uint64_t{1U});
+    CheckString(dataset.Get(), "step_name", "Step-1");
+    CheckAttribute(dataset.Get(), "frame_index", H5T_STD_U64LE,
+                   H5T_NATIVE_UINT64, std::uint64_t{frame.frame_index});
+    CheckAttribute(dataset.Get(), "increment_index", H5T_STD_U64LE,
+                   H5T_NATIVE_UINT64, std::uint64_t{frame.increment_index});
+    CheckAttribute(dataset.Get(), "time", H5T_IEEE_F64LE, H5T_NATIVE_DOUBLE,
+                   frame.time);
+    CheckAttribute(dataset.Get(), "is_initial", H5T_STD_U8LE, H5T_NATIVE_UINT8,
+                   static_cast<std::uint8_t>(frame.is_initial));
+  } else {
+    WriteFrameAttributes(dataset.Get(), frame);
+  }
+  if (path.find("/nodal/") != std::string::npos) {
+    string_attribute("node_identity_dataset", "/model/nodes");
+  }
+  const std::string leaf = path.substr(path.find_last_of('/') + 1U);
+  if (leaf == "displacement" || leaf == "velocity" || leaf == "acceleration" ||
+      leaf == "algorithmic_acceleration") {
+    string_attribute("rotation_representation", "total-rotation-vector-chart");
+    string_attribute(
+        "quantity_semantics",
+        leaf == "displacement" ? "global-translation-and-total-rotation-vector"
+        : leaf == "velocity"   ? "global-translation-rate-and-chart-rate"
+        : leaf == "acceleration" ? "physical-endpoint-chart-acceleration"
+                                 : "auxiliary-HHT-chart-acceleration");
+  }
+  if (leaf == "triad") string_attribute("axis_names", "A,B,D");
+  if (path.find("/element/shell/") != std::string::npos) {
+    string_attribute("element_identity_dataset", "/model/elements");
+    string_attribute("source_element_type_dataset",
+                     "/model/elements.source_element_type");
+    string_attribute("internal_formulation", "FESA-MITC4-total-lagrangian");
+    string_attribute("midsurface_location_dataset",
+                     "/model/shell/midsurface_locations");
+    if (leaf == "local_frame") {
+      string_attribute("axis_names", "E1,E2,E3");
+    } else {
+      string_attribute(
+          "local_frame_dataset",
+          path.substr(0U, path.find_last_of('/') + 1U) + "local_frame");
+    }
+    if (leaf == "stress") {
+      string_attribute("section_position_dataset",
+                       "/model/shell/section_positions");
+    }
+  }
+}
+
+/// @brief Flattens nodal triad axes in A,B,D row order.
+std::vector<double> FlattenTriad(const DynamicAcceptedFrameState& frame) {
+  std::vector<double> values;
+  values.reserve(frame.nodal_triad.size() * 9U);
+  for (const auto& triad : frame.nodal_triad) {
+    for (const auto& axis : triad)
+      values.insert(values.end(), axis.begin(), axis.end());
+  }
+  return values;
+}
+
+/// @brief Flattens nodal directors in stable node order.
+std::vector<double> FlattenDirector(const DynamicAcceptedFrameState& frame) {
+  std::vector<double> values;
+  values.reserve(frame.nodal_director.size() * 3U);
+  for (const auto& director : frame.nodal_director)
+    values.insert(values.end(), director.begin(), director.end());
+  return values;
+}
+
+/// @brief Flattens physical recovery in element and Gauss order.
+std::vector<double> FlattenShell(const DynamicAcceptedFrameState& frame,
+                                 const int quantity) {
+  std::vector<double> values;
+  for (const ShellResultRow& row : frame.shell_results) {
+    if (quantity == 0)
+      for (const auto& a : row.local_frame)
+        values.insert(values.end(), a.begin(), a.end());
+    if (quantity == 1)
+      values.insert(values.end(), row.generalized_strain.begin(),
+                    row.generalized_strain.end());
+    if (quantity == 2)
+      values.insert(values.end(), row.section_resultant.begin(),
+                    row.section_resultant.end());
+    if (quantity == 3)
+      for (const auto& s : row.stress)
+        values.insert(values.end(), s.components.begin(), s.components.end());
+  }
+  return values;
+}
+
+/// @brief Maps generalized support moments to work-conjugate spatial moments.
+std::vector<double> SpatialReaction(const DynamicAcceptedFrameState& frame) {
+  std::vector<double> values = Values(frame.reaction);
+  for (std::size_t node = 0U; node < frame.nodal_internal_order.size();
+       ++node) {
+    const std::size_t offset = node * 6U;
+    const Vector3 phi{frame.generalized_coordinates[offset + 3U],
+                      frame.generalized_coordinates[offset + 4U],
+                      frame.generalized_coordinates[offset + 5U]};
+    const Matrix transform = InverseTransposeLeftJacobianSO3(phi);
+    for (std::size_t row = 0U; row < 3U; ++row) {
+      values[offset + 3U + row] = 0.0;
+      for (std::size_t column = 0U; column < 3U; ++column) {
+        values[offset + 3U + row] +=
+            transform(row, column) * frame.reaction[offset + 3U + column];
+      }
+    }
+  }
+  return values;
+}
+
+/// @brief Writes or reads back all mandatory accepted-endpoint quantities.
+void WriteFrame(const hid_t file, const Domain& domain,
+                const DynamicAcceptedFrameState& frame,
+                const bool readback = false) {
+  const hsize_t nodes = static_cast<hsize_t>(domain.Nodes().size());
+  const hsize_t elements = static_cast<hsize_t>(domain.ShellElements().Size());
+  const std::string root =
+      "/steps/Step-1/frames/" + std::to_string(frame.frame_index);
+  if (!readback) {
+    (void)hdf5_internal::CreateGroup(file, (root + "/nodal").c_str());
+    (void)hdf5_internal::CreateGroup(file, (root + "/element/shell").c_str());
+    (void)hdf5_internal::CreateGroup(file, (root + "/global").c_str());
+  }
+  const auto WriteDataset = [&](const hid_t target, const std::string& path,
+                                const std::vector<hsize_t>& dimensions,
+                                const std::vector<double>& values,
+                                const char* names, const char* units,
+                                const char* coordinates, const char* location,
+                                const DynamicAcceptedFrameState& endpoint) {
+    ProcessDataset(target, path, dimensions, values, names, units, coordinates,
+                   location, endpoint, domain.Dynamic()->source_step_name_raw,
+                   readback);
+  };
+  constexpr const char* kGeneralized = "F1,F2,F3,MPHI1,MPHI2,MPHI3";
+  constexpr const char* kGeneralizedUnits =
+      "force,force,force,force*length,force*length,force*length";
+  const std::vector<hsize_t> nodal{nodes, 6U};
+  WriteDataset(file, root + "/nodal/displacement", nodal,
+               Values(frame.generalized_coordinates), "UX,UY,UZ,URX,URY,URZ",
+               "length,length,length,1,1,1", "global-cartesian", "nodal",
+               frame);
+  WriteDataset(file, root + "/nodal/velocity", nodal, Values(frame.velocity),
+               "V1,V2,V3,PHIDOT1,PHIDOT2,PHIDOT3",
+               "length/time,length/time,length/time,1/time,1/time,1/time",
+               "fixed-initial-global-chart", "nodal", frame);
+  WriteDataset(
+      file, root + "/nodal/acceleration", nodal, Values(frame.acceleration),
+      "A1,A2,A3,PHIDDOT1,PHIDDOT2,PHIDDOT3",
+      "length/time^2,length/time^2,length/time^2,1/time^2,1/time^2,1/time^2",
+      "fixed-initial-global-chart", "nodal", frame);
+  WriteDataset(
+      file, root + "/nodal/algorithmic_acceleration", nodal,
+      Values(frame.algorithmic_acceleration), "AUX1,AUX2,AUX3,AUX4,AUX5,AUX6",
+      "length/time^2,length/time^2,length/time^2,1/time^2,1/time^2,1/time^2",
+      "fixed-initial-global-chart", "nodal", frame);
+  WriteDataset(file, root + "/nodal/angular_velocity", {nodes, 3U},
+               Values(frame.angular_velocity), "OMEGA1,OMEGA2,OMEGA3",
+               "1/time,1/time,1/time", "global-cartesian", "nodal", frame);
+  WriteDataset(file, root + "/nodal/angular_acceleration", {nodes, 3U},
+               Values(frame.angular_acceleration),
+               "OMEGADOT1,OMEGADOT2,OMEGADOT3", "1/time^2,1/time^2,1/time^2",
+               "global-cartesian", "nodal", frame);
+  WriteDataset(file, root + "/nodal/triad", {nodes, 3U, 3U},
+               FlattenTriad(frame), "X,Y,Z", "1,1,1", "global-cartesian",
+               "nodal", frame);
+  WriteDataset(file, root + "/nodal/director", {nodes, 3U},
+               FlattenDirector(frame), "D1,D2,D3", "1,1,1", "global-cartesian",
+               "nodal", frame);
+  WriteDataset(file, root + "/nodal/generalized_inertia_force", nodal,
+               Values(frame.inertia_force), kGeneralized, kGeneralizedUnits,
+               "fixed-initial-global-chart", "nodal", frame);
+  WriteDataset(file, root + "/nodal/generalized_internal_force", nodal,
+               Values(frame.internal_force), kGeneralized, kGeneralizedUnits,
+               "fixed-initial-global-chart", "nodal", frame);
+  WriteDataset(file, root + "/nodal/generalized_external_force", nodal,
+               Values(frame.external_force), kGeneralized, kGeneralizedUnits,
+               "fixed-initial-global-chart", "nodal", frame);
+  WriteDataset(file, root + "/nodal/generalized_residual", nodal,
+               Values(frame.residual), kGeneralized, kGeneralizedUnits,
+               "fixed-initial-global-chart", "nodal", frame);
+  WriteDataset(file, root + "/nodal/generalized_reaction", nodal,
+               Values(frame.reaction), kGeneralized, kGeneralizedUnits,
+               "fixed-initial-global-chart", "nodal", frame);
+  WriteDataset(file, root + "/nodal/reaction", nodal, SpatialReaction(frame),
+               "RF1,RF2,RF3,RM1,RM2,RM3", kGeneralizedUnits, "global-cartesian",
+               "nodal", frame);
+  const std::string shell = root + "/element/shell/";
+  WriteDataset(file, shell + "local_frame", {elements, 4U, 3U, 3U},
+               FlattenShell(frame, 0), "X,Y,Z", "1,1,1", "global-cartesian",
+               "shell-local-frame", frame);
+  WriteDataset(file, shell + "generalized_strain", {elements, 4U, 8U},
+               FlattenShell(frame, 1), "E11,E22,G12,K11,K22,K12,G13,G23",
+               "1,1,1,1/length,1/length,1/length,1,1", "shell-local",
+               "midsurface", frame);
+  WriteDataset(file, shell + "section_resultant", {elements, 4U, 8U},
+               FlattenShell(frame, 2), "N11,N22,N12,M11,M22,M12,Q13,Q23",
+               "force/length,force/length,force/length,force,force,force,force/"
+               "length,force/length",
+               "shell-local", "midsurface", frame);
+  WriteDataset(file, shell + "stress", {elements, 4U, 3U, 3U},
+               FlattenShell(frame, 3), "S11,S22,S12",
+               "force/length^2,force/length^2,force/length^2", "shell-local",
+               "section-position", frame);
+  WriteDataset(
+      file, root + "/global/energy", {5U},
+      {frame.kinetic_energy, frame.physical_strain_energy,
+       frame.drilling_energy, frame.external_work, frame.energy_defect},
+      "KINETIC_ENERGY,PHYSICAL_STRAIN_ENERGY,DRILLING_ENERGY,EXTERNAL_WORK,"
+      "ENERGY_DEFECT",
+      "force*length,force*length,force*length,force*length,force*length",
+      "global", "global", frame);
+  WriteDataset(file, root + "/global/equilibrium", {6U},
+               std::vector<double>{frame.global_equilibrium.begin(),
+                                   frame.global_equilibrium.end()},
+               "FORCE_1,FORCE_2,FORCE_3,MOMENT_1,MOMENT_2,MOMENT_3",
+               kGeneralizedUnits, "global-cartesian", "global-balance-error",
+               frame);
+}
+
+/// @brief Writes ordinal and exact-time accepted frame identities.
+void WriteAcceptedFrames(const hid_t file,
+                         const std::vector<DynamicAcceptedFrameState>& frames) {
+  std::vector<AcceptedFrameRow> rows;
+  rows.reserve(frames.size());
+  for (const auto& frame : frames)
+    rows.push_back({frame.frame_index, frame.increment_index, frame.time,
+                    frame.iteration_count,
+                    static_cast<std::uint8_t>(frame.is_initial)});
+  Hdf5Handle type{hdf5_internal::RequireHdf5Id(
+                      H5Tcreate(H5T_COMPOUND, sizeof(AcceptedFrameRow)),
+                      "Unable to create accepted-frame type."),
+                  H5Tclose};
+  hdf5_internal::RequireHdf5(
+      H5Tinsert(type.Get(), "frame_index",
+                HOFFSET(AcceptedFrameRow, frame_index), H5T_STD_U64LE),
+      "Unable to define accepted-frame field.");
+  hdf5_internal::RequireHdf5(
+      H5Tinsert(type.Get(), "increment_index",
+                HOFFSET(AcceptedFrameRow, increment_index), H5T_STD_U64LE),
+      "Unable to define accepted-frame field.");
+  hdf5_internal::RequireHdf5(
+      H5Tinsert(type.Get(), "time", HOFFSET(AcceptedFrameRow, time),
+                H5T_IEEE_F64LE),
+      "Unable to define accepted-frame field.");
+  hdf5_internal::RequireHdf5(
+      H5Tinsert(type.Get(), "iteration_count",
+                HOFFSET(AcceptedFrameRow, iteration_count), H5T_STD_U64LE),
+      "Unable to define accepted-frame field.");
+  hdf5_internal::RequireHdf5(
+      H5Tinsert(type.Get(), "is_initial", HOFFSET(AcceptedFrameRow, is_initial),
+                H5T_STD_U8LE),
+      "Unable to define accepted-frame field.");
+  (void)hdf5_internal::WriteCompoundDataset(
+      file, "/steps/Step-1/accepted_frames", rows.size(), type.Get(),
+      type.Get(), rows.data());
+}
+
+/// @brief Writes sorted diagnostics with dynamic schema field names.
+void WriteDiagnostics(const hid_t file,
+                      const std::vector<Diagnostic>& input_diagnostics) {
+  std::vector<Diagnostic> diagnostics = input_diagnostics;
+  SortDiagnostics(diagnostics);
+  std::vector<std::string> files;
+  std::vector<DiagnosticRow> rows;
+  files.reserve(diagnostics.size());
+  rows.reserve(diagnostics.size());
+  for (const Diagnostic& diagnostic : diagnostics) {
+    files.push_back(
+        hdf5_internal::NormalizedPathString(diagnostic.location.file));
+  }
+  for (std::size_t index = 0U; index < diagnostics.size(); ++index) {
+    const Diagnostic& diagnostic = diagnostics[index];
+    rows.push_back(
+        {diagnostic.severity == Severity::kWarning ? "warning" : "error",
+         diagnostic.code.c_str(), files[index].c_str(),
+         static_cast<std::uint64_t>(diagnostic.location.line),
+         diagnostic.keyword.c_str(), diagnostic.entity_identity.c_str(),
+         diagnostic.message.c_str()});
+  }
+  auto string_type = hdf5_internal::MakeUtf8StringType();
+  Hdf5Handle type{hdf5_internal::RequireHdf5Id(
+                      H5Tcreate(H5T_COMPOUND, sizeof(DiagnosticRow)),
+                      "Unable to create dynamic diagnostic type."),
+                  H5Tclose};
+  const auto add = [&](const char* name, const std::size_t offset,
+                       const hid_t value_type) {
+    hdf5_internal::RequireHdf5(H5Tinsert(type.Get(), name, offset, value_type),
+                               "Unable to define dynamic diagnostic field.");
+  };
+  add("severity", HOFFSET(DiagnosticRow, severity), string_type.Get());
+  add("code", HOFFSET(DiagnosticRow, code), string_type.Get());
+  add("source_file", HOFFSET(DiagnosticRow, file), string_type.Get());
+  add("source_line", HOFFSET(DiagnosticRow, line), H5T_STD_U64LE);
+  add("keyword", HOFFSET(DiagnosticRow, keyword), string_type.Get());
+  add("entity_identity", HOFFSET(DiagnosticRow, entity_identity),
+      string_type.Get());
+  add("message", HOFFSET(DiagnosticRow, message), string_type.Get());
+  (void)hdf5_internal::WriteCompoundDataset(
+      file, "/diagnostics", rows.size(), type.Get(), type.Get(), rows.data());
+}
+
+/// @brief Checks every source-model field written by the shared model writer.
+void CheckModel(const hid_t file, const Domain& domain,
+                const hdf5_internal::WriterModelData& model) {
+  const hsize_t count = static_cast<hsize_t>(domain.Nodes().size());
+  auto nodes = OpenDataset(file, "/model/nodes", {count});
+  CheckMembers(nodes.Get(), {"internal_node_id", "instance_name",
+                             "source_label", "coordinates"});
+  std::vector<std::uint64_t> ids;
+  std::vector<std::string> instances;
+  std::vector<std::string> labels;
+  std::vector<std::array<double, 3>> coordinates;
+  for (std::size_t index = 0U; index < domain.Nodes().size(); ++index) {
+    ids.push_back(index);
+    instances.push_back(domain.Nodes()[index].source_id.instance_name);
+    labels.push_back(domain.Nodes()[index].source_id.source_label_text);
+    coordinates.push_back(domain.Nodes()[index].coordinates);
+  }
+  const hsize_t three = 3U;
+  Hdf5Handle triple_file{H5Tarray_create2(H5T_IEEE_F64LE, 1, &three), H5Tclose};
+  Hdf5Handle triple_memory{H5Tarray_create2(H5T_NATIVE_DOUBLE, 1, &three),
+                           H5Tclose};
+  CheckColumn(nodes.Get(), "internal_node_id", H5T_STD_U64LE, H5T_NATIVE_UINT64,
+              ids);
+  CheckStringColumn(nodes.Get(), "instance_name", instances);
+  CheckStringColumn(nodes.Get(), "source_label", labels);
+  CheckColumn(nodes.Get(), "coordinates", triple_file.Get(),
+              triple_memory.Get(), coordinates);
+  CheckString(nodes.Get(), "coordinate_system", "global-cartesian");
+  CheckString(nodes.Get(), "units_label", "length");
+
+  auto elements = OpenDataset(file, "/model/elements",
+                              {static_cast<hsize_t>(domain.Elements().Size())});
+  CheckMembers(
+      elements.Get(),
+      {"internal_element_id", "instance_name", "source_label",
+       "source_element_type", "internal_formulation", "node_internal_ids",
+       "shell_section_internal_id", "material_internal_id"});
+  ids.clear();
+  instances.clear();
+  labels.clear();
+  std::vector<std::string> source_types;
+  std::vector<std::string> formulations;
+  std::vector<std::uint64_t> sections;
+  std::vector<std::uint64_t> materials;
+  std::vector<std::array<std::uint64_t, 4>> connectivity;
+  for (std::size_t index = 0U; index < domain.ShellElements().Size(); ++index) {
+    const auto& element = domain.ShellElements()[index];
+    ids.push_back(index);
+    instances.push_back(element.source_id.instance_name);
+    labels.push_back(element.source_id.source_label_text);
+    source_types.push_back(
+        hdf5_internal::ShellSourceTypeName(element.source_type));
+    formulations.push_back("FESA-MITC4");
+    sections.push_back(element.section_index);
+    materials.push_back(element.material_index);
+    connectivity.push_back({element.node_indices[0U], element.node_indices[1U],
+                            element.node_indices[2U],
+                            element.node_indices[3U]});
+  }
+  const hsize_t four = 4U;
+  Hdf5Handle nodes_file{H5Tarray_create2(H5T_STD_U64LE, 1, &four), H5Tclose};
+  Hdf5Handle nodes_memory{H5Tarray_create2(H5T_NATIVE_UINT64, 1, &four),
+                          H5Tclose};
+  CheckColumn(elements.Get(), "internal_element_id", H5T_STD_U64LE,
+              H5T_NATIVE_UINT64, ids);
+  CheckStringColumn(elements.Get(), "instance_name", instances);
+  CheckStringColumn(elements.Get(), "source_label", labels);
+  CheckStringColumn(elements.Get(), "source_element_type", source_types);
+  CheckStringColumn(elements.Get(), "internal_formulation", formulations);
+  CheckColumn(elements.Get(), "node_internal_ids", nodes_file.Get(),
+              nodes_memory.Get(), connectivity);
+  CheckColumn(elements.Get(), "shell_section_internal_id", H5T_STD_U64LE,
+              H5T_NATIVE_UINT64, sections);
+  CheckColumn(elements.Get(), "material_internal_id", H5T_STD_U64LE,
+              H5T_NATIVE_UINT64, materials);
+
+  auto material_table =
+      OpenDataset(file, "/model/shell/materials",
+                  {static_cast<hsize_t>(domain.Materials().Size())});
+  CheckMembers(material_table.Get(),
+               {"internal_material_id", "name", "E", "nu"});
+  ids.clear();
+  labels.clear();
+  std::vector<double> youngs;
+  std::vector<double> poisson;
+  for (std::size_t index = 0U; index < domain.Materials().Size(); ++index) {
+    const auto& material = domain.LinearElasticMaterials()[index];
+    ids.push_back(index);
+    labels.push_back(material.name);
+    youngs.push_back(material.youngs_modulus);
+    poisson.push_back(material.poisson_ratio);
+  }
+  CheckColumn(material_table.Get(), "internal_material_id", H5T_STD_U64LE,
+              H5T_NATIVE_UINT64, ids);
+  CheckStringColumn(material_table.Get(), "name", labels);
+  CheckColumn(material_table.Get(), "E", H5T_IEEE_F64LE, H5T_NATIVE_DOUBLE,
+              youngs);
+  CheckColumn(material_table.Get(), "nu", H5T_IEEE_F64LE, H5T_NATIVE_DOUBLE,
+              poisson);
+  auto density_table =
+      OpenDataset(file, "/model/material_density",
+                  {static_cast<hsize_t>(domain.Materials().Size())});
+  CheckMembers(density_table.Get(), {"internal_material_id", "rho"});
+  std::vector<double> densities;
+  for (const auto& density : domain.Densities())
+    densities.push_back(density.rho);
+  CheckColumn(density_table.Get(), "internal_material_id", H5T_STD_U64LE,
+              H5T_NATIVE_UINT64, ids);
+  CheckColumn(density_table.Get(), "rho", H5T_IEEE_F64LE, H5T_NATIVE_DOUBLE,
+              densities);
+
+  auto section_table =
+      OpenDataset(file, "/model/shell/sections",
+                  {static_cast<hsize_t>(domain.ShellSections().Size())});
+  CheckMembers(section_table.Get(),
+               {"internal_section_id", "source_file", "source_line",
+                "source_elset", "material_internal_id", "thickness"});
+  ids.clear();
+  labels.clear();
+  materials.clear();
+  std::vector<std::string> files;
+  std::vector<std::uint64_t> lines;
+  std::vector<double> thickness;
+  for (std::size_t index = 0U; index < domain.ShellSections().Size(); ++index) {
+    const auto& section = domain.ShellSections()[index];
+    ids.push_back(index);
+    files.push_back(hdf5_internal::NormalizedPathString(section.location.file));
+    lines.push_back(section.location.line);
+    labels.push_back(section.name);
+    materials.push_back(section.material_index);
+    thickness.push_back(section.thickness);
+  }
+  CheckColumn(section_table.Get(), "internal_section_id", H5T_STD_U64LE,
+              H5T_NATIVE_UINT64, ids);
+  CheckStringColumn(section_table.Get(), "source_file", files);
+  CheckColumn(section_table.Get(), "source_line", H5T_STD_U64LE,
+              H5T_NATIVE_UINT64, lines);
+  CheckStringColumn(section_table.Get(), "source_elset", labels);
+  CheckColumn(section_table.Get(), "material_internal_id", H5T_STD_U64LE,
+              H5T_NATIVE_UINT64, materials);
+  CheckColumn(section_table.Get(), "thickness", H5T_IEEE_F64LE,
+              H5T_NATIVE_DOUBLE, thickness);
+
+  auto mask = OpenDataset(file, "/model/nodal_constraint_mask", {count, 6U});
+  Hdf5Handle mask_type{H5Dget_type(mask.Get()), H5Tclose};
+  Check(H5Tequal(mask_type.Get(), H5T_STD_U8LE) > 0,
+        "Constraint dtype mismatch.");
+  std::vector<std::uint8_t> actual_mask(model.constraint_mask.size());
+  hdf5_internal::RequireHdf5(H5Dread(mask.Get(), H5T_NATIVE_UINT8, H5S_ALL,
+                                     H5S_ALL, H5P_DEFAULT, actual_mask.data()),
+                             "Unable to read constraint mask.");
+  Check(actual_mask == model.constraint_mask, "Constraint mask mismatch.");
+  (void)CheckDoubles(file, "/model/prescribed_displacement", {count, 6U},
+                     model.prescribed_displacement);
+  std::vector<double> directors;
+  std::vector<double> frames;
+  for (const auto& frame : domain.ShellNodeInitialFrames()) {
+    directors.insert(directors.end(), frame.director.begin(),
+                     frame.director.end());
+    frames.insert(frames.end(), frame.tangent_a.begin(), frame.tangent_a.end());
+    frames.insert(frames.end(), frame.tangent_b.begin(), frame.tangent_b.end());
+    frames.insert(frames.end(), frame.director.begin(), frame.director.end());
+  }
+  (void)CheckDoubles(file, "/model/shell/nodal_director", {count, 3U},
+                     directors);
+  (void)CheckDoubles(file, "/model/shell/nodal_frame", {count, 3U, 3U}, frames);
+  const double gauss = 1.0 / std::sqrt(3.0);
+  (void)CheckDoubles(
+      file, "/model/shell/midsurface_locations", {4U, 2U},
+      {-gauss, -gauss, gauss, -gauss, gauss, gauss, -gauss, gauss});
+  (void)CheckDoubles(file, "/model/shell/section_positions", {3U},
+                     {-1.0, 0.0, 1.0});
+}
+
+/// @brief Checks complete accepted-frame table and diagnostic identities.
+void CheckTables(const hid_t file, const DynamicAnalysisState& state,
+                 std::vector<Diagnostic> diagnostics) {
+  auto table =
+      OpenDataset(file, "/steps/Step-1/accepted_frames",
+                  {static_cast<hsize_t>(state.AcceptedFrames().size())});
+  CheckMembers(table.Get(), {"frame_index", "increment_index", "time",
+                             "iteration_count", "is_initial"});
+  std::vector<std::uint64_t> frames;
+  std::vector<std::uint64_t> increments;
+  std::vector<std::uint64_t> iterations;
+  std::vector<double> times;
+  std::vector<std::uint8_t> initial;
+  for (const auto& frame : state.AcceptedFrames()) {
+    frames.push_back(frame.frame_index);
+    increments.push_back(frame.increment_index);
+    iterations.push_back(frame.iteration_count);
+    times.push_back(frame.time);
+    initial.push_back(static_cast<std::uint8_t>(frame.is_initial));
+  }
+  CheckColumn(table.Get(), "frame_index", H5T_STD_U64LE, H5T_NATIVE_UINT64,
+              frames);
+  CheckColumn(table.Get(), "increment_index", H5T_STD_U64LE, H5T_NATIVE_UINT64,
+              increments);
+  CheckColumn(table.Get(), "iteration_count", H5T_STD_U64LE, H5T_NATIVE_UINT64,
+              iterations);
+  CheckColumn(table.Get(), "time", H5T_IEEE_F64LE, H5T_NATIVE_DOUBLE, times);
+  CheckColumn(table.Get(), "is_initial", H5T_STD_U8LE, H5T_NATIVE_UINT8,
+              initial);
+  SortDiagnostics(diagnostics);
+  auto diagnostic_table = OpenDataset(
+      file, "/diagnostics", {static_cast<hsize_t>(diagnostics.size())});
+  CheckMembers(diagnostic_table.Get(),
+               {"severity", "code", "source_file", "source_line", "keyword",
+                "entity_identity", "message"});
+  std::vector<std::string> severity;
+  std::vector<std::string> codes;
+  std::vector<std::string> files;
+  std::vector<std::uint64_t> lines;
+  std::vector<std::string> keywords;
+  std::vector<std::string> identities;
+  std::vector<std::string> messages;
+  for (const auto& diagnostic : diagnostics) {
+    severity.push_back(diagnostic.severity == Severity::kWarning ? "warning"
+                                                                 : "error");
+    codes.push_back(diagnostic.code);
+    files.push_back(
+        hdf5_internal::NormalizedPathString(diagnostic.location.file));
+    lines.push_back(diagnostic.location.line);
+    keywords.push_back(diagnostic.keyword);
+    identities.push_back(diagnostic.entity_identity);
+    messages.push_back(diagnostic.message);
+  }
+  CheckStringColumn(diagnostic_table.Get(), "severity", severity);
+  CheckStringColumn(diagnostic_table.Get(), "code", codes);
+  CheckStringColumn(diagnostic_table.Get(), "source_file", files);
+  CheckColumn(diagnostic_table.Get(), "source_line", H5T_STD_U64LE,
+              H5T_NATIVE_UINT64, lines);
+  CheckStringColumn(diagnostic_table.Get(), "keyword", keywords);
+  CheckStringColumn(diagnostic_table.Get(), "entity_identity", identities);
+  CheckStringColumn(diagnostic_table.Get(), "message", messages);
+}
+
+/// @brief Reopens and verifies the complete dynamic publication candidate.
+Status SelfCheck(const std::filesystem::path& path, const Domain& domain,
+                 const DynamicAnalysisState& state,
+                 const hdf5_internal::WriterModelData& model,
+                 const std::vector<Diagnostic>& diagnostics) {
+  try {
+    Hdf5Handle file{
+        hdf5_internal::RequireHdf5Id(
+            H5Fopen(path.string().c_str(), H5F_ACC_RDONLY, H5P_DEFAULT),
+            "Unable to reopen dynamic candidate."),
+        H5Fclose};
+    Hdf5Handle metadata{hdf5_internal::RequireHdf5Id(
+                            H5Gopen2(file.Get(), "/metadata", H5P_DEFAULT),
+                            "The dynamic metadata group is missing."),
+                        H5Gclose};
+    const auto& step = *domain.Dynamic();
+    CheckString(metadata.Get(), "feature_id", "hht-implicit-dynamics");
+    CheckString(metadata.Get(), "analysis_procedure", "hht-implicit-dynamics");
+    CheckString(metadata.Get(), "mass_formulation", "consistent-kinetic");
+    CheckString(metadata.Get(), "internal_formulation",
+                "FESA-MITC4-total-lagrangian");
+    CheckString(metadata.Get(), "initial_state", "zero-q-v-step-load-0+");
+    CheckString(metadata.Get(), "acceleration_convention",
+                "physical-endpoint-and-auxiliary-separated");
+    CheckString(metadata.Get(), "source_step_name", step.source_step_name_raw);
+    CheckString(metadata.Get(), "step_name", "Step-1");
+    CheckString(metadata.Get(), "unit_system_label", "consistent-input-units");
+    CheckString(metadata.Get(), "solver_version", std::string{SolverVersion()});
+    CheckString(metadata.Get(), "source_input_identity",
+                hdf5_internal::SourceInputIdentity(domain));
+    CheckAttribute(metadata.Get(), "schema_version", H5T_STD_U64LE,
+                   H5T_NATIVE_UINT64, std::uint64_t{1U});
+    CheckAttribute(metadata.Get(), "increment_count", H5T_STD_U64LE,
+                   H5T_NATIVE_UINT64, std::uint64_t{step.increment_count});
+    CheckAttribute(metadata.Get(), "maximum_increments", H5T_STD_U64LE,
+                   H5T_NATIVE_UINT64, std::uint64_t{step.maximum_increments});
+    for (const auto& entry : std::vector<std::pair<const char*, double>>{
+             {"alpha", step.alpha},
+             {"beta", step.beta},
+             {"gamma", step.gamma},
+             {"initial_increment", step.initial_increment},
+             {"time_period", step.time_period}}) {
+      CheckAttribute(metadata.Get(), entry.first, H5T_IEEE_F64LE,
+                     H5T_NATIVE_DOUBLE, entry.second);
+    }
+    CheckModel(file.Get(), domain, model);
+    CheckTables(file.Get(), state, diagnostics);
+    Hdf5Handle frames{H5Gopen2(file.Get(), "/steps/Step-1/frames", H5P_DEFAULT),
+                      H5Gclose};
+    H5G_info_t information{};
+    hdf5_internal::RequireHdf5(H5Gget_info(frames.Get(), &information),
+                               "Unable to inspect accepted frame group.");
+    Check(information.nlinks == state.AcceptedFrames().size(),
+          "Unexpected frame group inventory.");
+    for (const auto& frame : state.AcceptedFrames()) {
+      WriteFrame(file.Get(), domain, frame, true);
+    }
+    return Status::Ok();
+  } catch (const std::exception& error) {
+    return Failure("dynamic-output-schema", error.what());
+  }
+}
+
+}  // namespace
+
+Status DynamicHdf5ResultsWriter::Write(
+    const std::filesystem::path& output_path, const Domain& domain,
+    const DynamicAnalysisState& state,
+    const std::vector<Diagnostic>& diagnostics) {
+  if (output_path.empty() || output_path.filename().empty() ||
+      !state.IsInitialized() || state.AcceptedFrames().empty() ||
+      domain.Dynamic() == nullptr)
+    return Failure("dynamic-output-schema",
+                   "Dynamic output requires a named path, initialized state, "
+                   "and accepted frames.");
+  try {
+    hdf5_internal::Hdf5ErrorSilencer silence;
+    const auto& step = *domain.Dynamic();
+    Check(state.AcceptedFrames().size() ==
+                  static_cast<std::size_t>(step.increment_count) + 1U &&
+              state.AcceptedFrames().back().time == step.time_period,
+          "Dynamic output requires the complete accepted history.");
+    auto analysis_model = AnalysisModel::Create(domain);
+    Check(analysis_model.HasValue(), "Dynamic model inventory is invalid.");
+    auto dofs_result = DofManager::Create(analysis_model.Value());
+    Check(dofs_result.HasValue(), "Dynamic constraint inventory is invalid.");
+    const auto& dofs = dofs_result.Value();
+    auto validated_state = DynamicAnalysisState::Create(domain, dofs);
+    Check(validated_state.HasValue(),
+          "Dynamic schedule or inventory is invalid.");
+    for (const auto& frame : state.AcceptedFrames()) {
+      Check(validated_state.Value().CommitAcceptedFrame(frame).IsOk(),
+            "Dynamic frame does not match the output Domain.");
+    }
+    Check(
+        domain.Densities().size() == domain.Materials().Size() &&
+            domain.LinearElasticMaterials().Size() == domain.Materials().Size(),
+        "Material and density inventories differ.");
+    for (std::size_t index = 0U; index < domain.Densities().size(); ++index) {
+      const auto& density = domain.Densities()[index];
+      Check(density.material_index == index && std::isfinite(density.rho) &&
+                density.rho > 0.0,
+            "Material density identity or value is invalid.");
+    }
+    hdf5_internal::WriterModelData model{};
+    model.constraint_mask.assign(dofs.FullDofCount(), 0U);
+    model.prescribed_displacement.assign(dofs.FullDofCount(), 0.0);
+    for (const std::size_t dof : dofs.ConstrainedDofs()) {
+      model.constraint_mask[dof] = 1U;
+    }
+    const std::filesystem::path candidate_path =
+        hdf5_internal::MakeCandidatePath(output_path);
+    hdf5_internal::CandidateFileGuard cleanup{candidate_path};
+    Hdf5Handle file{hdf5_internal::RequireHdf5Id(
+                        H5Fcreate(candidate_path.string().c_str(), H5F_ACC_EXCL,
+                                  H5P_DEFAULT, H5P_DEFAULT),
+                        "Unable to create dynamic candidate."),
+                    H5Fclose};
+    (void)hdf5_internal::CreateGroup(file.Get(), "/model/shell");
+    hdf5_internal::WriteModel(file.Get(), domain, model);
+    WriteMetadata(file.Get(), domain);
+    WriteDensity(file.Get(), domain);
+    (void)hdf5_internal::CreateGroup(file.Get(), "/steps");
+    (void)hdf5_internal::CreateGroup(file.Get(), "/steps/Step-1");
+    WriteAcceptedFrames(file.Get(), state.AcceptedFrames());
+    for (const auto& frame : state.AcceptedFrames()) {
+      WriteFrame(file.Get(), domain, frame);
+    }
+    WriteDiagnostics(file.Get(), diagnostics);
+    hdf5_internal::RequireHdf5(H5Fflush(file.Get(), H5F_SCOPE_GLOBAL),
+                               "Unable to flush dynamic candidate.");
+    hdf5_internal::RequireHdf5(file.CloseChecked(),
+                               "Unable to close dynamic candidate.");
+    const Status check =
+        SelfCheck(candidate_path, domain, state, model, diagnostics);
+    const Status finalization = hdf5_internal::AtomicFinalizeValidatedCandidate(
+        candidate_path, output_path, check);
+    if (finalization.IsOk()) cleanup.Release();
+    return finalization;
+  } catch (const Hdf5Failure& error) {
+    return Failure("dynamic-output-schema", error.what());
+  } catch (const std::exception& error) {
+    return Failure("hdf5-write-failure", error.what());
+  }
+}
+
+}  // namespace fesa
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 58b6f91..50f3c0c 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -6,8 +6,14 @@ add_executable(
     unit/analysis/analysis_test.cpp
     unit/analysis/analysis_model_test.cpp
     unit/analysis/analysis_state_test.cpp
+    unit/analysis/dynamic_analysis_state_test.cpp
     unit/analysis/eigen_reduction_test.cpp
     unit/analysis/eigen_mass_assembly_test.cpp
+    unit/analysis/hht_time_integration_test.cpp
+    unit/analysis/hht_energy_verification_test.cpp
+    unit/analysis/hht_temporal_verification_test.cpp
+    unit/analysis/hht_dynamic_algebra_test.cpp
+    unit/analysis/hht_dynamic_procedure_test.cpp
     unit/analysis/nonlinear_analysis_state_test.cpp
     unit/analysis/nonlinear_static_control_test.cpp
     unit/analysis/newton_iteration_log_test.cpp
@@ -28,6 +34,7 @@ add_executable(
     unit/elements/mitc4_shell_test.cpp
     unit/elements/mitc4_shell_mass_contract_test.cpp
     unit/elements/nonlinear_mitc4_shell_test.cpp
+    unit/elements/nonlinear_mitc4_inertia_test.cpp
     unit/elements/nonlinear_mitc4_shell_tangent_test.cpp
     unit/fem/dof_manager_test.cpp
     unit/math/dense_blas_internal_test.cpp
@@ -43,6 +50,7 @@ add_executable(
     unit/io/abaqus/input_syntax_test.cpp
     unit/io/abaqus/shell_surface_pressure_domain_test.cpp
     unit/io/hdf5/hdf5_results_writer_test.cpp
+    unit/io/hdf5/dynamic_hdf5_results_writer_test.cpp
     unit/io/hdf5/eigen_hdf5_results_writer_test.cpp
     unit/io/hdf5/nonlinear_hdf5_results_writer_test.cpp
     unit/io/hdf5/hdf5_writer_components_test.cpp
diff --git a/tests/test_compare_hht_dynamic.py b/tests/test_compare_hht_dynamic.py
new file mode 100644
index 0000000..a359ac7
--- /dev/null
+++ b/tests/test_compare_hht_dynamic.py
@@ -0,0 +1,302 @@
+"""HHT reference identity, time, projection and common-tolerance regressions."""
+
+import csv
+import json
+import math
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+
+import pytest
+
+h5py = pytest.importorskip("h5py", reason="Run with uv --with h5py for HHT comparison tests.")
+np = pytest.importorskip("numpy")
+from scripts.verification import compare_hht_dynamic as comparator
+
+
+@pytest.fixture(scope="module")
+def artifacts(tmp_path_factory):
+    directory = tmp_path_factory.mktemp("hht-comparison")
+    input_path = comparator.REFERENCE_DIRECTORY / f"{comparator.CASE}.inp"
+    reference_path = comparator.REFERENCE_DIRECTORY / f"{comparator.CASE} displacements.csv"
+    nodes, content_identity = comparator.input_inventory(input_path)
+    reference = comparator.read_reference(reference_path)
+    result_path = directory / "matching_results.h5"
+    string_type = h5py.string_dtype("utf-8")
+    node_type = np.dtype([("internal_node_id", "<u8"), ("instance_name", string_type),
+                          ("source_label", string_type), ("coordinates", "<f8", (3,))])
+    node_rows = np.empty(729, dtype=node_type)
+    labels = list(nodes)
+    for index, label in enumerate(labels):
+        node_rows[index] = (index, "PART-1-1", str(label), nodes[label])
+    frame_type = np.dtype([("frame_index", "<u8"), ("increment_index", "<u8"),
+                           ("time", "<f8"), ("iteration_count", "<u8"), ("is_initial", "u1")])
+    frames = np.empty(101, dtype=frame_type)
+    with h5py.File(result_path, "w") as file:
+        metadata = file.create_group("metadata")
+        metadata.attrs.update({
+            "feature_id": "hht-implicit-dynamics", "analysis_procedure": "hht-implicit-dynamics",
+            "mass_formulation": "consistent-kinetic", "internal_formulation": "FESA-MITC4-total-lagrangian",
+            "initial_state": "zero-q-v-step-load-0+",
+            "acceleration_convention": "physical-endpoint-and-auxiliary-separated",
+            "source_step_name": "Step-1", "step_name": "Step-1", "unit_system_label": "consistent-input-units",
+            "solver_version": "test-fixture", "source_input_identity": f"path={input_path};content_identity={content_identity}",
+            "schema_version": np.uint64(1), "increment_count": np.uint64(100), "maximum_increments": np.uint64(1000),
+            "alpha": -0.05, "beta": 0.275625, "gamma": 0.55, "initial_increment": 0.1, "time_period": 10.0,
+        })
+        file.create_dataset("model/nodes", data=node_rows)
+        for increment in range(101):
+            time = float(increment) * 0.1
+            frames[increment] = (increment, increment, time, 0 if increment == 0 else 2, int(increment == 0))
+            values = np.zeros((729, 6), dtype="<f8")
+            for label in (2, 21, 22, 69, 70, 165, 309, 442, 586):
+                values[labels.index(label)] = reference[(increment, label)]
+            dataset = file.create_dataset(f"steps/Step-1/frames/{increment}/nodal/displacement", data=values)
+            dataset.attrs.update({
+                "component_names": "UX,UY,UZ,URX,URY,URZ", "component_unit_dimensions": "length,length,length,1,1,1",
+                "coordinate_system": "global-cartesian", "location": "nodal", "step_name": "Step-1", "source_step_name": "Step-1",
+                "rotation_representation": "total-rotation-vector-chart",
+                "quantity_semantics": "global-translation-and-total-rotation-vector",
+                "schema_version": np.uint64(1), "frame_index": np.uint64(increment), "increment_index": np.uint64(increment),
+                "time": time, "is_initial": np.uint8(increment == 0),
+            })
+        file.create_dataset("steps/Step-1/accepted_frames", data=frames)
+    return input_path, reference_path, result_path
+
+
+def changed_result(tmp_path, artifacts):
+    target = tmp_path / "changed.h5"
+    shutil.copyfile(artifacts[2], target)
+    return target
+
+
+def test_original_csv_exact_matching_history_and_deterministic_report(artifacts):
+    first = comparator.compare(*artifacts)
+    second = comparator.compare(*artifacts)
+    assert first == second
+    assert first["precheck"]["passed"], first["precheck"]
+    assert first["precheck"]["reference_row_count"] == 909
+    assert first["precheck"]["checked_result_scalars"] == 441774
+    assert first["verdict"] == "passed"
+    assert first["warnings"] == []
+    assert len(first["families"]) == 202
+    assert sum(family["row_count"] for family in first["families"]) == 5454
+    assert [family["quantity"] for family in first["families"][:4]] == ["U", "UR", "U", "UR"]
+    assert all(family["passed"] for family in first["families"])
+    assert first["families"][0]["reference_scale"] == 0.0
+    assert first["families"][6]["hdf5_time"] == 3 * 0.1
+    assert first["families"][6]["reference_decimal_time"] == "0.3"
+    assert 3 * 0.1 != float("0.3")  # Both legitimate representations were validated independently.
+    json.dumps(first, allow_nan=False)
+
+
+@pytest.mark.parametrize("mutation,code", [
+    ("procedure", "wrong-hdf5-attribute-value"),
+    ("mass", "wrong-hdf5-attribute-value"),
+    ("coefficient", "wrong-hdf5-attribute-value"),
+    ("initial_convention", "wrong-hdf5-attribute-value"),
+    ("input_content", "wrong-input-content-identity"),
+    ("component", "wrong-hdf5-attribute-value"),
+    ("rotation", "wrong-hdf5-attribute-value"),
+    ("missing_component_attribute", "missing-hdf5-attribute"),
+    ("nonprojected_nan", "nonfinite-result-value"),
+    ("rotation_inf", "nonfinite-result-value"),
+    ("initial_motion", "nonzero-initial-displacement"),
+    ("duplicate_node", "duplicate-result-node"),
+    ("extra_node_label", "extra-result-node"),
+    ("wrong_instance", "wrong-result-instance"),
+    ("coordinate", "wrong-result-coordinate"),
+    ("wrong_shape", "wrong-hdf5-dataset-layout"),
+    ("float32", "wrong-displacement-type"),
+    ("missing_frame", "result-frame-inventory"),
+    ("extra_frame", "result-frame-inventory"),
+    ("leading_zero_frame", "result-frame-inventory"),
+    ("duplicate_increment", "wrong-result-frame-time"),
+    ("decimal_binary_time", "wrong-result-frame-time"),
+    ("frame_attribute_time", "wrong-hdf5-attribute-value"),
+    ("trial_iteration", "wrong-result-frame-time"),
+    ("initial_iteration", "wrong-result-frame-time"),
+])
+def test_hdf5_precheck_rejects_before_tolerance(tmp_path, artifacts, mutation, code):
+    path = changed_result(tmp_path, artifacts)
+    with h5py.File(path, "r+") as file:
+        metadata = file["metadata"]
+        displacement = file["steps/Step-1/frames/3/nodal/displacement"]
+        nodes = file["model/nodes"]
+        table = file["steps/Step-1/accepted_frames"]
+        if mutation in {"procedure", "mass", "coefficient", "initial_convention", "input_content"}:
+            key, value = {
+                "procedure": ("analysis_procedure", "linear-static"),
+                "mass": ("mass_formulation", "lumped"),
+                "coefficient": ("alpha", 0.0),
+                "initial_convention": ("initial_state", "unloaded"),
+                "input_content": ("source_input_identity", "wrong-content"),
+            }[mutation]
+            metadata.attrs.modify(key, value)
+        elif mutation in {"component", "rotation", "frame_attribute_time"}:
+            key, value = {"component": ("component_names", "U1,U2,U3,UR1,UR2,UR3"),
+                          "rotation": ("rotation_representation", "incremental-rotation"),
+                          "frame_attribute_time": ("time", 0.3)}[mutation]
+            displacement.attrs.modify(key, value)
+        elif mutation == "missing_component_attribute":
+            del displacement.attrs["component_names"]
+        elif mutation in {"nonprojected_nan", "rotation_inf"}:
+            displacement[0, 0 if mutation == "nonprojected_nan" else 3] = float("nan") if mutation == "nonprojected_nan" else float("inf")
+        elif mutation == "initial_motion":
+            file["steps/Step-1/frames/0/nodal/displacement"][0, 0] = 1.0e-100
+        elif mutation in {"duplicate_node", "extra_node_label", "wrong_instance", "coordinate"}:
+            rows = nodes[:]
+            if mutation == "duplicate_node":
+                rows[1]["source_label"] = rows[0]["source_label"]
+            elif mutation == "extra_node_label":
+                rows[0]["source_label"] = "99999"
+            elif mutation == "wrong_instance":
+                rows[0]["instance_name"] = "Other"
+            else:
+                rows[0]["coordinates"] = [1.0, 2.0, 3.0]
+            nodes[:] = rows
+        elif mutation in {"wrong_shape", "float32"}:
+            name = displacement.name
+            values = displacement[:]
+            del file[name]
+            file.create_dataset(name, data=values[:-1] if mutation == "wrong_shape" else values.astype("<f4"))
+        elif mutation == "missing_frame":
+            del file["steps/Step-1/frames/100"]
+        elif mutation == "extra_frame":
+            file.create_group("steps/Step-1/frames/101")
+        elif mutation == "leading_zero_frame":
+            file.move("steps/Step-1/frames/1", "steps/Step-1/frames/01")
+        else:
+            rows = table[:]
+            if mutation == "duplicate_increment":
+                rows[3]["increment_index"] = 2
+            elif mutation == "decimal_binary_time":
+                rows[3]["time"] = 0.3
+            elif mutation == "trial_iteration":
+                rows[3]["iteration_count"] = 101
+            elif mutation == "initial_iteration":
+                rows[0]["iteration_count"] = 1
+            table[:] = rows
+    report = comparator.compare(artifacts[0], artifacts[1], path)
+    assert report["precheck"]["passed"] is False
+    assert report["precheck"]["code"] == code, report["precheck"]
+    assert report["families"] == []
+    assert report["verdict"] == "failed"
+
+
+@pytest.mark.parametrize("mutation,code", [
+    ("duplicate_header", "duplicate-reference-column"),
+    ("missing_header", "missing-reference-column"),
+    ("duplicate_row", "duplicate-reference-row"),
+    ("missing_row", "reference-row-inventory"),
+    ("extra_node", "reference-row-inventory"),
+    ("extra_frame", "reference-row-inventory"),
+    ("time", "wrong-reference-time"),
+    ("instance", "wrong-reference-instance"),
+    ("label", "invalid-node-label"),
+    ("nonfinite_rotation", "nonfinite-reference-value"),
+])
+def test_reference_precheck_rejects_before_tolerance(tmp_path, artifacts, mutation, code):
+    with artifacts[1].open(newline="", encoding="utf-8") as stream:
+        rows = list(csv.reader(stream))
+    if mutation == "duplicate_header":
+        rows[0][-1] = rows[0][-2]
+    elif mutation == "missing_header":
+        rows[0][-1] = "Not a required component"
+    elif mutation == "duplicate_row":
+        rows.append(rows[1])
+    elif mutation == "missing_row":
+        rows.pop()
+    elif mutation in {"extra_node", "extra_frame"}:
+        row = rows[1].copy()
+        if mutation == "extra_node":
+            row[2] = "1"
+        else:
+            row[0] = "Increment 101: Step Time = 10.1"
+        rows.append(row)
+    elif mutation == "time":
+        rows[1][0] = "Increment 0: Step Time = 0.0000000001"
+    elif mutation == "instance":
+        rows[1][1] = "WRONG-INSTANCE"
+    elif mutation == "label":
+        rows[1][2] = "2.0"
+    else:
+        rows[1][-1] = "nan"
+    reference = tmp_path / "changed.csv"
+    with reference.open("w", newline="", encoding="utf-8") as stream:
+        csv.writer(stream).writerows(rows)
+    report = comparator.compare(artifacts[0], reference, artifacts[2])
+    assert not report["precheck"]["passed"]
+    assert report["precheck"]["code"] == code, report["precheck"]
+    assert report["families"] == []
+
+
+def test_projection_joins_source_identity_and_csv_order_is_irrelevant(tmp_path, artifacts):
+    path = changed_result(tmp_path, artifacts)
+    with h5py.File(path, "r+") as file:
+        nodes = file["model/nodes"][:][::-1]
+        nodes["internal_node_id"] = np.arange(729, dtype="<u8")
+        file["model/nodes"][:] = nodes
+        for frame in range(101):
+            values = file[f"steps/Step-1/frames/{frame}/nodal/displacement"]
+            values[:] = values[:][::-1]
+    with artifacts[1].open(newline="", encoding="utf-8") as stream:
+        rows = list(csv.reader(stream))
+    reference = tmp_path / "reordered.csv"
+    with reference.open("w", newline="", encoding="utf-8") as stream:
+        csv.writer(stream).writerows([rows[0], *reversed(rows[1:])])
+    report = comparator.compare(artifacts[0], reference, path)
+    assert report["precheck"]["passed"], report["precheck"]
+    assert report["verdict"] == "passed"
+
+
+@pytest.mark.parametrize("component,passed", [(0, False), (3, True)])
+def test_translation_blocks_rotation_warns(tmp_path, artifacts, component, passed):
+    path = changed_result(tmp_path, artifacts)
+    with h5py.File(path, "r+") as file:
+        values = file["steps/Step-1/frames/1/nodal/displacement"]
+        rows = values[:]
+        rows[:, component:component + 3] *= 2.0
+        values[:] = rows
+    report = comparator.compare(artifacts[0], artifacts[1], path)
+    assert report["precheck"]["passed"]
+    assert report["blocking_passed"] is passed
+    assert len(report["warnings"]) == (2 if passed else 0)
+    if passed:
+        assert [warning["code"] for warning in report["warnings"]] == ["row-tolerance-failure", "relative-rms-failure"]
+    else:
+        assert report["blocking_failures"] == ["U-global:Step-1:increment-1"]
+
+
+def test_common_policy_boundaries_and_zero_scale():
+    near = comparator.evaluate_family(1, "U", [100.0, 2.0, 1.0], [100.0, 1.0, 0.0])
+    assert near["passed"]
+    assert [row["branch"] for row in near["rows"]] == ["relative", "near-zero", "near-zero"]
+    relative = comparator.evaluate_family(1, "U", [105.0], [100.0])
+    assert relative["rows_passed"] and not relative["rms_passed"]
+    boundary = comparator.evaluate_family(1, "U", [101.0], [100.0])
+    assert boundary["passed"]
+    assert boundary["relative_rms"] == 0.01
+    outside = comparator.evaluate_family(1, "U", [math.nextafter(101.0, math.inf)], [100.0])
+    assert outside["rows_passed"] and not outside["rms_passed"]
+    zero = comparator.evaluate_family(0, "U", [0.0], [0.0])
+    assert zero["passed"] and zero["relative_rms"] is None
+    nonzero = comparator.evaluate_family(0, "U", [1.0e-300], [0.0])
+    assert not nonzero["passed"]
+    assert nonzero["diagnostic_code"] == "zero-reference-scale-nonzero-error"
+    json.dumps(nonzero, allow_nan=False)
+    with pytest.raises(comparator.ComparisonError, match="U"):
+        comparator.evaluate_family(1, "U", [1.0e308], [-1.0e308])
+
+
+def test_cli_writes_json_and_exit_two_for_missing_results(tmp_path, artifacts):
+    report = tmp_path / "evidence.json"
+    completed = subprocess.run([sys.executable, "-B", str(Path(comparator.__file__)),
+        "--input", str(artifacts[0]), "--reference", str(artifacts[1]),
+        "--results", str(tmp_path / "absent.h5"), "--report", str(report)],
+        check=False, capture_output=True, text=True)
+    assert completed.returncode == 2, completed.stderr
+    evidence = json.loads(report.read_text())
+    assert not evidence["precheck"]["passed"]
+    assert evidence["families"] == []
diff --git a/tests/unit/analysis/dynamic_analysis_state_test.cpp b/tests/unit/analysis/dynamic_analysis_state_test.cpp
new file mode 100644
index 0000000..27eb739
--- /dev/null
+++ b/tests/unit/analysis/dynamic_analysis_state_test.cpp
@@ -0,0 +1,305 @@
+#include "fesa/analysis/dynamic_analysis_state.h"
+
+#include <gtest/gtest.h>
+
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <filesystem>
+#include <functional>
+#include <limits>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+#include "fesa/analysis/analysis_model.h"
+#include "fesa/fem/dof_manager.h"
+
+namespace {
+
+constexpr std::array<std::array<double, 3>, 3> kIdentityTriad{
+    std::array<double, 3>{1.0, 0.0, 0.0}, std::array<double, 3>{0.0, 1.0, 0.0},
+    std::array<double, 3>{0.0, 0.0, 1.0}};
+
+fesa::ModelDefinition MakeDefinition(const bool fixed = true) {
+  const std::filesystem::path source{"dynamic-state.inp"};
+  fesa::ModelDefinition definition{};
+  definition.source_path = source;
+  definition.source_content_identity = "hht-output-unit-fixture";
+  definition.nodes = {{{"Shell-A", 10, "0010"}, {0.0, 0.0, 0.0}, {source, 1U}},
+                      {{"Shell-A", 20, "20"}, {1.0, 0.0, 0.0}, {source, 2U}},
+                      {{"Shell-A", 30, "30"}, {1.0, 1.0, 0.0}, {source, 3U}},
+                      {{"Shell-A", 40, "40"}, {0.0, 1.0, 0.0}, {source, 4U}}};
+  definition.materials = {{"Material", 1000.0, 0.25, {source, 5U}}};
+  definition.densities = {{0U, 2.0, {source, 6U}}};
+  definition.shell_sections = {{"Shell", 0.1, 0U, {source, 7U}}};
+  definition.shell_elements = {{{"Shell-A", 9, "0009"},
+                                fesa::ShellSourceElementType::kS4,
+                                {0U, 1U, 2U, 3U},
+                                0U,
+                                0U,
+                                {source, 8U}}};
+  for (std::size_t node = 0U; node < 4U; ++node) {
+    definition.shell_node_initial_frames.push_back(
+        {static_cast<fesa::EntityIndex>(node),
+         {0.0, 0.0, 1.0},
+         {1.0, 0.0, 0.0},
+         {0.0, 1.0, 0.0}});
+  }
+  definition.node_sets = {{"All", std::nullopt, {0U, 1U, 2U, 3U}, {source, 9U}},
+                          {"Loaded", std::nullopt, {0U}, {source, 10U}}};
+  fesa::DynamicStepDefinition step{};
+  step.source_step_name_raw = "Transient Load";
+  step.source_step_name_canonical = "TRANSIENT LOAD";
+  step.initial_increment = 0.25;
+  step.time_period = 0.5;
+  step.increment_count = 2U;
+  step.maximum_increments = 3U;
+  if (fixed) {
+    step.boundaries = {{"All", 1, 6, 0.0, {source, 11U}}};
+    step.loads = {{"Loaded", 3, 4.0, {source, 12U}}};
+  }
+  definition.dynamic_step = step;
+  return definition;
+}
+
+struct Fixture {
+  std::unique_ptr<fesa::Domain> domain;
+  fesa::DynamicAnalysisState state;
+};
+
+Fixture MakeFixture(fesa::ModelDefinition definition = MakeDefinition()) {
+  auto domain_result = fesa::Domain::Create(std::move(definition));
+  if (!domain_result.HasValue())
+    throw std::runtime_error{"Invalid fixture Domain."};
+  auto domain =
+      std::make_unique<fesa::Domain>(std::move(domain_result.Value()));
+  auto model = fesa::AnalysisModel::Create(*domain);
+  if (!model.HasValue())
+    throw std::runtime_error{"Invalid fixture AnalysisModel."};
+  auto dofs = fesa::DofManager::Create(model.Value());
+  if (!dofs.HasValue()) throw std::runtime_error{"Invalid fixture DofManager."};
+  auto state = fesa::DynamicAnalysisState::Create(*domain, dofs.Value());
+  if (!state.HasValue()) throw std::runtime_error{"Invalid fixture state."};
+  return {std::move(domain), std::move(state.Value())};
+}
+
+// A fully restrained, initially undeformed shell under a dead nodal force has
+// zero motion and strain, and nonzero support force at every accepted endpoint.
+fesa::DynamicAcceptedFrameState MakeFrame(const fesa::Domain& domain,
+                                          const std::uint32_t index) {
+  fesa::DynamicAcceptedFrameState frame{};
+  frame.frame_index = index;
+  frame.increment_index = index;
+  frame.time = static_cast<double>(index) * domain.Dynamic()->initial_increment;
+  frame.is_initial = index == 0U;
+  for (std::size_t node = 0U; node < domain.Nodes().size(); ++node) {
+    frame.nodal_internal_order.push_back(static_cast<fesa::EntityIndex>(node));
+    frame.nodal_source_ids.push_back(domain.Nodes()[node].source_id);
+    frame.nodal_triad.push_back(kIdentityTriad);
+    frame.nodal_director.push_back({0.0, 0.0, 1.0});
+  }
+  for (auto* vector :
+       {&frame.generalized_coordinates, &frame.velocity, &frame.acceleration,
+        &frame.algorithmic_acceleration, &frame.inertia_force,
+        &frame.internal_force, &frame.external_force, &frame.residual,
+        &frame.reaction, &frame.residual_scale}) {
+    *vector = fesa::Vector{24U};
+  }
+  frame.angular_velocity = fesa::Vector{12U};
+  frame.angular_acceleration = fesa::Vector{12U};
+  if (!domain.Dynamic()->loads.empty()) {
+    frame.external_force[2U] = 4.0;
+    frame.residual[2U] = -4.0;
+    frame.reaction[2U] = -4.0;
+    frame.residual_scale[2U] = 4.0;
+  }
+  const double gauss = 1.0 / std::sqrt(3.0);
+  const std::array<std::array<double, 2>, 4> natural{
+      std::array<double, 2>{-gauss, -gauss},
+      {gauss, -gauss},
+      {gauss, gauss},
+      {-gauss, gauss}};
+  const std::array<fesa::ShellMidsurfaceLocation, 4> locations{
+      fesa::ShellMidsurfaceLocation::kGp1, fesa::ShellMidsurfaceLocation::kGp2,
+      fesa::ShellMidsurfaceLocation::kGp3, fesa::ShellMidsurfaceLocation::kGp4};
+  for (std::size_t point = 0U; point < 4U; ++point) {
+    frame.shell_results.push_back(
+        {0U,
+         locations[point],
+         natural[point],
+         kIdentityTriad,
+         {},
+         {},
+         {{{fesa::ShellSectionPosition::kBottom, -1.0, {}},
+           {fesa::ShellSectionPosition::kMiddle, 0.0, {}},
+           {fesa::ShellSectionPosition::kTop, 1.0, {}}}}});
+  }
+  return frame;
+}
+
+TEST(DynamicAnalysisState, DefaultStateRejectsTrialAndCommit) {
+  fesa::DynamicAnalysisState state;
+  EXPECT_FALSE(state.IsInitialized());
+  EXPECT_TRUE(state.AcceptedFrames().empty());
+  EXPECT_FALSE(state.BeginTrialFromCommitted().HasValue());
+  EXPECT_THROW((void)state.CommittedState(), std::logic_error);
+  const auto status = state.CommitAcceptedFrame({});
+  EXPECT_FALSE(status.IsOk());
+  ASSERT_EQ(status.Diagnostics().size(), 1U);
+  EXPECT_EQ(status.Diagnostics()[0U].code, "dynamic-invalid-state");
+}
+
+TEST(DynamicAnalysisState,
+     CommitsCompleteZeroCorrectionHistoryAndCopiesTrials) {
+  auto fixture = MakeFixture();
+  EXPECT_TRUE(fixture.state.IsInitialized());
+  EXPECT_FALSE(fixture.state.BeginTrialFromCommitted().HasValue());
+  for (std::uint32_t index = 0U; index <= 2U; ++index) {
+    auto frame = MakeFrame(*fixture.domain, index);
+    ASSERT_TRUE(fixture.state.CommitAcceptedFrame(frame).IsOk());
+    frame.reaction[2U] = 123.0;
+    EXPECT_DOUBLE_EQ(fixture.state.CommittedState().reaction[2U], -4.0);
+    EXPECT_EQ(fixture.state.AcceptedFrames().size(), index + 1U);
+  }
+  auto trial = fixture.state.BeginTrialFromCommitted();
+  ASSERT_TRUE(trial.HasValue());
+  trial.Value().generalized_coordinates[0U] = 1.0;
+  trial.Value().shell_results[0U].stress[0U].components[0U] = 1.0;
+  fixture.state.DiscardTrial();
+  EXPECT_DOUBLE_EQ(fixture.state.CommittedState().generalized_coordinates[0U],
+                   0.0);
+  EXPECT_DOUBLE_EQ(fixture.state.CommittedState()
+                       .shell_results[0U]
+                       .stress[0U]
+                       .components[0U],
+                   0.0);
+  EXPECT_DOUBLE_EQ(fixture.state.CommittedState().time, 0.5);
+  EXPECT_FALSE(
+      fixture.state.CommitAcceptedFrame(MakeFrame(*fixture.domain, 3U)).IsOk());
+  EXPECT_EQ(fixture.state.AcceptedFrames().size(), 3U);
+}
+
+TEST(DynamicAnalysisState,
+     RejectsMalformedInventoryScheduleAndPreservesEndpoint) {
+  auto fixture = MakeFixture();
+  ASSERT_TRUE(
+      fixture.state.CommitAcceptedFrame(MakeFrame(*fixture.domain, 0U)).IsOk());
+  using Frame = fesa::DynamicAcceptedFrameState;
+  const std::vector<std::function<void(Frame&)>> mutations{
+      [](Frame& frame) { frame.frame_index = 2U; },
+      [](Frame& frame) { frame.increment_index = 2U; },
+      [](Frame& frame) { frame.time = 0.26; },
+      [](Frame& frame) {
+        frame.time = std::numeric_limits<double>::quiet_NaN();
+      },
+      [](Frame& frame) { frame.is_initial = true; },
+      [](Frame& frame) { frame.iteration_count = 101U; },
+      [](Frame& frame) { frame.nodal_internal_order[1U] = 0U; },
+      [](Frame& frame) {
+        frame.nodal_source_ids[1U].source_label_text = "wrong";
+      },
+      [](Frame& frame) { frame.nodal_triad.pop_back(); },
+      [](Frame& frame) {
+        frame.nodal_director[0U][2U] = std::numeric_limits<double>::infinity();
+      },
+      [](Frame& frame) { frame.acceleration = fesa::Vector{23U}; },
+      [](Frame& frame) { frame.velocity[0U] = 1.0; },
+      [](Frame& frame) { frame.acceleration[0U] = 1.0; },
+      [](Frame& frame) { frame.algorithmic_acceleration[0U] = 1.0; },
+      [](Frame& frame) { frame.generalized_coordinates[0U] = 1.0; },
+      [](Frame& frame) { frame.reaction[2U] = 0.0; },
+      [](Frame& frame) { frame.residual[2U] = 0.0; },
+      [](Frame& frame) { frame.residual_scale[0U] = -1.0; },
+      [](Frame& frame) {
+        frame.external_force[0U] = 1.0;
+        frame.residual[0U] = -1.0;
+        frame.reaction[0U] = -1.0;
+      },
+      [](Frame& frame) { frame.shell_results.pop_back(); },
+      [](Frame& frame) { frame.shell_results[0U].element = 1U; },
+      [](Frame& frame) {
+        frame.shell_results[0U].natural_coordinates[0U] = 0.0;
+      },
+      [](Frame& frame) { frame.shell_results[0U].stress[0U].zeta = 0.0; },
+      [](Frame& frame) {
+        frame.shell_results[0U].stress[0U].components[0U] =
+            std::numeric_limits<double>::quiet_NaN();
+      },
+      [](Frame& frame) {
+        frame.kinetic_energy = std::numeric_limits<double>::infinity();
+      },
+      [](Frame& frame) {
+        frame.angular_momentum_rate[0U] =
+            std::numeric_limits<double>::quiet_NaN();
+      },
+      [](Frame& frame) { frame.hidden_constraint = fesa::Vector{1U}; },
+      [](Frame& frame) { frame.free_residual_metrics[0U] = -1.0; }};
+  for (std::size_t index = 0U; index < mutations.size(); ++index) {
+    SCOPED_TRACE(index);
+    auto frame = MakeFrame(*fixture.domain, 1U);
+    mutations[index](frame);
+    const auto status = fixture.state.CommitAcceptedFrame(frame);
+    ASSERT_FALSE(status.IsOk());
+    ASSERT_EQ(status.Diagnostics().size(), 1U);
+    EXPECT_EQ(status.Diagnostics()[0U].code, "dynamic-invalid-state");
+    ASSERT_EQ(fixture.state.AcceptedFrames().size(), 1U);
+    EXPECT_DOUBLE_EQ(fixture.state.CommittedState().time, 0.0);
+    EXPECT_DOUBLE_EQ(fixture.state.CommittedState().reaction[2U], -4.0);
+  }
+  EXPECT_TRUE(
+      fixture.state.CommitAcceptedFrame(MakeFrame(*fixture.domain, 1U)).IsOk());
+}
+
+TEST(DynamicAnalysisState, RejectsInvalidInitialStateAndFreeReaction) {
+  auto fixture = MakeFixture(MakeDefinition(false));
+  auto initial = MakeFrame(*fixture.domain, 0U);
+  initial.generalized_coordinates[0U] = 1.0;
+  EXPECT_FALSE(fixture.state.CommitAcceptedFrame(initial).IsOk());
+  initial = MakeFrame(*fixture.domain, 0U);
+  initial.acceleration[0U] = 1.0;
+  EXPECT_FALSE(fixture.state.CommitAcceptedFrame(initial).IsOk());
+  initial = MakeFrame(*fixture.domain, 0U);
+  initial.time = -0.0;
+  EXPECT_FALSE(fixture.state.CommitAcceptedFrame(initial).IsOk());
+  initial = MakeFrame(*fixture.domain, 0U);
+  initial.reaction[0U] = 1.0;
+  EXPECT_FALSE(fixture.state.CommitAcceptedFrame(initial).IsOk());
+  EXPECT_TRUE(fixture.state.AcceptedFrames().empty());
+  EXPECT_TRUE(
+      fixture.state.CommitAcceptedFrame(MakeFrame(*fixture.domain, 0U)).IsOk());
+}
+
+TEST(DynamicAnalysisState, CreateRejectsInvalidScheduleAndNonzeroBoundary) {
+  const std::vector<std::function<void(fesa::ModelDefinition&)>> mutations{
+      [](auto& definition) { definition.dynamic_step->increment_count = 0U; },
+      [](auto& definition) { definition.dynamic_step->time_period = 0.6; },
+      [](auto& definition) {
+        definition.dynamic_step->maximum_increments = 1U;
+      },
+      [](auto& definition) {
+        definition.dynamic_step->initial_increment =
+            std::numeric_limits<double>::quiet_NaN();
+      },
+      [](auto& definition) {
+        definition.dynamic_step->boundaries[0U].value = 1.0;
+      }};
+  for (std::size_t index = 0U; index < mutations.size(); ++index) {
+    SCOPED_TRACE(index);
+    auto definition = MakeDefinition();
+    mutations[index](definition);
+    auto domain = fesa::Domain::Create(std::move(definition));
+    ASSERT_TRUE(domain.HasValue());
+    auto model = fesa::AnalysisModel::Create(domain.Value());
+    ASSERT_TRUE(model.HasValue());
+    auto dofs = fesa::DofManager::Create(model.Value());
+    ASSERT_TRUE(dofs.HasValue());
+    EXPECT_FALSE(
+        fesa::DynamicAnalysisState::Create(domain.Value(), dofs.Value())
+            .HasValue());
+  }
+}
+
+}  // namespace
diff --git a/tests/unit/analysis/hht_dynamic_algebra_test.cpp b/tests/unit/analysis/hht_dynamic_algebra_test.cpp
new file mode 100644
index 0000000..98cc5c3
--- /dev/null
+++ b/tests/unit/analysis/hht_dynamic_algebra_test.cpp
@@ -0,0 +1,330 @@
+#include <gtest/gtest.h>
+
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+#include "analysis/hht_dynamic_internal.h"
+#include "fesa/analysis/analysis_model.h"
+#include "fesa/math/matrix.h"
+#include "fesa/solvers/linear/mkl_pardiso_solver.h"
+#include "fesa/solvers/linear/mkl_pardiso_tangent_solver.h"
+
+namespace {
+
+struct Fixture {
+  std::unique_ptr<fesa::Domain> domain;
+  fesa::DofManager dofs;
+};
+
+Fixture MakeFixture(const std::size_t free_nodes = 1U,
+                    const bool partial_rotation = false,
+                    const bool translations_free = true) {
+  fesa::ModelDefinition definition{};
+  definition.source_path = "hht-algebra.inp";
+  definition.nodes = {
+      {{"Plate", 1, "1"}, {-1, -1, 0}, {definition.source_path, 1U}},
+      {{"Plate", 2, "2"}, {1, -1, 0}, {definition.source_path, 2U}},
+      {{"Plate", 3, "3"}, {1, 1, 0}, {definition.source_path, 3U}},
+      {{"Plate", 4, "4"}, {-1, 1, 0}, {definition.source_path, 4U}}};
+  definition.materials = {{"Elastic", 1000, 0.3, {definition.source_path, 5U}}};
+  definition.densities = {{0U, 1.0, {definition.source_path, 6U}}};
+  definition.shell_sections = {
+      {"Plate", 0.2, 0U, {definition.source_path, 7U}}};
+  definition.shell_elements = {{{"Plate", 1, "1"},
+                                fesa::ShellSourceElementType::kS4,
+                                {0U, 1U, 2U, 3U},
+                                0U,
+                                0U,
+                                {definition.source_path, 8U}}};
+  fesa::DynamicStepDefinition step{};
+  step.source_step_name_raw = "Dynamic";
+  step.source_step_name_canonical = "DYNAMIC";
+  step.initial_increment = 0.1;
+  step.time_period = 0.1;
+  step.increment_count = 1U;
+  step.maximum_increments = 1U;
+  for (std::size_t i = 0; i < 4; ++i) {
+    definition.shell_node_initial_frames.push_back(
+        {static_cast<fesa::EntityIndex>(i), {0, 0, 1}, {1, 0, 0}, {0, 1, 0}});
+    const std::string name = "Node" + std::to_string(i);
+    definition.node_sets.push_back({name,
+                                    std::nullopt,
+                                    {static_cast<fesa::EntityIndex>(i)},
+                                    {definition.source_path, 9U}});
+    if (i >= free_nodes) {
+      step.boundaries.push_back(
+          {name, 1, 6, 0.0, {definition.source_path, 10U}});
+    } else {
+      if (partial_rotation)
+        step.boundaries.push_back(
+            {name, 4, 5, 0.0, {definition.source_path, 10U}});
+      if (!translations_free)
+        step.boundaries.push_back(
+            {name, 1, 3, 0.0, {definition.source_path, 10U}});
+    }
+  }
+  definition.dynamic_step = step;
+  auto result = fesa::Domain::Create(std::move(definition));
+  if (!result.HasValue()) throw std::runtime_error{"Invalid algebra domain."};
+  auto domain = std::make_unique<fesa::Domain>(std::move(result.Value()));
+  auto model = fesa::AnalysisModel::Create(*domain);
+  if (!model.HasValue()) throw std::runtime_error{"Invalid algebra model."};
+  auto dofs = fesa::DofManager::Create(model.Value());
+  if (!dofs.HasValue()) throw std::runtime_error{"Invalid algebra DOFs."};
+  return {std::move(domain), std::move(dofs.Value())};
+}
+
+fesa::SparseMatrix Sparse(const fesa::Matrix& matrix) {
+  std::vector<fesa::CooContribution> entries;
+  for (std::size_t i = 0; i < matrix.Rows(); ++i) {
+    for (std::size_t j = 0; j < matrix.Columns(); ++j) {
+      entries.push_back({i, j, matrix(i, j), 0U, entries.size()});
+    }
+  }
+  auto result = fesa::hht_internal::MakeSparse(matrix.Rows(), matrix.Columns(),
+                                               std::move(entries));
+  EXPECT_TRUE(result.HasValue());
+  return std::move(result.Value());
+}
+
+fesa::hht_internal::DynamicAssembly Assembly(
+    const double second_stiffness = 3.0, const double mass_scale = 1.0) {
+  fesa::DynamicAcceptedFrameState frame;
+  frame.is_initial = true;
+  for (auto* vector :
+       {&frame.generalized_coordinates, &frame.velocity, &frame.acceleration,
+        &frame.algorithmic_acceleration, &frame.inertia_force,
+        &frame.internal_force, &frame.external_force, &frame.residual,
+        &frame.residual_scale})
+    *vector = fesa::Vector{24U};
+  frame.external_force[0] = 2.0;
+  frame.residual_scale[0] = 2.0;
+  fesa::Matrix mass{24U, 24U};
+  fesa::Matrix stiffness{24U, 24U};
+  fesa::Matrix metric{24U, 24U};
+  std::vector<fesa::DynamicRotationKinematics> rotations;
+  for (std::size_t i = 0; i < 4; ++i) {
+    const std::size_t base = 6U * i;
+    for (std::size_t j = 0; j < 5; ++j)
+      mass(base + j, base + j) = mass_scale * (j < 3U ? 2.0 : 1.0);
+    const double k = i == 1U ? second_stiffness : 3.0;
+    stiffness(base, base) = 8.0 + k * 0.7 * 0.7;
+    stiffness(base, base + 5U) = -0.7 * k;
+    stiffness(base + 5U, base) = -0.7 * k;
+    stiffness(base + 5U, base + 5U) = k;
+    metric(base + 5U, base + 5U) = 3.0;
+    auto rotation = fesa::EvaluateDynamicRotation({}, {0, 0, 1}, {}, {});
+    EXPECT_TRUE(rotation.HasValue());
+    rotations.push_back(std::move(rotation.Value()));
+  }
+  return {std::move(frame),
+          Sparse(mass),
+          Sparse(stiffness),
+          Sparse(stiffness),
+          Sparse(metric),
+          fesa::Vector{24U},
+          fesa::Vector{24U},
+          std::move(rotations),
+          0.0,
+          0.0,
+          fesa::Vector{4U},
+          fesa::Vector{4U}};
+}
+
+TEST(HhtDynamicAlgebra,
+     InitializesCoupledMasslessAccelerationFromHiddenEquation) {
+  const auto fixture = MakeFixture();
+  auto assembly = Assembly();
+  fesa::MklPardisoSolver positive;
+  fesa::MklPardisoTangentSolver tangent;
+  const auto acceleration = fesa::hht_internal::InitializeAcceleration(
+      *fixture.domain, fixture.dofs, assembly, 2.0, positive, tangent);
+  ASSERT_TRUE(acceleration.HasValue());
+  EXPECT_NEAR(acceleration.Value()[0], 1.0, 1.0e-12);
+  EXPECT_NEAR(acceleration.Value()[5], 0.7, 1.0e-12);
+  for (const auto full : fixture.dofs.ConstrainedDofs())
+    EXPECT_EQ(acceleration.Value()[full], 0.0);
+  const auto nodes =
+      fesa::hht_internal::NullNodes(fixture.dofs, assembly.rotations);
+  ASSERT_EQ(nodes, std::vector<std::size_t>{0U});
+  assembly.frame.acceleration = acceleration.Value();
+  auto frame = assembly.frame;
+  EXPECT_TRUE(fesa::hht_internal::CompleteConstraintEvidence(
+                  *fixture.domain, fixture.dofs, assembly, 2.0, nodes, positive,
+                  tangent, &frame)
+                  .IsOk());
+  ASSERT_EQ(frame.hidden_acceleration_defect.Size(), 1U);
+  EXPECT_NEAR(frame.hidden_acceleration_defect[0], 0.0, 1.0e-12);
+  EXPECT_GT(frame.hidden_acceleration_defect_scale[0], 0.0);
+  frame.acceleration[5] = 0.0;
+  const auto pseudoinverse = fesa::hht_internal::CompleteConstraintEvidence(
+      *fixture.domain, fixture.dofs, assembly, 2.0, nodes, positive, tangent,
+      &frame);
+  EXPECT_FALSE(pseudoinverse.IsOk());
+}
+
+TEST(HhtDynamicAlgebra, ChecksInitialConstraintAndVelocityWithoutRepair) {
+  const auto fixture = MakeFixture();
+  fesa::MklPardisoSolver positive;
+  fesa::MklPardisoTangentSolver tangent;
+  auto inconsistent = Assembly();
+  inconsistent.frame.internal_force[5] = 0.3;
+  inconsistent.frame.residual_scale[5] = 0.3;
+  EXPECT_FALSE(
+      fesa::hht_internal::InitializeAcceleration(
+          *fixture.domain, fixture.dofs, inconsistent, 2.0, positive, tangent)
+          .HasValue());
+  inconsistent = Assembly();
+  inconsistent.frame.velocity[5] = 0.1;
+  EXPECT_FALSE(
+      fesa::hht_internal::InitializeAcceleration(
+          *fixture.domain, fixture.dofs, inconsistent, 2.0, positive, tangent)
+          .HasValue());
+}
+
+TEST(HhtDynamicAlgebra, KeepsAcceptedHiddenRateDefectsAsDiagnostics) {
+  const auto fixture = MakeFixture();
+  auto assembly = Assembly();
+  assembly.frame.is_initial = false;
+  assembly.frame.velocity[5] = 0.1;
+  assembly.frame.acceleration[5] = -0.2;
+  auto frame = assembly.frame;
+  fesa::MklPardisoSolver positive;
+  fesa::MklPardisoTangentSolver tangent;
+  const auto nodes =
+      fesa::hht_internal::NullNodes(fixture.dofs, assembly.rotations);
+  const auto result = fesa::hht_internal::CompleteConstraintEvidence(
+      *fixture.domain, fixture.dofs, assembly, 2.0, nodes, positive, tangent,
+      &frame);
+  ASSERT_TRUE(result.IsOk());
+  EXPECT_NEAR(frame.hidden_velocity_defect[0], 0.3, 1.0e-12);
+  EXPECT_NEAR(frame.hidden_acceleration_defect[0], -0.6, 1.0e-12);
+}
+
+TEST(HhtDynamicAlgebra, RejectsNegativePhysicalMassAndAlgebraicRankLoss) {
+  const auto fixture = MakeFixture(2U);
+  fesa::MklPardisoSolver positive;
+  fesa::MklPardisoTangentSolver tangent;
+  const auto negative = Assembly(3.0, -1.0);
+  EXPECT_FALSE(
+      fesa::hht_internal::InitializeAcceleration(
+          *fixture.domain, fixture.dofs, negative, 2.0, positive, tangent)
+          .HasValue());
+  const auto singular = Assembly(0.0);
+  EXPECT_FALSE(
+      fesa::hht_internal::InitializeAcceleration(
+          *fixture.domain, fixture.dofs, singular, 2.0, positive, tangent)
+          .HasValue());
+}
+
+TEST(HhtDynamicAlgebra, AppliesTheExactRegularityConditionBoundary) {
+  const auto fixture = MakeFixture(2U);
+  fesa::MklPardisoSolver positive;
+  fesa::MklPardisoTangentSolver tangent;
+  for (const int exponent : {31, 32, 33}) {
+    auto assembly = Assembly();
+    // The boundary oracle is exactly diag(1,c), with W=I. Avoid a rounded
+    // sqrt(3) congruence when testing a binary-exact inclusive threshold.
+    fesa::Matrix stiffness{24U, 24U};
+    fesa::Matrix metric{24U, 24U};
+    for (std::size_t node = 0; node < 4; ++node) {
+      const std::size_t drill = 6U * node + 5U;
+      stiffness(drill, drill) = node == 1U ? std::ldexp(1.0, -exponent) : 1.0;
+      metric(drill, drill) = 1.0;
+    }
+    assembly.internal_tangent = Sparse(stiffness);
+    assembly.drilling_metric = Sparse(metric);
+    const auto result = fesa::hht_internal::InitializeAcceleration(
+        *fixture.domain, fixture.dofs, assembly, 2.0, positive, tangent);
+    EXPECT_EQ(result.HasValue(), exponent <= 32)
+        << exponent
+        << (result.HasValue() ? ""
+                              : result.GetStatus().Diagnostics()[0].message);
+    if (exponent == 33) {
+      ASSERT_FALSE(result.HasValue());
+      EXPECT_EQ(result.GetStatus().Diagnostics()[0].code,
+                "dynamic-algebraic-conditioning");
+    }
+  }
+}
+
+TEST(HhtDynamicAlgebra, AllFixedModelHasAnEmptyValidAccelerationSolve) {
+  const auto fixture = MakeFixture(0U);
+  auto assembly = Assembly();
+  fesa::MklPardisoSolver positive;
+  fesa::MklPardisoTangentSolver tangent;
+  const auto result = fesa::hht_internal::InitializeAcceleration(
+      *fixture.domain, fixture.dofs, assembly, 2.0, positive, tangent);
+  ASSERT_TRUE(result.HasValue());
+  EXPECT_EQ(result.Value().Norm(), 0.0);
+  auto frame = assembly.frame;
+  EXPECT_TRUE(fesa::hht_internal::CompleteConstraintEvidence(
+                  *fixture.domain, fixture.dofs, assembly, 2.0, {}, positive,
+                  tangent, &frame)
+                  .IsOk());
+  EXPECT_EQ(frame.hidden_constraint.Size(), 0U);
+}
+
+TEST(HhtDynamicAlgebra, PartialBoundaryRetainsEveryNonzeroPhysicalDirection) {
+  for (const bool translations_free : {false, true}) {
+    const auto fixture = MakeFixture(1U, true, translations_free);
+    for (const double p : {0.0, 1.0 / 2000.0, 1.0e-8}) {
+      auto assembly = Assembly();
+      assembly.frame.external_force[0] = 0.0;
+      fesa::Matrix mass{24U, 24U};
+      const double nz = std::sqrt(1.0 - p * p);
+      for (std::size_t node = 0; node < 4; ++node) {
+        for (std::size_t j = 0; j < 3; ++j)
+          mass(6U * node + j, 6U * node + j) = 2.0;
+        mass(6U * node + 3U, 6U * node + 3U) = nz * nz;
+        mass(6U * node + 4U, 6U * node + 4U) = 1.0;
+        mass(6U * node + 5U, 6U * node + 5U) = p * p;
+        mass(6U * node + 3U, 6U * node + 5U) = -p * nz;
+        mass(6U * node + 5U, 6U * node + 3U) = -p * nz;
+        assembly.rotations[node].drill_null = {p, 0, nz};
+      }
+      assembly.mass = Sparse(mass);
+      const auto nodes =
+          fesa::hht_internal::NullNodes(fixture.dofs, assembly.rotations);
+      EXPECT_EQ(nodes.size(), p == 0.0 ? 1U : 0U);
+      fesa::MklPardisoSolver positive;
+      fesa::MklPardisoTangentSolver tangent;
+      const auto result = fesa::hht_internal::InitializeAcceleration(
+          *fixture.domain, fixture.dofs, assembly, 2.0, positive, tangent);
+      const bool expected = !(translations_free && p == 1.0e-8);
+      EXPECT_EQ(result.HasValue(), expected) << "p=" << p;
+      if (!expected) {
+        ASSERT_FALSE(result.HasValue());
+        EXPECT_EQ(result.GetStatus().Diagnostics()[0].code,
+                  "dynamic-positive-mass-conditioning");
+      }
+    }
+  }
+}
+
+TEST(HhtDynamicAlgebra, RejectsAdmissibleNullRankChangeBeforeAcceptingFrame) {
+  const auto fixture = MakeFixture(1U, true);
+  auto assembly = Assembly();
+  const auto initial_nodes =
+      fesa::hht_internal::NullNodes(fixture.dofs, assembly.rotations);
+  ASSERT_EQ(initial_nodes.size(), 1U);
+  assembly.rotations[0].drill_null = {1.0e-8, 0, std::sqrt(1.0 - 1.0e-16)};
+  auto frame = assembly.frame;
+  frame.hidden_constraint = fesa::Vector{1U, 23.0};
+  fesa::MklPardisoSolver positive;
+  fesa::MklPardisoTangentSolver tangent;
+  const auto result = fesa::hht_internal::CompleteConstraintEvidence(
+      *fixture.domain, fixture.dofs, assembly, 2.0, initial_nodes, positive,
+      tangent, &frame);
+  ASSERT_FALSE(result.IsOk());
+  EXPECT_EQ(result.Diagnostics()[0].code, "dynamic-mass-null-rank-change");
+  EXPECT_EQ(frame.hidden_constraint[0], 23.0);
+}
+
+}  // namespace
diff --git a/tests/unit/analysis/hht_dynamic_procedure_test.cpp b/tests/unit/analysis/hht_dynamic_procedure_test.cpp
new file mode 100644
index 0000000..f72ba56
--- /dev/null
+++ b/tests/unit/analysis/hht_dynamic_procedure_test.cpp
@@ -0,0 +1,125 @@
+#include "fesa/analysis/hht_dynamic_procedure.h"
+
+#include <gtest/gtest.h>
+
+#include <filesystem>
+#include <optional>
+
+#include "fesa/analysis/newton_iteration_log.h"
+#include "fesa/assembly/parallel_for.h"
+#include "fesa/solvers/linear/mkl_pardiso_solver.h"
+#include "fesa/solvers/linear/mkl_pardiso_tangent_solver.h"
+namespace {
+fesa::ModelDefinition MakeDefinition(const bool fixed = true) {
+  const std::filesystem::path source{"dynamic-state.inp"};
+  fesa::ModelDefinition definition{};
+  definition.source_path = source;
+  definition.source_content_identity = "hht-output-unit-fixture";
+  definition.nodes = {{{"Shell-A", 10, "0010"}, {0.0, 0.0, 0.0}, {source, 1U}},
+                      {{"Shell-A", 20, "20"}, {1.0, 0.0, 0.0}, {source, 2U}},
+                      {{"Shell-A", 30, "30"}, {1.0, 1.0, 0.0}, {source, 3U}},
+                      {{"Shell-A", 40, "40"}, {0.0, 1.0, 0.0}, {source, 4U}}};
+  definition.materials = {{"Material", 1000.0, 0.25, {source, 5U}}};
+  definition.densities = {{0U, 2.0, {source, 6U}}};
+  definition.shell_sections = {{"Shell", 0.1, 0U, {source, 7U}}};
+  definition.shell_elements = {{{"Shell-A", 9, "0009"},
+                                fesa::ShellSourceElementType::kS4,
+                                {0U, 1U, 2U, 3U},
+                                0U,
+                                0U,
+                                {source, 8U}}};
+  for (std::size_t node = 0U; node < 4U; ++node) {
+    definition.shell_node_initial_frames.push_back(
+        {static_cast<fesa::EntityIndex>(node),
+         {0.0, 0.0, 1.0},
+         {1.0, 0.0, 0.0},
+         {0.0, 1.0, 0.0}});
+  }
+  definition.node_sets = {{"All", std::nullopt, {0U, 1U, 2U, 3U}, {source, 9U}},
+                          {"Loaded", std::nullopt, {0U}, {source, 10U}}};
+  fesa::DynamicStepDefinition step{};
+  step.source_step_name_raw = "Transient Load";
+  step.source_step_name_canonical = "TRANSIENT LOAD";
+  step.initial_increment = 0.25;
+  step.time_period = 0.5;
+  step.increment_count = 2U;
+  step.maximum_increments = 3U;
+  if (fixed) {
+    step.boundaries = {{"All", 1, 6, 0.0, {source, 11U}}};
+    step.loads = {{"Loaded", 3, 4.0, {source, 12U}}};
+  }
+  definition.dynamic_step = step;
+  return definition;
+}
+
+TEST(HhtDynamicProcedure, ClampedStepLoadHasPhysicalReactionAndZeroMotion) {
+  auto domain = fesa::Domain::Create(MakeDefinition());
+  ASSERT_TRUE(domain.HasValue());
+  fesa::SerialParallelFor parallel;
+  fesa::MklPardisoSolver mass;
+  fesa::MklPardisoTangentSolver tangent;
+  fesa::NewtonIterationLogWriter log;
+  const auto path =
+      std::filesystem::temp_directory_path() / "fesa-hht-clamped.log";
+  ASSERT_TRUE(log.Open(path).IsOk());
+  const fesa::HhtDynamicProcedureExecutor executor(parallel, mass, tangent);
+  auto result = executor.Execute(domain.Value(), log);
+  ASSERT_TRUE(log.Close().IsOk());
+  std::filesystem::remove(path);
+  ASSERT_TRUE(result.HasValue())
+      << (result.HasValue() ? ""
+                            : result.GetStatus().Diagnostics().front().message);
+  ASSERT_EQ(result.Value().state.AcceptedFrames().size(), 3U);
+  for (const auto& frame : result.Value().state.AcceptedFrames()) {
+    EXPECT_EQ(frame.iteration_count, 0U);
+    EXPECT_DOUBLE_EQ(frame.reaction[2U], -4.0);
+    EXPECT_DOUBLE_EQ(frame.external_force[2U], 4.0);
+    EXPECT_DOUBLE_EQ(frame.kinetic_energy, 0.0);
+    EXPECT_DOUBLE_EQ(frame.energy_defect, 0.0);
+    for (std::size_t i = 0; i < 24U; ++i) {
+      EXPECT_DOUBLE_EQ(frame.generalized_coordinates[i], 0.0);
+      EXPECT_DOUBLE_EQ(frame.acceleration[i], 0.0);
+    }
+  }
+}
+
+TEST(HhtDynamicProcedure, LargeDirectStepStartsFromAcceptedGeometry) {
+  auto definition = MakeDefinition(false);
+  definition.materials[0U].youngs_modulus = 1e9;
+  definition.dynamic_step->increment_count = 1U;
+  definition.dynamic_step->time_period =
+      definition.dynamic_step->initial_increment;
+  definition.node_sets[0U].node_indices = {0U, 3U};
+  definition.node_sets[1U].node_indices = {2U};
+  definition.dynamic_step->boundaries = {
+      {"All", 1, 6, 0.0, {"dynamic-state.inp", 11U}}};
+  definition.dynamic_step->loads = {
+      {"Loaded", 3, -40000.0, {"dynamic-state.inp", 12U}}};
+  auto domain = fesa::Domain::Create(std::move(definition));
+  ASSERT_TRUE(domain.HasValue());
+  fesa::SerialParallelFor parallel;
+  fesa::MklPardisoSolver mass;
+  fesa::MklPardisoTangentSolver tangent;
+  fesa::NewtonIterationLogWriter log;
+  const auto path =
+      std::filesystem::temp_directory_path() / "fesa-hht-large-direct.log";
+  ASSERT_TRUE(log.Open(path).IsOk());
+  auto result = fesa::HhtDynamicProcedureExecutor(parallel, mass, tangent)
+                    .Execute(domain.Value(), log);
+  ASSERT_TRUE(log.Close().IsOk());
+  ASSERT_TRUE(result.HasValue())
+      << (result.HasValue() ? ""
+                            : result.GetStatus().Diagnostics().front().message);
+  EXPECT_GT(
+      std::abs(result.Value().state.AcceptedFrames()[0U].acceleration[14U]),
+      1e5);
+  EXPECT_LT(result.Value().state.CommittedState().generalized_coordinates[14U],
+            0.0);
+  for (double metric :
+       result.Value().state.CommittedState().free_residual_metrics)
+    EXPECT_LE(metric, 1e-10);
+  EXPECT_GT(result.Value().state.CommittedState().iteration_count, 0U);
+  std::filesystem::remove(path);
+}
+
+}  // namespace
diff --git a/tests/unit/analysis/hht_energy_verification_test.cpp b/tests/unit/analysis/hht_energy_verification_test.cpp
new file mode 100644
index 0000000..2726693
--- /dev/null
+++ b/tests/unit/analysis/hht_energy_verification_test.cpp
@@ -0,0 +1,223 @@
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <complex>
+#include <cstddef>
+#include <iostream>
+#include <stdexcept>
+
+#include "fesa/analysis/hht_time_integration.h"
+
+namespace {
+
+struct Oscillator {
+  fesa::Vector q{1U};
+  fesa::Vector v{1U};
+  fesa::Vector a{1U};
+  fesa::Vector auxiliary{1U};
+};
+
+void Advance(Oscillator* state, const double mass, const double stiffness,
+             const double force, const double h,
+             const fesa::HhtParameters& parameters) {
+  const auto predictor =
+      fesa::PredictHht(state->q, state->v, state->auxiliary, h, parameters);
+  if (!predictor.HasValue())
+    throw std::runtime_error{"Invalid oscillator predictor."};
+  fesa::Vector q{1U};
+  q[0] =
+      (mass * predictor.Value().coordinates[0] +
+       parameters.beta * h * h *
+           ((1.0 + parameters.alpha) * force -
+            mass * parameters.alpha * state->a[0])) /
+      (mass + (1.0 + parameters.alpha) * stiffness * parameters.beta * h * h);
+  const auto rates =
+      fesa::EvaluateHhtRates(q, predictor.Value(), state->a, h, parameters);
+  if (!rates.HasValue()) throw std::runtime_error{"Invalid oscillator rates."};
+  state->q = q;
+  state->v = rates.Value().velocity;
+  state->a = rates.Value().acceleration;
+  state->auxiliary = rates.Value().algorithmic_acceleration;
+}
+
+using Matrix3 = std::array<std::array<double, 3>, 3>;
+
+Matrix3 Amplification(const double frequency_step, const double alpha) {
+  // Independent dimensionless recurrence in (q,h*v,h^2*A), with m=1.
+  const double beta = (1.0 - alpha) * (1.0 - alpha) / 4.0;
+  const double gamma = 0.5 - alpha;
+  const double stiffness = frequency_step * frequency_step;
+  Matrix3 matrix{};
+  for (std::size_t column = 0; column < 3; ++column) {
+    const double q = column == 0U ? 1.0 : 0.0;
+    const double velocity = column == 1U ? 1.0 : 0.0;
+    const double auxiliary = column == 2U ? 1.0 : 0.0;
+    const double predictor = q + velocity + (0.5 - beta) * auxiliary;
+    const double next_auxiliary =
+        (-(1.0 + alpha) * stiffness * predictor + alpha * stiffness * q) /
+        (1.0 + (1.0 + alpha) * stiffness * beta);
+    matrix[0][column] = predictor + beta * next_auxiliary;
+    matrix[1][column] =
+        velocity + (1.0 - gamma) * auxiliary + gamma * next_auxiliary;
+    matrix[2][column] = next_auxiliary;
+  }
+  return matrix;
+}
+
+std::array<std::complex<double>, 3> Eigenvalues(const Matrix3& matrix) {
+  const double trace = matrix[0][0] + matrix[1][1] + matrix[2][2];
+  const double second =
+      matrix[0][0] * matrix[1][1] + matrix[0][0] * matrix[2][2] +
+      matrix[1][1] * matrix[2][2] - matrix[0][1] * matrix[1][0] -
+      matrix[0][2] * matrix[2][0] - matrix[1][2] * matrix[2][1];
+  const double determinant =
+      matrix[0][0] *
+          (matrix[1][1] * matrix[2][2] - matrix[1][2] * matrix[2][1]) -
+      matrix[0][1] *
+          (matrix[1][0] * matrix[2][2] - matrix[1][2] * matrix[2][0]) +
+      matrix[0][2] *
+          (matrix[1][0] * matrix[2][1] - matrix[1][1] * matrix[2][0]);
+  if (determinant == 0.0) {
+    const auto discriminant =
+        std::sqrt(std::complex<double>{trace * trace - 4.0 * second, 0.0});
+    return {std::complex<double>{0.0, 0.0}, 0.5 * (trace + discriminant),
+            0.5 * (trace - discriminant)};
+  }
+  std::array<std::complex<double>, 3> roots{
+      std::complex<double>{1.1, 0.0}, {-0.6, 0.9}, {-0.6, -0.9}};
+  bool converged = false;
+  for (std::size_t iteration = 0; iteration < 500U; ++iteration) {
+    const auto previous = roots;
+    double change = 0.0;
+    for (std::size_t i = 0; i < 3; ++i) {
+      const auto value =
+          ((previous[i] - trace) * previous[i] + second) * previous[i] -
+          determinant;
+      const auto denominator = (previous[i] - previous[(i + 1U) % 3U]) *
+                               (previous[i] - previous[(i + 2U) % 3U]);
+      roots[i] = previous[i] - value / denominator;
+      change = std::max(change, std::abs(roots[i] - previous[i]));
+    }
+    if (change <= 1.0e-13) {
+      converged = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(converged);
+  for (const auto root : roots) {
+    const double numerator =
+        std::abs(((root - trace) * root + second) * root - determinant);
+    const double scale =
+        std::pow(std::abs(root), 3) + std::abs(trace) * std::norm(root) +
+        std::abs(second) * std::abs(root) + std::abs(determinant);
+    EXPECT_LE(scale > 0.0 ? numerator / scale : numerator, 1.0e-12);
+  }
+  return roots;
+}
+
+TEST(HhtEnergyVerification, C07AlphaZeroConservesLinearOscillatorEnergy) {
+  const auto parameters = fesa::MakeHhtParameters(0.0);
+  ASSERT_TRUE(parameters.HasValue());
+  Oscillator state;
+  state.q[0] = 1.0;
+  state.a[0] = -4.0;
+  state.auxiliary = state.a;
+  double maximum = 0.0;
+  for (std::size_t step = 0; step < 640U; ++step) {
+    Advance(&state, 1.0, 4.0, 0.0, 1.0 / 64.0, parameters.Value());
+    const double energy =
+        0.5 * state.v[0] * state.v[0] + 2.0 * state.q[0] * state.q[0];
+    maximum = std::max(maximum, std::abs(energy - 2.0) / 2.0);
+  }
+  std::cout << "C07 alpha0 max energy defect=" << maximum << '\n';
+  EXPECT_LE(maximum, 1.0e-10);
+}
+
+TEST(HhtEnergyVerification, C07DefaultAlphaReportsEnergyAndPhaseChanges) {
+  const auto parameters = fesa::MakeHhtParameters(-0.05);
+  ASSERT_TRUE(parameters.HasValue());
+  Oscillator state;
+  state.q[0] = 1.0;
+  state.a[0] = -4.0;
+  state.auxiliary = state.a;
+  double maximum = 0.0;
+  for (std::size_t step = 0; step < 640U; ++step) {
+    Advance(&state, 1.0, 4.0, 0.0, 1.0 / 64.0, parameters.Value());
+    const double energy =
+        0.5 * state.v[0] * state.v[0] + 2.0 * state.q[0] * state.q[0];
+    maximum = std::max(maximum, std::abs(energy - 2.0) / 2.0);
+  }
+  const double energy =
+      0.5 * state.v[0] * state.v[0] + 2.0 * state.q[0] * state.q[0];
+  std::cout << "C07 default alpha max energy defect=" << maximum
+            << " signed endpoint=" << (energy - 2.0) / 2.0
+            << " displacement error=" << state.q[0] - std::cos(20.0)
+            << " phase error="
+            << std::remainder(std::atan2(-state.v[0] / 2.0, state.q[0]) - 20.0,
+                              2.0 * std::acos(-1.0))
+            << '\n';
+  EXPECT_TRUE(std::isfinite(energy));
+  EXPECT_LT(energy, 2.0);
+}
+
+TEST(HhtEnergyVerification,
+     C07IndependentAmplificationHasThePrescribedSpectrum) {
+  for (const double alpha : {0.0, -0.05}) {
+    double previous_limit_error = 1.0;
+    for (const double frequency_step : {0.01, 0.1, 1.0, 10.0, 100.0, 1000.0}) {
+      auto roots = Eigenvalues(Amplification(frequency_step, alpha));
+      std::sort(roots.begin(), roots.end(), [](const auto& a, const auto& b) {
+        return std::abs(a) < std::abs(b);
+      });
+      const double radius = std::abs(roots.back());
+      std::cout << "C07 alpha=" << alpha << " omega*h=" << frequency_step
+                << " spectral radius=" << radius << '\n';
+      if (alpha == 0.0) {
+        EXPECT_NEAR(std::abs(roots[1]), 1.0, 1.0e-10);
+        EXPECT_NEAR(std::abs(roots[2]), 1.0, 1.0e-10);
+      } else {
+        EXPECT_LE(radius, 1.0 + 1.0e-10);
+        const double limit = (1.0 + alpha) / (1.0 - alpha);
+        if (frequency_step >= 100.0) {
+          const double error = std::abs(radius - limit);
+          EXPECT_LT(error, previous_limit_error);
+          previous_limit_error = error;
+          std::cout << "C07 high-frequency limit=" << limit
+                    << " error=" << error << '\n';
+        }
+      }
+    }
+  }
+}
+
+TEST(HhtEnergyVerification,
+     C07SupportReactionUsesPhysicalAccelerationAndCoupling) {
+  const auto parameters = fesa::MakeHhtParameters(-0.05);
+  ASSERT_TRUE(parameters.HasValue());
+  Oscillator state;
+  state.a[0] = 1.0;
+  state.auxiliary = state.a;
+  double mutation_difference = 0.0;
+  for (std::size_t step = 1; step <= 64U; ++step) {
+    Advance(&state, 2.0, 8.0, 2.0, 1.0 / 64.0, parameters.Value());
+    const std::array<double, 2> displacement{state.q[0], 0.0};
+    const std::array<double, 2> acceleration{state.a[0], 0.0};
+    const std::array<std::array<double, 2>, 2> mass{{{2.0, 0.5}, {0.5, 1.0}}};
+    const double reaction = mass[1][0] * acceleration[0] +
+                            mass[1][1] * acceleration[1] +
+                            3.0 * displacement[1];
+    EXPECT_EQ(reaction, 0.5 * state.a[0]);
+    mutation_difference = std::max(
+        mutation_difference, std::abs(reaction - 0.5 * state.auxiliary[0]));
+    const double momentum_rate = 2.5 * state.a[0];
+    const double balance = 2.0 + reaction - 8.0 * state.q[0] - momentum_rate;
+    const double scale = 2.0 + std::abs(reaction) + std::abs(8.0 * state.q[0]) +
+                         std::abs(momentum_rate);
+    EXPECT_LE(std::abs(balance) / scale, 1.0e-10);
+  }
+  EXPECT_GT(mutation_difference, 1.0e-6);
+}
+
+}  // namespace
diff --git a/tests/unit/analysis/hht_temporal_verification_test.cpp b/tests/unit/analysis/hht_temporal_verification_test.cpp
new file mode 100644
index 0000000..f88bdcd
--- /dev/null
+++ b/tests/unit/analysis/hht_temporal_verification_test.cpp
@@ -0,0 +1,507 @@
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <iostream>
+#include <limits>
+#include <stdexcept>
+#include <vector>
+
+#include "fesa/analysis/hht_time_integration.h"
+
+namespace {
+
+enum class Case { kC01, kC03, kC04a, kC04b };
+using Dense = std::array<std::array<double, 2>, 2>;
+
+struct ExactState {
+  fesa::Vector q;
+  fesa::Vector v;
+  fesa::Vector a;
+};
+
+std::size_t Dimension(const Case model) {
+  return model == Case::kC01 || model == Case::kC03 ? 1U : 2U;
+}
+
+ExactState Exact(const Case model, const double time) {
+  const std::size_t size = Dimension(model);
+  ExactState result{fesa::Vector{size}, fesa::Vector{size}, fesa::Vector{size}};
+  if (model == Case::kC01) {
+    result.q[0] = std::cos(2.0 * time) + 0.15 * std::sin(2.0 * time);
+    result.v[0] = -2.0 * std::sin(2.0 * time) + 0.3 * std::cos(2.0 * time);
+    result.a[0] = -4.0 * result.q[0];
+  } else if (model == Case::kC03) {
+    result.q[0] = 0.4 + std::sin(time);
+    result.v[0] = std::cos(time);
+    result.a[0] = -std::sin(time);
+  } else if (model == Case::kC04a) {
+    result.q[0] = 0.25 * (1.0 - std::cos(2.0 * time));
+    result.v[0] = 0.5 * std::sin(2.0 * time);
+    result.a[0] = std::cos(2.0 * time);
+    result.q[1] = 0.7 * result.q[0];
+    result.v[1] = 0.7 * result.v[0];
+    result.a[1] = 0.7 * result.a[0];
+  } else {
+    result.q[0] = std::cos(time);
+    result.q[1] = std::sin(time);
+    result.v[0] = -std::sin(time);
+    result.v[1] = std::cos(time);
+    result.a[0] = -result.q[0];
+    result.a[1] = -result.q[1];
+  }
+  return result;
+}
+
+std::array<double, 3> Amplitudes(const Case model) {
+  if (model == Case::kC01) {
+    const double q = std::sqrt(1.0 + 0.15 * 0.15);
+    return {q, 2.0 * q, 4.0 * q};
+  }
+  if (model == Case::kC04a) {
+    const double direction = std::sqrt(1.0 + 0.7 * 0.7);
+    return {0.5 * direction, 0.5 * direction, direction};
+  }
+  return {1.0, 1.0, 1.0};
+}
+
+struct Equation {
+  Dense mass{};
+  Dense dq{};
+  Dense dv{};
+  fesa::Vector residual;
+  fesa::Vector scale;
+};
+
+Equation Evaluate(const Case model, const fesa::Vector& q,
+                  const fesa::Vector& v, const fesa::Vector& a,
+                  const double time) {
+  const std::size_t size = q.Size();
+  Equation result{{}, {}, {}, fesa::Vector{size}, fesa::Vector{size}};
+  fesa::Vector c{size};
+  fesa::Vector internal{size};
+  fesa::Vector force{size};
+  if (model == Case::kC01) {
+    result.mass[0][0] = 1.0;
+    result.dq[0][0] = 4.0;
+    internal[0] = 4.0 * q[0];
+  } else if (model == Case::kC03) {
+    result.mass[0][0] = 1.0 + q[0] * q[0];
+    c[0] = q[0] * v[0] * v[0];
+    const auto exact = Exact(model, time);
+    force[0] = (1.0 + exact.q[0] * exact.q[0]) * exact.a[0] +
+               exact.q[0] * exact.v[0] * exact.v[0];
+    result.dq[0][0] = 2.0 * q[0] * a[0] + v[0] * v[0];
+    result.dv[0][0] = 2.0 * q[0] * v[0];
+  } else if (model == Case::kC04a) {
+    result.mass[0][0] = 2.0;
+    result.dq = {{{8.0 + 3.0 * 0.7 * 0.7, -3.0 * 0.7}, {-3.0 * 0.7, 3.0}}};
+    internal[0] = result.dq[0][0] * q[0] + result.dq[0][1] * q[1];
+    internal[1] = result.dq[1][0] * q[0] + result.dq[1][1] * q[1];
+    force[0] = 2.0;
+  } else {
+    const double radius = q.Norm();
+    if (!(radius > 0.0)) throw std::runtime_error{"Invalid circle chart."};
+    const double r2 = radius * radius;
+    const double r4 = r2 * r2;
+    const double r6 = r4 * r2;
+    const double s = q.Dot(v);
+    std::array<double, 2> mv{};
+    for (std::size_t i = 0; i < 2; ++i) {
+      for (std::size_t j = 0; j < 2; ++j) {
+        result.mass[i][j] = (i == j ? 1.0 / r2 : 0.0) - q[i] * q[j] / r4;
+        mv[i] += result.mass[i][j] * v[j];
+      }
+      c[i] = -2.0 * s / r2 * mv[i];
+      internal[i] = (1.0 - 1.0 / radius) * q[i];
+    }
+    for (std::size_t column = 0; column < 2; ++column) {
+      for (std::size_t row = 0; row < 2; ++row) {
+        double dma = 0.0;
+        double dmv = 0.0;
+        for (std::size_t j = 0; j < 2; ++j) {
+          const double derivative =
+              (row == j ? -2.0 * q[column] / r4 : 0.0) +
+              4.0 * q[column] * q[row] * q[j] / r6 -
+              ((row == column ? q[j] : 0.0) + (j == column ? q[row] : 0.0)) /
+                  r4;
+          dma += derivative * a[j];
+          dmv += derivative * v[j];
+        }
+        result.dq[row][column] =
+            dma + (-2.0 * v[column] / r2 + 4.0 * s * q[column] / r4) * mv[row] -
+            2.0 * s / r2 * dmv + (row == column ? 1.0 - 1.0 / radius : 0.0) +
+            q[row] * q[column] / (r2 * radius);
+        result.dv[row][column] = -2.0 * q[column] / r2 * mv[row] -
+                                 2.0 * s / r2 * result.mass[row][column];
+      }
+    }
+  }
+  for (std::size_t i = 0; i < size; ++i) {
+    result.residual[i] = c[i] + internal[i] - force[i];
+    result.scale[i] =
+        std::abs(c[i]) + std::abs(internal[i]) + std::abs(force[i]);
+    for (std::size_t j = 0; j < size; ++j) {
+      result.residual[i] += result.mass[i][j] * a[j];
+      result.scale[i] += std::abs(result.mass[i][j] * a[j]);
+    }
+  }
+  return result;
+}
+
+fesa::Vector Multiply(const Dense& matrix, const fesa::Vector& x) {
+  fesa::Vector result{x.Size()};
+  for (std::size_t i = 0; i < x.Size(); ++i) {
+    for (std::size_t j = 0; j < x.Size(); ++j) result[i] += matrix[i][j] * x[j];
+  }
+  return result;
+}
+
+fesa::Vector Solve(const Dense& matrix, const fesa::Vector& rhs) {
+  fesa::Vector result{rhs.Size()};
+  if (rhs.Size() == 1U) {
+    if (matrix[0][0] == 0.0)
+      throw std::runtime_error{"Singular scalar tangent."};
+    result[0] = rhs[0] / matrix[0][0];
+  } else {
+    Dense lu = matrix;
+    std::array<double, 2> b{rhs[0], rhs[1]};
+    if (std::abs(lu[1][0]) > std::abs(lu[0][0])) {
+      std::swap(lu[0], lu[1]);
+      std::swap(b[0], b[1]);
+    }
+    if (lu[0][0] == 0.0) throw std::runtime_error{"Singular Cartesian pivot."};
+    const double multiplier = lu[1][0] / lu[0][0];
+    lu[1][1] -= multiplier * lu[0][1];
+    b[1] -= multiplier * b[0];
+    if (lu[1][1] == 0.0) throw std::runtime_error{"Singular Cartesian pivot."};
+    result[1] = b[1] / lu[1][1];
+    result[0] = (b[0] - lu[0][1] * result[1]) / lu[0][0];
+  }
+  double residual_norm = 0.0;
+  double scale_norm = 0.0;
+  for (std::size_t i = 0; i < rhs.Size(); ++i) {
+    double residual = -rhs[i];
+    double scale = std::abs(rhs[i]);
+    for (std::size_t j = 0; j < rhs.Size(); ++j) {
+      residual += matrix[i][j] * result[j];
+      scale += std::abs(matrix[i][j] * result[j]);
+    }
+    EXPECT_TRUE(std::isfinite(result[i]));
+    residual_norm = std::max(residual_norm, std::abs(residual));
+    scale_norm = std::max(scale_norm, scale);
+  }
+  EXPECT_LE(scale_norm > 0.0 ? residual_norm / scale_norm : residual_norm,
+            1.0e-12);
+  return result;
+}
+
+Dense Effective(const Equation& equation, const double cv, const double ca) {
+  Dense tangent{};
+  for (std::size_t i = 0; i < 2; ++i) {
+    for (std::size_t j = 0; j < 2; ++j) {
+      tangent[i][j] =
+          equation.dq[i][j] + cv * equation.dv[i][j] + ca * equation.mass[i][j];
+    }
+  }
+  return tangent;
+}
+
+struct Errors {
+  std::array<double, 3> maximum{};
+  std::array<double, 3> first{};
+  std::array<double, 3> tail{};
+  std::array<double, 3> endpoint{};
+  std::array<double, 3> noise{};
+  double position_constraint = 0.0;
+  double hidden_velocity = 0.0;
+  double hidden_acceleration = 0.0;
+  double auxiliary_difference = 0.0;
+  double constant_mass_recurrence_difference = 0.0;
+  double reduced_difference = 0.0;
+};
+
+Errors Integrate(const Case model, const std::size_t increments,
+                 const bool naive_variable_mass = false) {
+  const double h = 1.0 / static_cast<double>(increments);
+  const auto parameter_result = fesa::MakeHhtParameters(-0.05);
+  if (!parameter_result.HasValue())
+    throw std::runtime_error{"Invalid HHT parameters."};
+  const auto parameters = parameter_result.Value();
+  const double cv = parameters.gamma / (parameters.beta * h);
+  const double ca = 1.0 / ((1.0 + parameters.alpha) * parameters.beta * h * h);
+  ExactState state = Exact(model, 0.0);
+  fesa::Vector auxiliary = state.a;
+  const auto amplitudes = Amplitudes(model);
+  Errors errors;
+  double old_naive_b = 0.0;
+  double old_naive_scale = 2.0 * std::abs(state.q[0] * state.v[0] * state.v[0]);
+  if (naive_variable_mass)
+    old_naive_b = -(1.0 + state.q[0] * state.q[0]) * state.a[0];
+  // Independent scalar constant-M HHT recurrence, used for C01 and the exact
+  // algebraic reduction of C04a; it does not call the production rate helpers.
+  double rq = state.q[0];
+  double rv = state.v[0];
+  double ra = state.a[0];
+  for (std::size_t step = 1; step <= increments; ++step) {
+    const double time = static_cast<double>(step) * h;
+    const auto predictor_result =
+        fesa::PredictHht(state.q, state.v, auxiliary, h, parameters);
+    if (!predictor_result.HasValue())
+      throw std::runtime_error{"Invalid predictor."};
+    const auto predictor = predictor_result.Value();
+    fesa::Vector q = predictor.coordinates;
+    q.Axpy(parameters.beta * h * h, auxiliary);
+    fesa::Vector last_delta{q.Size()};
+    fesa::Vector last_residual{q.Size()};
+    Dense last_tangent{};
+    std::size_t corrections = 0U;
+    for (;;) {
+      const auto rates =
+          fesa::EvaluateHhtRates(q, predictor, state.a, h, parameters);
+      if (!rates.HasValue()) throw std::runtime_error{"Invalid trial rates."};
+      auto equation = Evaluate(model, q, rates.Value().velocity,
+                               rates.Value().acceleration, time);
+      Dense tangent = Effective(equation, cv, ca);
+      if (naive_variable_mass) {
+        const auto exact = Exact(model, time);
+        const double force = (1.0 + exact.q[0] * exact.q[0]) * exact.a[0] +
+                             exact.q[0] * exact.v[0] * exact.v[0];
+        const double v = rates.Value().velocity[0];
+        const double a = rates.Value().algorithmic_acceleration[0];
+        const double b = q[0] * v * v - force;
+        equation.residual[0] = (1.0 + q[0] * q[0]) * a +
+                               (1.0 + parameters.alpha) * b -
+                               parameters.alpha * old_naive_b;
+        equation.scale[0] = std::abs((1.0 + q[0] * q[0]) * a) +
+                            (1.0 + parameters.alpha) *
+                                (std::abs(q[0] * v * v) + std::abs(force)) +
+                            std::abs(parameters.alpha) * old_naive_scale;
+        tangent[0][0] =
+            2.0 * q[0] * a + (1.0 + q[0] * q[0]) / (parameters.beta * h * h) +
+            (1.0 + parameters.alpha) * (v * v + 2.0 * q[0] * v * cv);
+      }
+      double residual = 0.0;
+      double scale = 0.0;
+      double correction = 0.0;
+      for (std::size_t i = 0; i < q.Size(); ++i) {
+        residual = std::max(residual, std::abs(equation.residual[i]));
+        scale = std::max(scale, equation.scale[i]);
+        correction = std::max(correction, std::abs(last_delta[i]));
+      }
+      const bool force_pass =
+          scale > 0.0 ? residual / scale <= 1.0e-10 : residual == 0.0;
+      const bool correction_pass = correction <= 1.0e-10 &&
+                                   h * cv * correction <= 1.0e-10 &&
+                                   h * h * ca * correction <= 1.0e-10 &&
+                                   correction / parameters.beta <= 1.0e-10;
+      if (force_pass && correction_pass) {
+        if (corrections == 0U) {
+          last_tangent = tangent;
+          last_residual = equation.residual;
+        }
+        break;
+      }
+      if (corrections >= 100U)
+        throw std::runtime_error{"Newton correction limit."};
+      auto rhs = equation.residual;
+      rhs.Scale(-1.0);
+      last_delta = Solve(tangent, rhs);
+      last_tangent = tangent;
+      last_residual = equation.residual;
+      q.Axpy(1.0, last_delta);
+      ++corrections;
+    }
+    const auto rates_result =
+        fesa::EvaluateHhtRates(q, predictor, state.a, h, parameters);
+    if (!rates_result.HasValue())
+      throw std::runtime_error{"Invalid accepted rates."};
+    const auto rates = rates_result.Value();
+    const auto endpoint_equation =
+        Evaluate(model, q, rates.velocity, rates.acceleration, time);
+    const Dense endpoint_tangent = Effective(endpoint_equation, cv, ca);
+    if (!naive_variable_mass) {
+      auto linear_defect = Multiply(last_tangent, last_delta);
+      linear_defect.Axpy(1.0, last_residual);
+      linear_defect.Scale(-1.0);
+      const auto z_linear = Solve(last_tangent, linear_defect);
+      auto endpoint_rhs = endpoint_equation.residual;
+      endpoint_rhs.Scale(-1.0);
+      const auto z_nonlinear = Solve(endpoint_tangent, endpoint_rhs);
+      const double eta_q =
+          last_delta.Norm() + z_linear.Norm() + z_nonlinear.Norm();
+      const double unit_roundoff = std::ldexp(1.0, -53);
+      const double gamma32 =
+          32.0 * unit_roundoff / (1.0 - 32.0 * unit_roundoff);
+      const double eta_round =
+          gamma32 * (q.Norm() + predictor.coordinates.Norm());
+      const std::array<double, 3> factors{1.0, cv, ca};
+      for (std::size_t channel = 0; channel < 3; ++channel) {
+        errors.noise[channel] =
+            std::max(errors.noise[channel], factors[channel] *
+                                                std::max(eta_q, eta_round) /
+                                                amplitudes[channel]);
+      }
+    }
+    const auto exact = Exact(model, time);
+    const std::array<const fesa::Vector*, 3> actual{&q, &rates.velocity,
+                                                    &rates.acceleration};
+    const std::array<const fesa::Vector*, 3> reference{&exact.q, &exact.v,
+                                                       &exact.a};
+    for (std::size_t channel = 0; channel < 3; ++channel) {
+      auto difference = *actual[channel];
+      difference.Axpy(-1.0, *reference[channel]);
+      const double error = difference.Norm() / amplitudes[channel];
+      errors.maximum[channel] = std::max(errors.maximum[channel], error);
+      if (step == 1U) errors.first[channel] = error;
+      if (time >= 0.25)
+        errors.tail[channel] = std::max(errors.tail[channel], error);
+      if (step == increments) errors.endpoint[channel] = error;
+    }
+    auto auxiliary_difference = rates.algorithmic_acceleration;
+    auxiliary_difference.Axpy(-1.0, rates.acceleration);
+    errors.auxiliary_difference =
+        std::max(errors.auxiliary_difference, auxiliary_difference.Norm());
+    if (model == Case::kC04b) {
+      errors.position_constraint =
+          std::max(errors.position_constraint, std::abs(q.Norm() - 1.0));
+      errors.hidden_velocity =
+          std::max(errors.hidden_velocity, std::abs(q.Dot(rates.velocity)));
+      errors.hidden_acceleration =
+          std::max(errors.hidden_acceleration,
+                   std::abs(q.Dot(rates.acceleration) +
+                            rates.velocity.Dot(rates.velocity)));
+    }
+    if (model == Case::kC01 || model == Case::kC04a) {
+      const double m = model == Case::kC01 ? 1.0 : 2.0;
+      const double k = model == Case::kC01 ? 4.0 : 8.0;
+      const double force = model == Case::kC01 ? 0.0 : 2.0;
+      const double qp = rq + h * rv + h * h * (0.5 - parameters.beta) * ra;
+      const double next_a =
+          ((1.0 + parameters.alpha) * (force - k * qp) -
+           parameters.alpha * (force - k * rq)) /
+          (m + (1.0 + parameters.alpha) * k * parameters.beta * h * h);
+      const double next_q = qp + parameters.beta * h * h * next_a;
+      const double next_v =
+          rv + h * ((1.0 - parameters.gamma) * ra + parameters.gamma * next_a);
+      errors.constant_mass_recurrence_difference = std::max(
+          errors.constant_mass_recurrence_difference,
+          std::max(std::abs(q[0] - next_q) / amplitudes[0],
+                   std::abs(rates.velocity[0] - next_v) / amplitudes[1]));
+      if (model == Case::kC04a) {
+        errors.reduced_difference = std::max(
+            errors.reduced_difference,
+            std::max({std::abs(q[1] - 0.7 * q[0]),
+                      std::abs(rates.velocity[1] - 0.7 * rates.velocity[0]),
+                      std::abs(rates.acceleration[1] -
+                               0.7 * rates.acceleration[0])}));
+      }
+      rq = next_q;
+      rv = next_v;
+      ra = next_a;
+    }
+    if (naive_variable_mass) {
+      const double force = (1.0 + exact.q[0] * exact.q[0]) * exact.a[0] +
+                           exact.q[0] * exact.v[0] * exact.v[0];
+      old_naive_b = q[0] * rates.velocity[0] * rates.velocity[0] - force;
+      old_naive_scale = std::abs(q[0] * rates.velocity[0] * rates.velocity[0]) +
+                        std::abs(force);
+    }
+    state = {q, rates.velocity, rates.acceleration};
+    auxiliary = rates.algorithmic_acceleration;
+  }
+  return errors;
+}
+
+std::vector<Errors> Sweep(const Case model) {
+  std::vector<Errors> errors;
+  for (const std::size_t increments : {16U, 32U, 64U, 128U, 256U}) {
+    errors.push_back(Integrate(model, increments));
+    const auto& current = errors.back();
+    for (std::size_t channel = 0; channel < 3; ++channel) {
+      std::cout << "N7 model=" << static_cast<int>(model)
+                << " increments=" << increments << " channel=" << channel
+                << " maximum=" << current.maximum[channel]
+                << " first=" << current.first[channel]
+                << " tail=" << current.tail[channel]
+                << " endpoint=" << current.endpoint[channel]
+                << " noise=" << current.noise[channel] << '\n';
+      EXPECT_GT(current.maximum[channel], 100.0 * current.noise[channel])
+          << "N7 inconclusive: iteration/roundoff dominates channel "
+          << channel;
+    }
+    std::cout << "N7 hidden v=" << current.hidden_velocity
+              << " a=" << current.hidden_acceleration
+              << " A-a=" << current.auxiliary_difference << '\n';
+  }
+  for (std::size_t channel = 0; channel < 3; ++channel) {
+    for (std::size_t grid = 3; grid < 5; ++grid) {
+      EXPECT_LT(errors[grid].maximum[channel],
+                errors[grid - 1U].maximum[channel]);
+      EXPECT_GE(std::log2(errors[grid - 1U].maximum[channel] /
+                          errors[grid].maximum[channel]),
+                1.8);
+    }
+    EXPECT_LE(errors.back().maximum[channel], 1.0e-4);
+  }
+  return errors;
+}
+
+TEST(HhtTemporalVerification, C01MatchesConstantMassRecurrenceAndSecondOrder) {
+  const auto errors = Sweep(Case::kC01);
+  for (const auto& error : errors)
+    EXPECT_LE(error.constant_mass_recurrence_difference, 1.0e-12);
+}
+
+TEST(HhtTemporalVerification,
+     C03VariableMassIsSecondOrderAndNaiveWeightingIsNot) {
+  const auto errors = Sweep(Case::kC03);
+  EXPECT_GT(errors.back().auxiliary_difference, 0.0);
+  const auto coarse = Integrate(Case::kC03, 128U, true);
+  const auto fine = Integrate(Case::kC03, 256U, true);
+  const double order = std::log2(coarse.maximum[0] / fine.maximum[0]);
+  std::cout << "C03 naive q-order=" << order << '\n';
+  EXPECT_LT(order, 1.5);
+}
+
+TEST(HhtTemporalVerification, C04aCoupledMasslessCoordinatesHaveSecondOrder) {
+  const auto errors = Sweep(Case::kC04a);
+  for (std::size_t grid = 0; grid < errors.size(); ++grid) {
+    EXPECT_LE(errors[grid].constant_mass_recurrence_difference, 1.0e-12);
+    if (grid + 1U < errors.size())
+      EXPECT_LE(errors[grid].reduced_difference, 1.0e-10);
+  }
+}
+
+TEST(HhtTemporalVerification,
+     C04aFinestReductionComparisonIsNumericallyResolved) {
+  const auto error = Integrate(Case::kC04a, 256U);
+  if (error.reduced_difference > 1.0e-10 &&
+      error.reduced_difference <= error.noise[2]) {
+    GTEST_SKIP() << "N7 INCONCLUSIVE: h=1/256 full/reduced acceleration defect="
+                 << error.reduced_difference
+                 << ", arithmetic/solve resolution=" << error.noise[2]
+                 << "; coarse grids remain blocking. Independent decimal80 "
+                    "full2x2/reduced"
+                    " recurrence evidence is recorded separately; this "
+                    "binary64 comparison is not passed.";
+  }
+  EXPECT_LE(error.reduced_difference, 1.0e-10);
+}
+
+TEST(HhtTemporalVerification, C04bFullCartesianMovingNullConverges) {
+  const auto errors = Sweep(Case::kC04b);
+  for (const auto& error : errors)
+    EXPECT_LE(error.position_constraint, 1.0e-10);
+  for (std::size_t grid = 3; grid < 5; ++grid) {
+    EXPECT_LT(errors[grid].hidden_velocity, errors[grid - 1U].hidden_velocity);
+    EXPECT_LT(errors[grid].hidden_acceleration,
+              errors[grid - 1U].hidden_acceleration);
+  }
+  EXPECT_LE(errors.back().hidden_velocity, 1.0e-6);
+  EXPECT_LE(errors.back().hidden_acceleration, 1.0e-4);
+}
+
+}  // namespace
diff --git a/tests/unit/analysis/hht_time_integration_test.cpp b/tests/unit/analysis/hht_time_integration_test.cpp
new file mode 100644
index 0000000..af2ed95
--- /dev/null
+++ b/tests/unit/analysis/hht_time_integration_test.cpp
@@ -0,0 +1,97 @@
+#include "fesa/analysis/hht_time_integration.h"
+
+#include <cmath>
+
+#include <gtest/gtest.h>
+
+namespace fesa {
+namespace {
+
+TEST(HhtTimeIntegrationTest, KeepsPhysicalAndAlgorithmicAccelerationDistinct) {
+  const auto parameters = MakeHhtParameters(-0.05);
+  ASSERT_TRUE(parameters.HasValue());
+  Vector q(1U);
+  Vector v(1U);
+  Vector old_a(1U);
+  old_a[0U] = 1.0;
+  const auto predictor = PredictHht(q, v, old_a, 0.1, parameters.Value());
+  ASSERT_TRUE(predictor.HasValue());
+  q[0U] = predictor.Value().coordinates[0U] +
+          parameters.Value().beta * 0.01 * 2.0;
+  const auto rates = EvaluateHhtRates(q, predictor.Value(), old_a, 0.1,
+                                     parameters.Value());
+  ASSERT_TRUE(rates.HasValue());
+  EXPECT_NEAR(rates.Value().algorithmic_acceleration[0U], 2.0, 1e-14);
+  EXPECT_NEAR(rates.Value().acceleration[0U], 1.95 / 0.95, 1e-14);
+  EXPECT_NEAR(rates.Value().velocity[0U], 0.155, 1e-14);
+}
+
+TEST(HhtTimeIntegrationTest, RejectsInvalidParametersAndTime) {
+  EXPECT_FALSE(MakeHhtParameters(0.01).HasValue());
+  EXPECT_FALSE(MakeHhtParameters(-0.34).HasValue());
+  ASSERT_TRUE(MakeHhtParameters(-1.0 / 3.0).HasValue());
+  const auto parameters = MakeHhtParameters(0.0);
+  ASSERT_TRUE(parameters.HasValue());
+  EXPECT_EQ(parameters.Value().beta, 0.25);
+  EXPECT_EQ(parameters.Value().gamma, 0.5);
+  const Vector zero(1U);
+  EXPECT_FALSE(PredictHht(zero, zero, zero, 0.0, parameters.Value()).HasValue());
+}
+
+// C02 is a right-continuous STEP load with a nonzero physical a0.
+TEST(HhtTimeIntegrationTest, StepOscillatorHasSecondOrderMaximumError) {
+  const auto parameters = MakeHhtParameters(-0.05);
+  ASSERT_TRUE(parameters.HasValue());
+  double previous_q = 0.0;
+  double previous_v = 0.0;
+  double previous_a = 0.0;
+  for (unsigned int power = 4U; power <= 8U; ++power) {
+    const unsigned int count = 1U << power;
+    const double h = 1.0 / static_cast<double>(count);
+    Vector q(1U);
+    Vector v(1U);
+    Vector a(1U);
+    Vector auxiliary(1U);
+    a[0U] = auxiliary[0U] = 1.0;
+    double error_q = 0.0;
+    double error_v = 0.0;
+    double error_a = 0.0;
+    for (unsigned int n = 1U; n <= count; ++n) {
+      const auto predictor = PredictHht(q, v, auxiliary, h, parameters.Value());
+      ASSERT_TRUE(predictor.HasValue());
+      const double coefficient =
+          1.0 / ((1.0 + parameters.Value().alpha) *
+                 parameters.Value().beta * h * h);
+      q[0U] = (2.0 + 2.0 * coefficient * predictor.Value().coordinates[0U] -
+               2.0 * parameters.Value().alpha * a[0U] /
+                   (1.0 + parameters.Value().alpha)) /
+              (8.0 + 2.0 * coefficient);
+      const auto rates = EvaluateHhtRates(q, predictor.Value(), a, h,
+                                         parameters.Value());
+      ASSERT_TRUE(rates.HasValue());
+      v = rates.Value().velocity;
+      a = rates.Value().acceleration;
+      auxiliary = rates.Value().algorithmic_acceleration;
+      const double time = static_cast<double>(n) * h;
+      error_q = (std::max)(error_q, std::abs(q[0U] - 0.25 * (1.0 - std::cos(2.0 * time))) / 0.5);
+      error_v = (std::max)(error_v, std::abs(v[0U] - 0.5 * std::sin(2.0 * time)) / 0.5);
+      error_a = (std::max)(error_a, std::abs(a[0U] - std::cos(2.0 * time)));
+    }
+    if (power >= 7U) {
+      EXPECT_GE(std::log2(previous_q / error_q), 1.8);
+      EXPECT_GE(std::log2(previous_v / error_v), 1.8);
+      EXPECT_GE(std::log2(previous_a / error_a), 1.8);
+    }
+    if (power == 8U) {
+      EXPECT_LT(error_q, 1e-4);
+      EXPECT_LT(error_v, 1e-4);
+      EXPECT_LT(error_a, 1e-4);
+    }
+    previous_q = error_q;
+    previous_v = error_v;
+    previous_a = error_a;
+  }
+}
+
+}  // namespace
+}  // namespace fesa
diff --git a/tests/unit/analysis/newton_iteration_log_test.cpp b/tests/unit/analysis/newton_iteration_log_test.cpp
index 8b77ad0..afebbd9 100644
--- a/tests/unit/analysis/newton_iteration_log_test.cpp
+++ b/tests/unit/analysis/newton_iteration_log_test.cpp
@@ -6,6 +6,8 @@
 #include <cmath>
 #include <filesystem>
 #include <fstream>
+#include <functional>
+#include <limits>
 #include <iterator>
 #include <stdexcept>
 #include <string>
@@ -412,4 +414,152 @@ TEST(NewtonIterationLog,
             "residual_moment_threshold_unit=1");
 }
 
+fesa::DynamicNewtonIterationLogRecord CompleteDynamicRecord() {
+  return {2U,
+          3U,
+          0.25,
+          "convergence",
+          "accepted",
+          "",
+          {2.0e-12, 0.0},
+          {2.0, 0.0},
+          {1.0e-11, 2.0e-11},
+          {3.0e-11, 4.0e-11},
+          {5.0e-11, 6.0e-11},
+          {7.0e-11, 8.0e-11},
+          true,
+          true};
+}
+
+std::string ReadLogBytes(const std::filesystem::path& path) {
+  std::ifstream input{path, std::ios::binary};
+  return std::string{std::istreambuf_iterator<char>{input},
+                     std::istreambuf_iterator<char>{}};
+}
+
+TEST(DynamicNewtonIterationLog, WritesTimeAndAllTwoChannelMetrics) {
+  TempDirectory directory{"dynamic-complete"};
+  const auto path = directory.Path() / "dynamic_log.txt";
+  fesa::NewtonIterationLogWriter writer;
+  const auto record = CompleteDynamicRecord();
+  ASSERT_TRUE(writer.Open(path).IsOk());
+  ASSERT_TRUE(writer.Write(record).IsOk());
+  ASSERT_TRUE(writer.Flush().IsOk());
+  ASSERT_TRUE(writer.Close().IsOk());
+  const std::string bytes = ReadLogBytes(path);
+  ASSERT_FALSE(bytes.empty());
+  EXPECT_EQ(bytes.back(), '\n');
+  EXPECT_EQ(std::count(bytes.begin(), bytes.end(), '\n'), 1);
+  EXPECT_EQ(bytes.find('\r'), std::string::npos);
+  EXPECT_EQ(bytes.find("target_factor"), std::string::npos);
+  EXPECT_EQ(bytes.find("nsnr-log-v1"), std::string::npos);
+  const auto fields = SplitTabs(bytes.substr(0U, bytes.size() - 1U));
+  EXPECT_EQ(fields.size(), 24U);
+  EXPECT_EQ(FieldValue(fields, "record"), "record=dynamic-newton-iteration");
+  EXPECT_EQ(FieldValue(fields, "schema"), "schema=hht-log-v1");
+  EXPECT_EQ(FieldValue(fields, "increment"), "increment=2");
+  EXPECT_EQ(FieldValue(fields, "iteration"), "iteration=3");
+  EXPECT_EQ(FieldValue(fields, "time"), "time=0.25");
+  EXPECT_EQ(FieldValue(fields, "stage"), "stage=convergence");
+  EXPECT_EQ(FieldValue(fields, "residual_u_branch"),
+            "residual_u_branch=relative");
+  EXPECT_EQ(FieldValue(fields, "residual_phi_branch"),
+            "residual_phi_branch=zero-scale");
+  EXPECT_EQ(FieldValue(fields, "residual_pass"), "residual_pass=1");
+  EXPECT_EQ(FieldValue(fields, "correction_pass"), "correction_pass=1");
+  const std::vector<std::pair<std::string, double>> expected{
+      {"residual_u_numerator", 2.0e-12},
+      {"residual_u_scale", 2.0},
+      {"residual_phi_numerator", 0.0},
+      {"residual_phi_scale", 0.0},
+      {"coordinate_correction_u", 1.0e-11},
+      {"coordinate_correction_phi", 2.0e-11},
+      {"velocity_correction_u", 3.0e-11},
+      {"velocity_correction_phi", 4.0e-11},
+      {"acceleration_correction_u", 5.0e-11},
+      {"acceleration_correction_phi", 6.0e-11},
+      {"algorithmic_correction_u", 7.0e-11},
+      {"algorithmic_correction_phi", 8.0e-11}};
+  for (const auto& metric : expected) {
+    const auto text = ValueAfterEquals(FieldValue(fields, metric.first));
+    double value = 0.0;
+    const auto parsed =
+        std::from_chars(text.data(), text.data() + text.size(), value);
+    EXPECT_EQ(parsed.ec, std::errc{});
+    EXPECT_EQ(parsed.ptr, text.data() + text.size());
+    EXPECT_DOUBLE_EQ(value, metric.second);
+  }
+}
+
+TEST(DynamicNewtonIterationLog, EscapesFailureContextAndKeepsZeroScaleFailure) {
+  TempDirectory directory{"dynamic-failure"};
+  const auto path = directory.Path() / "dynamic_log.txt";
+  auto record = CompleteDynamicRecord();
+  record.stage = "mass\tcheck";
+  record.outcome = "failed\ntrial";
+  record.failure_code = "dynamic\\mass\rregularity";
+  record.residual_numerator = {1.0, 0.0};
+  record.residual_scale = {0.0, 0.0};
+  record.residual_pass = false;
+  record.correction_pass = false;
+  fesa::NewtonIterationLogWriter writer;
+  ASSERT_TRUE(writer.Open(path).IsOk());
+  ASSERT_TRUE(writer.Write(record).IsOk());
+  ASSERT_TRUE(writer.Close().IsOk());
+  const auto bytes = ReadLogBytes(path);
+  EXPECT_EQ(std::count(bytes.begin(), bytes.end(), '\n'), 1);
+  const auto fields = SplitTabs(bytes.substr(0U, bytes.size() - 1U));
+  EXPECT_EQ(FieldValue(fields, "stage"), "stage=mass\\tcheck");
+  EXPECT_EQ(FieldValue(fields, "outcome"), "outcome=failed\\ntrial");
+  EXPECT_EQ(FieldValue(fields, "failure_code"),
+            "failure_code=dynamic\\\\mass\\rregularity");
+  EXPECT_EQ(FieldValue(fields, "residual_u_numerator"),
+            "residual_u_numerator=1");
+  EXPECT_EQ(FieldValue(fields, "residual_u_scale"), "residual_u_scale=0");
+  EXPECT_EQ(FieldValue(fields, "residual_u_branch"),
+            "residual_u_branch=zero-scale");
+  EXPECT_EQ(FieldValue(fields, "residual_pass"), "residual_pass=0");
+}
+
+TEST(DynamicNewtonIterationLog,
+     InvalidEvidencePreservesFlushedPrefixAndFailsLifecycle) {
+  using Record = fesa::DynamicNewtonIterationLogRecord;
+  const double nan = std::numeric_limits<double>::quiet_NaN();
+  const double infinity = std::numeric_limits<double>::infinity();
+  const std::vector<std::function<void(Record&)>> mutations{
+      [nan](Record& record) { record.time = nan; },
+      [nan](Record& record) { record.residual_numerator[0U] = nan; },
+      [infinity](Record& record) { record.residual_scale[1U] = infinity; },
+      [nan](Record& record) { record.coordinate_correction[0U] = nan; },
+      [infinity](Record& record) { record.velocity_correction[1U] = infinity; },
+      [nan](Record& record) { record.acceleration_correction[0U] = nan; },
+      [infinity](Record& record) {
+        record.algorithmic_correction[1U] = infinity;
+      },
+      [](Record& record) { record.time = -0.1; },
+      [](Record& record) { record.residual_scale[0U] = -1.0; },
+      [](Record& record) { record.coordinate_correction[0U] = -1.0; },
+      [](Record& record) { record.stage.clear(); },
+      [](Record& record) { record.outcome.clear(); }};
+  TempDirectory directory{"dynamic-invalid"};
+  const auto path = directory.Path() / "dynamic_log.txt";
+  for (std::size_t index = 0U; index < mutations.size(); ++index) {
+    SCOPED_TRACE(index);
+    fesa::NewtonIterationLogWriter writer;
+    ASSERT_TRUE(writer.Open(path).IsOk());
+    ASSERT_TRUE(writer.Write(CompleteDynamicRecord()).IsOk());
+    ASSERT_TRUE(writer.Flush().IsOk());
+    const std::string prefix = ReadLogBytes(path);
+    auto invalid = CompleteDynamicRecord();
+    mutations[index](invalid);
+    ExpectLogOutputFailure(writer.Write(invalid));
+    ExpectLogOutputFailure(writer.Write(CompleteDynamicRecord()));
+    ExpectLogOutputFailure(writer.Flush());
+    ExpectLogOutputFailure(writer.Close());
+    EXPECT_EQ(ReadLogBytes(path), prefix);
+  }
+  fesa::NewtonIterationLogWriter unopened;
+  ExpectLogOutputFailure(unopened.Write(CompleteDynamicRecord()));
+}
+
 }  // namespace
diff --git a/tests/unit/elements/nonlinear_mitc4_inertia_test.cpp b/tests/unit/elements/nonlinear_mitc4_inertia_test.cpp
new file mode 100644
index 0000000..a11b4a5
--- /dev/null
+++ b/tests/unit/elements/nonlinear_mitc4_inertia_test.cpp
@@ -0,0 +1,1051 @@
+#include "fesa/elements/nonlinear_mitc4_inertia.h"
+
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <iostream>
+#include <limits>
+#include <string>
+#include <vector>
+
+#include "fesa/elements/finite_rotation.h"
+#include "fesa/model/model_types.h"
+#include "fesa/model/shell_geometry.h"
+
+namespace {
+
+fesa::Node Node(const std::int64_t label,
+                const std::array<double, 3>& coordinates) {
+  return {{"Shell-Instance", label, std::to_string(label)},
+          coordinates,
+          {"nonlinear-inertia.inp", static_cast<std::size_t>(label)}};
+}
+
+std::array<fesa::Node, 4> Nodes() {
+  return {Node(1, {-1.0, -1.0, 0.0}), Node(2, {1.0, -1.0, 0.0}),
+          Node(3, {1.0, 1.0, 0.0}), Node(4, {-1.0, 1.0, 0.0})};
+}
+
+std::array<const fesa::Node*, 4> Pointers(
+    const std::array<fesa::Node, 4>& nodes) {
+  return {&nodes[0], &nodes[1], &nodes[2], &nodes[3]};
+}
+
+std::array<fesa::ShellNodeInitialFrame, 4> Frames() {
+  return {{{0U, {0.0, 0.0, 1.0}, {1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}},
+           {1U, {0.0, 0.0, 1.0}, {1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}},
+           {2U, {0.0, 0.0, 1.0}, {1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}},
+           {3U, {0.0, 0.0, 1.0}, {1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}}}};
+}
+
+fesa::NonlinearMitc4Inertia Inertia(const std::array<fesa::Node, 4>& nodes) {
+  const fesa::ShellSection section{
+      "Section", 0.2, 0U, {"nonlinear-inertia.inp", 20U}};
+  const fesa::LinearElasticMaterial material{
+      "Material", 120.0, 0.25, {"nonlinear-inertia.inp", 21U}};
+  const auto inertia = fesa::NonlinearMitc4Inertia::Create(
+      Pointers(nodes), Frames(), section, material, 1.0);
+  EXPECT_TRUE(inertia.HasValue());
+  return inertia.Value();
+}
+
+fesa::NonlinearMitc4TrialDofs AddRotation(fesa::NonlinearMitc4TrialDofs trial,
+                                          const fesa::Vector& direction,
+                                          const double step) {
+  for (std::size_t node = 0U; node < 4U; ++node) {
+    trial.displacement[node] =
+        trial.displacement[node] + fesa::Vector3{direction[6U * node],
+                                                 direction[6U * node + 1U],
+                                                 direction[6U * node + 2U]} *
+                                       step;
+    trial.rotation_vector[node] =
+        trial.rotation_vector[node] + fesa::Vector3{direction[6U * node + 3U],
+                                                    direction[6U * node + 4U],
+                                                    direction[6U * node + 5U]} *
+                                          step;
+  }
+  return trial;
+}
+
+fesa::Vector Difference(const fesa::Vector& left, const fesa::Vector& right,
+                        const double denominator) {
+  fesa::Vector result = left;
+  result.Axpy(-1.0, right);
+  result.Scale(1.0 / denominator);
+  return result;
+}
+
+TEST(NonlinearMitc4Inertia, IntegratesTheRectangleConsistentMassAndNull) {
+  const auto nodes = Nodes();
+  const auto evaluation =
+      Inertia(nodes).Evaluate({}, fesa::Vector{24U}, fesa::Vector{24U});
+  ASSERT_TRUE(evaluation.HasValue());
+  const fesa::Matrix& mass = evaluation.Value().mass;
+  constexpr std::array<double, 4> kWeights{4.0, 2.0, 1.0, 2.0};
+  constexpr double kC0 = 0.8 / 36.0;
+  for (std::size_t row = 0U; row < 4U; ++row) {
+    for (std::size_t column = 0U; column < 4U; ++column) {
+      const std::size_t offset = (column + 4U - row) % 4U;
+      EXPECT_NEAR(mass(6U * row, 6U * column), kC0 * kWeights[offset], 1.0e-12);
+    }
+    EXPECT_NEAR(mass(6U * row + 5U, 6U * row + 5U), 0.0, 1.0e-12);
+  }
+  fesa::Vector drilling_null{24U};
+  for (std::size_t node = 0U; node < 4U; ++node) {
+    drilling_null[6U * node + 5U] = 1.0;
+  }
+  EXPECT_LE(mass.Multiply(drilling_null).Norm(), 1.0e-12);
+}
+
+TEST(NonlinearMitc4Inertia, UsesPhysicalAccelerationAndExactCurrentForce) {
+  const auto nodes = Nodes();
+  fesa::NonlinearMitc4TrialDofs trial{};
+  for (std::size_t node = 0U; node < 4U; ++node) {
+    trial.rotation_vector[node] = {0.05 * (node + 1U), -0.03 * (node + 1U),
+                                   0.02 * (node + 1U)};
+  }
+  fesa::Vector acceleration{24U};
+  for (std::size_t index = 0U; index < acceleration.Size(); ++index) {
+    acceleration[index] = 0.01 * static_cast<double>(index + 1U);
+  }
+  const auto evaluation =
+      Inertia(nodes).Evaluate(trial, fesa::Vector{24U}, acceleration);
+  ASSERT_TRUE(evaluation.HasValue());
+  const fesa::Vector expected = evaluation.Value().mass.Multiply(acceleration);
+  for (std::size_t index = 0U; index < expected.Size(); ++index) {
+    EXPECT_NEAR(evaluation.Value().force[index], expected[index], 1.0e-11);
+    EXPECT_NEAR(evaluation.Value().convective_force[index], 0.0, 1.0e-11);
+  }
+}
+
+using V3 = fesa::Vector3;
+
+V3 Multiply(const fesa::Matrix& matrix, const V3& value) {
+  return {matrix(0, 0) * value.X() + matrix(0, 1) * value.Y() +
+              matrix(0, 2) * value.Z(),
+          matrix(1, 0) * value.X() + matrix(1, 1) * value.Y() +
+              matrix(1, 2) * value.Z(),
+          matrix(2, 0) * value.X() + matrix(2, 1) * value.Y() +
+              matrix(2, 2) * value.Z()};
+}
+
+// exp of the 24x24 subset-block matrix applied to (d0,0,...,0).
+// Its off-diagonal blocks are the three direction skew matrices; the
+// subset-7 block is the mixed third derivative. No Jl scalar is reused.
+V3 BlockExponentialDerivative(const V3& phi, const V3& initial,
+                              const std::vector<V3>& directions) {
+  std::array<V3, 8> term{};
+  std::array<V3, 8> sum{};
+  term[0] = initial;
+  sum[0] = initial;
+  const std::size_t blocks = std::size_t{1U} << directions.size();
+  for (std::size_t order = 1U; order <= 64U; ++order) {
+    std::array<V3, 8> next{};
+    for (std::size_t subset = 0U; subset < blocks; ++subset) {
+      next[subset] = phi.Cross(term[subset]);
+      for (std::size_t axis = 0U; axis < directions.size(); ++axis) {
+        const std::size_t bit = std::size_t{1U} << axis;
+        if ((subset & bit) != 0U) {
+          next[subset] =
+              next[subset] + directions[axis].Cross(term[subset ^ bit]);
+        }
+      }
+      next[subset] = next[subset] / static_cast<double>(order);
+      sum[subset] = sum[subset] + next[subset];
+    }
+    term = next;
+  }
+  return sum[blocks - 1U];
+}
+
+V3 Second(const fesa::DynamicRotationKinematics& value, const V3& p,
+          const V3& r) {
+  V3 result{};
+  for (std::size_t i = 0; i < 3; ++i) {
+    for (std::size_t j = 0; j < 3; ++j) {
+      result = result + value.director_second[i][j] * p[i] * r[j];
+    }
+  }
+  return result;
+}
+
+V3 Third(const fesa::DynamicRotationKinematics& value, const V3& p, const V3& r,
+         const V3& t) {
+  V3 result{};
+  for (std::size_t i = 0; i < 3; ++i) {
+    for (std::size_t j = 0; j < 3; ++j) {
+      for (std::size_t k = 0; k < 3; ++k) {
+        result = result + value.director_third[i][j][k] * p[i] * r[j] * t[k];
+      }
+    }
+  }
+  return result;
+}
+
+double MatrixNorm(const fesa::Matrix& matrix) {
+  double norm = 0.0;
+  for (std::size_t i = 0; i < matrix.Rows(); ++i) {
+    for (std::size_t j = 0; j < matrix.Columns(); ++j) {
+      norm = std::hypot(norm, matrix(i, j));
+    }
+  }
+  return norm;
+}
+
+struct Fixture {
+  std::array<fesa::Node, 4> nodes = Nodes();
+  std::array<fesa::ShellNodeInitialFrame, 4> frames = Frames();
+  double thickness = 0.2;
+  double density = 1.0;
+  double modulus = 1000.0;
+
+  double Length() const {
+    double length = 0.0;
+    for (std::size_t i = 0; i < 4; ++i) {
+      length = std::max(length, (V3{nodes[(i + 1U) % 4U].coordinates} -
+                                 V3{nodes[i].coordinates})
+                                    .Norm());
+    }
+    return length;
+  }
+
+  fesa::Result<fesa::NonlinearMitc4Inertia> Create() const {
+    return fesa::NonlinearMitc4Inertia::Create(
+        Pointers(nodes), frames,
+        {"Section", thickness, 0U, {"nonlinear-inertia.inp", 20U}},
+        {"Material", modulus, 0.3, {"nonlinear-inertia.inp", 21U}}, density);
+  }
+};
+
+Fixture Warped() {
+  Fixture fixture;
+  fixture.nodes[2].coordinates[2] = 0.1;
+  const fesa::Mitc4ShellDefinition element{{"Shell-Instance", 1, "1"},
+                                           fesa::ShellSourceElementType::kS4,
+                                           {0U, 1U, 2U, 3U},
+                                           0U,
+                                           0U,
+                                           {"nonlinear-inertia.inp", 10U}};
+  const auto geometry = fesa::PreprocessShellGeometry(
+      std::vector<fesa::Node>{fixture.nodes.begin(), fixture.nodes.end()},
+      {element}, {{"Section", 0.2, 0U, {"nonlinear-inertia.inp", 20U}}});
+  EXPECT_TRUE(geometry.HasValue());
+  for (std::size_t i = 0; i < 4; ++i) {
+    fixture.frames[i] = geometry.Value().nodal_frames[i];
+  }
+  return fixture;
+}
+
+struct State {
+  fesa::NonlinearMitc4TrialDofs q{};
+  fesa::Vector v{24U};
+  fesa::Vector a{24U};
+};
+
+State FiniteState() {
+  State state;
+  for (std::size_t node = 0; node < 4; ++node) {
+    const double i = static_cast<double>(node + 1U);
+    state.q.displacement[node] = {0.01 * i, -0.01 * i, 0.005 * i};
+    state.q.rotation_vector[node] = {0.05 * i, -0.03 * i, 0.02 * i};
+    const std::array<double, 6> v{0.1, 0.05 * i, -0.03 * i,
+                                  0.2, -0.1 * i, 0.04 * i};
+    const std::array<double, 6> a{0.3, -0.2, 0.1 * i, -0.07 * i, 0.06, 0.05};
+    for (std::size_t j = 0; j < 6; ++j) {
+      state.v[6U * node + j] = v[j];
+      state.a[6U * node + j] = a[j];
+    }
+  }
+  return state;
+}
+
+fesa::Vector ApplyD(fesa::Vector vector, const double length) {
+  for (std::size_t i = 0; i < vector.Size(); ++i) {
+    if (i % 6U < 3U) {
+      vector[i] *= length;
+    }
+  }
+  return vector;
+}
+
+fesa::Matrix ScaledMatrix(const fesa::Matrix& matrix, const double length) {
+  fesa::Matrix result{matrix.Rows(), matrix.Columns()};
+  for (std::size_t i = 0; i < matrix.Rows(); ++i) {
+    for (std::size_t j = 0; j < matrix.Columns(); ++j) {
+      result(i, j) = matrix(i, j) * (i % 6U < 3U ? length : 1.0) *
+                     (j % 6U < 3U ? length : 1.0);
+    }
+  }
+  return result;
+}
+
+TEST(DynamicRotation, InverseIdentityAndCurrentAnalyticNullAtFiniteRotation) {
+  for (const V3 phi : {V3{0.5, 0.0, 0.0}, V3{0.2, -0.3, 0.1}}) {
+    const auto rotation = fesa::ExpSkew(phi);
+    const auto jacobian = fesa::LeftJacobianSO3(phi);
+    const auto inverse_transpose = fesa::InverseTransposeLeftJacobianSO3(phi);
+    for (std::size_t column = 0; column < 3; ++column) {
+      // R^T e_j is a unit initial director; its current director is e_j.
+      const V3 initial{rotation(column, 0), rotation(column, 1),
+                       rotation(column, 2)};
+      const auto value = fesa::EvaluateDynamicRotation(phi, initial, {}, {});
+      ASSERT_TRUE(value.HasValue());
+      const V3 inverse_column{inverse_transpose(column, 0),
+                              inverse_transpose(column, 1),
+                              inverse_transpose(column, 2)};
+      EXPECT_LE(
+          (value.Value().drill_null - inverse_column / inverse_column.Norm())
+              .Norm(),
+          1.0e-12);
+      const V3 identity_column =
+          Multiply(jacobian, value.Value().drill_null) * inverse_column.Norm();
+      for (std::size_t row = 0; row < 3; ++row) {
+        EXPECT_NEAR(identity_column[row], row == column ? 1.0 : 0.0, 1.0e-12);
+      }
+    }
+  }
+  for (const Fixture fixture : {Fixture{}, Warped()}) {
+    const auto inertia = fixture.Create();
+    ASSERT_TRUE(inertia.HasValue());
+    for (const bool uniform : {false, true}) {
+      State state = FiniteState();
+      if (uniform) {
+        state.q.rotation_vector.fill(V3{0.2, -0.3, 0.1});
+      }
+      const auto value = inertia.Value().Evaluate(state.q, state.v, state.a);
+      ASSERT_TRUE(value.HasValue());
+      const auto mass = ScaledMatrix(value.Value().mass, fixture.Length());
+      for (std::size_t node = 0; node < 4; ++node) {
+        const auto rotation = fesa::EvaluateDynamicRotation(
+            state.q.rotation_vector[node], V3{fixture.frames[node].director},
+            {}, {});
+        ASSERT_TRUE(rotation.HasValue());
+        fesa::Vector n{24U};
+        for (std::size_t j = 0; j < 3; ++j) {
+          n[6U * node + 3U + j] = rotation.Value().drill_null[j];
+        }
+        EXPECT_LE(mass.Multiply(n).Norm() / MatrixNorm(mass), 1.0e-12);
+        const auto scaled_force = ApplyD(value.Value().force, fixture.Length());
+        EXPECT_LE(std::abs(n.Dot(scaled_force)) / scaled_force.Norm(), 1.0e-10);
+        fesa::Vector fixed_drill{24U};
+        fixed_drill[6U * node + 5U] = 1.0;
+        EXPECT_GT(mass.Multiply(fixed_drill).Norm() / MatrixNorm(mass), 1.0e-8);
+      }
+    }
+  }
+}
+
+TEST(NonlinearMitc4Inertia,
+     RejectsIllConditionedPhysicalMassWithoutDeletingIt) {
+  for (const double density : {1.0e-180, 1.0, 1.0e180}) {
+    Fixture normal;
+    normal.density = density;
+    EXPECT_TRUE(normal.Create().HasValue());
+    Fixture thin = normal;
+    thin.thickness = 1.0e-5;
+    const auto rejected = thin.Create();
+    ASSERT_FALSE(rejected.HasValue());
+    EXPECT_EQ(rejected.GetStatus().Diagnostics()[0].code,
+              "ill-conditioned-nonlinear-inertia-positive-mass");
+  }
+}
+
+TEST(NonlinearMitc4Inertia,
+     ConvectiveForceDoesNotLoseSmallValuesToAcceleration) {
+  const auto inertia = Fixture{}.Create();
+  ASSERT_TRUE(inertia.HasValue());
+  State state = FiniteState();
+  const auto ordinary = inertia.Value().Evaluate(state.q, state.v, state.a);
+  state.a.Scale(1.0e15);
+  const auto large = inertia.Value().Evaluate(state.q, state.v, state.a);
+  ASSERT_TRUE(ordinary.HasValue());
+  ASSERT_TRUE(large.HasValue());
+  EXPECT_GT(ordinary.Value().convective_force.Norm(), 0.0);
+  for (std::size_t i = 0; i < 24; ++i) {
+    EXPECT_EQ(ordinary.Value().convective_force[i],
+              large.Value().convective_force[i]);
+  }
+}
+
+TEST(NonlinearMitc4Inertia,
+     PartialAndEffectiveTangentsPassTheScaledFixedSweep) {
+  constexpr std::array<int, 7> kExponents{8, 10, 12, 14, 16, 18, 20};
+  for (const Fixture fixture : {Fixture{}, Warped()}) {
+    const auto inertia = fixture.Create();
+    ASSERT_TRUE(inertia.HasValue());
+    const State state = FiniteState();
+    const auto value = inertia.Value().Evaluate(state.q, state.v, state.a);
+    ASSERT_TRUE(value.HasValue());
+    for (std::size_t channel = 0; channel < 3; ++channel) {
+      fesa::Vector p{24U};
+      for (std::size_t i = 0; i < 24; ++i) {
+        if (channel == 2U || (channel == 0U) == (i % 6U < 3U)) {
+          p[i] = static_cast<double>(i + 1U) * (i % 2U == 0U ? 1.0 : -1.0);
+        }
+      }
+      p.Scale(1.0 / p.Norm());
+      const auto direction = ApplyD(p, fixture.Length());
+      // q, v, a partials and the two HHT dependent-rate effective tangents.
+      for (std::size_t mode = 0; mode < 5; ++mode) {
+        const double h = mode == 4U ? 0.025 : 0.1;
+        const double cv =
+            mode >= 3U ? 0.55 / (0.275625 * h) : (mode == 1U ? 1.0 : 0.0);
+        const double ca = mode >= 3U ? 1.0 / (0.95 * 0.275625 * h * h)
+                                     : (mode == 2U ? 1.0 : 0.0);
+        const double cq = mode == 0U || mode >= 3U ? 1.0 : 0.0;
+        fesa::Matrix tangent{24U, 24U};
+        for (std::size_t i = 0; i < 24; ++i) {
+          for (std::size_t j = 0; j < 24; ++j) {
+            tangent(i, j) = cq * value.Value().position_tangent(i, j) +
+                            cv * value.Value().velocity_tangent(i, j) +
+                            ca * value.Value().mass(i, j);
+          }
+        }
+        const auto scaled = ScaledMatrix(tangent, fixture.Length());
+        const auto analytical = scaled.Multiply(p);
+        bool previous_pass = false;
+        bool consecutive = false;
+        for (const int exponent : kExponents) {
+          const double step = std::ldexp(1.0, -exponent);
+          State plus = state;
+          State minus = state;
+          plus.q = AddRotation(state.q, direction, cq * step);
+          minus.q = AddRotation(state.q, direction, -cq * step);
+          plus.v.Axpy(cv * step, direction);
+          minus.v.Axpy(-cv * step, direction);
+          plus.a.Axpy(ca * step, direction);
+          minus.a.Axpy(-ca * step, direction);
+          const auto vp = inertia.Value().Evaluate(plus.q, plus.v, plus.a);
+          const auto vm = inertia.Value().Evaluate(minus.q, minus.v, minus.a);
+          ASSERT_TRUE(vp.HasValue());
+          ASSERT_TRUE(vm.HasValue());
+          const auto fd =
+              ApplyD(Difference(vp.Value().force, vm.Value().force, 2.0 * step),
+                     fixture.Length());
+          const double error = Difference(analytical, fd, 1.0).Norm();
+          const double scale = analytical.Norm() > 0.0
+                                   ? analytical.Norm() + fd.Norm()
+                                   : MatrixNorm(scaled);
+          const double metric = scale > 0.0 ? error / scale : error;
+          const double tolerance = analytical.Norm() > 0.0 ? 1.0e-6 : 1.0e-10;
+          std::cout << "C06 tangent channel=" << channel << " mode=" << mode
+                    << " j=" << exponent << " raw=" << error
+                    << " metric=" << metric << '\n';
+          const bool pass =
+              metric <= tolerance && exponent >= 10 && exponent <= 18;
+          consecutive = consecutive || (previous_pass && pass);
+          previous_pass = pass;
+        }
+        EXPECT_TRUE(consecutive) << "channel=" << channel << " mode=" << mode;
+      }
+    }
+  }
+}
+
+struct Integral {
+  std::array<std::array<std::array<double, 4>, 4>, 3> moments{};
+  fesa::Matrix mass{24U, 24U};
+  fesa::Vector force{24U};
+  double energy = 0.0;
+  double power = 0.0;
+  double total_mass = 0.0;
+  V3 momentum{};
+  V3 angular_momentum{};
+  V3 momentum_rate{};
+  V3 angular_momentum_rate{};
+};
+
+Integral IntegrateFivePoints(const Fixture& fixture, const State& state) {
+  const double r = std::sqrt(10.0 / 7.0);
+  const double outer = std::sqrt(5.0 + 2.0 * r) / 3.0;
+  const double inner = std::sqrt(5.0 - 2.0 * r) / 3.0;
+  const double wouter = (322.0 - 13.0 * std::sqrt(70.0)) / 900.0;
+  const double winner = (322.0 + 13.0 * std::sqrt(70.0)) / 900.0;
+  const std::array<double, 5> points{-outer, -inner, 0.0, inner, outer};
+  const std::array<double, 5> weights{wouter, winner, 128.0 / 225.0, winner,
+                                      wouter};
+  const std::array<double, 4> sx{-1, 1, 1, -1};
+  const std::array<double, 4> sy{-1, -1, 1, 1};
+  std::array<V3, 4> directors{};
+  std::array<std::array<V3, 3>, 4> first{};
+  std::array<V3, 4> convective{};
+  for (std::size_t node = 0; node < 4; ++node) {
+    const V3 phi = state.q.rotation_vector[node];
+    const V3 d0{fixture.frames[node].director};
+    directors[node] = BlockExponentialDerivative(phi, d0, {});
+    const V3 vr{state.v[6U * node + 3U], state.v[6U * node + 4U],
+                state.v[6U * node + 5U]};
+    convective[node] = BlockExponentialDerivative(phi, d0, {vr, vr});
+    for (std::size_t j = 0; j < 3; ++j) {
+      std::array<double, 3> basis{};
+      basis[j] = 1.0;
+      first[node][j] = BlockExponentialDerivative(phi, d0, {V3{basis}});
+    }
+  }
+  Integral integral;
+  for (std::size_t xi = 0; xi < 5; ++xi) {
+    for (std::size_t eta = 0; eta < 5; ++eta) {
+      for (std::size_t zeta = 0; zeta < 5; ++zeta) {
+        const double z = 0.5 * fixture.thickness * points[zeta];
+        std::array<double, 4> shape{};
+        std::array<V3, 24> h{};
+        V3 a1{};
+        V3 a2{};
+        V3 a3{};
+        V3 position{};
+        V3 velocity{};
+        V3 acceleration{};
+        for (std::size_t node = 0; node < 4; ++node) {
+          shape[node] = 0.25 * (1.0 + sx[node] * points[xi]) *
+                        (1.0 + sy[node] * points[eta]);
+          const double dx = 0.25 * sx[node] * (1.0 + sy[node] * points[eta]);
+          const double dy = 0.25 * sy[node] * (1.0 + sx[node] * points[xi]);
+          const V3 d0{fixture.frames[node].director};
+          const V3 x0{fixture.nodes[node].coordinates};
+          a1 = a1 + dx * (x0 + z * d0);
+          a2 = a2 + dy * (x0 + z * d0);
+          a3 = a3 + 0.5 * fixture.thickness * shape[node] * d0;
+          position = position + shape[node] * (x0 + state.q.displacement[node] +
+                                               z * directors[node]);
+          acceleration = acceleration + z * shape[node] * convective[node];
+          for (std::size_t j = 0; j < 3; ++j) {
+            std::array<double, 3> axis{};
+            axis[j] = shape[node];
+            h[6U * node + j] = V3{axis};
+            h[6U * node + 3U + j] = z * shape[node] * first[node][j];
+          }
+        }
+        const double weight = fixture.density * weights[xi] * weights[eta] *
+                              weights[zeta] * a1.Dot(a2.Cross(a3));
+        EXPECT_GT(weight, 0.0);
+        integral.total_mass += weight;
+        for (std::size_t i = 0; i < 24; ++i) {
+          velocity = velocity + h[i] * state.v[i];
+          acceleration = acceleration + h[i] * state.a[i];
+        }
+        integral.energy += 0.5 * weight * velocity.Dot(velocity);
+        integral.power += weight * velocity.Dot(acceleration);
+        integral.momentum = integral.momentum + weight * velocity;
+        integral.angular_momentum =
+            integral.angular_momentum + weight * position.Cross(velocity);
+        integral.momentum_rate = integral.momentum_rate + weight * acceleration;
+        integral.angular_momentum_rate = integral.angular_momentum_rate +
+                                         weight * position.Cross(acceleration);
+        for (std::size_t i = 0; i < 24; ++i) {
+          integral.force[i] += weight * h[i].Dot(acceleration);
+          for (std::size_t j = 0; j < 24; ++j) {
+            integral.mass(i, j) += weight * h[i].Dot(h[j]);
+          }
+        }
+        for (std::size_t i = 0; i < 4; ++i) {
+          for (std::size_t j = 0; j < 4; ++j) {
+            double moment = weight * shape[i] * shape[j];
+            for (std::size_t k = 0; k < 3; ++k) {
+              integral.moments[k][i][j] += moment;
+              moment *= z;
+            }
+          }
+        }
+      }
+    }
+  }
+  return integral;
+}
+
+TEST(NonlinearMitc4Inertia,
+     MatchesIndependentWarpedVolumeMomentsEnergyAndPower) {
+  for (const Fixture fixture : {Fixture{}, Warped()}) {
+    const auto inertia = fixture.Create();
+    ASSERT_TRUE(inertia.HasValue());
+    const State state = FiniteState();
+    const auto value = inertia.Value().Evaluate(state.q, state.v, state.a);
+    ASSERT_TRUE(value.HasValue());
+    const Integral oracle = IntegrateFivePoints(fixture, state);
+    const auto actual_mass = ScaledMatrix(value.Value().mass, fixture.Length());
+    const auto expected_mass = ScaledMatrix(oracle.mass, fixture.Length());
+    double mass_error = 0.0;
+    double symmetry_error = 0.0;
+    for (std::size_t i = 0; i < 24; ++i) {
+      for (std::size_t j = 0; j < 24; ++j) {
+        mass_error =
+            std::hypot(mass_error, actual_mass(i, j) - expected_mass(i, j));
+        symmetry_error =
+            std::hypot(symmetry_error, actual_mass(i, j) - actual_mass(j, i));
+      }
+    }
+    EXPECT_LE(mass_error / MatrixNorm(expected_mass), 1.0e-12);
+    EXPECT_LE(symmetry_error / MatrixNorm(expected_mass), 1.0e-12);
+    EXPECT_LE(
+        std::abs(value.Value().kinetic_energy - oracle.energy) / oracle.energy,
+        1.0e-12);
+    EXPECT_LE(std::abs(0.5 * state.v.Dot(value.Value().mass.Multiply(state.v)) -
+                       oracle.energy) /
+                  oracle.energy,
+              1.0e-12);
+    EXPECT_LE(std::abs(state.v.Dot(value.Value().force) - oracle.power) /
+                  std::abs(oracle.power),
+              1.0e-10);
+    EXPECT_LE(Difference(ApplyD(value.Value().force, fixture.Length()),
+                         ApplyD(oracle.force, fixture.Length()), 1.0)
+                      .Norm() /
+                  ApplyD(oracle.force, fixture.Length()).Norm(),
+              1.0e-12);
+    EXPECT_LE((value.Value().momentum - oracle.momentum).Norm() /
+                  oracle.momentum.Norm(),
+              1.0e-12);
+    EXPECT_LE(
+        (value.Value().angular_momentum - oracle.angular_momentum).Norm() /
+            oracle.angular_momentum.Norm(),
+        1.0e-12);
+    EXPECT_LE((value.Value().momentum_rate - oracle.momentum_rate).Norm() /
+                  oracle.momentum_rate.Norm(),
+              1.0e-12);
+    EXPECT_LE(
+        (value.Value().angular_momentum_rate - oracle.angular_momentum_rate)
+                .Norm() /
+            oracle.angular_momentum_rate.Norm(),
+        1.0e-12);
+    // Recover C0/C1/C2 from their known tensor factors, with the prescribed
+    // m_e*(t/2)^k scales even when a centered C1 is exactly zero.
+    for (std::size_t i = 0; i < 4; ++i) {
+      const auto bi = fesa::EvaluateDynamicRotation(
+          state.q.rotation_vector[i], V3{fixture.frames[i].director}, {}, {});
+      ASSERT_TRUE(bi.HasValue());
+      for (std::size_t j = 0; j < 4; ++j) {
+        const auto bj = fesa::EvaluateDynamicRotation(
+            state.q.rotation_vector[j], V3{fixture.frames[j].director}, {}, {});
+        ASSERT_TRUE(bj.HasValue());
+        std::array<double, 3> numerator{};
+        std::array<double, 3> denominator{1.0, 0.0, 0.0};
+        numerator[0] = value.Value().mass(6U * i, 6U * j);
+        for (std::size_t a = 0; a < 3; ++a) {
+          for (std::size_t b = 0; b < 3; ++b) {
+            const double b1 = bj.Value().director_first[b][a];
+            const double b2 =
+                bi.Value().director_first[a].Dot(bj.Value().director_first[b]);
+            numerator[1] +=
+                value.Value().mass(6U * i + a, 6U * j + 3U + b) * b1;
+            denominator[1] += b1 * b1;
+            numerator[2] +=
+                value.Value().mass(6U * i + 3U + a, 6U * j + 3U + b) * b2;
+            denominator[2] += b2 * b2;
+          }
+        }
+        double scale = oracle.total_mass;
+        for (std::size_t k = 0; k < 3; ++k) {
+          EXPECT_LE(std::abs(numerator[k] / denominator[k] -
+                             oracle.moments[k][i][j]) /
+                        scale,
+                    1.0e-12);
+          scale *= fixture.thickness / 2.0;
+        }
+      }
+    }
+    State uniform;
+    for (std::size_t i = 0; i < 4; ++i) {
+      uniform.v[6U * i] = 0.3;
+      uniform.v[6U * i + 1U] = -0.4;
+      uniform.v[6U * i + 2U] = 0.5;
+    }
+    const auto translation = inertia.Value().Evaluate({}, uniform.v, uniform.a);
+    ASSERT_TRUE(translation.HasValue());
+    EXPECT_NEAR(translation.Value().kinetic_energy / oracle.total_mass, 0.25,
+                1.0e-12);
+  }
+}
+
+TEST(DynamicRotation, ThirdDerivativesMatchAllPermutationsAndInteriorSweep) {
+  const std::array<V3, 5> states{
+      V3{}, V3{1.0e-6, -2.0e-6, 3.0e-6}, V3{0.2, -0.3, 0.4},
+      V3{1.0e-4 * (1.0 - std::ldexp(1.0, -10)), 0.0, 0.0},
+      V3{1.0e-4 * (1.0 + std::ldexp(1.0, -10)), 0.0, 0.0}};
+  const std::array<V3, 4> directions{V3{1, 0, 0}, V3{0, 1, 0}, V3{0, 0, 1},
+                                     V3{1, 2, -1} / std::sqrt(6.0)};
+  const V3 initial{0, 0, 1};
+  for (std::size_t state_index = 0; state_index < states.size();
+       ++state_index) {
+    const auto value =
+        fesa::EvaluateDynamicRotation(states[state_index], initial, {}, {});
+    ASSERT_TRUE(value.HasValue());
+    for (std::size_t p = 0; p < 4; ++p) {
+      std::array<std::array<bool, 4>, 4> previous{};
+      std::array<std::array<bool, 4>, 4> consecutive{};
+      for (const int exponent : {8, 10, 12, 14, 16, 18, 20}) {
+        const double step = std::ldexp(1.0, -exponent);
+        const auto plus = fesa::EvaluateDynamicRotation(
+            states[state_index] + step * directions[p], initial, {}, {});
+        const auto minus = fesa::EvaluateDynamicRotation(
+            states[state_index] - step * directions[p], initial, {}, {});
+        ASSERT_TRUE(plus.HasValue());
+        ASSERT_TRUE(minus.HasValue());
+        for (std::size_t r = 0; r < 4; ++r) {
+          for (std::size_t t = 0; t < 4; ++t) {
+            const V3 analytic = Third(value.Value(), directions[p],
+                                      directions[r], directions[t]);
+            const V3 fd =
+                (Second(plus.Value(), directions[r], directions[t]) -
+                 Second(minus.Value(), directions[r], directions[t])) /
+                (2.0 * step);
+            const V3 oracle = BlockExponentialDerivative(
+                states[state_index], initial,
+                {directions[p], directions[r], directions[t]});
+            EXPECT_LE((analytic - oracle).Norm(), 1.0e-12);
+            EXPECT_LE((analytic - Third(value.Value(), directions[t],
+                                        directions[p], directions[r]))
+                          .Norm(),
+                      1.0e-12);
+            const double error = (analytic - fd).Norm();
+            const double scale =
+                analytic.Norm() > 0.0 ? analytic.Norm() + fd.Norm() : 1.0;
+            const double metric = error / scale;
+            const double tolerance = analytic.Norm() > 0.0 ? 1.0e-6 : 1.0e-10;
+            std::cout << "C06 D3 state=" << state_index << " triple=" << p << r
+                      << t << " j=" << exponent << " raw=" << error
+                      << " metric=" << metric << '\n';
+            const bool pass =
+                metric <= tolerance && exponent >= 10 && exponent <= 18;
+            consecutive[r][t] = consecutive[r][t] || (previous[r][t] && pass);
+            previous[r][t] = pass;
+          }
+        }
+      }
+      for (std::size_t r = 0; r < 4; ++r) {
+        for (std::size_t t = 0; t < 4; ++t) {
+          EXPECT_TRUE(consecutive[r][t])
+              << "state=" << state_index << " triple=" << p << r << t;
+        }
+      }
+    }
+  }
+}
+
+TEST(DynamicRotation, NormalizedNullDerivativesIncludeNormalizationCurvature) {
+  const V3 initial{0, 0, 1};
+  const V3 direction = V3{1, -2, 3} / std::sqrt(14.0);
+  for (const V3 phi : {V3{}, V3{1.0e-6, -2.0e-6, 3.0e-6}, V3{0.2, -0.3, 0.4}}) {
+    const auto value =
+        fesa::EvaluateDynamicRotation(phi, initial, direction, {});
+    ASSERT_TRUE(value.HasValue());
+    const V3 first = Multiply(value.Value().null_gradient, direction);
+    EXPECT_NEAR(value.Value().drill_null.Norm(), 1.0, 1.0e-12);
+    EXPECT_NEAR(value.Value().drill_null.Dot(first), 0.0, 1.0e-12);
+    EXPECT_NEAR(
+        value.Value().drill_null.Dot(value.Value().null_directional_second),
+        -first.Dot(first), 1.0e-12);
+    bool previous = false;
+    bool consecutive = false;
+    for (const int exponent : {8, 10, 12, 14, 16, 18, 20}) {
+      const double step = std::ldexp(1.0, -exponent);
+      const auto plus = fesa::EvaluateDynamicRotation(phi + step * direction,
+                                                      initial, direction, {});
+      const auto minus = fesa::EvaluateDynamicRotation(phi - step * direction,
+                                                       initial, direction, {});
+      ASSERT_TRUE(plus.HasValue());
+      ASSERT_TRUE(minus.HasValue());
+      const V3 fd1 =
+          (plus.Value().drill_null - minus.Value().drill_null) / (2.0 * step);
+      const V3 fd2 = (Multiply(plus.Value().null_gradient, direction) -
+                      Multiply(minus.Value().null_gradient, direction)) /
+                     (2.0 * step);
+      const double error1 = (fd1 - first).Norm() / (fd1.Norm() + first.Norm());
+      const double error2 =
+          (fd2 - value.Value().null_directional_second).Norm() /
+          (fd2.Norm() + value.Value().null_directional_second.Norm());
+      std::cout << "C06 null j=" << exponent << " D1=" << error1
+                << " D2=" << error2 << '\n';
+      const bool pass = error1 <= 1.0e-6 && error2 <= 1.0e-6 &&
+                        exponent >= 10 && exponent <= 18;
+      consecutive = consecutive || (previous && pass);
+      previous = pass;
+    }
+    EXPECT_TRUE(consecutive);
+  }
+  EXPECT_FALSE(fesa::EvaluateDynamicRotation({}, {0, 0, 2}, {}, {}).HasValue());
+  EXPECT_FALSE(
+      fesa::EvaluateDynamicRotation(
+          {std::numeric_limits<double>::quiet_NaN(), 0, 0}, initial, {}, {})
+          .HasValue());
+}
+
+TEST(NonlinearMitc4Inertia, UnitAndGlobalFrameChangesPreservePhysicalMetrics) {
+  const Fixture fixture = Warped();
+  const State state = FiniteState();
+  const auto inertia = fixture.Create();
+  ASSERT_TRUE(inertia.HasValue());
+  const auto value = inertia.Value().Evaluate(state.q, state.v, state.a);
+  ASSERT_TRUE(value.HasValue());
+  constexpr double kLength = 1.0e-3;
+  constexpr double kMass = 1.0e-6;
+  constexpr double kTime = 1.0e2;
+  Fixture units = fixture;
+  State converted = state;
+  units.thickness *= kLength;
+  units.density *= kMass / (kLength * kLength * kLength);
+  units.modulus *= kMass / (kLength * kTime * kTime);
+  for (std::size_t node = 0; node < 4; ++node) {
+    for (double& coordinate : units.nodes[node].coordinates) {
+      coordinate *= kLength;
+    }
+    converted.q.displacement[node] = kLength * state.q.displacement[node];
+    for (std::size_t j = 0; j < 6; ++j) {
+      const double length_factor = j < 3U ? kLength : 1.0;
+      converted.v[6U * node + j] *= length_factor / kTime;
+      converted.a[6U * node + j] *= length_factor / (kTime * kTime);
+    }
+  }
+  const auto converted_inertia = units.Create();
+  ASSERT_TRUE(converted_inertia.HasValue());
+  const auto uv =
+      converted_inertia.Value().Evaluate(converted.q, converted.v, converted.a);
+  ASSERT_TRUE(uv.HasValue());
+  const double energy_scale = kMass * kLength * kLength / (kTime * kTime);
+  EXPECT_LE(std::abs(uv.Value().kinetic_energy / energy_scale -
+                     value.Value().kinetic_energy) /
+                value.Value().kinetic_energy,
+            1.0e-12);
+  const auto original_scaled =
+      ScaledMatrix(value.Value().mass, fixture.Length());
+  const auto converted_scaled = ScaledMatrix(uv.Value().mass, units.Length());
+  double error = 0.0;
+  for (std::size_t i = 0; i < 24; ++i) {
+    for (std::size_t j = 0; j < 24; ++j) {
+      error = std::hypot(error,
+                         converted_scaled(i, j) / (kMass * kLength * kLength) -
+                             original_scaled(i, j));
+    }
+  }
+  EXPECT_LE(error / MatrixNorm(original_scaled), 1.0e-12);
+  const auto original_force = ApplyD(value.Value().force, fixture.Length());
+  auto converted_force = ApplyD(uv.Value().force, units.Length());
+  converted_force.Scale(1.0 / energy_scale);
+  EXPECT_LE(Difference(original_force, converted_force, 1.0).Norm() /
+                original_force.Norm(),
+            1.0e-10);
+
+  const auto qx = fesa::ExpSkew(V3{0.4, 0, 0});
+  const auto qz = fesa::ExpSkew(V3{0, 0, 0.7});
+  const auto rotate = [&](const V3& v) {
+    return Multiply(qz, Multiply(qx, v));
+  };
+  Fixture frame = fixture;
+  State rotated = state;
+  for (std::size_t node = 0; node < 4; ++node) {
+    frame.nodes[node].coordinates =
+        rotate(V3{fixture.nodes[node].coordinates}).Components();
+    frame.frames[node].director =
+        rotate(V3{fixture.frames[node].director}).Components();
+    frame.frames[node].tangent_a =
+        rotate(V3{fixture.frames[node].tangent_a}).Components();
+    frame.frames[node].tangent_b =
+        rotate(V3{fixture.frames[node].tangent_b}).Components();
+    rotated.q.displacement[node] = rotate(state.q.displacement[node]);
+    rotated.q.rotation_vector[node] = rotate(state.q.rotation_vector[node]);
+    for (std::size_t offset = 0; offset < 6; offset += 3) {
+      const std::size_t base = 6U * node + offset;
+      const V3 v =
+          rotate(V3{state.v[base], state.v[base + 1U], state.v[base + 2U]});
+      const V3 a =
+          rotate(V3{state.a[base], state.a[base + 1U], state.a[base + 2U]});
+      for (std::size_t j = 0; j < 3; ++j) {
+        rotated.v[base + j] = v[j];
+        rotated.a[base + j] = a[j];
+      }
+    }
+  }
+  const auto frame_inertia = frame.Create();
+  ASSERT_TRUE(frame_inertia.HasValue());
+  const auto fv =
+      frame_inertia.Value().Evaluate(rotated.q, rotated.v, rotated.a);
+  ASSERT_TRUE(fv.HasValue());
+  EXPECT_LE(std::abs(fv.Value().kinetic_energy - value.Value().kinetic_energy) /
+                value.Value().kinetic_energy,
+            1.0e-12);
+  EXPECT_LE((fv.Value().momentum - rotate(value.Value().momentum)).Norm() /
+                value.Value().momentum.Norm(),
+            1.0e-12);
+  EXPECT_LE(
+      (fv.Value().angular_momentum - rotate(value.Value().angular_momentum))
+              .Norm() /
+          value.Value().angular_momentum.Norm(),
+      1.0e-12);
+  for (std::size_t base = 0; base < 24; base += 3) {
+    const V3 expected =
+        rotate(V3{value.Value().force[base], value.Value().force[base + 1U],
+                  value.Value().force[base + 2U]});
+    const V3 actual{fv.Value().force[base], fv.Value().force[base + 1U],
+                    fv.Value().force[base + 2U]};
+    EXPECT_LE((actual - expected).Norm() / expected.Norm(), 1.0e-10);
+  }
+  // Full matrix congruence checks every translation/rotation cross-block.
+  double covariance_error = 0.0;
+  for (std::size_t i = 0; i < 24; i += 3) {
+    for (std::size_t j = 0; j < 24; j += 3) {
+      for (std::size_t column = 0; column < 3; ++column) {
+        std::array<double, 3> axis{};
+        axis[column] = 1.0;
+        const V3 global_axis = rotate(V3{axis});
+        V3 result{};
+        std::array<double, 3> components{};
+        for (std::size_t row = 0; row < 3; ++row) {
+          for (std::size_t k = 0; k < 3; ++k) {
+            components[row] += fv.Value().mass(i + row, j + k) * global_axis[k];
+          }
+        }
+        result = V3{components};
+        const V3 expected = rotate(V3{value.Value().mass(i, j + column),
+                                      value.Value().mass(i + 1U, j + column),
+                                      value.Value().mass(i + 2U, j + column)});
+        covariance_error =
+            std::hypot(covariance_error, (result - expected).Norm());
+      }
+    }
+  }
+  EXPECT_LE(covariance_error / MatrixNorm(value.Value().mass), 1.0e-12);
+}
+
+TEST(DynamicRotation, MatchesEightyDigitIndependentBlockExponentialAnchors) {
+  // Constants were evaluated with Python decimal precision 80 by applying
+  // exp(A) to (e3,0,...,0), with A the 24x24 subset-block matrix described
+  // above, summing 99 matrix-power terms. This oracle uses no Rodrigues/Jl
+  // coefficients and retains high precision even on MSVC (long double=double).
+  const std::array<std::array<V3, 3>, 5> expected{
+      std::array<V3, 3>{V3{0, 1, 0}, V3{0, 0, 0},
+                        V3{-0.81649658092772603, 0.40824829046386302, 0}},
+      std::array<V3, 3>{
+          V3{-7.5000039999910002e-07, 0.9999999999982, 9.9999999999883338e-07},
+          V3{1.6666686666628888e-07, -8.3332933333111116e-08,
+             2.6666666666643096e-19},
+          V3{-0.8164969891729138, 0.40824706571842007,
+             -1.6329931618530299e-06}},
+      std::array<V3, 3>{
+          V3{-0.10876310154778675, 0.95485599102728924, 0.19478607292927094},
+          V3{0.029022554703521119, -0.0080127091261333588,
+             0.0010465349668405597},
+          V3{-0.80418976262207553, 0.24008088229171029, -0.21102407953866634}},
+      std::array<V3, 3>{V3{0, 0.99999999500976089, 9.9902343583821137e-05},
+                        V3{0, -8.325195306960704e-06, 1.111111111020202e-108},
+                        V3{-0.81648298485418402, 0.40825508659919563,
+                           3.7386214252198052e-05}},
+      std::array<V3, 3>{V3{0, 0.99999999499022962, 0.00010009765608284457},
+                        V3{0, -8.3414713485948191e-06, 8.5714285692063495e-99},
+                        V3{-0.81648295827126682, 0.40825509988321224,
+                           3.7459305579990838e-05}}};
+  const std::array<V3, 5> states{
+      V3{}, V3{1.0e-6, -2.0e-6, 3.0e-6}, V3{0.2, -0.3, 0.4},
+      V3{1.0e-4 * (1.0 - std::ldexp(1.0, -10)), 0.0, 0.0},
+      V3{1.0e-4 * (1.0 + std::ldexp(1.0, -10)), 0.0, 0.0}};
+  const V3 e1{1, 0, 0};
+  const V3 e2{0, 1, 0};
+  const V3 e3{0, 0, 1};
+  const V3 mixed = V3{1, 2, -1} / std::sqrt(6.0);
+  for (std::size_t i = 0; i < states.size(); ++i) {
+    const auto value = fesa::EvaluateDynamicRotation(states[i], e3, {}, {});
+    ASSERT_TRUE(value.HasValue());
+    EXPECT_LE((Third(value.Value(), e1, e1, e1) - expected[i][0]).Norm(),
+              1.0e-12);
+    EXPECT_LE((Third(value.Value(), e1, e2, e3) - expected[i][1]).Norm(),
+              1.0e-12);
+    EXPECT_LE(
+        (Third(value.Value(), mixed, mixed, mixed) - expected[i][2]).Norm(),
+        1.0e-12);
+  }
+}
+
+TEST(NonlinearMitc4Inertia, IndependentOracleDetectsEachRequiredOmission) {
+  const Fixture fixture = Warped();
+  const auto inertia = fixture.Create();
+  ASSERT_TRUE(inertia.HasValue());
+  const State state = FiniteState();
+  const auto value = inertia.Value().Evaluate(state.q, state.v, state.a);
+  ASSERT_TRUE(value.HasValue());
+  const Integral oracle = IntegrateFivePoints(fixture, state);
+  fesa::Vector p{24U};
+  for (std::size_t i = 0; i < 24; ++i) {
+    if (i % 6U >= 3U) {
+      p[i] = static_cast<double>(i + 1U) * (i % 2U == 0U ? 1.0 : -1.0);
+    }
+  }
+  p.Scale(1.0 / p.Norm());
+  std::array<V3, 4> first_acceleration{};
+  std::array<V3, 4> third{};
+  std::array<std::array<V3, 3>, 4> first{};
+  std::array<std::array<V3, 3>, 4> second{};
+  for (std::size_t node = 0; node < 4; ++node) {
+    const std::size_t b = 6U * node + 3U;
+    const V3 phi = state.q.rotation_vector[node];
+    const V3 d0{fixture.frames[node].director};
+    const V3 v{state.v[b], state.v[b + 1U], state.v[b + 2U]};
+    const V3 a{state.a[b], state.a[b + 1U], state.a[b + 2U]};
+    const V3 direction{p[b], p[b + 1U], p[b + 2U]};
+    first_acceleration[node] = BlockExponentialDerivative(phi, d0, {a}) +
+                               BlockExponentialDerivative(phi, d0, {v, v});
+    third[node] = BlockExponentialDerivative(phi, d0, {direction, v, v});
+    for (std::size_t j = 0; j < 3; ++j) {
+      std::array<double, 3> axis{};
+      axis[j] = 1.0;
+      first[node][j] = BlockExponentialDerivative(phi, d0, {V3{axis}});
+      second[node][j] =
+          BlockExponentialDerivative(phi, d0, {direction, V3{axis}});
+    }
+  }
+  fesa::Vector transposed_h_derivative{24U};
+  fesa::Vector third_derivative{24U};
+  for (std::size_t i = 0; i < 4; ++i) {
+    for (std::size_t j = 0; j < 4; ++j) {
+      const V3 au{state.a[6U * j], state.a[6U * j + 1U], state.a[6U * j + 2U]};
+      for (std::size_t c = 0; c < 3; ++c) {
+        transposed_h_derivative[6U * i + 3U + c] +=
+            oracle.moments[1][i][j] * second[i][c].Dot(au) +
+            oracle.moments[2][i][j] * second[i][c].Dot(first_acceleration[j]);
+        third_derivative[6U * i + c] += oracle.moments[1][i][j] * third[j][c];
+        third_derivative[6U * i + 3U + c] +=
+            oracle.moments[2][i][j] * first[i][c].Dot(third[j]);
+      }
+    }
+  }
+  const double step = std::ldexp(1.0, -12);
+  const auto plus =
+      inertia.Value().Evaluate(AddRotation(state.q, p, step), state.v, state.a);
+  const auto minus = inertia.Value().Evaluate(AddRotation(state.q, p, -step),
+                                              state.v, state.a);
+  ASSERT_TRUE(plus.HasValue());
+  ASSERT_TRUE(minus.HasValue());
+  const auto fd =
+      ApplyD(Difference(plus.Value().force, minus.Value().force, 2.0 * step),
+             fixture.Length());
+  const auto correct =
+      ApplyD(value.Value().position_tangent.Multiply(p), fixture.Length());
+  for (const auto& omitted : {transposed_h_derivative, third_derivative}) {
+    auto mutant = correct;
+    mutant.Axpy(-1.0, ApplyD(omitted, fixture.Length()));
+    EXPECT_GT(Difference(mutant, fd, 1.0).Norm() / (mutant.Norm() + fd.Norm()),
+              1.0e-6);
+  }
+  auto no_convective = value.Value().force;
+  no_convective.Axpy(-1.0, value.Value().convective_force);
+  EXPECT_GT(Difference(ApplyD(no_convective, fixture.Length()),
+                       ApplyD(oracle.force, fixture.Length()), 1.0)
+                    .Norm() /
+                ApplyD(oracle.force, fixture.Length()).Norm(),
+            1.0e-6);
+  fesa::Vector vp = state.v;
+  fesa::Vector vm = state.v;
+  vp.Axpy(step, p);
+  vm.Axpy(-step, p);
+  const auto vplus = inertia.Value().Evaluate(state.q, vp, state.a);
+  const auto vminus = inertia.Value().Evaluate(state.q, vm, state.a);
+  ASSERT_TRUE(vplus.HasValue());
+  ASSERT_TRUE(vminus.HasValue());
+  const auto vfd =
+      ApplyD(Difference(vplus.Value().force, vminus.Value().force, 2.0 * step),
+             fixture.Length());
+  EXPECT_GT(vfd.Norm(), 0.0);
+  const fesa::Vector missing_dv{24U};
+  EXPECT_GT(Difference(missing_dv, vfd, 1.0).Norm() / vfd.Norm(), 1.0e-6);
+}
+
+}  // namespace
diff --git a/tests/unit/elements/nonlinear_mitc4_shell_tangent_test.cpp b/tests/unit/elements/nonlinear_mitc4_shell_tangent_test.cpp
index 2379f1e..232728d 100644
--- a/tests/unit/elements/nonlinear_mitc4_shell_tangent_test.cpp
+++ b/tests/unit/elements/nonlinear_mitc4_shell_tangent_test.cpp
@@ -10,6 +10,7 @@
 #include <string>
 
 #include "fesa/elements/finite_rotation.h"
+#include "fesa/elements/nonlinear_mitc4_inertia.h"
 #include "fesa/elements/nonlinear_mitc4_shell.h"
 #include "fesa/model/model_types.h"
 
@@ -417,4 +418,165 @@ TEST(NonlinearMitc4Residual, RejectsNonfiniteTrialData) {
   EXPECT_FALSE(overflow_result.HasValue());
 }
 
+void CheckThirdSweep(const fesa::NonlinearMitc4TrialDofs& trial) {
+  const auto nodes = Nodes();
+  const auto shell = Shell(nodes);
+  auto direction = Direction();
+  double norm = 0.0;
+  const auto unscaled = ToVector(direction);
+  for (std::size_t i = 0U; i < 24U; ++i) {
+    norm = std::hypot(norm, unscaled[i]);
+  }
+  for (std::size_t node = 0U; node < 4U; ++node) {
+    direction.displacement[node] = 2.0 * direction.displacement[node] / norm;
+    direction.rotation_vector[node] = direction.rotation_vector[node] / norm;
+  }
+  const auto velocity = ToVector(direction);
+  const auto exact =
+      fesa::EvaluateInternalResidualAndTangent(shell, trial, &velocity);
+  ASSERT_TRUE(exact.HasValue());
+  unsigned int consecutive = 0U;
+  bool passed = false;
+  for (int power = 8; power <= 20; power += 2) {
+    const double h = std::ldexp(1.0, -power);
+    const auto plus = fesa::EvaluateInternalResidualAndTangent(
+        shell, AddScaled(trial, direction, h));
+    const auto minus = fesa::EvaluateInternalResidualAndTangent(
+        shell, AddScaled(trial, direction, -h));
+    ASSERT_TRUE(plus.HasValue());
+    ASSERT_TRUE(minus.HasValue());
+    double error = 0.0;
+    double analytic_norm = 0.0;
+    double fd_norm = 0.0;
+    for (std::size_t i = 0U; i < 24U; ++i) {
+      double fd = 0.0;
+      for (std::size_t j = 0U; j < 24U; ++j) {
+        fd += (plus.Value().internal_tangent(i, j) -
+               minus.Value().internal_tangent(i, j)) *
+              velocity[j] / (2.0 * h);
+      }
+      const double d = i % 6U < 3U ? 2.0 : 1.0;
+      const double analytic = exact.Value().force_directional_second[i];
+      error = std::hypot(error, d * (analytic - fd));
+      analytic_norm = std::hypot(analytic_norm, d * analytic);
+      fd_norm = std::hypot(fd_norm, d * fd);
+    }
+    if (power >= 10 && power <= 18 &&
+        error / (analytic_norm + fd_norm) <= 1e-6) {
+      ++consecutive;
+      passed = passed || consecutive >= 2U;
+    } else {
+      consecutive = 0U;
+    }
+  }
+  EXPECT_TRUE(passed);
+  EXPECT_GE(exact.Value().drilling_energy, 0.0);
+  for (std::size_t i = 0U; i < 24U; ++i) {
+    EXPECT_DOUBLE_EQ(
+        exact.Value().internal_force[i],
+        exact.Value().physical_force[i] + exact.Value().drilling_force[i]);
+  }
+}
+
+TEST(NonlinearMitc4Residual,
+     ZeroTrialOnTranslatedDecimalMeshHasNoArtificialForce) {
+  auto nodes = Nodes();
+  nodes[0].coordinates = {3.84615385, 2.30769231, 0.0};
+  nodes[1].coordinates = {4.23076923, 2.30769231, 0.0};
+  nodes[2].coordinates = {4.23076923, 2.69230769, 0.0};
+  nodes[3].coordinates = {3.84615385, 2.69230769, 0.0};
+  const auto shell = Shell(nodes);
+  const auto evaluated = fesa::EvaluateInternalResidualAndTangent(shell, {});
+  ASSERT_TRUE(evaluated.HasValue());
+  for (std::size_t i = 0; i < 24U; ++i)
+    EXPECT_DOUBLE_EQ(evaluated.Value().internal_force[i], 0.0);
+  EXPECT_DOUBLE_EQ(evaluated.Value().drilling_energy, 0.0);
+}
+
+TEST(NonlinearMitc4Residual, ExactDirectionalThirdGradientMatchesTangentSweep) {
+  CheckThirdSweep(Trial());
+}
+
+TEST(NonlinearMitc4Residual, ThirdGradientIsStableAcrossSmallAngleBranches) {
+  for (const double angle : {1e-4 * (1 - std::ldexp(1., -10)),
+                             1e-4 * (1 + std::ldexp(1., -10)), 2e-4, 1e-3}) {
+    SCOPED_TRACE(angle);
+    auto trial = Trial();
+    for (auto& phi : trial.rotation_vector) phi = {angle, 0., 0.};
+    CheckThirdSweep(trial);
+  }
+}
+
+TEST(NonlinearMitc4Residual,
+     ExactDrillingConstraintHasIndependentForceGradientAndHessian) {
+  for (bool warped : {false, true}) {
+    auto nodes = Nodes();
+    if (warped) nodes[2U].coordinates[2U] = 0.1;
+    const auto shell = Shell(nodes);
+    auto trial = Trial();
+    trial.rotation_vector[0U] = {.6, -.2, .1};
+    const auto direction = Direction();
+    const auto velocity = ToVector(direction);
+    const auto exact =
+        fesa::EvaluateInternalResidualAndTangent(shell, trial, &velocity);
+    ASSERT_TRUE(exact.HasValue());
+    for (std::size_t node = 0U; node < 4U; ++node) {
+      const auto rotation = fesa::EvaluateDynamicRotation(
+          trial.rotation_vector[node], {0., 0., 1.},
+          direction.rotation_vector[node], {});
+      ASSERT_TRUE(rotation.HasValue());
+      double psi = 0.;
+      for (std::size_t c = 0U; c < 3U; ++c)
+        psi += rotation.Value().drill_null[c] *
+               exact.Value().internal_force[6U * node + 3U + c];
+      EXPECT_NEAR(exact.Value().drilling_constraint[node], psi, 1e-11);
+      for (std::size_t i = 0U; i < 24U; ++i) {
+        double gradient = 0.;
+        for (std::size_t c = 0U; c < 3U; ++c) {
+          gradient += rotation.Value().drill_null[c] *
+                      exact.Value().internal_tangent(6U * node + 3U + c, i);
+          if (i / 6U == node && i % 6U >= 3U)
+            gradient += rotation.Value().null_gradient(c, i % 6U - 3U) *
+                        exact.Value().internal_force[6U * node + 3U + c];
+        }
+        EXPECT_NEAR(exact.Value().drilling_constraint_gradient(node, i),
+                    gradient, 1e-10);
+      }
+    }
+    unsigned consecutive = 0U;
+    bool passed = false;
+    for (int power = 8; power <= 20; power += 2) {
+      const double h = std::ldexp(1., -power);
+      const auto plus = fesa::EvaluateInternalResidualAndTangent(
+          shell, AddScaled(trial, direction, h), &velocity);
+      const auto minus = fesa::EvaluateInternalResidualAndTangent(
+          shell, AddScaled(trial, direction, -h), &velocity);
+      ASSERT_TRUE(plus.HasValue());
+      ASSERT_TRUE(minus.HasValue());
+      double error = 0., anorm = 0., fnorm = 0.;
+      for (std::size_t node = 0U; node < 4U; ++node)
+        for (std::size_t i = 0U; i < 24U; ++i) {
+          double analytic = 0.;
+          for (std::size_t j = 0U; j < 24U; ++j)
+            analytic += exact.Value().drilling_constraint_hessian[node](i, j) *
+                        velocity[j];
+          const double fd =
+              (plus.Value().drilling_constraint_gradient(node, i) -
+               minus.Value().drilling_constraint_gradient(node, i)) /
+              (2 * h);
+          const double scale = i % 6U < 3U ? 2. : 1.;
+          error = std::hypot(error, scale * (analytic - fd));
+          anorm = std::hypot(anorm, scale * analytic);
+          fnorm = std::hypot(fnorm, scale * fd);
+        }
+      if (power >= 10 && power <= 18 && error / (anorm + fnorm) <= 1e-6) {
+        ++consecutive;
+        passed = passed || consecutive >= 2U;
+      } else
+        consecutive = 0U;
+    }
+    EXPECT_TRUE(passed);
+  }
+}
+
 }  // namespace
diff --git a/tests/unit/io/hdf5/dynamic_hdf5_results_writer_test.cpp b/tests/unit/io/hdf5/dynamic_hdf5_results_writer_test.cpp
new file mode 100644
index 0000000..b325a53
--- /dev/null
+++ b/tests/unit/io/hdf5/dynamic_hdf5_results_writer_test.cpp
@@ -0,0 +1,636 @@
+#include "fesa/io/hdf5/dynamic_hdf5_results_writer.h"
+
+#include <Windows.h>
+#include <gtest/gtest.h>
+#include <hdf5.h>
+
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <filesystem>
+#include <fstream>
+#include <iterator>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "fesa/analysis/analysis_model.h"
+#include "fesa/analysis/dynamic_analysis_state.h"
+#include "fesa/elements/finite_rotation.h"
+#include "fesa/fem/dof_manager.h"
+#include "io/hdf5/hdf5_raii.h"
+
+namespace {
+
+using fesa::hdf5_internal::Hdf5Handle;
+
+constexpr std::array<std::array<double, 3>, 3> kIdentityTriad{
+    std::array<double, 3>{1.0, 0.0, 0.0}, std::array<double, 3>{0.0, 1.0, 0.0},
+    std::array<double, 3>{0.0, 0.0, 1.0}};
+
+fesa::ModelDefinition MakeDefinition(const bool fixed = true) {
+  const std::filesystem::path source{"dynamic-state.inp"};
+  fesa::ModelDefinition definition{};
+  definition.source_path = source;
+  definition.source_content_identity = "hht-output-unit-fixture";
+  definition.nodes = {{{"Shell-A", 10, "0010"}, {0.0, 0.0, 0.0}, {source, 1U}},
+                      {{"Shell-A", 20, "20"}, {1.0, 0.0, 0.0}, {source, 2U}},
+                      {{"Shell-A", 30, "30"}, {1.0, 1.0, 0.0}, {source, 3U}},
+                      {{"Shell-A", 40, "40"}, {0.0, 1.0, 0.0}, {source, 4U}}};
+  definition.materials = {{"Material", 1000.0, 0.25, {source, 5U}}};
+  definition.densities = {{0U, 2.0, {source, 6U}}};
+  definition.shell_sections = {{"Shell", 0.1, 0U, {source, 7U}}};
+  definition.shell_elements = {{{"Shell-A", 9, "0009"},
+                                fesa::ShellSourceElementType::kS4,
+                                {0U, 1U, 2U, 3U},
+                                0U,
+                                0U,
+                                {source, 8U}}};
+  for (std::size_t node = 0U; node < 4U; ++node) {
+    definition.shell_node_initial_frames.push_back(
+        {static_cast<fesa::EntityIndex>(node),
+         {0.0, 0.0, 1.0},
+         {1.0, 0.0, 0.0},
+         {0.0, 1.0, 0.0}});
+  }
+  definition.node_sets = {{"All", std::nullopt, {0U, 1U, 2U, 3U}, {source, 9U}},
+                          {"Loaded", std::nullopt, {0U}, {source, 10U}}};
+  fesa::DynamicStepDefinition step{};
+  step.source_step_name_raw = "Transient Load";
+  step.source_step_name_canonical = "TRANSIENT LOAD";
+  step.initial_increment = 0.25;
+  step.time_period = 0.5;
+  step.increment_count = 2U;
+  step.maximum_increments = 3U;
+  if (fixed) {
+    step.boundaries = {{"All", 1, 6, 0.0, {source, 11U}}};
+    step.loads = {{"Loaded", 3, 4.0, {source, 12U}}};
+  }
+  definition.dynamic_step = step;
+  return definition;
+}
+
+struct Fixture {
+  std::unique_ptr<fesa::Domain> domain;
+  fesa::DynamicAnalysisState state;
+};
+
+Fixture MakeFixture(fesa::ModelDefinition definition = MakeDefinition()) {
+  auto domain_result = fesa::Domain::Create(std::move(definition));
+  if (!domain_result.HasValue())
+    throw std::runtime_error{"Invalid fixture Domain."};
+  auto domain =
+      std::make_unique<fesa::Domain>(std::move(domain_result.Value()));
+  auto model = fesa::AnalysisModel::Create(*domain);
+  if (!model.HasValue())
+    throw std::runtime_error{"Invalid fixture AnalysisModel."};
+  auto dofs = fesa::DofManager::Create(model.Value());
+  if (!dofs.HasValue()) throw std::runtime_error{"Invalid fixture DofManager."};
+  auto state = fesa::DynamicAnalysisState::Create(*domain, dofs.Value());
+  if (!state.HasValue()) throw std::runtime_error{"Invalid fixture state."};
+  return {std::move(domain), std::move(state.Value())};
+}
+
+// A fully restrained, initially undeformed shell under a dead nodal force has
+// zero motion and strain, and nonzero support force at every accepted endpoint.
+fesa::DynamicAcceptedFrameState MakeFrame(const fesa::Domain& domain,
+                                          const std::uint32_t index) {
+  fesa::DynamicAcceptedFrameState frame{};
+  frame.frame_index = index;
+  frame.increment_index = index;
+  frame.time = static_cast<double>(index) * domain.Dynamic()->initial_increment;
+  frame.is_initial = index == 0U;
+  for (std::size_t node = 0U; node < domain.Nodes().size(); ++node) {
+    frame.nodal_internal_order.push_back(static_cast<fesa::EntityIndex>(node));
+    frame.nodal_source_ids.push_back(domain.Nodes()[node].source_id);
+    frame.nodal_triad.push_back(kIdentityTriad);
+    frame.nodal_director.push_back({0.0, 0.0, 1.0});
+  }
+  for (auto* vector :
+       {&frame.generalized_coordinates, &frame.velocity, &frame.acceleration,
+        &frame.algorithmic_acceleration, &frame.inertia_force,
+        &frame.internal_force, &frame.external_force, &frame.residual,
+        &frame.reaction, &frame.residual_scale}) {
+    *vector = fesa::Vector{24U};
+  }
+  frame.angular_velocity = fesa::Vector{12U};
+  frame.angular_acceleration = fesa::Vector{12U};
+  if (!domain.Dynamic()->loads.empty()) {
+    frame.external_force[2U] = 4.0;
+    frame.residual[2U] = -4.0;
+    frame.reaction[2U] = -4.0;
+    frame.residual_scale[2U] = 4.0;
+  }
+  const double gauss = 1.0 / std::sqrt(3.0);
+  const std::array<std::array<double, 2>, 4> natural{
+      std::array<double, 2>{-gauss, -gauss},
+      {gauss, -gauss},
+      {gauss, gauss},
+      {-gauss, gauss}};
+  const std::array<fesa::ShellMidsurfaceLocation, 4> locations{
+      fesa::ShellMidsurfaceLocation::kGp1, fesa::ShellMidsurfaceLocation::kGp2,
+      fesa::ShellMidsurfaceLocation::kGp3, fesa::ShellMidsurfaceLocation::kGp4};
+  for (std::size_t point = 0U; point < 4U; ++point) {
+    frame.shell_results.push_back(
+        {0U,
+         locations[point],
+         natural[point],
+         kIdentityTriad,
+         {},
+         {},
+         {{{fesa::ShellSectionPosition::kBottom, -1.0, {}},
+           {fesa::ShellSectionPosition::kMiddle, 0.0, {}},
+           {fesa::ShellSectionPosition::kTop, 1.0, {}}}}});
+  }
+  return frame;
+}
+
+class TempFile {
+ public:
+  explicit TempFile(const std::string& name)
+      : path_{std::filesystem::temp_directory_path() /
+              ("fesa-dynamic-writer-" + name + ".h5")} {
+    std::error_code error;
+    std::filesystem::remove(path_, error);
+  }
+  ~TempFile() {
+    std::error_code error;
+    std::filesystem::remove(path_, error);
+  }
+  const std::filesystem::path& Path() const { return path_; }
+
+ private:
+  std::filesystem::path path_;
+};
+
+void CommitHistory(Fixture& fixture) {
+  for (std::uint32_t index = 0U; index <= 2U; ++index) {
+    ASSERT_TRUE(
+        fixture.state.CommitAcceptedFrame(MakeFrame(*fixture.domain, index))
+            .IsOk());
+  }
+}
+
+std::string ReadBytes(const std::filesystem::path& path) {
+  std::ifstream input{path, std::ios::binary};
+  return std::string{std::istreambuf_iterator<char>{input}, {}};
+}
+
+std::string ReadString(const hid_t object, const char* name) {
+  Hdf5Handle attribute{H5Aopen(object, name, H5P_DEFAULT), H5Aclose};
+  Hdf5Handle type{H5Aget_type(attribute.Get()), H5Tclose};
+  EXPECT_EQ(H5Tget_class(type.Get()), H5T_STRING);
+  EXPECT_GT(H5Tis_variable_str(type.Get()), 0);
+  EXPECT_EQ(H5Tget_cset(type.Get()), H5T_CSET_UTF8);
+  char* raw = nullptr;
+  EXPECT_GE(H5Aread(attribute.Get(), type.Get(), &raw), 0);
+  const std::string value = raw == nullptr ? "" : raw;
+  (void)H5free_memory(raw);
+  return value;
+}
+
+template <typename Value>
+Value ReadAttribute(const hid_t object, const char* name, const hid_t file_type,
+                    const hid_t memory_type) {
+  Hdf5Handle attribute{H5Aopen(object, name, H5P_DEFAULT), H5Aclose};
+  Hdf5Handle type{H5Aget_type(attribute.Get()), H5Tclose};
+  Hdf5Handle space{H5Aget_space(attribute.Get()), H5Sclose};
+  EXPECT_GT(H5Tequal(type.Get(), file_type), 0);
+  EXPECT_EQ(H5Sget_simple_extent_type(space.Get()), H5S_SCALAR);
+  Value result{};
+  EXPECT_GE(H5Aread(attribute.Get(), memory_type, &result), 0);
+  return result;
+}
+
+std::vector<double> ReadDoubles(const hid_t file, const std::string& path,
+                                const std::vector<hsize_t>& dimensions) {
+  Hdf5Handle dataset{H5Dopen2(file, path.c_str(), H5P_DEFAULT), H5Dclose};
+  EXPECT_GE(dataset.Get(), 0);
+  Hdf5Handle type{H5Dget_type(dataset.Get()), H5Tclose};
+  EXPECT_GT(H5Tequal(type.Get(), H5T_IEEE_F64LE), 0);
+  Hdf5Handle space{H5Dget_space(dataset.Get()), H5Sclose};
+  EXPECT_EQ(H5Sget_simple_extent_ndims(space.Get()), dimensions.size());
+  std::vector<hsize_t> actual(dimensions.size());
+  EXPECT_GE(H5Sget_simple_extent_dims(space.Get(), actual.data(), nullptr), 0);
+  EXPECT_EQ(actual, dimensions);
+  Hdf5Handle properties{H5Dget_create_plist(dataset.Get()), H5Pclose};
+  EXPECT_EQ(H5Pget_layout(properties.Get()), H5D_CONTIGUOUS);
+  EXPECT_EQ(H5Pget_nfilters(properties.Get()), 0);
+  std::size_t count = 1U;
+  for (const auto size : dimensions) count *= static_cast<std::size_t>(size);
+  std::vector<double> values(count);
+  EXPECT_GE(H5Dread(dataset.Get(), H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL,
+                    H5P_DEFAULT, values.data()),
+            0);
+  for (const double value : values) EXPECT_TRUE(std::isfinite(value));
+  return values;
+}
+
+void ExpectCompound(const hid_t file, const char* path,
+                    const std::vector<std::pair<const char*, hid_t>>& fields,
+                    const hsize_t rows) {
+  Hdf5Handle dataset{H5Dopen2(file, path, H5P_DEFAULT), H5Dclose};
+  ASSERT_GE(dataset.Get(), 0);
+  Hdf5Handle type{H5Dget_type(dataset.Get()), H5Tclose};
+  EXPECT_EQ(H5Tget_nmembers(type.Get()), fields.size());
+  for (std::size_t index = 0U; index < fields.size(); ++index) {
+    char* name = H5Tget_member_name(type.Get(), static_cast<unsigned>(index));
+    ASSERT_NE(name, nullptr);
+    EXPECT_STREQ(name, fields[index].first);
+    (void)H5free_memory(name);
+    Hdf5Handle member{
+        H5Tget_member_type(type.Get(), static_cast<unsigned>(index)), H5Tclose};
+    EXPECT_GT(H5Tequal(member.Get(), fields[index].second), 0);
+  }
+  Hdf5Handle space{H5Dget_space(dataset.Get()), H5Sclose};
+  EXPECT_EQ(H5Sget_simple_extent_ndims(space.Get()), 1);
+  hsize_t actual = 0U;
+  EXPECT_GE(H5Sget_simple_extent_dims(space.Get(), &actual, nullptr), 0);
+  EXPECT_EQ(actual, rows);
+}
+
+TEST(DynamicHdf5ResultsWriter, RejectsDefaultStateBeforeCreatingOutput) {
+  auto domain = fesa::Domain::Create(fesa::ModelDefinition{});
+  ASSERT_TRUE(domain.HasValue());
+  TempFile output{"default"};
+  fesa::DynamicHdf5ResultsWriter writer;
+  const auto status = writer.Write(output.Path(), domain.Value(), {}, {});
+  EXPECT_FALSE(status.IsOk());
+  ASSERT_EQ(status.Diagnostics().size(), 1U);
+  EXPECT_EQ(status.Diagnostics()[0U].code, "dynamic-output-schema");
+  EXPECT_FALSE(std::filesystem::exists(output.Path()));
+}
+
+TEST(DynamicHdf5ResultsWriter, WritesCompletePhysicalClampedHistoryAndSchema) {
+  auto fixture = MakeFixture();
+  CommitHistory(fixture);
+  TempFile output{"complete"};
+  fesa::DynamicHdf5ResultsWriter writer;
+  const std::vector<fesa::Diagnostic> diagnostics{{fesa::Severity::kWarning,
+                                                   "ignored-output-request",
+                                                   {"dynamic-state.inp", 22U},
+                                                   "OUTPUT",
+                                                   "",
+                                                   "Field request ignored."},
+                                                  {fesa::Severity::kWarning,
+                                                   "ignored-output-request",
+                                                   {"dynamic-state.inp", 21U},
+                                                   "RESTART",
+                                                   "",
+                                                   "Restart request ignored."}};
+  const auto status =
+      writer.Write(output.Path(), *fixture.domain, fixture.state, diagnostics);
+  ASSERT_TRUE(status.IsOk())
+      << (status.Diagnostics().empty() ? "" : status.Diagnostics()[0U].message);
+  Hdf5Handle file{
+      H5Fopen(output.Path().string().c_str(), H5F_ACC_RDONLY, H5P_DEFAULT),
+      H5Fclose};
+  ASSERT_GE(file.Get(), 0);
+  Hdf5Handle metadata{H5Gopen2(file.Get(), "/metadata", H5P_DEFAULT), H5Gclose};
+  EXPECT_EQ(ReadString(metadata.Get(), "feature_id"), "hht-implicit-dynamics");
+  EXPECT_EQ(ReadString(metadata.Get(), "analysis_procedure"),
+            "hht-implicit-dynamics");
+  EXPECT_EQ(ReadString(metadata.Get(), "source_step_name"), "Transient Load");
+  EXPECT_EQ(ReadString(metadata.Get(), "mass_formulation"),
+            "consistent-kinetic");
+  EXPECT_EQ(ReadString(metadata.Get(), "acceleration_convention"),
+            "physical-endpoint-and-auxiliary-separated");
+  EXPECT_EQ(ReadString(metadata.Get(), "initial_state"),
+            "zero-q-v-step-load-0+");
+  EXPECT_EQ(ReadString(metadata.Get(), "unit_system_label"),
+            "consistent-input-units");
+  EXPECT_EQ(ReadAttribute<std::uint64_t>(metadata.Get(), "schema_version",
+                                         H5T_STD_U64LE, H5T_NATIVE_UINT64),
+            1U);
+  EXPECT_DOUBLE_EQ(ReadAttribute<double>(metadata.Get(), "alpha",
+                                         H5T_IEEE_F64LE, H5T_NATIVE_DOUBLE),
+                   -0.05);
+  EXPECT_DOUBLE_EQ(ReadAttribute<double>(metadata.Get(), "beta", H5T_IEEE_F64LE,
+                                         H5T_NATIVE_DOUBLE),
+                   0.275625);
+  EXPECT_DOUBLE_EQ(ReadAttribute<double>(metadata.Get(), "gamma",
+                                         H5T_IEEE_F64LE, H5T_NATIVE_DOUBLE),
+                   0.55);
+  ExpectCompound(file.Get(), "/steps/Step-1/accepted_frames",
+                 {{"frame_index", H5T_STD_U64LE},
+                  {"increment_index", H5T_STD_U64LE},
+                  {"time", H5T_IEEE_F64LE},
+                  {"iteration_count", H5T_STD_U64LE},
+                  {"is_initial", H5T_STD_U8LE}},
+                 3U);
+  ExpectCompound(
+      file.Get(), "/model/material_density",
+      {{"internal_material_id", H5T_STD_U64LE}, {"rho", H5T_IEEE_F64LE}}, 1U);
+  struct Density {
+    std::uint64_t id;
+    double rho;
+  };
+  Hdf5Handle density{
+      H5Dopen2(file.Get(), "/model/material_density", H5P_DEFAULT), H5Dclose};
+  Hdf5Handle density_type{H5Dget_type(density.Get()), H5Tclose};
+  Density density_row{};
+  ASSERT_GE(H5Dread(density.Get(), density_type.Get(), H5S_ALL, H5S_ALL,
+                    H5P_DEFAULT, &density_row),
+            0);
+  EXPECT_EQ(density_row.id, 0U);
+  EXPECT_DOUBLE_EQ(density_row.rho, 2.0);
+  Hdf5Handle mask{
+      H5Dopen2(file.Get(), "/model/nodal_constraint_mask", H5P_DEFAULT),
+      H5Dclose};
+  Hdf5Handle mask_type{H5Dget_type(mask.Get()), H5Tclose};
+  EXPECT_GT(H5Tequal(mask_type.Get(), H5T_STD_U8LE), 0);
+  std::array<std::uint8_t, 24U> constraints{};
+  ASSERT_GE(H5Dread(mask.Get(), H5T_NATIVE_UINT8, H5S_ALL, H5S_ALL, H5P_DEFAULT,
+                    constraints.data()),
+            0);
+  for (const auto value : constraints) EXPECT_EQ(value, 1U);
+  EXPECT_EQ(ReadDoubles(file.Get(), "/model/prescribed_displacement", {4U, 6U}),
+            std::vector<double>(24U, 0.0));
+  EXPECT_EQ(H5Lexists(file.Get(), "/model/prescribed_displacement_start",
+                      H5P_DEFAULT),
+            0);
+  EXPECT_EQ(H5Lexists(file.Get(), "/model/prescribed_displacement_target",
+                      H5P_DEFAULT),
+            0);
+  struct Dataset {
+    const char* path;
+    std::vector<hsize_t> dimensions;
+    const char* components;
+  };
+  const std::vector<Dataset> datasets{
+      {"nodal/displacement", {4U, 6U}, "UX,UY,UZ,URX,URY,URZ"},
+      {"nodal/velocity", {4U, 6U}, "V1,V2,V3,PHIDOT1,PHIDOT2,PHIDOT3"},
+      {"nodal/acceleration", {4U, 6U}, "A1,A2,A3,PHIDDOT1,PHIDDOT2,PHIDDOT3"},
+      {"nodal/algorithmic_acceleration",
+       {4U, 6U},
+       "AUX1,AUX2,AUX3,AUX4,AUX5,AUX6"},
+      {"nodal/angular_velocity", {4U, 3U}, "OMEGA1,OMEGA2,OMEGA3"},
+      {"nodal/angular_acceleration", {4U, 3U}, "OMEGADOT1,OMEGADOT2,OMEGADOT3"},
+      {"nodal/triad", {4U, 3U, 3U}, "X,Y,Z"},
+      {"nodal/director", {4U, 3U}, "D1,D2,D3"},
+      {"nodal/generalized_inertia_force",
+       {4U, 6U},
+       "F1,F2,F3,MPHI1,MPHI2,MPHI3"},
+      {"nodal/generalized_internal_force",
+       {4U, 6U},
+       "F1,F2,F3,MPHI1,MPHI2,MPHI3"},
+      {"nodal/generalized_external_force",
+       {4U, 6U},
+       "F1,F2,F3,MPHI1,MPHI2,MPHI3"},
+      {"nodal/generalized_residual", {4U, 6U}, "F1,F2,F3,MPHI1,MPHI2,MPHI3"},
+      {"nodal/generalized_reaction", {4U, 6U}, "F1,F2,F3,MPHI1,MPHI2,MPHI3"},
+      {"nodal/reaction", {4U, 6U}, "RF1,RF2,RF3,RM1,RM2,RM3"},
+      {"element/shell/local_frame", {1U, 4U, 3U, 3U}, "X,Y,Z"},
+      {"element/shell/generalized_strain",
+       {1U, 4U, 8U},
+       "E11,E22,G12,K11,K22,K12,G13,G23"},
+      {"element/shell/section_resultant",
+       {1U, 4U, 8U},
+       "N11,N22,N12,M11,M22,M12,Q13,Q23"},
+      {"element/shell/stress", {1U, 4U, 3U, 3U}, "S11,S22,S12"},
+      {"global/energy",
+       {5U},
+       "KINETIC_ENERGY,PHYSICAL_STRAIN_ENERGY,DRILLING_ENERGY,EXTERNAL_WORK,"
+       "ENERGY_DEFECT"},
+      {"global/equilibrium",
+       {6U},
+       "FORCE_1,FORCE_2,FORCE_3,MOMENT_1,MOMENT_2,MOMENT_3"}};
+  for (std::uint64_t index = 0U; index <= 2U; ++index) {
+    const std::string root =
+        "/steps/Step-1/frames/" + std::to_string(index) + "/";
+    for (const auto& expected : datasets) {
+      const std::string path = root + expected.path;
+      SCOPED_TRACE(path);
+      const auto values = ReadDoubles(file.Get(), path, expected.dimensions);
+      Hdf5Handle dataset{H5Dopen2(file.Get(), path.c_str(), H5P_DEFAULT),
+                         H5Dclose};
+      EXPECT_EQ(ReadString(dataset.Get(), "component_names"),
+                expected.components);
+      EXPECT_FALSE(
+          ReadString(dataset.Get(), "component_unit_dimensions").empty());
+      EXPECT_FALSE(ReadString(dataset.Get(), "coordinate_system").empty());
+      EXPECT_FALSE(ReadString(dataset.Get(), "location").empty());
+      EXPECT_EQ(ReadString(dataset.Get(), "step_name"), "Step-1");
+      EXPECT_EQ(ReadString(dataset.Get(), "source_step_name"),
+                "Transient Load");
+      EXPECT_EQ(ReadAttribute<std::uint64_t>(dataset.Get(), "frame_index",
+                                             H5T_STD_U64LE, H5T_NATIVE_UINT64),
+                index);
+      EXPECT_EQ(ReadAttribute<std::uint64_t>(dataset.Get(), "increment_index",
+                                             H5T_STD_U64LE, H5T_NATIVE_UINT64),
+                index);
+      EXPECT_EQ(ReadAttribute<std::uint8_t>(dataset.Get(), "is_initial",
+                                            H5T_STD_U8LE, H5T_NATIVE_UINT8),
+                index == 0U ? 1U : 0U);
+      EXPECT_DOUBLE_EQ(ReadAttribute<double>(dataset.Get(), "time",
+                                             H5T_IEEE_F64LE, H5T_NATIVE_DOUBLE),
+                       static_cast<double>(index) * 0.25);
+      EXPECT_EQ(H5Aexists(dataset.Get(), "load_factor"), 0);
+      const std::string leaf{expected.path};
+      if (leaf == "nodal/triad" || leaf == "element/shell/local_frame") {
+        for (std::size_t entry = 0U; entry < values.size(); ++entry) {
+          EXPECT_DOUBLE_EQ(
+              values[entry],
+              entry % 9U == 0U || entry % 9U == 4U || entry % 9U == 8U ? 1.0
+                                                                       : 0.0);
+        }
+      } else if (leaf == "nodal/director") {
+        for (std::size_t entry = 0U; entry < values.size(); ++entry)
+          EXPECT_DOUBLE_EQ(values[entry], entry % 3U == 2U ? 1.0 : 0.0);
+      } else {
+        for (std::size_t entry = 0U; entry < values.size(); ++entry) {
+          const bool force =
+              entry == 2U && (leaf == "nodal/generalized_external_force" ||
+                              leaf == "nodal/generalized_residual" ||
+                              leaf == "nodal/generalized_reaction" ||
+                              leaf == "nodal/reaction");
+          EXPECT_DOUBLE_EQ(
+              values[entry],
+              force ? (leaf == "nodal/generalized_external_force" ? 4.0 : -4.0)
+                    : 0.0);
+        }
+      }
+    }
+  }
+  Hdf5Handle stress{
+      H5Dopen2(file.Get(), "/steps/Step-1/frames/2/element/shell/stress",
+               H5P_DEFAULT),
+      H5Dclose};
+  EXPECT_EQ(ReadString(stress.Get(), "source_element_type_dataset"),
+            "/model/elements.source_element_type");
+  EXPECT_EQ(ReadString(stress.Get(), "midsurface_location_dataset"),
+            "/model/shell/midsurface_locations");
+  EXPECT_EQ(ReadString(stress.Get(), "section_position_dataset"),
+            "/model/shell/section_positions");
+  EXPECT_EQ(ReadString(stress.Get(), "local_frame_dataset"),
+            "/steps/Step-1/frames/2/element/shell/local_frame");
+  Hdf5Handle diagnostic_table{H5Dopen2(file.Get(), "/diagnostics", H5P_DEFAULT),
+                              H5Dclose};
+  Hdf5Handle diagnostic_type{H5Dget_type(diagnostic_table.Get()), H5Tclose};
+  EXPECT_GE(H5Tget_member_index(diagnostic_type.Get(), "source_file"), 0);
+  EXPECT_GE(H5Tget_member_index(diagnostic_type.Get(), "source_line"), 0);
+}
+
+TEST(DynamicHdf5ResultsWriter,
+     PreservesSeparateSuppliedEndpointAndAuxiliaryEvidence) {
+  auto fixture = MakeFixture(MakeDefinition(false));
+  ASSERT_TRUE(
+      fixture.state.CommitAcceptedFrame(MakeFrame(*fixture.domain, 0U)).IsOk());
+  // This checks serialization of supplied endpoint evidence; it does not assert
+  // that these records are a converged HHT trajectory or independent physics
+  // proof.
+  for (std::uint32_t index = 1U; index <= 2U; ++index) {
+    auto frame = MakeFrame(*fixture.domain, index);
+    frame.acceleration[0U] = 2.0;
+    frame.algorithmic_acceleration[0U] = 3.0;
+    frame.velocity[0U] = 4.0;
+    frame.inertia_force[0U] = 5.0;
+    frame.residual[0U] = 5.0;
+    frame.residual_scale[0U] = 5.0;
+    frame.kinetic_energy = 6.0;
+    frame.physical_strain_energy = 7.0;
+    frame.drilling_energy = 8.0;
+    frame.external_work = 9.0;
+    frame.energy_defect = 12.0;
+    ASSERT_TRUE(fixture.state.CommitAcceptedFrame(frame).IsOk());
+  }
+  TempFile output{"separate-accelerations"};
+  fesa::DynamicHdf5ResultsWriter writer;
+  ASSERT_TRUE(
+      writer.Write(output.Path(), *fixture.domain, fixture.state, {}).IsOk());
+  Hdf5Handle file{
+      H5Fopen(output.Path().string().c_str(), H5F_ACC_RDONLY, H5P_DEFAULT),
+      H5Fclose};
+  const std::string root = "/steps/Step-1/frames/2/";
+  EXPECT_DOUBLE_EQ(
+      ReadDoubles(file.Get(), root + "nodal/acceleration", {4U, 6U})[0U], 2.0);
+  EXPECT_DOUBLE_EQ(
+      ReadDoubles(file.Get(), root + "nodal/algorithmic_acceleration",
+                  {4U, 6U})[0U],
+      3.0);
+  EXPECT_DOUBLE_EQ(
+      ReadDoubles(file.Get(), root + "nodal/generalized_inertia_force",
+                  {4U, 6U})[0U],
+      5.0);
+  EXPECT_EQ(ReadDoubles(file.Get(), root + "global/energy", {5U}),
+            (std::vector<double>{6.0, 7.0, 8.0, 9.0, 12.0}));
+  Hdf5Handle acceleration{
+      H5Dopen2(file.Get(), (root + "nodal/acceleration").c_str(), H5P_DEFAULT),
+      H5Dclose};
+  EXPECT_EQ(ReadString(acceleration.Get(), "rotation_representation"),
+            "total-rotation-vector-chart");
+  EXPECT_EQ(ReadString(acceleration.Get(), "quantity_semantics"),
+            "physical-endpoint-chart-acceleration");
+}
+
+TEST(DynamicHdf5ResultsWriter,
+     ConvertsPartialConstraintMomentToSpatialReaction) {
+  auto definition = MakeDefinition(false);
+  definition.dynamic_step->boundaries = {{"Loaded", 4, 4, 0.0, {}}};
+  auto fixture = MakeFixture(std::move(definition));
+  ASSERT_TRUE(
+      fixture.state.CommitAcceptedFrame(MakeFrame(*fixture.domain, 0U)).IsOk());
+  // A supplied finite-chart endpoint tests the output coordinate transform,
+  // independently of time-integration acceptance.
+  for (std::uint32_t index = 1U; index <= 2U; ++index) {
+    auto frame = MakeFrame(*fixture.domain, index);
+    frame.generalized_coordinates[4U] = 0.2;
+    frame.generalized_coordinates[5U] = 0.3;
+    const auto rotation = fesa::ExpSkew(fesa::Vector3{0.0, 0.2, 0.3});
+    for (std::size_t axis = 0U; axis < 3U; ++axis) {
+      for (std::size_t component = 0U; component < 3U; ++component) {
+        frame.nodal_triad[0U][axis][component] = rotation(component, axis);
+      }
+      frame.nodal_director[0U][axis] = rotation(axis, 2U);
+    }
+    frame.internal_force[3U] = 5.0;
+    frame.residual[3U] = 5.0;
+    frame.reaction[3U] = 5.0;
+    frame.residual_scale[3U] = 5.0;
+    ASSERT_TRUE(fixture.state.CommitAcceptedFrame(frame).IsOk());
+  }
+  TempFile output{"spatial-reaction"};
+  fesa::DynamicHdf5ResultsWriter writer;
+  ASSERT_TRUE(
+      writer.Write(output.Path(), *fixture.domain, fixture.state, {}).IsOk());
+  Hdf5Handle file{
+      H5Fopen(output.Path().string().c_str(), H5F_ACC_RDONLY, H5P_DEFAULT),
+      H5Fclose};
+  const std::string root = "/steps/Step-1/frames/2/nodal/";
+  const auto generalized =
+      ReadDoubles(file.Get(), root + "generalized_reaction", {4U, 6U});
+  const auto spatial = ReadDoubles(file.Get(), root + "reaction", {4U, 6U});
+  EXPECT_DOUBLE_EQ(generalized[3U], 5.0);
+  EXPECT_DOUBLE_EQ(generalized[4U], 0.0);
+  EXPECT_DOUBLE_EQ(generalized[5U], 0.0);
+  const double angle = std::sqrt(0.13);
+  const double coefficient =
+      1.0 / 0.13 - (1.0 + std::cos(angle)) / (2.0 * angle * std::sin(angle));
+  EXPECT_NEAR(spatial[3U], 5.0 * (1.0 - coefficient * 0.13), 1.0e-14);
+  EXPECT_NEAR(spatial[4U], 0.75, 1.0e-14);
+  EXPECT_NEAR(spatial[5U], -0.5, 1.0e-14);
+}
+
+TEST(DynamicHdf5ResultsWriter,
+     IncompleteOrMismatchedHistoryPreservesExistingFile) {
+  auto fixture = MakeFixture();
+  ASSERT_TRUE(
+      fixture.state.CommitAcceptedFrame(MakeFrame(*fixture.domain, 0U)).IsOk());
+  TempFile output{"preservation"};
+  {
+    std::ofstream existing{output.Path(), std::ios::binary};
+    existing << "previous-result";
+  }
+  fesa::DynamicHdf5ResultsWriter writer;
+  EXPECT_FALSE(
+      writer.Write(output.Path(), *fixture.domain, fixture.state, {}).IsOk());
+  EXPECT_EQ(ReadBytes(output.Path()), "previous-result");
+  for (std::uint32_t index = 1U; index <= 2U; ++index)
+    ASSERT_TRUE(
+        fixture.state.CommitAcceptedFrame(MakeFrame(*fixture.domain, index))
+            .IsOk());
+  auto different_definition = MakeDefinition();
+  different_definition.nodes[0U].source_id.source_label_text = "10";
+  auto other = MakeFixture(std::move(different_definition));
+  EXPECT_FALSE(
+      writer.Write(output.Path(), *other.domain, fixture.state, {}).IsOk());
+  EXPECT_EQ(ReadBytes(output.Path()), "previous-result");
+  ASSERT_TRUE(
+      writer.Write(output.Path(), *fixture.domain, fixture.state, {}).IsOk());
+  const auto valid_bytes = ReadBytes(output.Path());
+  // Deliberate post-commit corruption proves writer revalidation is independent
+  // of the state API that normally prevents these mutations.
+  auto& corrupt = const_cast<fesa::DynamicAcceptedFrameState&>(
+      fixture.state.CommittedState());
+  corrupt.reaction[2U] = 0.0;
+  EXPECT_FALSE(
+      writer.Write(output.Path(), *fixture.domain, fixture.state, {}).IsOk());
+  EXPECT_EQ(ReadBytes(output.Path()), valid_bytes);
+}
+
+TEST(DynamicHdf5ResultsWriter, FailedAtomicReplacementPreservesPreviousBytes) {
+  auto fixture = MakeFixture();
+  CommitHistory(fixture);
+  TempFile output{"locked"};
+  {
+    std::ofstream existing{output.Path(), std::ios::binary};
+    existing << "locked-previous-result";
+  }
+  const HANDLE locked =
+      CreateFileW(output.Path().c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr,
+                  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+  ASSERT_NE(locked, INVALID_HANDLE_VALUE);
+  fesa::DynamicHdf5ResultsWriter writer;
+  const auto status =
+      writer.Write(output.Path(), *fixture.domain, fixture.state, {});
+  EXPECT_FALSE(status.IsOk());
+  EXPECT_TRUE(CloseHandle(locked));
+  ASSERT_EQ(status.Diagnostics().size(), 1U);
+  EXPECT_EQ(status.Diagnostics()[0U].code, "hdf5-finalization-failure");
+  EXPECT_EQ(ReadBytes(output.Path()), "locked-previous-result");
+}
+
+}  // namespace