diff --git a/Marlin/Configuration_adv.h b/Marlin/Configuration_adv.h
index 38859c314ea7..979576c8ae6b 100644
--- a/Marlin/Configuration_adv.h
+++ b/Marlin/Configuration_adv.h
@@ -1237,16 +1237,29 @@
 
   #define FTM_POLYS                             // Disable POLY5/6 to save ~3k of Flash. Preserves TRAPEZOIDAL.
   #if ENABLED(FTM_POLYS)
-    #define FTM_TRAJECTORY_TYPE TRAPEZOIDAL     // Block acceleration profile (TRAPEZOIDAL, POLY5, POLY6)
-                                                // TRAPEZOIDAL: Continuous Velocity. Max acceleration is respected.
-                                                // POLY5:       Like POLY6 with 1.5x but uses less CPU.
-                                                // POLY6:       Continuous Acceleration (aka S_CURVE).
-                                                // POLY trajectories not only reduce resonances without rounding corners, but also
-                                                // reduce extruder strain due to linear advance.
-
     #define FTM_POLY6_ACCELERATION_OVERSHOOT 1.875f // Max acceleration overshoot factor for POLY6 (1.25 to 1.875)
   #endif
 
+  /**
+   * FTM Constant-Jolt Trajectory (7-phase S-curve).
+   * Jolt is the rate of change of acceleration, not related to Marlin's "classic jerk."
+   * Ramps acceleration gradually so max acceleration is limited by max speed and distance traveled.
+   */
+  //#define FTM_CONSTANT_JOLT
+  #if ENABLED(FTM_CONSTANT_JOLT)
+    #define FTM_DEFAULT_JOLT 250.0f         // (m/s³) Default jolt for constant-jolt trajectory.
+                                            // Higher values print faster at the cost of increased resonance and extruder stress
+  #endif
+
+  // Block acceleration profile
+  // :[ 'TRAPEZOIDAL', 'POLY5', 'POLY6', 'CONSTANT_JOLT' ]
+  #define FTM_TRAJECTORY_TYPE TRAPEZOIDAL   //   TRAPEZOIDAL: Continuous Velocity. Max acceleration is respected.
+                                            //         POLY5: Like POLY6 with 1.5x but uses less CPU. Requires FTM_POLYS.
+                                            //         POLY6: Continuous Acceleration (aka S_CURVE). Requires FTM_POLYS.
+                                            // CONSTANT_JOLT: 7-phase S-curve. Requires FTM_CONSTANT_JOLT.
+                                            // POLY trajectories not only reduce resonances without rounding corners, but
+                                            // also reduce extruder strain due to linear advance.
+
   /**
    * Advanced configuration
    */
diff --git a/Marlin/Version.h b/Marlin/Version.h
index 8a7d93b6e238..56528e53daac 100644
--- a/Marlin/Version.h
+++ b/Marlin/Version.h
@@ -41,7 +41,7 @@
  * here we define this default string as the date where the latest release
  * version was tagged.
  */
-//#define STRING_DISTRIBUTION_DATE "2026-06-28"
+//#define STRING_DISTRIBUTION_DATE "2026-06-29"
 
 /**
  * The protocol for communication to the host. Protocol indicates communication
diff --git a/Marlin/src/gcode/feature/ft_motion/M494.cpp b/Marlin/src/gcode/feature/ft_motion/M494.cpp
index d6161a957473..0c0250f6a6a4 100644
--- a/Marlin/src/gcode/feature/ft_motion/M494.cpp
+++ b/Marlin/src/gcode/feature/ft_motion/M494.cpp
@@ -30,14 +30,20 @@
 #include "../../../lcd/marlinui.h"
 
 void say_ftm_settings() {
-  #if ANY(FTM_POLYS, FTM_SMOOTHING)
+  #if ANY(FTM_POLYS, FTM_SMOOTHING, FTM_CONSTANT_JOLT)
     const ft_config_t &c = ftMotion.cfg;
   #endif
 
-  #if ENABLED(FTM_POLYS)
+  #if HAS_FTM_TRAJECTORY_SELECTION
     SERIAL_ECHOLN(F("  Trajectory: "), ftMotion.getTrajectoryName(), C('('), (uint8_t)ftMotion.getTrajectoryType(), C(')'));
-    if (ftMotion.getTrajectoryType() == TrajectoryType::POLY6)
-      SERIAL_ECHOLNPGM("  Poly6 Overshoot: ", p_float_t(c.poly6_acceleration_overshoot, 3));
+    #if ENABLED(FTM_POLYS)
+      if (ftMotion.getTrajectoryType() == TrajectoryType::POLY6)
+        SERIAL_ECHOLNPGM("  Poly6 Overshoot: ", p_float_t(c.poly6_acceleration_overshoot, 3));
+    #endif
+    #if ENABLED(FTM_CONSTANT_JOLT)
+      if (ftMotion.getTrajectoryType() == TrajectoryType::CONSTANT_JOLT)
+        SERIAL_ECHOLNPGM("  Jolt: ", p_float_t(c.jolt / 1000.0f, 1), " m/s^3");
+    #endif
   #endif
 
   #if ENABLED(FTM_SMOOTHING)
@@ -52,7 +58,7 @@ void GcodeSuite::M494_report(const bool forReplay/*=true*/) {
   report_heading_etc(forReplay, F("FT Motion"));
   SERIAL_ECHOPGM("  M494 T", (uint8_t)ftMotion.getTrajectoryType());
 
-  #if ANY(FTM_POLYS, FTM_SMOOTHING)
+  #if ANY(FTM_POLYS, FTM_SMOOTHING, FTM_CONSTANT_JOLT)
     const ft_config_t &c = ftMotion.cfg;
   #endif
 
@@ -70,6 +76,11 @@ void GcodeSuite::M494_report(const bool forReplay/*=true*/) {
       SERIAL_ECHOPGM(" O", c.poly6_acceleration_overshoot);
   #endif
 
+  #if ENABLED(FTM_CONSTANT_JOLT)
+    if (ftMotion.getTrajectoryType() == TrajectoryType::CONSTANT_JOLT)
+      SERIAL_ECHOPGM(" J", c.jolt / 1000.0f);
+  #endif
+
   SERIAL_EOL();
 }
 
@@ -77,8 +88,9 @@ void GcodeSuite::M494_report(const bool forReplay/*=true*/) {
  * M494: Set Fixed-time Motion Control parameters
  *
  * Parameters:
- *    T<type> Set trajectory generator type (0=TRAPEZOIDAL, 1=POLY5, 2=POLY6)
+ *    T<type> Set trajectory generator type (0=TRAPEZOIDAL, 1=POLY5, 2=POLY6, 3=CONSTANT_JOLT)
  *    O<overshoot> Set acceleration overshoot for POLY6 (1.25-1.875)
+ *    J<jolt> Set maximum jolt for CONSTANT_JOLT (m/s³, positive)
  *    X<time> Set smoothing time for the X axis
  *    Y<time> Set smoothing time for the Y axis
  *    Z<time> Set smoothing time for the Z axis
@@ -87,16 +99,23 @@ void GcodeSuite::M494_report(const bool forReplay/*=true*/) {
 void GcodeSuite::M494() {
   bool report = !parser.seen_any();
 
-  #if ENABLED(FTM_POLYS)
+  #if HAS_FTM_TRAJECTORY_SELECTION
 
     // Parse trajectory type parameter.
     if (parser.seenval('T')) {
       if (ftMotion.updateTrajectoryType(TrajectoryType(parser.value_int())))
         report = true;
       else
-        SERIAL_ECHOLN(F("?Invalid "), F("(T)rajectory type value. Use 0=TRAPEZOIDAL, 1=POLY5, 2=POLY6"));
+        SERIAL_ECHOLN(F("?Invalid (T)rajectory type value. (0=TRAPEZOIDAL"
+          TERN_(FTM_POLYS, ", 1=POLY5, 2=POLY6")
+          TERN_(FTM_CONSTANT_JOLT, ", 3=CONSTANT_JOLT")
+          ")"));
     }
 
+  #endif // HAS_FTM_TRAJECTORY_SELECTION
+
+  #if ENABLED(FTM_POLYS)
+
     // Parse overshoot parameter.
     if (parser.seenval('O')) {
       const float val = parser.value_float();
@@ -110,6 +129,16 @@ void GcodeSuite::M494() {
 
   #endif // FTM_POLYS
 
+  #if ENABLED(FTM_CONSTANT_JOLT)
+
+    // Parse jolt parameter (user provides m/s³, stored internally as mm/s³).
+    if (parser.seenval('J')) {
+      ftMotion.cfg.set_jolt(parser.value_float() * 1000.0f);
+      report = true;
+    }
+
+  #endif // FTM_CONSTANT_JOLT
+
   #if ENABLED(FTM_SMOOTHING)
 
     auto smooth_set = [](AxisEnum axis, char axis_name) {
diff --git a/Marlin/src/inc/Conditionals-4-adv.h b/Marlin/src/inc/Conditionals-4-adv.h
index f4a574dac0ce..38ea6fc73f37 100644
--- a/Marlin/src/inc/Conditionals-4-adv.h
+++ b/Marlin/src/inc/Conditionals-4-adv.h
@@ -370,6 +370,13 @@
   #if ANY(FTM_DIR_CHANGE_HOLD_X, FTM_DIR_CHANGE_HOLD_Y, FTM_DIR_CHANGE_HOLD_Z, FTM_DIR_CHANGE_HOLD_E)
     #define HAS_FTM_DIR_CHANGE_HOLD 1
   #endif
+  #if ANY(FTM_POLYS, FTM_CONSTANT_JOLT)
+    #define HAS_FTM_TRAJECTORY_SELECTION 1
+  #endif
+  // Default trajectory type when not explicitly set
+  #ifndef FTM_TRAJECTORY_TYPE
+    #define FTM_TRAJECTORY_TYPE TRAPEZOIDAL
+  #endif
 #endif
 
 // Standard Motion
diff --git a/Marlin/src/inc/Version.h b/Marlin/src/inc/Version.h
index 9de1b89ef3c2..db34d4c3bff3 100644
--- a/Marlin/src/inc/Version.h
+++ b/Marlin/src/inc/Version.h
@@ -42,7 +42,7 @@
  * version was tagged.
  */
 #ifndef STRING_DISTRIBUTION_DATE
-  #define STRING_DISTRIBUTION_DATE "2026-06-28"
+  #define STRING_DISTRIBUTION_DATE "2026-06-29"
 #endif
 
 /**
diff --git a/Marlin/src/lcd/language/language_en.h b/Marlin/src/lcd/language/language_en.h
index c66288c4e799..dff8f4fcdeba 100644
--- a/Marlin/src/lcd/language/language_en.h
+++ b/Marlin/src/lcd/language/language_en.h
@@ -838,6 +838,8 @@ namespace LanguageNarrow_en {
   LSTR MSG_FTM_TRAPEZOIDAL                = _UxGT("Trapezoidal");
   LSTR MSG_FTM_POLY5                      = _UxGT("5th Order");
   LSTR MSG_FTM_POLY6                      = _UxGT("6th Order");
+  LSTR MSG_FTM_CONSTANT_JOLT              = _UxGT("Constant Jolt");
+  LSTR MSG_FTM_JOLT                       = _UxGT("Jolt (m/s3)");
   LSTR MSG_FTM_TRAJECTORY                 = _UxGT("Trajectory: $");
   LSTR MSG_FILAMENT_EN                    = _UxGT("Filament *");
   LSTR MSG_SEGMENTS_PER_SECOND            = _UxGT("Segments/Sec");
diff --git a/Marlin/src/lcd/menu/menu_motion.cpp b/Marlin/src/lcd/menu/menu_motion.cpp
index 5afa70e266e8..9d8eb2c79d61 100644
--- a/Marlin/src/lcd/menu/menu_motion.cpp
+++ b/Marlin/src/lcd/menu/menu_motion.cpp
@@ -428,7 +428,7 @@ void menu_move() {
     END_MENU();
   }
 
-  #if ENABLED(FTM_POLYS)
+  #if HAS_FTM_TRAJECTORY_SELECTION
 
     void menu_ftm_trajectory_generator() {
       const TrajectoryType traj_type = ftMotion.getTrajectoryType();
@@ -438,17 +438,24 @@ void menu_move() {
       if (traj_type != TrajectoryType::TRAPEZOIDAL) ACTION_ITEM(MSG_FTM_TRAPEZOIDAL, []{
         queue.inject(TS(F("M494"), 'T', int(TrajectoryType::TRAPEZOIDAL))); ui.go_back();
       });
-      if (traj_type != TrajectoryType::POLY5) ACTION_ITEM(MSG_FTM_POLY5, []{
-        queue.inject(TS(F("M494"), 'T', int(TrajectoryType::POLY5))); ui.go_back();
-      });
-      if (traj_type != TrajectoryType::POLY6) ACTION_ITEM(MSG_FTM_POLY6, []{
-        queue.inject(TS(F("M494"), 'T', int(TrajectoryType::POLY6))); ui.go_back();
-      });
+      #if ENABLED(FTM_POLYS)
+        if (traj_type != TrajectoryType::POLY5) ACTION_ITEM(MSG_FTM_POLY5, []{
+          queue.inject(TS(F("M494"), 'T', int(TrajectoryType::POLY5))); ui.go_back();
+        });
+        if (traj_type != TrajectoryType::POLY6) ACTION_ITEM(MSG_FTM_POLY6, []{
+          queue.inject(TS(F("M494"), 'T', int(TrajectoryType::POLY6))); ui.go_back();
+        });
+      #endif
+      #if ENABLED(FTM_CONSTANT_JOLT)
+        if (traj_type != TrajectoryType::CONSTANT_JOLT) ACTION_ITEM(MSG_FTM_CONSTANT_JOLT, []{
+          queue.inject(TS(F("M494"), 'T', int(TrajectoryType::CONSTANT_JOLT))); ui.go_back();
+        });
+      #endif
 
       END_MENU();
     }
 
-  #endif // FTM_POLYS
+  #endif // HAS_FTM_TRAJECTORY_SELECTION
 
   #if HAS_DYNAMIC_FREQ
 
@@ -548,14 +555,24 @@ void menu_move() {
     // Show only when FT Motion is active (or optionally always show)
     if (TERN(FT_MOTION_NO_MENU_TOGGLE, true, c.active)) {
 
-      #if ENABLED(FTM_POLYS)
+      #if HAS_FTM_TRAJECTORY_SELECTION
         SUBMENU_S(ftMotion.getTrajectoryName(), MSG_FTM_TRAJECTORY, menu_ftm_trajectory_generator);
-        if (ftMotion.getTrajectoryType() == TrajectoryType::POLY6) {
-          editable.decimal = c.poly6_acceleration_overshoot;
-          EDIT_ITEM(float42_52, MSG_FTM_POLY6_OVERSHOOT, &editable.decimal, 1.25f, 1.875f, []{
-            queue.inject(TS(F("M494"), 'O', editable.decimal));
-          });
-        }
+        #if ENABLED(FTM_POLYS)
+          if (ftMotion.getTrajectoryType() == TrajectoryType::POLY6) {
+            editable.decimal = c.poly6_acceleration_overshoot;
+            EDIT_ITEM(float42_52, MSG_FTM_POLY6_OVERSHOOT, &editable.decimal, 1.25f, 1.875f, []{
+              queue.inject(TS(F("M494"), 'O', editable.decimal));
+            });
+          }
+        #endif
+        #if ENABLED(FTM_CONSTANT_JOLT)
+          if (ftMotion.getTrajectoryType() == TrajectoryType::CONSTANT_JOLT) {
+            editable.decimal = c.jolt / 1000.0f;
+            EDIT_ITEM(float4, MSG_FTM_JOLT, &editable.decimal, 1.0f, 10000.0f, []{
+              queue.inject(TS(F("M494"), 'J', editable.decimal));
+            });
+          }
+        #endif
       #endif
 
       CARTES_MAP(_FTM_AXIS_SUBMENU);
@@ -576,7 +593,7 @@ void menu_move() {
       // Copy Flash strings to RAM for C-string substitution
       // For U8G paged rendering check and skip extra string copy
 
-      #if ENABLED(FTM_POLYS)
+      #if HAS_FTM_TRAJECTORY_SELECTION
         #if CACHE_FOR_SPEED
           bool got_t = false;
         #endif
@@ -592,7 +609,7 @@ void menu_move() {
 
     #else // !__AVR__
 
-      #if ENABLED(FTM_POLYS)
+      #if HAS_FTM_TRAJECTORY_SELECTION
         auto _traj_name = []{ return ftMotion.getTrajectoryName(); };
       #endif
 
@@ -601,14 +618,24 @@ void menu_move() {
     START_MENU();
     BACK_ITEM(MSG_TUNE);
 
-    #if ENABLED(FTM_POLYS)
+    #if HAS_FTM_TRAJECTORY_SELECTION
       SUBMENU_S(_traj_name(), MSG_FTM_TRAJECTORY, menu_ftm_trajectory_generator);
-      if (ftMotion.getTrajectoryType() == TrajectoryType::POLY6) {
-        editable.decimal = ftMotion.cfg.poly6_acceleration_overshoot;
-        EDIT_ITEM(float42_52, MSG_FTM_POLY6_OVERSHOOT, &editable.decimal, 1.25f, 1.875f, []{
-          queue.inject(TS(F("M494"), 'O', editable.decimal));
-        });
-      }
+      #if ENABLED(FTM_POLYS)
+        if (ftMotion.getTrajectoryType() == TrajectoryType::POLY6) {
+          editable.decimal = ftMotion.cfg.poly6_acceleration_overshoot;
+          EDIT_ITEM(float42_52, MSG_FTM_POLY6_OVERSHOOT, &editable.decimal, 1.25f, 1.875f, []{
+            queue.inject(TS(F("M494"), 'O', editable.decimal));
+          });
+        }
+      #endif
+      #if ENABLED(FTM_CONSTANT_JOLT)
+        if (ftMotion.getTrajectoryType() == TrajectoryType::CONSTANT_JOLT) {
+          editable.decimal = ftMotion.cfg.jolt / 1000.0f;
+          EDIT_ITEM(float4, MSG_FTM_JOLT, &editable.decimal, 1.0f, 10000.0f, []{
+            queue.inject(TS(F("M494"), 'J', editable.decimal));
+          });
+        }
+      #endif
     #endif
 
     SHAPED_MAP(_FTM_AXIS_SUBMENU);
diff --git a/Marlin/src/module/ft_motion.cpp b/Marlin/src/module/ft_motion.cpp
index f0e5fa5e555b..01dd4a4415be 100644
--- a/Marlin/src/module/ft_motion.cpp
+++ b/Marlin/src/module/ft_motion.cpp
@@ -83,9 +83,14 @@ bool FTMotion::fastForwardUntilMotion = false;      // Fast forward time if ther
 // Trajectory generators
 TrapezoidalTrajectoryGenerator FTMotion::trapezoidalGenerator;
 #if ENABLED(FTM_POLYS)
-  TrajectoryType FTMotion::trajectoryType = TrajectoryType::FTM_TRAJECTORY_TYPE;
   Poly5TrajectoryGenerator FTMotion::poly5Generator;
   Poly6TrajectoryGenerator FTMotion::poly6Generator;
+#endif
+#if ENABLED(FTM_CONSTANT_JOLT)
+  ConstantJoltTrajectoryGenerator FTMotion::cjGenerator;
+#endif
+#if HAS_FTM_TRAJECTORY_SELECTION
+  TrajectoryType FTMotion::trajectoryType = TrajectoryType::FTM_TRAJECTORY_TYPE;
   TrajectoryGenerator* FTMotion::currentGenerator = &FTMotion::trapezoidalGenerator;
 #endif
 
@@ -302,11 +307,11 @@ void FTMotion::plan_runout_block() {
 void FTMotion::init() {
   update_shaping_params();
   TERN_(FTM_SMOOTHING, update_smoothing_params());
-  TERN_(FTM_POLYS, setTrajectoryType(cfg.trajectory_type));
+  TERN_(HAS_FTM_TRAJECTORY_SELECTION, setTrajectoryType(cfg.trajectory_type));
   reset(); // Precautionary.
 }
 
-#if ENABLED(FTM_POLYS)
+#if HAS_FTM_TRAJECTORY_SELECTION
 
   // Set trajectory generator type
   void FTMotion::setTrajectoryType(const TrajectoryType type) {
@@ -314,19 +319,32 @@ void FTMotion::init() {
     switch (type) {
       default:
       case TrajectoryType::TRAPEZOIDAL: currentGenerator = &trapezoidalGenerator; break;
-      case TrajectoryType::POLY5:       currentGenerator = &poly5Generator;       break;
-      case TrajectoryType::POLY6:       currentGenerator = &poly6Generator;       break;
+      #if ENABLED(FTM_POLYS)
+        case TrajectoryType::POLY5:     currentGenerator = &poly5Generator;       break;
+        case TrajectoryType::POLY6:     currentGenerator = &poly6Generator;       break;
+      #endif
+      #if ENABLED(FTM_CONSTANT_JOLT)
+        case TrajectoryType::CONSTANT_JOLT:
+          cjGenerator.setJoltPtr(&cfg.jolt);
+          currentGenerator = &cjGenerator;
+          break;
+      #endif
     }
   }
 
   // Update trajectory generator type from G-code or UI
   bool FTMotion::updateTrajectoryType(const TrajectoryType type) {
-    if (type == trajectoryType) return false;
+    if (type == trajectoryType) return true;  // Already selected — valid, no-op
     switch (type) {
       default: return false;
       case TrajectoryType::TRAPEZOIDAL:
-      case TrajectoryType::POLY5:
-      case TrajectoryType::POLY6:
+      #if ENABLED(FTM_POLYS)
+        case TrajectoryType::POLY5:
+        case TrajectoryType::POLY6:
+      #endif
+      #if ENABLED(FTM_CONSTANT_JOLT)
+        case TrajectoryType::CONSTANT_JOLT:
+      #endif
         break;
     }
     prep_for_shaper_change();
@@ -334,14 +352,19 @@ void FTMotion::init() {
     return true;
   }
 
-#endif // FTM_POLYS
+#endif // HAS_FTM_TRAJECTORY_SELECTION
 
 FSTR_P FTMotion::getTrajectoryName() {
   switch (getTrajectoryType()) {
     default:
     case TrajectoryType::TRAPEZOIDAL: return GET_TEXT_F(MSG_FTM_TRAPEZOIDAL);
-    case TrajectoryType::POLY5:       return GET_TEXT_F(MSG_FTM_POLY5);
-    case TrajectoryType::POLY6:       return GET_TEXT_F(MSG_FTM_POLY6);
+    #if ENABLED(FTM_POLYS)
+      case TrajectoryType::POLY5:     return GET_TEXT_F(MSG_FTM_POLY5);
+      case TrajectoryType::POLY6:     return GET_TEXT_F(MSG_FTM_POLY6);
+    #endif
+    #if ENABLED(FTM_CONSTANT_JOLT)
+      case TrajectoryType::CONSTANT_JOLT: return GET_TEXT_F(MSG_FTM_CONSTANT_JOLT);
+    #endif
   }
 }
 
@@ -404,9 +427,8 @@ bool FTMotion::plan_next_block() {
     const ext_distance_t &moveDist = current_block->ext_distance_mm;
     ratio = moveDist / totalLength;
 
-    // Plan the trajectory using the trajectory generator
-    currentGenerator->plan(current_block->entry_speed, current_block->exit_speed, current_block->acceleration, current_block->nominal_speed, totalLength);
-
+    currentGenerator->plan(current_block->entry_speed, current_block->exit_speed,
+                           current_block->acceleration, current_block->nominal_speed, totalLength);
     endPos_prevBlock += moveDist;
 
     TERN_(FTM_HAS_LIN_ADVANCE, use_advance_lead = current_block->use_advance_lead);
diff --git a/Marlin/src/module/ft_motion.h b/Marlin/src/module/ft_motion.h
index 3d50e3fbd8a4..d2a77af8dd41 100644
--- a/Marlin/src/module/ft_motion.h
+++ b/Marlin/src/module/ft_motion.h
@@ -30,6 +30,9 @@
   #include "ft_motion/trajectory_poly5.h"
   #include "ft_motion/trajectory_poly6.h"
 #endif
+#if ENABLED(FTM_CONSTANT_JOLT)
+  #include "ft_motion/trajectory_constant_jolt.h"
+#endif
 #if ENABLED(RESONANCE_TEST)
   #include "../feature/resonance/resonance_generator.h"
 #endif
@@ -93,10 +96,21 @@ typedef struct FTConfig {
 
   #if ENABLED(FTM_POLYS)
     float poly6_acceleration_overshoot; // Overshoot factor for Poly6 (1.25 to 2.0)
+  #endif
+  #if HAS_FTM_TRAJECTORY_SELECTION
     TrajectoryType trajectory_type = TrajectoryType::FTM_TRAJECTORY_TYPE; // Trajectory generator type
   #else
     static constexpr TrajectoryType trajectory_type = TrajectoryType::TRAPEZOIDAL;
   #endif
+  #if ENABLED(FTM_CONSTANT_JOLT)
+    float jolt = FTM_DEFAULT_JOLT * 1000.0f;  // (mm/s³) stored internally; FTM_DEFAULT_JOLT is in m/s³
+
+    void set_jolt(float j) {
+      LIMIT(j, 1000.0f, 10'000'000.0f);
+      prep_for_shaper_change();
+      jolt = j;
+    }
+  #endif
 
   static void prep_for_shaper_change();
   static void update_shaping_params();
@@ -227,6 +241,7 @@ typedef struct FTConfig {
     #endif // HAS_FTM_SHAPING
 
     TERN_(FTM_POLYS, poly6_acceleration_overshoot = FTM_POLY6_ACCELERATION_OVERSHOOT);
+    TERN_(FTM_CONSTANT_JOLT, jolt = FTM_DEFAULT_JOLT * 1000.0f);
 
     update_shaping_params();
   }
@@ -253,7 +268,9 @@ class FTMotion {
         #undef _RESET_SMOOTH
       #endif
 
-      TERN_(FTM_POLYS, setTrajectoryType(TrajectoryType::FTM_TRAJECTORY_TYPE));
+      #if HAS_FTM_TRAJECTORY_SELECTION
+        setTrajectoryType(TrajectoryType::FTM_TRAJECTORY_TYPE);
+      #endif
 
       reset();
     }
@@ -285,11 +302,11 @@ class FTMotion {
     #endif
 
     // Trajectory generator selection
-    #if ENABLED(FTM_POLYS)
+    #if HAS_FTM_TRAJECTORY_SELECTION
       static void setTrajectoryType(const TrajectoryType type);
       static bool updateTrajectoryType(const TrajectoryType type);
     #endif
-    static TrajectoryType getTrajectoryType() { return TERN(FTM_POLYS, trajectoryType, TrajectoryType::TRAPEZOIDAL); }
+    static TrajectoryType getTrajectoryType() { return TERN(HAS_FTM_TRAJECTORY_SELECTION, trajectoryType, TrajectoryType::TRAPEZOIDAL); }
     static FSTR_P getTrajectoryName();
 
     FORCE_INLINE static bool axis_is_moving(const AxisEnum real) {
@@ -341,6 +358,11 @@ class FTMotion {
     #if ENABLED(FTM_POLYS)
       static Poly5TrajectoryGenerator poly5Generator;
       static Poly6TrajectoryGenerator poly6Generator;
+    #endif
+    #if ENABLED(FTM_CONSTANT_JOLT)
+      static ConstantJoltTrajectoryGenerator cjGenerator;
+    #endif
+    #if HAS_FTM_TRAJECTORY_SELECTION
       static TrajectoryType trajectoryType;
       static TrajectoryGenerator* currentGenerator;
     #else
diff --git a/Marlin/src/module/ft_motion/constant_jolt_math.h b/Marlin/src/module/ft_motion/constant_jolt_math.h
new file mode 100644
index 000000000000..26780798d89b
--- /dev/null
+++ b/Marlin/src/module/ft_motion/constant_jolt_math.h
@@ -0,0 +1,353 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2026 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+/**
+ * Internal math functions for the constant-jolt trajectory planner.
+ * Only included by constant_jolt_planner.cpp and trajectory_constant_jolt.cpp.
+ * NOT included via ft_motion.h — avoids bloating all 19+ TUs with unused code.
+ */
+
+#include "trajectory_constant_jolt.h"  // for constant_jolt::simulatePhase, CJP_* defines, _MIN, _MAX, SQRT
+#include <math.h>
+
+namespace constant_jolt {
+
+// Solve phaseDist(v, a, j, t) = d for t ∈ [t_lo, t_hi].
+// Bracketed Newton with quadratic initial guess. Returns t (upper bracket).
+// Used by getVelocityAtDistance and plan_decel_with_carry inner solve.
+static inline float solvePhaseTime(
+  float v, float a, float j, float d,
+  float t_lo, float t_hi
+) {
+  // Quadratic initial guess: v*t + 0.5*a*t² = d (ignores cubic jerk term).
+  float t;
+  if (ABS(a) > 1e-6f) {
+    const float disc = v * v + 2.0f * a * d;
+    t = (disc > 0.0f) ? (-v + SQRT(disc)) / a : d / _MAX(v, 1e-6f);
+  }
+  else {
+    t = (v > 1e-6f) ? d / v : 0.5f * (t_lo + t_hi);
+  }
+  t = _MAX(t_lo, _MIN(t, t_hi));
+  for (int i = 0; i < 16; i++) {
+    const float f = phaseDist(v, a, j, t) - d;
+    if (f < 0.0f) t_lo = t; else t_hi = t;
+    if (t_hi - t_lo < 1e-7f) break;
+    const float fp = v + a * t + 0.5f * j * t * t;  // f' = velocity at t
+    if (fp > 1e-6f) {
+      t -= f / fp;
+      if (t < t_lo || t > t_hi) t = 0.5f * (t_lo + t_hi);
+    }
+    else {
+      t = 0.5f * (t_lo + t_hi);
+    }
+  }
+  return t_hi;
+}
+
+// Distance of a 3-phase ramp: [j1 for t1, hold for t2, j3 for t3].
+// Horner-form polynomial per phase, no sequential state updates.
+static FORCE_INLINE float rampDist3Phase(
+  float v, float a,
+  float j1, float t1,
+  float t2,
+  float j3, float t3
+) {
+  const float a1 = a + j1 * t1;
+  const float v1 = v + (a + j1 * 0.5f * t1) * t1;
+  const float v2 = v1 + a1 * t2;
+  return (v + (a * 0.5f + (j1 / 6.0f) * t1) * t1) * t1
+       + (v1 + a1 * 0.5f * t2) * t2
+       + (v2 + (a1 * 0.5f + (j3 / 6.0f) * t3) * t3) * t3;
+}
+
+// Velocity after fully absorbing initial acceleration a (bringing a to 0).
+// v + a*|a|/(2j) — the minimum v_peak for an accel ramp starting at (v, a).
+static FORCE_INLINE float absorbedVelocity(float v, float a, float j) {
+  return v + a * ABS(a) / (2.0f * j);
+}
+
+// Phase durations for a 3-phase accel ramp [+j to a_peak, hold at a_peak, -j to 0].
+// Three regimes: triangular (a_peak² ≤ a_max²), a_start above a_max, trapezoidal.
+// Takes a_peak_sq to defer sqrt — only computed in the triangular branch.
+// Returns a_peak when computed (triangular), 0 otherwise.
+static FORCE_INLINE float accelRampTimings(
+  float a_peak_sq, float a_start,
+  float a_max, float j_max, float dv,
+  float &dt1, float &dt2, float &dt3
+) {
+  if (a_peak_sq <= a_max * a_max) {
+    const float a_peak = SQRT(a_peak_sq);
+    dt1 = (a_peak - a_start) / j_max;
+    dt2 = 0.0f;
+    dt3 = a_peak / j_max;
+    return a_peak;
+  }
+  if (a_start > a_max) {
+    dt1 = 0.0f;
+    dt3 = a_start / j_max;
+    dt2 = _MAX(0.0f, (dv - a_start * a_start / (2.0f * j_max)) / a_start);
+  }
+  else {
+    dt1 = (a_max - a_start) / j_max;
+    dt3 = a_max / j_max;
+    dt2 = _MAX(0.0f, (dv - (2.0f * a_max * a_max - a_start * a_start) / (2.0f * j_max)) / a_max);
+  }
+  return 0.0f;
+}
+
+// Plan a 3-phase ramp between v_start and v_peak.
+// Returns the distance consumed.
+// a_start: initial acceleration (default 0). Only used for accel ramps (decel=false).
+//   For accel: phases are [+j from a_start to a_peak, hold at a_peak, -j from a_peak to 0]
+//   For decel: a_start is ignored (decel always starts from a=0 at v_peak)
+static inline float planRamp(
+  float v_start, float v_peak, float j_max, float a_max,
+  bool decel, float &dt_jolt1, float &dt_hold, float &dt_jolt2,
+  float a_start = 0.0f
+) {
+  float dv = v_peak - v_start;
+  float a_peak_sq = j_max * dv + 0.5f * a_start * a_start;
+  if (a_peak_sq < 0) {
+    if (a_start < 0.0f) {
+      a_peak_sq = 0;
+    }
+    else {
+      dt_jolt1 = dt_hold = dt_jolt2 = 0;
+      return 0;
+    }
+  }
+  if (!decel) {
+    accelRampTimings(a_peak_sq, a_start, a_max, j_max, dv, dt_jolt1, dt_hold, dt_jolt2);
+  }
+  else {
+    if (a_peak_sq <= a_max * a_max) {
+      const float a_peak = SQRT(a_peak_sq);
+      dt_jolt1 = (a_peak - a_start) / j_max;
+      dt_hold = 0;
+      dt_jolt2 = a_peak / j_max;
+    }
+    else {
+      dt_jolt1 = (a_max - a_start) / j_max;
+      dt_jolt2 = a_max / j_max;
+      float dv_no_hold = (2.0f * a_max * a_max - a_start * a_start) / (2.0f * j_max);
+      dt_hold = _MAX(0.0f, (dv - dv_no_hold) / a_max);
+    }
+  }
+
+  // Distance: closed-form matching rampDist / rampDistWithA exactly,
+  // so planRamp and totalRampDistCF agree (no float precision gap).
+  // The a_start != 0 path uses rampDist3Phase (phaseDist internally),
+  // consistent with buildPhaseCache and rawDistanceAtTime.
+  if (decel || a_start == 0.0f) {
+    if (dv <= 0.0f) return 0.0f;
+    if (j_max * dv <= a_max * a_max)
+      return (v_start + v_peak) * dt_jolt2;  // dt_jolt2 = a_peak/j = sqrt(dv/j)
+    else
+      return (v_start + v_peak) * 0.5f * (a_max / j_max + dv / a_max);
+  }
+  else {
+    return rampDist3Phase(v_start, a_start, j_max, dt_jolt1, dt_hold, -j_max, dt_jolt2);
+  }
+}
+
+// Plan a 3-phase decel ramp from (v_start, a_start) to (v_end, 0).
+// Phases: [-j, 0, +j]. a_start can be positive, zero, or negative.
+// Returns distance consumed, or -1 if infeasible (|a_start| exceeds the
+// triangular peak — the -j phase would push acceleration further from zero).
+static inline float planDecelRampWithA(
+  float v_start, float v_end, float j_max, float a_max,
+  float &dt_jolt1, float &dt_hold, float &dt_jolt2,
+  float a_start = 0.0f
+) {
+  const float dv = v_start - v_end;
+  a_max = _MAX(a_max, ABS(a_start));
+  float a_peak_sq = (a_start * a_start + 2.0f * j_max * dv) / 2.0f;
+  if (a_peak_sq < 0.0f) a_peak_sq = 0.0f;
+  float a_peak = SQRT(a_peak_sq);
+
+  if (a_start < 0.0f && -a_start > a_peak * CJP_INFEASIBLE_REL + CJP_INFEASIBLE_ABS) {
+    dt_jolt1 = dt_hold = dt_jolt2 = 0.0f;
+    return -1.0f;
+  }
+
+  if (a_peak <= a_max) {
+    dt_jolt1 = (a_start + a_peak) / j_max;
+    dt_hold = 0.0f;
+    dt_jolt2 = a_peak / j_max;
+  }
+  else {
+    a_peak = a_max;
+    dt_jolt1 = (a_start + a_max) / j_max;
+    dt_jolt2 = a_max / j_max;
+    float dv_no_hold = (a_start * a_start - 2.0f * a_max * a_max) / (2.0f * j_max);
+    float dv_hold = -dv - dv_no_hold;
+    dt_hold = _MAX(0.0f, -dv_hold / a_max);
+  }
+
+  return rampDist3Phase(v_start, a_start, -j_max, dt_jolt1, dt_hold, j_max, dt_jolt2);
+}
+
+// Accel ramp distance given a_peak² (avoids all sqrt in trapezoidal regime).
+// Used by maxReachableSpeed bisection on a_peak² directly.
+static inline float rampDistFromApeakSq(
+  float v_start, float a_start,
+  float a_peak_sq, float j_max, float a_max
+) {
+  const float dv = (a_peak_sq - 0.5f * a_start * a_start) / j_max;
+  float dt1, dt2, dt3;
+  accelRampTimings(a_peak_sq, a_start, a_max, j_max, dv, dt1, dt2, dt3);
+  return rampDist3Phase(v_start, a_start, j_max, dt1, dt2, -j_max, dt3);
+}
+
+// Closed-form ramp distance (O(1), no simulation).
+static FORCE_INLINE float rampDist(float v_start, float v_peak, float j_max, float a_max) {
+  const float dv = v_peak - v_start;
+  if (dv <= 0.0f) return 0.0f;
+  if (j_max * dv <= a_max * a_max)
+    return (v_start + v_peak) * SQRT(dv / j_max);
+  else
+    return (v_start + v_peak) * 0.5f * (a_max / j_max + dv / a_max);
+}
+
+// Closed-form ramp distance with initial acceleration.
+// Delegates to planRamp (accel direction); discards phase durations.
+static FORCE_INLINE float rampDistWithA(
+  float v_start, float v_peak, float j_max, float a_max,
+  float a_start
+) {
+  if (a_start == 0.0f) return rampDist(v_start, v_peak, j_max, a_max);
+  float t1, t2, t3;
+  return planRamp(v_start, v_peak, j_max, a_max, false, t1, t2, t3, a_start);
+}
+
+// Total accel+decel ramp distance using closed-form.
+static inline float totalRampDistCF(float v_entry, float v_exit, float v_peak,
+                                        float j_max, float a_max, float a_entry) {
+  return rampDistWithA(v_entry, v_peak, j_max, a_max, a_entry)
+       + rampDist(v_exit, v_peak, j_max, a_max);
+}
+
+// Combined distance + derivative for total ramp. Shares SQRT and branch
+// decisions between the two computations. Used by the Newton loop in plan_accel_decel.
+static inline float totalRampDistAndDeriv(
+    float v_entry, float v_exit, float v_peak,
+    float j_max, float a_max, float a_entry,
+    float &deriv
+) {
+  float accel_dist, accel_deriv;
+
+  // === Accel ramp ===
+  {
+    const float dv = v_peak - v_entry;
+    if (a_entry == 0.0f) {
+      if (dv <= 0.0f) {
+        accel_dist = accel_deriv = 0.0f;
+      }
+      else if (j_max * dv <= a_max * a_max) {
+        const float s = SQRT(dv / j_max);
+        accel_dist = (v_entry + v_peak) * s;
+        accel_deriv = (3.0f * v_peak - v_entry) * 0.5f / (j_max * s);
+      }
+      else {
+        accel_dist = (v_entry + v_peak) * 0.5f * (a_max / j_max + dv / a_max);
+        accel_deriv = 0.5f * (a_max / j_max + 2.0f * v_peak / a_max);
+      }
+    }
+    else {
+      float a_peak_sq = j_max * dv + 0.5f * a_entry * a_entry;
+      bool feasible = true;
+      if (a_peak_sq < 0.0f) {
+        if (a_entry < 0.0f) a_peak_sq = 0.0f;
+        else feasible = false;
+      }
+      if (!feasible) {
+        accel_dist = accel_deriv = 0.0f;
+      }
+      else {
+        float dt1, dt2, dt3;
+        const float a_peak = accelRampTimings(a_peak_sq, a_entry, a_max, j_max, dv, dt1, dt2, dt3);
+        accel_dist = rampDist3Phase(v_entry, a_entry, j_max, dt1, dt2, -j_max, dt3);
+
+        // Derivative (reuses a_peak, branch, and phase durations)
+        if (a_peak > 0.0f) {  // triangular (a_peak was computed)
+          if (a_peak < 1e-10f) { accel_deriv = 0.0f; }
+          else {
+            const float da = j_max / (2.0f * a_peak);
+            const float ddt = da / j_max;
+            const float v1 = v_entry + a_entry * dt1 + 0.5f * j_max * dt1 * dt1;
+            const float dd1 = v1 * ddt;
+            const float dv1 = a_peak * ddt;
+            accel_deriv = dd1 + dv1 * dt3 + v1 * ddt
+                        + 0.5f * (da * dt3 * dt3 + a_peak * 2.0f * dt3 * ddt)
+                        - (j_max / 2.0f) * dt3 * dt3 * ddt;
+          }
+        }
+        else if (a_entry > a_max) {
+          accel_deriv = (dt2 <= 0.0f) ? 0.0f : (v_entry + a_entry * dt2) / a_entry + dt3;
+        }
+        else {
+          if (dt2 <= 0.0f) { accel_deriv = 0.0f; }
+          else {
+            const float v1 = v_entry + a_entry * dt1 + 0.5f * j_max * dt1 * dt1;
+            accel_deriv = (v1 + a_max * dt2) / a_max + dt3;
+          }
+        }
+      }
+    }
+  }
+
+  // === Decel ramp (always a_entry=0) ===
+  float decel_dist, decel_deriv;
+  {
+    const float dv = v_peak - v_exit;
+    if (dv <= 0.0f) {
+      decel_dist = decel_deriv = 0.0f;
+    }
+    else if (j_max * dv <= a_max * a_max) {
+      const float s = SQRT(dv / j_max);
+      decel_dist = (v_exit + v_peak) * s;
+      decel_deriv = (3.0f * v_peak - v_exit) * 0.5f / (j_max * s);
+    }
+    else {
+      decel_dist = (v_exit + v_peak) * 0.5f * (a_max / j_max + dv / a_max);
+      decel_deriv = 0.5f * (a_max / j_max + 2.0f * v_peak / a_max);
+    }
+  }
+
+  deriv = accel_deriv + decel_deriv;
+  return accel_dist + decel_dist;
+}
+
+// Algebraic initial guess for v_peak assuming both ramps are trapezoidal.
+static inline float vpeakGuess(float v_entry, float v_exit,
+                                    float dist_total, float j_max, float a_max) {
+  const float am2j = a_max * a_max / j_max;
+  const float B = am2j;
+  const float C = 0.5f * (v_entry * (am2j - v_entry) + v_exit * (am2j - v_exit)) - a_max * dist_total;
+  const float disc = B * B - 4.0f * C;
+  if (disc < 0.0f) return 0.5f * (v_entry + v_exit);
+  return (-B + SQRT(disc)) * 0.5f;
+}
+
+} // namespace constant_jolt
diff --git a/Marlin/src/module/ft_motion/constant_jolt_planner.cpp b/Marlin/src/module/ft_motion/constant_jolt_planner.cpp
new file mode 100644
index 000000000000..41016adbc1ee
--- /dev/null
+++ b/Marlin/src/module/ft_motion/constant_jolt_planner.cpp
@@ -0,0 +1,431 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2026 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../../inc/MarlinConfig.h"
+
+#if ENABLED(FTM_CONSTANT_JOLT)
+
+#include "trajectory_constant_jolt.h"
+#include "constant_jolt_math.h"
+
+bool ConstantJoltBlockPlanner::planNext(ConstantJoltTrajectoryGenerator& traj, float j_max) {
+  float mm[BLOCK_BUFFER_SIZE];
+  float nominal[BLOCK_BUFFER_SIZE];
+  float accel[BLOCK_BUFFER_SIZE];
+  float vmax_junction[BLOCK_BUFFER_SIZE + 1];  // max entry speed ceiling per block; [block_count]=0 (must stop)
+
+  uint8_t block_count = 0;
+
+  // Look ahead at future blocks.
+  for (uint8_t i = 0; i < BLOCK_BUFFER_SIZE; i++) {
+    block_t* blk = planner.get_future_block(i);
+    if (!blk) break;
+    if (blk->is_sync()) continue; // skip sync blocks in lookahead
+
+    mm[block_count] = blk->millimeters;
+    nominal[block_count] = blk->nominal_speed;
+    accel[block_count] = blk->acceleration;
+    vmax_junction[block_count] = blk->vmax_junction;
+    block_count++;
+  }
+  if (block_count == 0) {
+    traj.reset();
+    return false;
+  }
+  vmax_junction[block_count] = 0.0f;  // must stop after last block
+
+  // Carry both velocity and acceleration from previous block's exit.
+  // The previous exit state already happened — never cap or reset it.
+  float v_left_entry = traj.getExitSpeed();
+  float a_left_entry = traj.getExitAccel();
+
+
+  // Find max left-compatible extent: nominal spread ≤ 1%, accel ratio ≤ 1.1.
+  // Nominals may differ slightly on curves (speed_factor caps per-axis rates).
+  // The merged trajectory cruises at up to nom_max (per candidate). All blocks
+  // in the group are within 1% of each other, so reuse is safe.
+  uint8_t max_left_compatible = 1;
+  {
+    float a_min = accel[0], a_max_group = accel[0];
+    float nom_lo = nominal[0], nom_hi = nominal[0];
+    for (uint8_t i = 1; i < block_count; i++) {
+      float new_lo = _MIN(nom_lo, nominal[i]);
+      float new_hi = _MAX(nom_hi, nominal[i]);
+      if (new_hi > new_lo * CJP_MERGE_NOM_RATIO) break;
+      float new_a_min = _MIN(a_min, accel[i]);
+      float new_a_max = _MAX(a_max_group, accel[i]);
+      if (new_a_max > new_a_min * CJP_MERGE_AMAX_RATIO) break;
+      nom_lo = new_lo;
+      nom_hi = new_hi;
+      a_min = new_a_min;
+      a_max_group = new_a_max;
+      max_left_compatible++;
+    }
+  }
+
+  /**
+   * ─── Backward pass with integrated reuse check ───
+   *
+   * Compute max feasible entry speed for [i..N) assuming per-block (unmerged) planning.
+   * NOT valid for merged trajectories — merging has more distance and can safely exceed these.
+   *
+   * ─── Why trajectory reuse is essential (not just an optimization) ───
+   *
+   * When a merged trajectory is truncated at block 0, the exit state (v, a) is carried
+   * to the next cycle. Ideally, replanning from that state would reconstruct the same
+   * trajectory. In practice, plan_full's Newton solver converges to a slightly different
+   * v_peak due to float rounding along a different convergence path (different initial
+   * guess, different bracket tightening sequence). This epsilon difference in v_peak
+   * produces a different trajectory shape. After truncation, the next block's entry state
+   * diverges further. Over several cycles, the accumulated divergence can cause merged
+   * candidates to fail (overshoot by > CJP_TOL), forcing a v=0 fallback with
+   * harsh deceleration that prevents the last block from stopping.
+   *
+   * Reuse sidesteps this entirely: restore the saved pre-truncation trajectory and
+   * advance within it. No Newton, no convergence differences, exact continuation.
+   *
+   * When a previous trajectory is available for reuse, we check at the reuse junction
+   * whether the backward pass value has improved. If not, we reuse the previous
+   * trajectory — skipping the backward pass, tryLeftEnd, and Newton entirely.
+   * Fast path: all current blocks fit within the previous merge — reuse directly.
+   * The junction is the terminal condition (v=0), which can't improve.
+   */
+  if (prev_traj.left_end == block_count) {
+    traj.reuse(prev_traj, mm[0], v_left_entry, a_left_entry);
+    shiftSafeTails(block_count);
+    return true;
+  }
+
+  // Precompute cumulative distance, accel-min, and nominal-max for candidates.
+  float cum_dist[BLOCK_BUFFER_SIZE + 1];
+  float cum_accel_min[BLOCK_BUFFER_SIZE];
+  float cum_nom_max[BLOCK_BUFFER_SIZE];
+  cum_dist[0] = 0;
+  cum_accel_min[0] = accel[0];
+  cum_nom_max[0] = nominal[0];
+  for (uint8_t i = 0; i < max_left_compatible; i++) {
+    cum_dist[i + 1] = cum_dist[i] + mm[i];
+    if (i > 0) {
+      cum_accel_min[i] = _MIN(cum_accel_min[i - 1], accel[i]);
+      cum_nom_max[i] = _MAX(cum_nom_max[i - 1], nominal[i]);
+    }
+  }
+
+  /**
+   * ─── Lazy backward pass ───
+   *
+   * Chained backward pass computed on demand as candidates are tried.
+   * Positions behind the winning candidate are never computed — no trajectory
+   * depends on them, so the _MAX clamp on stale shifted values is sufficient.
+   */
+  shiftSafeTails(block_count);
+
+  float safe_exit = 0;  // terminal; then running backward pass accumulator
+  uint8_t i;
+  for (i = block_count; i > 0; i--) {
+    if (i < block_count) {
+      float new_entry = maxReachableSpeed(safe_exit, mm[i],
+                                             vmax_junction[i], accel[i], j_max);
+      safe_exit = prev_safe_tails[i] = _MAX(prev_safe_tails[i], new_entry);
+    }
+    if (i > max_left_compatible) continue;
+
+    // Reuse check (before multi-block — multi-block shouldn't prevent reuse)
+    if (i == prev_traj.left_end) {
+      if (safe_exit <= prev_traj.v_exit_junction * CJP_REUSE_MARGIN + CJP_TOL) {
+        traj.reuse(prev_traj, mm[0], v_left_entry, a_left_entry);
+        return true;
+      }
+    }
+
+    if (multi_block_tail && safe_exit < vmax_junction[i] - CJP_TOL) {
+      float multi = multiBlockSafeSpeed(i, block_count, mm, nominal, vmax_junction, accel, j_max);
+      if (multi > safe_exit) safe_exit = multi;
+    }
+
+    float v_target = maxReachableSpeed(v_left_entry, cum_dist[i], safe_exit,
+                                        cum_accel_min[i - 1], j_max, a_left_entry);
+
+    // Step 1: Standard 7-phase S-curve.
+    bool ok = traj.plan_accel_decel(v_left_entry, v_target, cum_accel_min[i - 1], j_max,
+                                  cum_dist[i], cum_nom_max[i - 1], a_left_entry);
+    if (ok) {
+      ok = verifyJunctions(traj, i, mm, vmax_junction);
+      if (!ok) continue;
+      break;
+    }
+
+    // Step 2: Partial absorption + decel (a_entry != 0).
+    if (a_left_entry != 0.0f) {
+      ok = traj.plan_decel(v_left_entry, v_target, cum_accel_min[i - 1], j_max,
+                                         cum_dist[i], a_left_entry);
+      if (ok) ok = verifyJunctions(traj, i, mm, vmax_junction);
+      if (ok) break;
+    }
+
+    // Step 3: [-j, +j] decel targeting safe exit speed.
+    ok = traj.plan_decel_with_carry(v_left_entry, safe_exit, cum_accel_min[i - 1], j_max,
+                                          cum_dist[i], a_left_entry);
+    if (ok) ok = verifyJunctions(traj, i, mm, vmax_junction);
+    if (ok) break;
+
+  }
+  uint8_t best_left_end = i;  // 0 if no candidate succeeded
+
+  // Fallbacks when all candidates failed.
+  if (best_left_end == 0) {
+    // Try reuse: previous merge's remaining trajectory is still valid
+    // (junctions never worsen — safe_tail >= prev exit speed).
+    if (prev_traj.left_end > 0) {
+      traj.reuse(prev_traj, mm[0], v_left_entry, a_left_entry);
+      return true;
+    }
+
+    // Try decel to full stop.
+    bool stop_ok = traj.plan_accel_decel(v_left_entry, 0.0f, accel[0], j_max,
+                                       cum_dist[1], cum_nom_max[0], a_left_entry);
+    if (!stop_ok && a_left_entry != 0.0f)
+      stop_ok = traj.plan_decel(v_left_entry, 0.0f, accel[0], j_max,
+                                              cum_dist[1], a_left_entry);
+    if (stop_ok) {
+      best_left_end = 1;
+    }
+  }
+
+  prev_traj.v_exit_junction = safe_exit;
+  prev_safe_tails[best_left_end] = _MAX(prev_safe_tails[best_left_end], safe_exit);
+
+  // Emit only 1 block: truncate trajectory to block 0's distance.
+  // truncateToDistance updates v_exit and a_exit on the trajectory.
+  // For normal single-block plans, dist_total == mm[0] so this is a no-op.
+  // For multi-block superblocks or can't-brake decel, it cuts to block 0.
+
+  // Save pre-truncation trajectory for potential reuse in next planNext call.
+  traj.savePreTruncation(prev_traj, best_left_end, mm[0]);
+
+  traj.truncateToDistance(mm[0]);
+  prev_traj.t_consumed = traj.getTotalDuration();  // view_t0=0, so this is t_abs
+
+  return true;
+}
+
+/**
+ * ─── verifyJunctions ─────────────────────────────────────────────────────────
+ * Check that the planned trajectory respects all interior junction speed limits
+ * and the exit junction. Returns true if all junctions are within tolerance.
+ */
+bool ConstantJoltBlockPlanner::verifyJunctions(
+  const ConstantJoltTrajectoryGenerator& traj,
+  uint8_t merge_count, const float mm[],
+  const float vmax_junction[]
+) {
+  float dist_cum = 0;
+  for (uint8_t k = 0; k < merge_count; k++) {
+    dist_cum += mm[k];
+    const float limit = vmax_junction[k + 1] + CJP_TOL;
+
+    /**
+     * Fast check: find which phase this junction falls in and compute the
+     * min/max velocity in that phase without solving for exact time.
+     * v(t) = v0 + a0*t + 0.5*j*t^2 is quadratic in jolt phases.
+     *   +j phases: parabola opens up   → max at endpoints, min at vertex
+     *   -j phases: parabola opens down → min at endpoints, max at vertex
+     *    0 phases: linear              → min/max at endpoints
+     */
+    const int ph = traj.findPhaseByDist(dist_cum);
+    const float v0 = traj.state.phase_start_v[ph];
+    const float v1 = (ph < 6) ? traj.state.phase_start_v[ph + 1] : traj.state.v_exit;
+    const float jl = traj.phaseJolt(ph);
+    const float a0 = traj.state.phase_start_a[ph];
+    const float dt = traj.state.phase_dt[ph];
+
+    float v_max_phase = _MAX(v0, v1);
+    float v_min_phase = _MIN(v0, v1);
+
+    // Vertex of the quadratic: t_v = -a0/jl (only meaningful if jl != 0)
+    if (jl != 0.0f) {
+      const float t_v = -a0 / jl;
+      if (t_v > 0.0f && t_v < dt) {
+        const float v_v = v0 + a0 * t_v + 0.5f * jl * t_v * t_v;
+        if (jl < 0.0f) v_max_phase = _MAX(v_max_phase, v_v);  // opens down: vertex is max
+        else            v_min_phase = _MIN(v_min_phase, v_v);  // opens up: vertex is min
+      }
+    }
+
+    if (v_max_phase <= limit) continue;    // entire phase below limit → safe
+    if (v_min_phase > limit) return false; // entire phase above limit → reject
+
+    // Peak exceeds limit — need exact velocity at this distance
+    const float v_at_junction = traj.getVelocityAtDistance(dist_cum);
+    if (v_at_junction > limit) return false;
+  }
+  return true;
+}
+
+/**
+ * ─── multiBlockSafeSpeed ─────────────────────────────────────────────────────
+ * Max exit speed at boundary i considering continuous decel across mergeable
+ * tail blocks (no a=0 at interior boundaries). Returns 0 if no improvement.
+ */
+float ConstantJoltBlockPlanner::multiBlockSafeSpeed(
+  uint8_t i, uint8_t block_count,
+  const float* mm, const float* nominal, const float* vmax_junction,
+  const float* accel, float j_max
+) {
+  uint8_t merge_ext = 1;
+  float nom_lo = nominal[i], nom_hi = nominal[i];
+  float a_lo = accel[i], a_hi = accel[i];
+  for (uint8_t k = i + 1; k < block_count; k++) {
+    float nlo = _MIN(nom_lo, nominal[k]), nhi = _MAX(nom_hi, nominal[k]);
+    if (nhi > nlo * CJP_MERGE_NOM_RATIO) break;
+    float alo = _MIN(a_lo, accel[k]), ahi = _MAX(a_hi, accel[k]);
+    if (ahi > alo * CJP_MERGE_AMAX_RATIO) break;
+    nom_lo = nlo; nom_hi = nhi; a_lo = alo; a_hi = ahi;
+    merge_ext++;
+  }
+  if (merge_ext < 2) return 0;
+
+  float v_exit_merge = 0;
+  if (i + merge_ext < block_count) v_exit_merge = prev_safe_tails[i + merge_ext];
+  float group_dist = 0, a_min = 1e30f;
+  for (uint8_t k = i; k < i + merge_ext; k++) {
+    group_dist += mm[k];
+    a_min = _MIN(a_min, accel[k]);
+  }
+
+  // Terminal: max V from which we can decel to a stop within group_dist.
+  // Always valid as a feasibility proof (forward pass can decel to 0 if needed).
+  // When v_exit_merge is above the non-monotone crossover (~62% of V),
+  // MRS from v_exit_merge gives a higher result (monotone region), so use that.
+  float safe_v = maxReachableSpeed(0, group_dist, vmax_junction[i], a_min, j_max);
+  if (v_exit_merge > safe_v * 0.62f)
+    safe_v = maxReachableSpeed(v_exit_merge, group_dist, vmax_junction[i], a_min, j_max);
+
+  // Each interior junction: max V that can decel to vj[k+1] over distance d_k.
+  // Uses independent constraints (no chaining), avoids non-monotone MRS.
+  // Stop once the ramp reaches v=0 before the end — further junctions are at v=0.
+  float cum_d = 0;
+  a_min = 1e30f;
+  for (uint8_t k = i; k < i + merge_ext - 1; k++) {
+    cum_d += mm[k];
+    a_min = _MIN(a_min, accel[k]);
+    if (constant_jolt::rampDist(0, safe_v, j_max, a_min) <= cum_d) break;
+    float constraint = maxReachableSpeed(vmax_junction[k + 1], cum_d, safe_v, a_min, j_max);
+    if (constraint < safe_v) safe_v = constraint;
+  }
+  return safe_v;
+}
+
+/**
+ * ─── maxReachableSpeed ──────────────────────────────────────────────────────
+ * Find max V such that an S-curve ramp from v_from to V fits within dist_total.
+ *
+ * Forward direction: distance from velocity is simple (closed-form):
+ *   Triangular (j·dv ≤ a²):  d = (v_from + V) · √(dv / j)
+ *   Trapezoidal (j·dv > a²): d = (v_from + V) · (a/j + dv/a) / 2
+ *
+ * Inverse (velocity from distance) is harder — no closed-form inversion:
+ *   Triangular: d = (v+V)·√((V-v)/j) → cubic in √(V-v), solved via Cardano
+ *   Trapezoidal: d = (v+V)·(a/j + (V-v)/a)/2 → quadratic in V, one √
+ *
+ * Note: d(v_from, V) is non-monotone in v_from for fixed V (peak at v_from = V/3
+ * in the triangular regime). Starting faster covers more ground during the jerk
+ * ramp (a builds from 0 at higher base speed). This is real physics, not a bug.
+ * The cross-cycle _MAX clamp on prev_safe_tails prevents regression from this.
+ */
+float ConstantJoltBlockPlanner::maxReachableSpeed(float v_from, float dist_total,
+                                                   float v_max, float a_max, float j_max,
+                                                   float a_entry) {
+  // Trapezoidal upper bound: v²=v₀²+2ad always overestimates reachable
+  // speed (no jolt phases), so v_trap >= the true S-curve answer.
+  // Skip sqrtf when the bound exceeds v_max (common for non-tiny blocks).
+  const float v_trap_sq = v_from * v_from + 2.0f * a_max * dist_total;
+  float hi = (v_trap_sq >= v_max * v_max) ? v_max : SQRT(v_trap_sq);
+
+  // For a_entry=0: V ≤ v_from is instantly reachable (no ramp needed).
+  // For a_entry≠0: absorption takes distance, so we must check even if V ≤ v_from.
+  if (a_entry == 0.0f && hi <= v_from) return hi;
+
+  if (constant_jolt::rampDistWithA(v_from, hi, j_max, a_max, a_entry) <= dist_total) return hi;
+
+  float v_lo;
+  if (a_entry == 0.0f) {
+    /**
+     * Closed-form solutions for a_entry=0:
+     * Trapezoidal regime (j*dv > amax²): quadratic in dv, one sqrtf.
+     * Triangular regime (j*dv ≤ amax²): depressed cubic via Cardano, one cbrtf.
+     * Trapezoidal regime: quadratic in dv, one sqrtf. Exact (up to float precision).
+     * Triangular regime would need Cardano (cbrtf, no MCU hardware) — falls through
+     * to bisection instead.
+     */
+    const float am2j = a_max * a_max / j_max;
+    const float B = 2.0f * v_from + am2j;
+    const float C = 2.0f * v_from * am2j - 2.0f * dist_total * a_max;
+    const float disc = B * B - 4.0f * C;
+    if (disc >= 0.0f) {
+      const float dv = (-B + SQRT(disc)) * 0.5f;
+      if (dv > 0.0f && j_max * dv > a_max * a_max) {
+        float V = _MIN(v_from + dv, hi);
+        if (constant_jolt::rampDist(v_from, V, j_max, a_max) > dist_total) V -= CJP_CONVERGE_TOL;
+        return _MAX(V, v_from);
+      }
+    }
+
+    // Triangular regime (a_entry=0): bisect on tau = sqrt(dv/j) instead of V.
+    // Distance becomes a polynomial: d(tau) = (2*v_from + j*tau^2) * tau
+    // No sqrtf per iteration — just multiplies and adds.
+    {
+      const float two_v = 2.0f * v_from;
+      float tau_lo = 0.0f;
+      float tau_hi = SQRT((hi - v_from) / j_max);
+      for (int i = 0; i < 32; i++) {
+        const float tau = 0.5f * (tau_lo + tau_hi);
+        const float f = (two_v + j_max * tau * tau) * tau - dist_total;
+        if (f <= 0.0f) tau_lo = tau; else tau_hi = tau;
+        if (f <= 0.0f && f > -CJP_CONVERGE_TOL) break;
+        if (tau_hi - tau_lo < 1e-7f) break;
+      }
+      float V = v_from + j_max * tau_lo * tau_lo;
+      return _MIN(V, v_max);
+    }
+  }
+  else {
+    // Bisect on a_peak² directly (a_entry ≠ 0). No sqrt at all in setup/recovery.
+    // a_peak² = j·(V − v_from) + ½·a_entry², so V = v_from + (a_peak² − ½a²) / j.
+    // accelRampTimings defers sqrt to the triangular branch only.
+    const float half_a_entry_sq = 0.5f * a_entry * a_entry;
+    float ap_sq_lo = (a_entry > 0.0f) ? a_entry * a_entry : 0.0f;
+    float ap_sq_hi = _MAX(0.0f, j_max * (hi - v_from) + half_a_entry_sq);
+
+    for (int i = 0; i < 32; i++) {
+      const float ap_sq = 0.5f * (ap_sq_lo + ap_sq_hi);
+      const float f = constant_jolt::rampDistFromApeakSq(v_from, a_entry, ap_sq, j_max, a_max) - dist_total;
+      if (f <= 0.0f) ap_sq_lo = ap_sq; else ap_sq_hi = ap_sq;
+      if (f <= 0.0f && f > -CJP_CONVERGE_TOL) break;
+      if (ap_sq_hi - ap_sq_lo < 1e-6f) break;
+    }
+    float V = v_from + (ap_sq_lo - half_a_entry_sq) / j_max;
+    return _MIN(_MAX(V, 0.0f), v_max);
+  }
+}
+
+#endif // FTM_CONSTANT_JOLT
diff --git a/Marlin/src/module/ft_motion/constant_jolt_planner.h b/Marlin/src/module/ft_motion/constant_jolt_planner.h
new file mode 100644
index 000000000000..bedcaa47933c
--- /dev/null
+++ b/Marlin/src/module/ft_motion/constant_jolt_planner.h
@@ -0,0 +1,187 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2026 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include "../planner.h"
+
+constexpr float CJP_MERGE_AMAX_RATIO = 1.1f;    // Max accel ratio between blocks to allow merging into a superblock
+constexpr float CJP_MERGE_NOM_RATIO  = 1.01f;   // Max nominal speed ratio between blocks to allow merging
+constexpr float CJP_TOL              = 0.01f;   // (mm or mm/s) Float-precision tolerance for velocity/distance "close enough" checks
+constexpr float CJP_CONVERGE_TOL     = 0.001f;  // (mm/s) Newton/bisection early-exit threshold — stop when bracket < this
+constexpr float CJP_REUSE_MARGIN     = 1.001f;  // Multiplicative margin for trajectory reuse: skip replan if junction improved < 0.1%
+constexpr float CJP_INFEASIBLE_REL   = 1.01f;   // Relative tolerance for infeasible decel ramp detection (1% margin)
+constexpr float CJP_INFEASIBLE_ABS   = 1.0f;    // (mm/s²) Absolute tolerance for infeasible decel ramp detection
+
+/**
+ * Constant-jolt block planner (1-block emission with non-zero a_entry)
+ *
+ * The standard trapezoidal planner assumes instant acceleration changes.
+ * Under jolt constraints, S-curves need more distance for the same speed
+ * change, so a different planner is needed.
+ *
+ * This planner:
+ * - Ignores Marlin's trapezoidal entry/exit speeds entirely
+ * - Uses block->vmax_junction as the junction speed ceiling (geometric limit)
+ * - Runs a jolt-aware backward pass on all visible blocks
+ * - Merges compatible consecutive blocks into a superblock trajectory,
+ *   but emits only the first block, carrying exit (v, a) to the next cycle
+ *
+ *
+ * ─── 1-block emission model ───
+ *
+ *   Each planNext() call:
+ *   1. Plans a multi-block superblock trajectory [0..left_end) for lookahead
+ *   2. Truncates the trajectory to block 0's distance (truncateToDistance)
+ *   3. Stores exit (v, a) at block 0 boundary for the next call
+ *   4. Consumes only 1 block from the buffer
+ *
+ *   The non-zero exit acceleration (a_exit) from block 0's cut point is
+ *   passed as a_entry to the next cycle's plan_accel_decel(). This gives
+ *   smoother transitions than forcing a=0 at every block boundary.
+ *
+ *   When a_entry is infeasible for plan_accel_decel (e.g., too high for the
+ *   available distance), the planner falls back to plan_decel,
+ *   then plan_decel_with_carry, then plan_accel_decel to v=0.
+ *
+ * ─── Backward pass (lazy) ───
+ *
+ *   safe_tail = max speed at which block i can be entered (with a=0)
+ *   such that blocks [i..N) can decelerate to a stop by block N.
+ *
+ *   Computed right-to-left using a single accumulator (no array):
+ *     safe_tail = 0  (terminal: must stop after last block)
+ *     safe_tail = maxReachableSpeed(safe_tail, mm[i], ...)  for i = N-1 down to max_left_compatible
+ *   Further steps computed lazily as candidates fail (see merge algorithm).
+ *
+ * ─── Merge algorithm (largest feasible left_end) ───
+ *
+ *   1. Find left-compatible extent: same nominal, accel ratio ≤ 1.1.
+ *   2. Try from largest left_end downward, take first feasible:
+ *      a. v_junction = min(safe_tail, nominal, vmax_junction)
+ *      b. Plan left S-curve toward v_junction
+ *      c. Check velocity at block 0 exit against vmax_junction[1]
+ *      d. Check interior junctions against vmax_junction[k]
+ *   3. For candidate=1 if exit overshoots vmax_junction[1], replan
+ *      targeting v=0 (safety fallback — no smaller candidate available).
+ *   4. Truncate trajectory to block 0, store (v, a) exit state.
+ *
+ *   Replanning each cycle from actual (v, a) compensates for the
+ *   conservative backward pass (which assumes a=0 at boundaries).
+ *
+ * ─── Feasibility invariant ───
+ *
+ *   The very first call starts with v_entry=0, a_entry=0. From rest,
+ *   a feasible trajectory always exists for any distance (accelerate
+ *   arbitrarily little, then decelerate back to zero). Each subsequent
+ *   call enters with the (v, a) from truncating a feasible trajectory
+ *   at block 0's boundary — a state that was reachable within a valid
+ *   plan. Since the planner can always fall back to decelerating to v=0
+ *   from any such state, feasibility is maintained across all cycles.
+ */
+
+class ConstantJoltTrajectoryGenerator;  // Forward declaration
+
+// Trajectory state: phases + cache + parameters.
+// Inherited by the generator (direct field access), embedded in snapshot (struct copy).
+struct CJTrajectoryState {
+  float phase_dt[7] = {};
+  float phase_start_time[7] = {};
+  float phase_start_pos[7] = {};
+  float phase_start_v[7] = {};
+  float phase_start_a[7] = {};
+  float v_exit = 0, a_exit = 0;
+  float a_max = 0, j_max = 0;
+  float dist_total = 0;
+  float total_duration = 0;
+};
+
+// Pre-truncation trajectory state for reuse optimization.
+struct CJTrajectorySnapshot {
+  CJTrajectoryState traj;
+  float mm_consumed = 0;   // Cumulative distance consumed from the original trajectory
+  float t_consumed = 0;    // Absolute time at mm_consumed in the original trajectory
+  float v_exit_junction = 0;  // Backward pass value at the merge boundary (for reuse check)
+  uint8_t left_end = 0;    // Remaining blocks after consuming block 0 (0 = invalid)
+};
+
+class ConstantJoltBlockPlanner {
+ public:
+  bool multi_block_tail = true;  // Use continuous decel across mergeable tail blocks
+
+  // Reset all planner state (called by the generator's planRunout/reset).
+  void resetPlannerState() {
+    prev_traj.left_end = 0;
+    prev_traj.v_exit_junction = 0;
+    for (int i = 0; i < BLOCK_BUFFER_SIZE; i++) prev_safe_tails[i] = 0;
+  }
+
+  /**
+   * Plan trajectory for the current block (already consumed from planner buffer).
+   *
+   * Looks ahead at future blocks via get_future_block(), runs a jolt-aware
+   * reverse/forward pass across all visible blocks, then plans the first
+   * block (or merged group) as an S-curve trajectory.
+   *
+   * Returns true if a trajectory is ready for execution.
+   */
+  bool planNext(ConstantJoltTrajectoryGenerator& traj, float j_max);
+
+
+ private:
+  /**
+   * Max speed reachable from v_from over dist_total via jolt-limited ramp,
+   * capped by v_max. Bracketed Newton on closed-form rampDist.
+   * When v_from > v_max, returns v_max (hard ceiling).
+   * Monotone in dist_total: more distance → higher or equal result.
+   *
+   * a_entry: initial acceleration (default 0). When non-zero, the ramp must
+   * first absorb a_entry (bring a to 0), which uses distance and reduces
+   * the max reachable speed. Uses rampDistWithA for distance.
+   */
+  float maxReachableSpeed(float v_from, float dist_total,
+                          float v_max, float a_max, float j_max,
+                          float a_entry = 0.0f);
+
+  // Verify all junctions (interior + exit) of a merged trajectory.
+  // Returns true if velocity at every block boundary respects vmax_junction.
+  bool verifyJunctions(const ConstantJoltTrajectoryGenerator& traj,
+                       uint8_t merge_count, const float mm[],
+                       const float vmax_junction[]);
+
+  float multiBlockSafeSpeed(uint8_t i, uint8_t block_count,
+                            const float* mm, const float* nominal,
+                            const float* vmax_junction, const float* accel,
+                            float j_max);
+
+  void shiftSafeTails(uint8_t block_count) {
+    for (int i = 0; i < block_count - 1; i++)
+      prev_safe_tails[i] = prev_safe_tails[i + 1];
+    for (int i = block_count - 1; i < BLOCK_BUFFER_SIZE; i++)
+      prev_safe_tails[i] = 0;
+  }
+
+  // Previous planNext state for trajectory reuse.
+  CJTrajectorySnapshot prev_traj;
+
+  float prev_safe_tails[BLOCK_BUFFER_SIZE] = {};
+
+};
diff --git a/Marlin/src/module/ft_motion/trajectory_constant_jolt.cpp b/Marlin/src/module/ft_motion/trajectory_constant_jolt.cpp
new file mode 100644
index 000000000000..142fd1bf01db
--- /dev/null
+++ b/Marlin/src/module/ft_motion/trajectory_constant_jolt.cpp
@@ -0,0 +1,465 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2026 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../../inc/MarlinConfig.h"
+
+#if ENABLED(FTM_CONSTANT_JOLT)
+
+#include "trajectory_constant_jolt.h"
+#include "constant_jolt_math.h"
+
+float ConstantJoltTrajectoryGenerator::jolt_default_ = FTM_DEFAULT_JOLT * 1000.0f;
+
+void ConstantJoltTrajectoryGenerator::plan(
+    const float, const float, const float, const float, const float) {
+  planner_.planNext(*this, *jolt_ptr_);
+}
+
+void ConstantJoltTrajectoryGenerator::planRunout(const float duration) {
+  reset();
+  // Cruise at zero speed for the entire duration (same as trapezoidal)
+  state.phase_dt[3] = duration;
+  state.total_duration = duration;
+  buildPhaseCache();
+}
+
+bool ConstantJoltTrajectoryGenerator::planNext(float j_max) {
+  return planner_.planNext(*this, j_max);
+}
+
+// Common state setup for plan_accel_decel and plan_decel.
+// Called at the start of each strategy, not by the caller.
+void ConstantJoltTrajectoryGenerator::setupPlanState(
+    float v_entry_in, float v_exit_in,
+    float a_max_in, float j_max_in,
+    float dist_total_in, float a_entry_in) {
+  view_t0 = view_d0 = 0.0f;
+  v_entry = v_entry_in;
+  state.v_exit = v_exit_in;
+  state.a_max = a_max_in;
+  state.j_max = j_max_in;
+  state.dist_total = dist_total_in;
+  a_entry = a_entry_in;
+  state.a_exit = 0.0f;
+}
+
+
+void ConstantJoltTrajectoryGenerator::truncateToDistance(float d) {
+  const float d_abs = d + view_d0;
+  if (d_abs >= state.dist_total) return;
+  const float t_abs = getTimeAtDistance(d) + view_t0;
+  const int ph = findPhase(t_abs);
+  const float dt = t_abs - state.phase_start_time[ph];
+  state.v_exit = state.phase_start_v[ph] + state.phase_start_a[ph] * dt + 0.5f * phaseJolt(ph) * dt * dt;
+  state.a_exit = state.phase_start_a[ph] + phaseJolt(ph) * dt;
+  state.dist_total = d_abs;
+  state.total_duration = t_abs;
+  // Ensure dist_total covers any float-precision overshoot at total_duration.
+  // Prevents the ghost-phase check in getVelocityAtTime from clamping velocity
+  // before total_duration.
+  const float d_at_end = rawDistanceAtTime(t_abs);
+  if (d_at_end > state.dist_total) state.dist_total = d_at_end;
+}
+
+float ConstantJoltTrajectoryGenerator::getVelocityAtDistance(const float d) const {
+  if (d <= 0.0f) return v_entry;
+  const float d_eff = state.dist_total - view_d0;
+  if (d >= d_eff) return state.v_exit;
+  const float d_abs = d + view_d0;
+  const int ph = findPhaseByDist(d_abs);
+  const float delta_s = d_abs - state.phase_start_pos[ph];
+  const float v_ph = state.phase_start_v[ph];
+  const float a_ph = state.phase_start_a[ph];
+  const float jl = phaseJolt(ph);
+
+  if (jl == 0.0f) {
+    // Constant accel: delta_s = v0*t + 0.5*a*t²
+    if (a_ph == 0.0f) return v_ph;  // cruise phase
+    // t = (-v0 + sqrt(v0² + 2*a*delta_s)) / a
+    const float disc = v_ph * v_ph + 2.0f * a_ph * delta_s;
+    const float t = (-v_ph + SQRT(_MAX(0.0f, disc))) / a_ph;
+    return v_ph + a_ph * t;
+  }
+
+  // Jolt phase: find t such that s(t) = delta_s, then return v(t).
+  const float t = constant_jolt::solvePhaseTime(v_ph, a_ph, jl, delta_s, 0.0f, state.phase_dt[ph]);
+  return v_ph + a_ph * t + 0.5f * jl * t * t;
+}
+
+float ConstantJoltTrajectoryGenerator::getTimeAtDistance(float d) const {
+  if (d <= 0.0f) return 0.0f;
+  const float d_eff = state.dist_total - view_d0;
+  if (d >= d_eff) return state.total_duration - view_t0;
+  // Work in absolute coordinates.
+  const float d_abs = d + view_d0;
+  const int ph = findPhaseByDist(d_abs);
+  const float t0 = state.phase_start_time[ph];
+  float lo = t0;
+  float hi = (ph < 6) ? state.phase_start_time[ph + 1] : state.total_duration;
+  float mid = lo;
+  for (int i = 0; i < 32; i++) {
+    mid = (lo + hi) * 0.5f;
+    if (mid == lo || mid == hi) break;
+    if (distanceInPhase(ph, mid - t0) < d_abs) lo = mid;
+    else hi = mid;
+  }
+  return mid - view_t0;
+}
+
+void ConstantJoltTrajectoryGenerator::reset() {
+  planner_.resetPlannerState();
+  state = CJTrajectoryState{};
+  view_t0 = view_d0 = v_entry = a_entry = 0.0f;
+}
+
+void ConstantJoltTrajectoryGenerator::savePreTruncation(
+    CJTrajectorySnapshot& snap, uint8_t merge_count, float mm_consumed) const {
+  if (merge_count <= 1) {
+    snap.left_end = 0;  // single block or failure — no reuse possible
+    return;
+  }
+  snap.traj = state;
+  snap.left_end = merge_count - 1;
+  snap.mm_consumed = mm_consumed;
+}
+
+bool ConstantJoltTrajectoryGenerator::finalizeAndTruncate(float dist_total_in) {
+  if (state.dist_total > dist_total_in) {
+    if (state.dist_total - dist_total_in > CJP_TOL)
+      return false;
+    // Save the target v_exit before truncation overwrites it.
+    const float v_exit_target = state.v_exit;
+    truncateToDistance(dist_total_in);
+    // After truncation, verify the exit velocity still matches the target.
+    // A tiny distance overshoot on a steep decel can produce large v error.
+    // v_exit=0 (can't-brake) is exempt — self-corrects next cycle.
+    if (v_exit_target > CJP_TOL && ABS(state.v_exit - v_exit_target) > CJP_TOL)
+      return false;
+  }
+  return true;
+}
+
+void ConstantJoltTrajectoryGenerator::reuse(
+    CJTrajectorySnapshot& snap, float mm0,
+    float v_entry_in, float a_entry_in) {
+  // Restore saved trajectory phases.
+  state = snap.traj;
+  // Set view offset to skip consumed distance.
+  if (snap.mm_consumed > 0.0f) {
+    view_d0 = snap.mm_consumed;
+    view_t0 = snap.t_consumed;
+    v_entry = v_entry_in;
+    a_entry = a_entry_in;
+  } else {
+    view_t0 = view_d0 = 0.0f;
+  }
+  // Advance snapshot: consume one more block.
+  float prev_t = snap.t_consumed;
+  snap.left_end--;
+  truncateToDistance(mm0);
+  snap.mm_consumed += mm0;
+  snap.t_consumed = getTotalDuration() + prev_t;
+}
+
+/**
+ * ─── plan_accel_decel ─────────────────────────────────────────────────────────
+ *
+ * Shape: [ +j    hold  -j    crse  -j    hold  +j    ]
+ *         ╰─ accel ramp ─╯        ╰─ decel ramp ─╯
+ *
+ * Accel ramp: accelerates from (v_entry, a_entry) up to v_peak with a=0.
+ * Cruise:     holds v_peak (a=0). Duration fills leftover distance.
+ * Decel ramp: decelerates from v_peak down to v_exit with a=0.
+ * Any phase can have zero duration (7 phases degenerate to fewer).
+ *
+ * Solver: finds v_peak (single variable) via bracketed Newton.
+ *
+ * Limitation: the template assumes "accelerate then decelerate", so the accel
+ * ramp always starts with +j (build acceleration upward). When a_entry > 0,
+ * the +j ramp must ride out the existing acceleration -- building a up to a_peak
+ * then back to 0 -- and velocity RISES during this (v_peak >= v_entry + a_entry^2/2j).
+ * If this minimum ramp doesn't fit in the available distance, plan_accel_decel
+ * fails and plan_decel takes over (it applies opposing jerk first to tame
+ * a_entry before decelerating -- a different phase structure that this template
+ * can't express).
+ */
+bool ConstantJoltTrajectoryGenerator::plan_accel_decel(
+    float v_entry_in, float v_exit_in, float a_max_in, float j_max_in,
+    float dist_total, float v_nominal, float a_entry_in) {
+  setupPlanState(v_entry_in, v_exit_in, a_max_in, j_max_in, dist_total, a_entry_in);
+
+  // Minimum v_peak: the accel ramp from (v_entry, a_entry) must complete a full
+  // [+j, hold, -j] cycle back to a=0. absorbedVelocity gives the velocity after
+  // this cycle — v_peak can't be lower (the ramp shape requires it).
+  const float v_peak_min_for_a = constant_jolt::absorbedVelocity(v_entry, a_entry, state.j_max);
+  const float v_hard_floor = (a_entry >= 0.0f) ? _MAX(v_entry, state.v_exit) : state.v_exit;
+  const float v_peak_floor = _MAX(v_hard_floor, v_peak_min_for_a);
+  const float dist_total_in = dist_total;
+
+  // Even the tightest ramps (v_peak = floor, no cruise) overshoot? Give up.
+  if (constant_jolt::totalRampDistCF(v_entry, state.v_exit, v_peak_floor, state.j_max, state.a_max, a_entry) > state.dist_total)
+    return false;
+
+  float v_peak = v_nominal;
+  // Bracketed Newton using closed-form distance (fast). Derivative also closed-form.
+  if (constant_jolt::totalRampDistCF(v_entry, state.v_exit, v_nominal, state.j_max, state.a_max, a_entry) > state.dist_total) {
+    float v_lo = v_peak_floor, v_hi = v_nominal;
+
+    // Initial guess: algebraic (trap+trap quadratic) for a_entry=0, midpoint otherwise
+    if (a_entry == 0.0f) {
+      float guess = constant_jolt::vpeakGuess(v_entry, state.v_exit, state.dist_total, state.j_max, state.a_max);
+      v_peak = _MAX(v_lo, _MIN(guess, v_hi));
+    } else {
+      v_peak = 0.5f * (v_lo + v_hi);
+    }
+
+    for (int i = 0; i < 10; i++) {
+      if (v_peak <= v_lo) v_peak = v_lo + CJP_CONVERGE_TOL;
+      float fp;
+      const float f = constant_jolt::totalRampDistAndDeriv(v_entry, state.v_exit, v_peak, state.j_max, state.a_max, a_entry, fp) - state.dist_total;
+      if (f <= 0.0f) v_lo = v_peak; else v_hi = v_peak;
+      if (f <= 0.0f && f > -CJP_TOL) break;
+      if (v_hi - v_lo < CJP_CONVERGE_TOL) break;
+      if (fp > 1e-10f) {
+        v_peak -= f / fp;
+        if (v_peak <= v_lo || v_peak >= v_hi) v_peak = 0.5f * (v_lo + v_hi);
+      } else {
+        v_peak = 0.5f * (v_lo + v_hi);
+      }
+    }
+    v_peak = v_lo;
+  }
+
+  // constant_jolt::planRamp now uses the same closed-form as constant_jolt::totalRampDistCF for distance,
+  // so dist_ramps <= state.dist_total is guaranteed (no precision gap to refine).
+  float t1, t2, t3, t4 = 0, t5, t6, t7;
+  float dist_accel = constant_jolt::planRamp(v_entry, v_peak, state.j_max, state.a_max, false, t1, t2, t3, a_entry);
+  float dist_decel = constant_jolt::planRamp(state.v_exit, v_peak, state.j_max, state.a_max, true, t5, t6, t7);
+  float dist_ramps = dist_accel + dist_decel;
+
+
+  if (v_peak > 0.0f && state.dist_total > dist_ramps)
+    t4 = (state.dist_total - dist_ramps) / v_peak;
+
+  state.phase_dt[0] = t1; state.phase_dt[1] = t2; state.phase_dt[2] = t3;
+  state.phase_dt[3] = t4;
+  state.phase_dt[4] = t5; state.phase_dt[5] = t6; state.phase_dt[6] = t7;
+  state.total_duration = t1 + t2 + t3 + t4 + t5 + t6 + t7;
+  buildPhaseCache();
+  return finalizeAndTruncate(dist_total_in);
+}
+
+/**
+ * ─── plan_decel ──────────────────────────────────────────────────────────────
+ *
+ * Shape (a>0): [             -j          -j    hold  +j    ]
+ *                           ╰ absorb ╯  ╰─ decel ramp ─╯
+ *
+ * Shape (a<0): [ +j                      -j    hold  +j    ]
+ *               ╰ absorb ╯              ╰─ decel ramp ─╯
+ *
+ * When plan_accel_decel fails (a_entry too large for the +j accel ramp to fit),
+ * this strategy applies OPPOSING jerk to tame a_entry before decelerating.
+ * The absorption phase reduces |a| toward 0. The decel ramp then handles the
+ * remaining state (v_mid, a_mid) via planDecelRampWithA (which supports a != 0).
+ *
+ * Solver: bisects on absorption time t0 to fill the available distance.
+ * More absorption = velocity changes more = decel ramp distance changes.
+ * The bisection finds the t0 where absorption + decel exactly fits.
+ *
+ * Note: absorption and decel start are BOTH the same jerk sign (-j for a_entry > 0)
+ * in consecutive phases (2 and 4, with phase 3 = 0). They're mathematically one
+ * continuous -j application, split only for code organization.
+ */
+bool ConstantJoltTrajectoryGenerator::plan_decel(
+    float v_entry_in, float v_exit_in, float a_max_in, float j_max_in,
+    float dist_total, float a_entry_in) {
+  setupPlanState(v_entry_in, v_exit_in, a_max_in, j_max_in, dist_total, a_entry_in);
+  const float dist_total_in = dist_total;
+  const float j_absorb = (a_entry > 0.0f) ? -state.j_max : state.j_max;  // opposes a_entry
+  const float t0_max = ABS(a_entry) / state.j_max;
+
+
+  // Bisect t0 so d_absorption + d_decel = dist_total.
+  // Save results when t0_lo is updated so we can reuse them after the loop.
+  float t0_lo = 0.0f, t0_hi = t0_max;
+  // Initialize with t0_lo=0 values (no absorption, immediate decel)
+  float v_mid = v_entry, d_abs = 0;
+  float dt_d1, dt_d2, dt_d3;
+  float d_dec = constant_jolt::planDecelRampWithA(v_entry, state.v_exit, state.j_max, state.a_max, dt_d1, dt_d2, dt_d3, a_entry);
+
+  // Check immediate decel (t0=0): if it already overshoots and absorption
+  // only adds distance (a_entry > 0), fail immediately.
+  if (d_dec > state.dist_total + CJP_TOL && a_entry > 0.0f)
+    return false;
+  for (int iter = 0; iter < 20; iter++) {
+    float t0_mid = 0.5f * (t0_lo + t0_hi);
+    float a_m = a_entry + j_absorb * t0_mid;
+    float v_m = v_entry + a_entry * t0_mid + 0.5f * j_absorb * t0_mid * t0_mid;
+    float d_a = constant_jolt::phaseDist(v_entry, a_entry, j_absorb, t0_mid);
+    float d1, d2, d3;
+    float d_d = constant_jolt::planDecelRampWithA(v_m, state.v_exit, state.j_max, state.a_max, d1, d2, d3, a_m);
+    // d_d < 0: decel ramp infeasible (|a_m| exceeds triangular peak) → need more absorption
+    if (d_d < 0.0f || d_a + d_d <= state.dist_total) {
+      t0_lo = t0_mid;
+      v_mid = v_m; d_abs = d_a; d_dec = d_d;
+      dt_d1 = d1; dt_d2 = d2; dt_d3 = d3;
+      if (d_d >= 0.0f && state.dist_total - (d_a + d_d) < CJP_TOL) break;
+    } else {
+      t0_hi = t0_mid;
+    }
+  }
+
+  float t0 = t0_lo;
+  if (d_dec < 0.0f) { d_dec = dt_d1 = dt_d2 = dt_d3 = 0.0f; }
+
+  if (v_mid < state.v_exit - CJP_TOL && d_dec < CJP_TOL) return false;
+
+  // Reject if the absorption + decel can't cover the target distance.
+  // This happens when the trajectory's total distance is invariant to
+  // absorption time (e.g., accel then decel back to 0 covers the same
+  // distance regardless of the peak velocity reached during absorption).
+  if (d_abs + d_dec < state.dist_total - CJP_TOL && d_dec >= 0.0f) return false;
+
+  // Phase mapping: absorption goes in the phase whose jolt matches j_absorb
+  if (a_entry > 0.0f) {
+    // j_absorb = -j_max → matches phase 2 jolt
+    state.phase_dt[0] = state.phase_dt[1] = 0.0f;
+    state.phase_dt[2] = t0;
+  } else {
+    // j_absorb = +j_max → matches phase 0 jolt
+    state.phase_dt[0] = t0;
+    state.phase_dt[1] = state.phase_dt[2] = 0.0f;
+  }
+  state.phase_dt[3] = 0.0f;
+  state.phase_dt[4] = dt_d1; state.phase_dt[5] = dt_d2; state.phase_dt[6] = dt_d3;
+
+  state.total_duration = t0 + dt_d1 + dt_d2 + dt_d3;
+  // _MAX because bisection uses conservative t0_lo, so d_covered may
+  // be slightly less than dist_total_in.
+  state.dist_total = _MAX(dist_total_in, d_abs + d_dec);
+  buildPhaseCache();
+  return finalizeAndTruncate(dist_total_in);
+}
+
+/**
+ * ─── plan_decel_with_carry ────────────────────────────────────────────────────
+ *
+ * Shape: [                         -j          +j    ]
+ *                               ╰ brake ╯ ╰ recover ╯
+ *
+ * Last resort when plan_accel_decel and plan_decel both fail.
+ * Pure braking: -j builds negative acceleration, then +j partially recovers
+ * toward a=0. Exits with (v <= safe_exit, a <= 0) -- the "carry" exit that
+ * hands off mid-deceleration to the next block. The next cycle enters with
+ * a < 0 and handles it via plan_accel_decel or plan_decel.
+ *
+ * Unlike the other strategies, this does NOT target a specific v_exit with a=0.
+ * Instead, it finds the MINIMUM braking that keeps v_exit <= safe_exit -- the
+ * gentlest decel that's still feasible for downstream blocks.
+ *
+ * Solver: bisects on t4 (-j duration). For each t4, an inner Newton solve
+ * finds t6 (+j duration) to fill the remaining distance, capped so a <= 0.
+ * More t4 = harder braking = lower v_exit.
+ */
+bool ConstantJoltTrajectoryGenerator::plan_decel_with_carry(
+    float v_entry_in, float v_max_safe_exit,
+    float a_max_in, float j_max_in,
+    float dist_total, float a_entry_in) {
+  const float j = j_max_in;
+  const float dist = dist_total;
+  const float v0 = v_entry_in;
+  const float a0 = a_entry_in;
+
+  // For a given t4 (-j duration), compute exit state after [-j, +j] covering
+  // exactly dist, with +j capped so a ≤ 0. Returns:
+  //   -1: need less -j (t4 too large — v_mid depleted or -j overshoots dist)
+  //   +1: need more -j (v_exit > v_safe, or a_exit > 0, or can't fill dist)
+  //    0: solution found (v_exit ≤ v_safe, a_exit ≤ 0, dist matched)
+  auto eval = [&](float t4, float &t6_out, float &v_exit_out, float &a_exit_out) -> int {
+    const float d4 = constant_jolt::phaseDist(v0, a0, -j, t4);
+    if (d4 > dist) return -1;
+    const float v_mid = v0 + a0 * t4 - 0.5f * j * t4 * t4;
+    if (v_mid < 0.0f) return -1;
+    const float a_mid = a0 - j * t4;
+    const float d_rem = dist - d4;
+
+    const float t6_max = (a_mid < 0.0f) ? -a_mid / j : 0.0f;
+    if (constant_jolt::phaseDist(v_mid, a_mid, j, t6_max) < d_rem) return -1;
+
+    t6_out = constant_jolt::solvePhaseTime(v_mid, a_mid, j, d_rem, 0.0f, t6_max);
+    a_exit_out = a_mid + j * t6_out;
+    v_exit_out = v_mid + a_mid * t6_out + 0.5f * j * t6_out * t6_out;
+
+    if (a_exit_out > 0.0f) return +1;
+    if (v_exit_out > v_max_safe_exit) return +1;
+    return 0;
+  };
+
+  const float disc_v = a0 * a0 + 2.0f * j * v0;
+  const float t4_max = (disc_v > 0.0f) ? (a0 + SQRT(disc_v)) / j : 0.0f;
+  if (t4_max <= 0.0f) return false;
+
+  const float t4_min = (a0 > 0.0f) ? a0 / j : 0.0f;
+  float lo = t4_min, hi = t4_max;
+  float t4_best = 0.0f, t6_best = 0.0f, v_best = 0.0f, a_best = 0.0f;
+  bool found = false;
+  for (int i = 0; i < 32; i++) {
+    float mid = 0.5f * (lo + hi);
+    if (mid == lo || mid == hi) break;
+    float t6_f, v_f, a_f;
+    const int dir = eval(mid, t6_f, v_f, a_f);
+    if (dir == 0) {
+      hi = mid;
+      t4_best = mid; t6_best = t6_f; v_best = v_f; a_best = a_f;
+      found = true;
+    } else if (dir < 0) {
+      hi = mid;
+    } else {
+      lo = mid;
+    }
+  }
+
+  if (!found) return false;
+
+  view_t0 = view_d0 = 0.0f;
+  v_entry = v_entry_in;
+  a_entry = a_entry_in;
+  state.a_max = a_max_in;
+  state.j_max = j_max_in;
+  for (int i = 0; i < 7; i++) state.phase_dt[i] = 0.0f;
+  state.phase_dt[4] = t4_best;
+  state.phase_dt[6] = t6_best;
+  state.total_duration = t4_best + t6_best;
+  state.v_exit = v_best;
+  state.a_exit = a_best;
+  state.dist_total = dist;
+  buildPhaseCache();
+
+  if (state.v_exit > v_max_safe_exit) return false;
+  if (state.a_exit > 0.0f) return false;
+  if (state.v_exit - state.a_exit * state.a_exit / (2.0f * j) < 0.0f) return false;
+
+  return true;
+}
+
+#endif // FTM_CONSTANT_JOLT
diff --git a/Marlin/src/module/ft_motion/trajectory_constant_jolt.h b/Marlin/src/module/ft_motion/trajectory_constant_jolt.h
new file mode 100644
index 000000000000..1e2c3d27b94d
--- /dev/null
+++ b/Marlin/src/module/ft_motion/trajectory_constant_jolt.h
@@ -0,0 +1,224 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2026 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+
+#include "constant_jolt_planner.h"
+#include "trajectory_generator.h"
+#include <math.h>
+
+/**
+ * Constant-jolt (7-phase S-curve) trajectory generator.
+ *
+ * Phases: [+jolt, cruise_accel, -jolt, cruise_velocity, -jolt, cruise_decel, +jolt]
+ * Supports non-zero boundary accelerations (a_entry carried across blocks).
+ * Uses bracketed Newton to find feasible peak velocity.
+ */
+
+namespace constant_jolt {
+
+// Distance traveled during one phase with constant jolt.
+// Uses j/6 (not (1/6)*j) for float consistency with the closed-form
+// ramp distance functions (rampDist, rampDistWithA).
+static FORCE_INLINE float phaseDist(float v, float a, float j, float dt) {
+  return v * dt + 0.5f * a * dt * dt + (j / 6.0f) * dt * dt * dt;
+}
+
+// Advance one phase: accumulate distance, update velocity and acceleration.
+static inline void simulatePhase(float j_phase, float dt, float &v, float &a, float &dist) {
+  if (dt <= 0.0f) return;
+  dist += phaseDist(v, a, j_phase, dt);
+  v += a * dt + 0.5f * j_phase * dt * dt;
+  a += j_phase * dt;
+}
+
+} // namespace constant_jolt
+
+class ConstantJoltTrajectoryGenerator : public TrajectoryGenerator {
+public:
+  ConstantJoltTrajectoryGenerator() = default;
+
+  // plan() delegates to the block planner. Defined in trajectory_constant_jolt.cpp.
+  void plan(const float, const float, const float, const float, const float) override;
+
+  // planRunout() resets planner sub-block state, then plans a zero-speed cruise.
+  // Defined in trajectory_constant_jolt.cpp.
+  void planRunout(const float duration) override;
+
+  void setJoltPtr(float* ptr) { jolt_ptr_ = ptr; }
+
+  // Convenience: delegates to planner_.planNext(*this, j_max).
+  // Defined in trajectory_constant_jolt.cpp.
+  bool planNext(float j_max);
+
+  // Strategy 1: Standard 7-phase [+j, 0, -j, cruise, -j, 0, +j].
+  bool plan_accel_decel(float v_entry_in, float v_exit_in, float a_max_in, float j_max_in,
+                     float dist_total, float v_nominal, float a_entry_in = 0.0f);
+
+  // Strategy 2: Partial absorption of a_entry, then decel ramp.
+  bool plan_decel(float v_entry_in, float v_exit_in, float a_max_in, float j_max_in,
+                               float dist_total, float a_entry_in);
+
+  // Strategy 3: [-j, +j] decel, exits with a ≤ 0.
+  bool plan_decel_with_carry(float v_entry_in, float v_max_safe_exit,
+                                  float a_max_in, float j_max_in,
+                                  float dist_total, float a_entry_in);
+
+  // Truncate the trajectory to cover only the first `d` mm of distance.
+  // After truncation, getTotalDuration() returns the time to reach `d`,
+  // and v_exit/a_exit reflect the state at that point.
+  void truncateToDistance(float d);
+
+  FORCE_INLINE float getDistanceAtTime(const float t) const override {
+    if (t <= 0.0f) return 0.0f;
+    const float view_dur = state.total_duration - view_t0;
+    if (t >= view_dur) return state.dist_total - view_d0;
+    const float d_raw = rawDistanceAtTime(t + view_t0);
+    return _MIN(d_raw, state.dist_total) - view_d0;
+  }
+
+  FORCE_INLINE float getTotalDuration() const override { return state.total_duration - view_t0; }
+
+  FORCE_INLINE float getVelocityAtTime(const float t) const {
+    if (t <= 0.0f) return v_entry;
+    const float t_abs = t + view_t0;
+    if (t_abs >= state.total_duration) return state.v_exit;
+    const int ph = findPhase(t_abs);
+    const float dt = t_abs - state.phase_start_time[ph];
+    // Guard against ghost phases: if distance at this time already exceeds
+    // dist_total (residual phase past truncation point), return exit velocity.
+    if (distanceInPhase(ph, dt) >= state.dist_total) return state.v_exit;
+    return state.phase_start_v[ph] + state.phase_start_a[ph] * dt + 0.5f * phaseJolt(ph) * dt * dt;
+  }
+
+  FORCE_INLINE float getAccelerationAtTime(const float t) const {
+    if (t <= 0.0f) return a_entry;
+    const float t_abs = t + view_t0;
+    if (t_abs >= state.total_duration) return state.a_exit;
+    const int ph = findPhase(t_abs);
+    const float dt = t_abs - state.phase_start_time[ph];
+    return state.phase_start_a[ph] + phaseJolt(ph) * dt;
+  }
+
+  FORCE_INLINE float getJoltAtTime(const float t) const {
+    const float t_abs = t + view_t0;
+    const float tc = (t <= 0.0f) ? view_t0 : (t_abs >= state.total_duration) ? _MAX(0.0f, state.total_duration - 1e-10f) : t_abs;
+    return phaseJolt(findPhase(tc));
+  }
+
+  // Get velocity at a given distance along the trajectory.
+  float getVelocityAtDistance(const float d) const;
+
+  float getExitSpeed() const { return state.v_exit; }
+  float getExitAccel() const { return state.a_exit; }
+
+  // Find time at which the trajectory reaches distance d.
+  float getTimeAtDistance(float d) const;
+
+  void reset() override;
+
+  // ─── Trajectory reuse: save/restore pre-truncation state ───
+
+  void savePreTruncation(CJTrajectorySnapshot& snap, uint8_t merge_count, float mm_consumed) const;
+
+  // Reuse a previously saved trajectory: restore phases, advance the view
+  // window by one block (mm0), and update the snapshot for the next cycle.
+  void reuse(CJTrajectorySnapshot& snap, float mm0,
+             float v_entry_in, float a_entry_in);
+
+  // Delegate accessors to the planner
+  ConstantJoltBlockPlanner& planner() { return planner_; }
+
+
+  friend class ConstantJoltBlockPlanner;  // verifyJunctions accesses phase internals
+
+private:
+  // Set member state from params (called at start of each strategy).
+  void setupPlanState(float v_entry_in, float v_exit_in,
+                      float a_max_in, float j_max_in,
+                      float dist_total_in, float a_entry_in);
+
+  // Check overshoot tolerance and truncate if within CJP_TOL.
+  bool finalizeAndTruncate(float dist_total_in);
+
+  // Raw distance-at-time without view offsets (used internally and by getTimeAtDistance)
+  FORCE_INLINE float rawDistanceAtTime(const float t) const {
+    if (t <= 0.0f) return 0.0f;
+    if (t >= state.total_duration) return state.dist_total;
+    const int ph = findPhase(t);
+    const float dt = t - state.phase_start_time[ph];
+    const float v = state.phase_start_v[ph];
+    const float a = state.phase_start_a[ph];
+    const float jl = phaseJolt(ph);
+    return state.phase_start_pos[ph] + constant_jolt::phaseDist(v, a, jl, dt);
+  }
+
+  FORCE_INLINE void buildPhaseCache() {
+    float v = v_entry, a = a_entry, dist = 0.0f, t = 0.0f;
+    for (int i = 0; i < 7; ++i) {
+      state.phase_start_time[i] = t;
+      state.phase_start_pos[i] = dist;
+      state.phase_start_v[i] = v;
+      state.phase_start_a[i] = a;
+      constant_jolt::simulatePhase(phaseJolt(i), state.phase_dt[i], v, a, dist);
+      t += state.phase_dt[i];
+    }
+  }
+
+  FORCE_INLINE int findPhase(float t) const {
+    for (int i = 0; i < 7; ++i)
+      if (t < state.phase_start_time[i] + state.phase_dt[i]) return i;
+    return 6;
+  }
+
+  // Absolute distance at time offset dt within a known phase.
+  FORCE_INLINE float distanceInPhase(int ph, float dt) const {
+    return state.phase_start_pos[ph]
+         + constant_jolt::phaseDist(state.phase_start_v[ph], state.phase_start_a[ph], phaseJolt(ph), dt);
+  }
+
+  FORCE_INLINE int findPhaseByDist(float d) const {
+    for (int i = 0; i < 6; ++i)
+      if (d < state.phase_start_pos[i + 1]) return i;
+    return 6;
+  }
+
+  FORCE_INLINE float phaseJolt(int phase) const {
+    switch (phase) {
+      case 0: case 6: return state.j_max;
+      case 2: case 4: return -state.j_max;
+      default: return 0.0f;
+    }
+  }
+
+  CJTrajectoryState state;              // Trajectory state (saved/restored as a unit)
+  ConstantJoltBlockPlanner planner_;   // Owned by value
+  static float jolt_default_;     // Safe fallback if setJoltPtr not called yet
+  float* jolt_ptr_ = &jolt_default_;
+
+  float view_t0 = 0;     // time offset: view origin in the original trajectory
+  float view_d0 = 0;     // distance offset: view origin in the original trajectory
+
+  float v_entry = 0;     // entry velocity (set by strategy or reuse)
+  float a_entry = 0;     // entry acceleration (non-zero when carried from previous block)
+
+};
diff --git a/Marlin/src/module/ft_motion/trajectory_generator.h b/Marlin/src/module/ft_motion/trajectory_generator.h
index f39fe4d7ab24..1009e4f0d1f5 100644
--- a/Marlin/src/module/ft_motion/trajectory_generator.h
+++ b/Marlin/src/module/ft_motion/trajectory_generator.h
@@ -74,5 +74,6 @@ class TrajectoryGenerator {
  */
 enum class TrajectoryType : uint8_t {
   TRAPEZOIDAL, POLY5, POLY6
+  OPTARG(FTM_CONSTANT_JOLT, CONSTANT_JOLT)
   OPTARG(RESONANCE_TEST, RESONANCE)
 };
diff --git a/Marlin/src/module/planner.cpp b/Marlin/src/module/planner.cpp
index 1d7944b5e888..1dfd1687dca4 100644
--- a/Marlin/src/module/planner.cpp
+++ b/Marlin/src/module/planner.cpp
@@ -1760,8 +1760,12 @@ bool Planner::_buffer_steps(const xyze_long_t &target
     minimum_planner_speed_sqr
   );
 
-  // Recalculate and optimize trapezoidal speed profiles
-  recalculate(safe_exit_speed_sqr);
+  // Recalculate and optimize trapezoidal speed profiles.
+  // CJ planner ignores trapezoidal entry/exit speeds — it runs its own
+  // jolt-aware passes via planNext(). Blocks are marked recalculate=false
+  // above, so skip the expensive reverse/forward pass and trapezoid calc.
+  if (TERN1(FTM_CONSTANT_JOLT, ftMotion.cfg.trajectory_type != TrajectoryType::CONSTANT_JOLT))
+    recalculate(safe_exit_speed_sqr);
 
   // Movement successfully queued!
   return true;
@@ -2753,6 +2757,10 @@ bool Planner::_populate_block(
 
   // Max entry speed of this block equals the max exit speed of the previous block.
   block->max_entry_speed_sqr = vmax_junction_sqr;
+  #if ENABLED(FTM_CONSTANT_JOLT)
+    if (ftMotion.cfg.trajectory_type == TrajectoryType::CONSTANT_JOLT)
+      block->vmax_junction = SQRT(vmax_junction_sqr);
+  #endif
   // Set entry speed. The reverse and forward passes will optimize it later.
   block->entry_speed_sqr = minimum_planner_speed_sqr;
   // Set min entry speed. Rarely it could be higher than the previous nominal speed but that's ok.
@@ -2762,7 +2770,9 @@ bool Planner::_populate_block(
   TERN_(HAS_STANDARD_MOTION, block->initial_rate = 0);
   TERN_(FT_MOTION, block->entry_speed = 0);
 
-  block->flag.recalculate = true;
+  // CJ planner runs its own jolt-aware passes — blocks are ready immediately.
+  // recalculate() is also skipped below, so no code will re-set this flag.
+  block->flag.recalculate = TERN1(FTM_CONSTANT_JOLT, ftMotion.cfg.trajectory_type != TrajectoryType::CONSTANT_JOLT);
 
   // Update previous path unit_vector and nominal speed
   previous_speed = current_speed;
diff --git a/Marlin/src/module/planner.h b/Marlin/src/module/planner.h
index 8bd9b6593784..d33023b4db7e 100644
--- a/Marlin/src/module/planner.h
+++ b/Marlin/src/module/planner.h
@@ -265,6 +265,10 @@ typedef struct PlannerBlock {
         steps_per_mm,                       // steps/mm
         acceleration;                       // acceleration mm/sec^2
 
+  #if ENABLED(FTM_CONSTANT_JOLT)
+    float vmax_junction;                    // Original junction speed limit (mm/sec), never modified by recalculate
+  #endif
+
   union {
     abce_ulong_t steps;                     // Step count along each axis
     abce_long_t position;                   // New position to force when this sync block is executed
diff --git a/buildroot/tests/I3DBEEZ9_V1/config-02.ini b/buildroot/tests/I3DBEEZ9_V1/config-02.ini
index 88c29b2a8142..95bdb7bd08c7 100644
--- a/buildroot/tests/I3DBEEZ9_V1/config-02.ini
+++ b/buildroot/tests/I3DBEEZ9_V1/config-02.ini
@@ -18,6 +18,8 @@ x_driver_type                            = TMC2209
 y_driver_type                            = TMC2130
 ft_motion                                = on
 ftm_smoothing                            = on
+ftm_constant_jolt                        = on
+ftm_trajectory_type                      = CONSTANT_JOLT
 ftm_home_and_probe                       = on
 resonance_test                           = on
 ft_motion_menu                           = on