diff --git a/doc/ChangeLog.txt b/doc/ChangeLog.txt
index f665546c..22db3f50 100644
--- a/doc/ChangeLog.txt
+++ b/doc/ChangeLog.txt
@@ -16,6 +16,14 @@ replaced with the -reduce flag. With the -reduce flag, the current
 delay calculator reduces the parastic network to the appropriate type
 and deletes the parasitic network.
 
+The report_clock_skew and report_clock_latency commands now supports
+the -include_internal_latency flag to control inclusion of macro
+internal clock delays from the cell liberty min/max_clock_tree_path
+timing groups.
+
+  report_clock_skew -include_internal_latency
+  report_clock_latency -include_internal_latency
+
 Release 2.4.0 2023/01/19
 -------------------------
 
diff --git a/doc/OpenSTA.odt b/doc/OpenSTA.odt
index 5c2ba015..977ee6df 100644
Binary files a/doc/OpenSTA.odt and b/doc/OpenSTA.odt differ
diff --git a/doc/OpenSTA.pdf b/doc/OpenSTA.pdf
index b2355614..f69f758b 100644
Binary files a/doc/OpenSTA.pdf and b/doc/OpenSTA.pdf differ
diff --git a/include/sta/Sta.hh b/include/sta/Sta.hh
index ebd0a1d8..5568ac3f 100644
--- a/include/sta/Sta.hh
+++ b/include/sta/Sta.hh
@@ -921,9 +921,11 @@ public:
 
   void reportClkLatency(ConstClockSeq clks,
                         const Corner *corner,
+                        bool include_internal_latency,
                         int digits);
   // Find min/max/rise/fall delays for clk.
-  ClkDelays findClkDelays(const Clock *clk);
+  ClkDelays findClkDelays(const Clock *clk,
+                          bool include_internal_latency);
 
   // Update arrival times for all pins.
   // If necessary updateTiming propagates arrivals around latch
diff --git a/search/ClkDelays.hh b/search/ClkDelays.hh
index 729deb66..dacf37f6 100644
--- a/search/ClkDelays.hh
+++ b/search/ClkDelays.hh
@@ -33,7 +33,7 @@ public:
              // Return values.
              Delay &insertion,
              Delay &delay,
-             float &lib_clk_delay,
+             float &internal_latency,
              Delay &latency,
              PathVertex &path,
              bool &exists) const;
@@ -49,6 +49,7 @@ public:
                   const RiseFall *end_rf,
                   const MinMax *min_max,
                   PathVertex *path,
+                  bool include_internal_latency,
                   StaState *sta);
 
 private:
@@ -61,7 +62,7 @@ private:
 
   Delay insertion_[RiseFall::index_count][RiseFall::index_count][MinMax::index_count];
   Delay delay_[RiseFall::index_count][RiseFall::index_count][MinMax::index_count];
-  float lib_clk_delay_[RiseFall::index_count][RiseFall::index_count][MinMax::index_count];
+  float internal_latency_[RiseFall::index_count][RiseFall::index_count][MinMax::index_count];
   Delay latency_[RiseFall::index_count][RiseFall::index_count][MinMax::index_count];
   PathVertex path_[RiseFall::index_count][RiseFall::index_count][MinMax::index_count];
   bool exists_[RiseFall::index_count][RiseFall::index_count][MinMax::index_count];
diff --git a/search/ClkLatency.cc b/search/ClkLatency.cc
index 818251a2..724cf20e 100644
--- a/search/ClkLatency.cc
+++ b/search/ClkLatency.cc
@@ -40,20 +40,23 @@ ClkLatency::ClkLatency(StaState *sta) :
 
 ClkDelays
 ClkLatency::findClkDelays(const Clock *clk,
-                          const Corner *corner)
+                          const Corner *corner,
+                          bool include_internal_latency)
 {
   ConstClockSeq clks;
   clks.push_back(clk);
-  ClkDelayMap clk_delay_map = findClkDelays(clks, corner);
+  ClkDelayMap clk_delay_map = findClkDelays(clks, corner,
+                                            include_internal_latency);
   return clk_delay_map[clk];
 }
 
 void
 ClkLatency::reportClkLatency(ConstClockSeq clks,
                              const Corner *corner,
+                             bool include_internal_latency,
                              int digits)
 {
-  ClkDelayMap clk_delay_map = findClkDelays(clks, corner);
+  ClkDelayMap clk_delay_map = findClkDelays(clks, corner, include_internal_latency);
 
   // Sort the clocks to report in a stable order.
   ConstClockSeq sorted_clks;
@@ -80,20 +83,20 @@ ClkLatency::reportClkLatency(const Clock *clk,
       PathVertex path_min;
       Delay insertion_min;
       Delay delay_min;
-      float lib_clk_delay_min;
+      float internal_latency_min;
       Delay latency_min;
       bool exists_min;
       clk_delays.delay(src_rf, end_rf, MinMax::min(), insertion_min,
-                       delay_min, lib_clk_delay_min, latency_min,
+                       delay_min, internal_latency_min, latency_min,
                        path_min, exists_min);
       PathVertex path_max;
       Delay insertion_max;
       Delay delay_max;
-      float lib_clk_delay_max;
+      float internal_latency_max;
       Delay latency_max;
       bool exists_max;
       clk_delays.delay(src_rf, end_rf, MinMax::max(), insertion_max,
-                       delay_max, lib_clk_delay_max, latency_max,
+                       delay_max, internal_latency_max, latency_max,
                        path_max, exists_max);
       if (exists_min & exists_max) {
         report_->reportLine("%s -> %s",
@@ -112,11 +115,11 @@ ClkLatency::reportClkLatency(const Clock *clk,
                             "",
                             delayAsString(delay_max, this, digits),
                             sdc_network_->pathName(path_max.pin(this)));
-        if (lib_clk_delay_min != 0.0
-            || lib_clk_delay_max != 0.0)
-          report_->reportLine("%7s %7s liberty clock tree delay",
-                              time_unit->asString(lib_clk_delay_min, digits),
-                              time_unit->asString(lib_clk_delay_max, digits));
+        if (internal_latency_min != 0.0
+            || internal_latency_max != 0.0)
+          report_->reportLine("%7s %7s internal clock latency",
+                              time_unit->asString(internal_latency_min, digits),
+                              time_unit->asString(internal_latency_max, digits));
         report_->reportLine("---------------");
         report_->reportLine("%7s %7s latency",
                             delayAsString(latency_min, this, digits),
@@ -132,7 +135,8 @@ ClkLatency::reportClkLatency(const Clock *clk,
 
 ClkDelayMap
 ClkLatency::findClkDelays(ConstClockSeq clks,
-                          const Corner *corner)
+                          const Corner *corner,
+                          bool include_internal_latency)
 {
   ClkDelayMap clk_delay_map;
   // Make entries for the relevant clocks to filter path clocks.
@@ -159,7 +163,8 @@ ClkLatency::findClkDelays(ConstClockSeq clks,
           bool exists;
           clk_delays.latency(clk_rf, end_rf, min_max, clk_latency, exists);
           if (!exists || delayGreater(latency, clk_latency, min_max, this))
-            clk_delays.setLatency(clk_rf, end_rf, min_max, path, this);
+            clk_delays.setLatency(clk_rf, end_rf, min_max, path,
+                                  include_internal_latency, this);
         }
       }
     }
@@ -176,7 +181,7 @@ ClkDelays::ClkDelays()
       for (auto mm_index : MinMax::rangeIndex()) {
         insertion_[src_rf_index][end_rf_index][mm_index] = 0.0;
         delay_[src_rf_index][end_rf_index][mm_index] = 0.0;
-        lib_clk_delay_[src_rf_index][end_rf_index][mm_index] = 0.0;
+        internal_latency_[src_rf_index][end_rf_index][mm_index] = 0.0;
         latency_[src_rf_index][end_rf_index][mm_index] = 0.0;
         exists_[src_rf_index][end_rf_index][mm_index] = false;
       }
@@ -202,7 +207,7 @@ ClkDelays::delay(const RiseFall *src_rf,
   path = path_[src_rf_index][end_rf_index][mm_index];
   insertion = insertion_[src_rf_index][end_rf_index][mm_index];
   delay = delay_[src_rf_index][end_rf_index][mm_index];
-  lib_clk_delay = lib_clk_delay_[src_rf_index][end_rf_index][mm_index];
+  lib_clk_delay = internal_latency_[src_rf_index][end_rf_index][mm_index];
   latency = latency_[src_rf_index][end_rf_index][mm_index];
   exists = exists_[src_rf_index][end_rf_index][mm_index];
 }
@@ -227,6 +232,7 @@ ClkDelays::setLatency(const RiseFall *src_rf,
                       const RiseFall *end_rf,
                       const MinMax *min_max,
                       PathVertex *path,
+                      bool include_internal_latency,
                       StaState *sta)
 {
   int src_rf_index = src_rf->index();
@@ -239,10 +245,13 @@ ClkDelays::setLatency(const RiseFall *src_rf,
   float delay1 = delay(path, sta);
   delay_[src_rf_index][end_rf_index][mm_index] = delay1;
 
-  float lib_clk_delay = clkTreeDelay(path, sta);
-  lib_clk_delay_[src_rf_index][end_rf_index][mm_index] = lib_clk_delay;
+  float internal_latency = 0.0;
+  if (include_internal_latency) {
+    internal_latency = clkTreeDelay(path, sta);
+    internal_latency_[src_rf_index][end_rf_index][mm_index] = internal_latency;
+  }
 
-  float latency = insertion + delay1 + lib_clk_delay;
+  float latency = insertion + delay1 + internal_latency;
   latency_[src_rf_index][end_rf_index][mm_index] = latency;
 
   path_[src_rf_index][end_rf_index][mm_index] = *path;
diff --git a/search/ClkLatency.hh b/search/ClkLatency.hh
index 4bbe5fab..e7614c8b 100644
--- a/search/ClkLatency.hh
+++ b/search/ClkLatency.hh
@@ -37,13 +37,16 @@ public:
   // Report clk latency for clks.
   void reportClkLatency(ConstClockSeq clks,
                         const Corner *corner,
+                        bool include_internal_latency,
                         int digits);
   ClkDelays findClkDelays(const Clock *clk,
-                          const Corner *corner);
+                          const Corner *corner,
+                          bool include_internal_latency);
   
 protected:
   ClkDelayMap findClkDelays(ConstClockSeq clks,
-                            const Corner *corner);
+                            const Corner *corner,
+                            bool include_internal_latency);
   void reportClkLatency(const Clock *clk,
                         ClkDelays &clk_delays,
                         int digits);
diff --git a/search/MakeTimingModel.cc b/search/MakeTimingModel.cc
index eb6941b5..d8252e3c 100644
--- a/search/MakeTimingModel.cc
+++ b/search/MakeTimingModel.cc
@@ -548,7 +548,7 @@ MakeTimingModel::findClkInsertionDelays()
         size_t clk_count = clks->size();
         if (clk_count == 1) {
           for (const Clock *clk : *clks) {
-            ClkDelays delays = sta_->findClkDelays(clk);
+            ClkDelays delays = sta_->findClkDelays(clk, true);
             for (const MinMax *min_max : MinMax::range()) {
               makeClkTreePaths(lib_port, min_max, TimingSense::positive_unate, delays);
               makeClkTreePaths(lib_port, min_max, TimingSense::negative_unate, delays);
diff --git a/search/Sta.cc b/search/Sta.cc
index 546475a3..4c9bb754 100644
--- a/search/Sta.cc
+++ b/search/Sta.cc
@@ -2634,19 +2634,21 @@ Sta::clkSkewPreamble()
 void
 Sta::reportClkLatency(ConstClockSeq clks,
                       const Corner *corner,
+                      bool include_internal_latency,
                       int digits)
 {
   ensureClkArrivals();
   ClkLatency clk_latency(this);
-  clk_latency.reportClkLatency(clks, corner, digits);
+  clk_latency.reportClkLatency(clks, corner, include_internal_latency, digits);
 }
 
 ClkDelays
-Sta::findClkDelays(const Clock *clk)
+Sta::findClkDelays(const Clock *clk,
+                   bool include_internal_latency)
 {
   ensureClkArrivals();
   ClkLatency clk_latency(this);
-  return clk_latency.findClkDelays(clk, nullptr);
+  return clk_latency.findClkDelays(clk, nullptr, include_internal_latency);
 }
 
 ////////////////////////////////////////////////////////////////
diff --git a/tcl/Search.tcl b/tcl/Search.tcl
index f93085e6..f6e5af90 100644
--- a/tcl/Search.tcl
+++ b/tcl/Search.tcl
@@ -356,13 +356,15 @@ proc_redirect report_clock_skew {
 
 define_cmd_args "report_clock_latency" {[-clock clocks]\
                                           [-corner corner]\
+                                          [-include_internal_latency]
                                           [-digits digits]}
 
 proc_redirect report_clock_latency {
   global sta_report_default_digits
 
   parse_key_args "report_clock_" args \
-    keys {-clock -corner -digits} flags {}
+    keys {-clock -corner -digits} \
+    flags {-include_internal_latency}
   check_argc_eq0 "report_clock_latency" $args
 
   if [info exists keys(-clock)] {
@@ -371,6 +373,7 @@ proc_redirect report_clock_latency {
     set clks [all_clocks]
   }
   set corner [parse_corner_or_all keys]
+  set include_internal_latency [info exists flags(-include_internal_latency)]
   if [info exists keys(-digits)] {
     set digits $keys(-digits)
     check_positive_integer "-digits" $digits
@@ -378,7 +381,7 @@ proc_redirect report_clock_latency {
     set digits $sta_report_default_digits
   }
   if { $clks != {} } {
-    report_clk_latency $clks $corner $digits
+    report_clk_latency $clks $corner $include_internal_latency $digits
   }
 }
 
diff --git a/tcl/StaTcl.i b/tcl/StaTcl.i
index 6977cd87..e36af43f 100644
--- a/tcl/StaTcl.i
+++ b/tcl/StaTcl.i
@@ -3051,10 +3051,11 @@ report_clk_skew(ConstClockSeq clks,
 void
 report_clk_latency(ConstClockSeq clks,
                    const Corner *corner,
+                   bool include_internal_latency,
                    int digits)
 {
   cmdLinkedNetwork();
-  Sta::sta()->reportClkLatency(clks, corner, digits);
+  Sta::sta()->reportClkLatency(clks, corner, include_internal_latency, digits);
 }
 
 float