diff --git a/esphome/components/alarm_control_panel/alarm_control_panel.cpp b/esphome/components/alarm_control_panel/alarm_control_panel.cpp
index fb61776532..623241851a 100644
--- a/esphome/components/alarm_control_panel/alarm_control_panel.cpp
+++ b/esphome/components/alarm_control_panel/alarm_control_panel.cpp
@@ -31,7 +31,7 @@ void AlarmControlPanel::publish_state(AlarmControlPanelState state) {
   this->last_update_ = millis();
   if (state != this->current_state_) {
     auto prev_state = this->current_state_;
-    ESP_LOGD(TAG, "'%s' >> %s (was %s)", this->get_name().c_str(),
+    ESP_LOGV(TAG, "'%s' >> %s (was %s)", this->get_name().c_str(),
              LOG_STR_ARG(alarm_control_panel_state_to_string(state)),
              LOG_STR_ARG(alarm_control_panel_state_to_string(prev_state)));
     this->current_state_ = state;
diff --git a/esphome/components/binary_sensor/binary_sensor.cpp b/esphome/components/binary_sensor/binary_sensor.cpp
index 0fb58082cb..7596975a68 100644
--- a/esphome/components/binary_sensor/binary_sensor.cpp
+++ b/esphome/components/binary_sensor/binary_sensor.cpp
@@ -38,7 +38,7 @@ bool BinarySensor::set_new_state(const optional<bool> &new_state) {
 #if defined(USE_BINARY_SENSOR) && defined(USE_CONTROLLER_REGISTRY)
     ControllerRegistry::notify_binary_sensor_update(this);
 #endif
-    ESP_LOGD(TAG, "'%s' >> %s", this->get_name().c_str(), ONOFFMAYBE(new_state));
+    ESP_LOGV(TAG, "'%s' >> %s", this->get_name().c_str(), ONOFFMAYBE(new_state));
     return true;
   }
   return false;
diff --git a/esphome/components/bm8563/bm8563.cpp b/esphome/components/bm8563/bm8563.cpp
index 07831485c1..269acfea44 100644
--- a/esphome/components/bm8563/bm8563.cpp
+++ b/esphome/components/bm8563/bm8563.cpp
@@ -56,7 +56,6 @@ void BM8563::read_time() {
   ESPTime rtc_time;
   this->get_time_(rtc_time);
   this->get_date_(rtc_time);
-  rtc_time.day_of_year = 1;  // unused by recalc_timestamp_utc, but needs to be valid
   ESP_LOGD(TAG, "Read time: %i-%i-%i %i, %i:%i:%i", rtc_time.year, rtc_time.month, rtc_time.day_of_month,
            rtc_time.day_of_week, rtc_time.hour, rtc_time.minute, rtc_time.second);
 
diff --git a/esphome/components/climate/climate.cpp b/esphome/components/climate/climate.cpp
index 3f44b986dc..5cbe9a5daf 100644
--- a/esphome/components/climate/climate.cpp
+++ b/esphome/components/climate/climate.cpp
@@ -46,45 +46,45 @@ constexpr StringToUint8 CLIMATE_SWING_MODES_BY_STR[] = {
 
 void ClimateCall::perform() {
   this->parent_->control_callback_.call(*this);
-  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+  ESP_LOGV(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
   this->validate_();
   if (this->mode_.has_value()) {
     const LogString *mode_s = climate_mode_to_string(*this->mode_);
-    ESP_LOGD(TAG, "  Mode: %s", LOG_STR_ARG(mode_s));
+    ESP_LOGV(TAG, "  Mode: %s", LOG_STR_ARG(mode_s));
   }
   if (this->custom_fan_mode_ != nullptr) {
     this->fan_mode_.reset();
-    ESP_LOGD(TAG, " Custom Fan: %s", this->custom_fan_mode_);
+    ESP_LOGV(TAG, " Custom Fan: %s", this->custom_fan_mode_);
   }
   if (this->fan_mode_.has_value()) {
     this->custom_fan_mode_ = nullptr;
     const LogString *fan_mode_s = climate_fan_mode_to_string(*this->fan_mode_);
-    ESP_LOGD(TAG, "  Fan: %s", LOG_STR_ARG(fan_mode_s));
+    ESP_LOGV(TAG, "  Fan: %s", LOG_STR_ARG(fan_mode_s));
   }
   if (this->custom_preset_ != nullptr) {
     this->preset_.reset();
-    ESP_LOGD(TAG, " Custom Preset: %s", this->custom_preset_);
+    ESP_LOGV(TAG, " Custom Preset: %s", this->custom_preset_);
   }
   if (this->preset_.has_value()) {
     this->custom_preset_ = nullptr;
     const LogString *preset_s = climate_preset_to_string(*this->preset_);
-    ESP_LOGD(TAG, "  Preset: %s", LOG_STR_ARG(preset_s));
+    ESP_LOGV(TAG, "  Preset: %s", LOG_STR_ARG(preset_s));
   }
   if (this->swing_mode_.has_value()) {
     const LogString *swing_mode_s = climate_swing_mode_to_string(*this->swing_mode_);
-    ESP_LOGD(TAG, "  Swing: %s", LOG_STR_ARG(swing_mode_s));
+    ESP_LOGV(TAG, "  Swing: %s", LOG_STR_ARG(swing_mode_s));
   }
   if (this->target_temperature_.has_value()) {
-    ESP_LOGD(TAG, "  Target Temperature: %.2f", *this->target_temperature_);
+    ESP_LOGV(TAG, "  Target Temperature: %.2f", *this->target_temperature_);
   }
   if (this->target_temperature_low_.has_value()) {
-    ESP_LOGD(TAG, "  Target Temperature Low: %.2f", *this->target_temperature_low_);
+    ESP_LOGV(TAG, "  Target Temperature Low: %.2f", *this->target_temperature_low_);
   }
   if (this->target_temperature_high_.has_value()) {
-    ESP_LOGD(TAG, "  Target Temperature High: %.2f", *this->target_temperature_high_);
+    ESP_LOGV(TAG, "  Target Temperature High: %.2f", *this->target_temperature_high_);
   }
   if (this->target_humidity_.has_value()) {
-    ESP_LOGD(TAG, "  Target Humidity: %.0f", *this->target_humidity_);
+    ESP_LOGV(TAG, "  Target Humidity: %.0f", *this->target_humidity_);
   }
   this->parent_->control(*this);
 }
@@ -435,43 +435,43 @@ void Climate::save_state_() {
 }
 
 void Climate::publish_state() {
-  ESP_LOGD(TAG, "'%s' >>", this->name_.c_str());
+  ESP_LOGV(TAG, "'%s' >>", this->name_.c_str());
   auto traits = this->get_traits();
 
-  ESP_LOGD(TAG, "  Mode: %s", LOG_STR_ARG(climate_mode_to_string(this->mode)));
+  ESP_LOGV(TAG, "  Mode: %s", LOG_STR_ARG(climate_mode_to_string(this->mode)));
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_ACTION)) {
-    ESP_LOGD(TAG, "  Action: %s", LOG_STR_ARG(climate_action_to_string(this->action)));
+    ESP_LOGV(TAG, "  Action: %s", LOG_STR_ARG(climate_action_to_string(this->action)));
   }
   if (traits.get_supports_fan_modes() && this->fan_mode.has_value()) {
-    ESP_LOGD(TAG, "  Fan Mode: %s", LOG_STR_ARG(climate_fan_mode_to_string(this->fan_mode.value())));
+    ESP_LOGV(TAG, "  Fan Mode: %s", LOG_STR_ARG(climate_fan_mode_to_string(this->fan_mode.value())));
   }
   if (!traits.get_supported_custom_fan_modes().empty() && this->has_custom_fan_mode()) {
-    ESP_LOGD(TAG, "  Custom Fan Mode: %s", this->custom_fan_mode_);
+    ESP_LOGV(TAG, "  Custom Fan Mode: %s", this->custom_fan_mode_);
   }
   if (traits.get_supports_presets() && this->preset.has_value()) {
-    ESP_LOGD(TAG, "  Preset: %s", LOG_STR_ARG(climate_preset_to_string(this->preset.value())));
+    ESP_LOGV(TAG, "  Preset: %s", LOG_STR_ARG(climate_preset_to_string(this->preset.value())));
   }
   if (!traits.get_supported_custom_presets().empty() && this->has_custom_preset()) {
-    ESP_LOGD(TAG, "  Custom Preset: %s", this->custom_preset_);
+    ESP_LOGV(TAG, "  Custom Preset: %s", this->custom_preset_);
   }
   if (traits.get_supports_swing_modes()) {
-    ESP_LOGD(TAG, "  Swing Mode: %s", LOG_STR_ARG(climate_swing_mode_to_string(this->swing_mode)));
+    ESP_LOGV(TAG, "  Swing Mode: %s", LOG_STR_ARG(climate_swing_mode_to_string(this->swing_mode)));
   }
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE)) {
-    ESP_LOGD(TAG, "  Current Temperature: %.2f°C", this->current_temperature);
+    ESP_LOGV(TAG, "  Current Temperature: %.2f°C", this->current_temperature);
   }
   if (traits.has_feature_flags(CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE |
                                CLIMATE_REQUIRES_TWO_POINT_TARGET_TEMPERATURE)) {
-    ESP_LOGD(TAG, "  Target Temperature: Low: %.2f°C High: %.2f°C", this->target_temperature_low,
+    ESP_LOGV(TAG, "  Target Temperature: Low: %.2f°C High: %.2f°C", this->target_temperature_low,
              this->target_temperature_high);
   } else {
-    ESP_LOGD(TAG, "  Target Temperature: %.2f°C", this->target_temperature);
+    ESP_LOGV(TAG, "  Target Temperature: %.2f°C", this->target_temperature);
   }
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_HUMIDITY)) {
-    ESP_LOGD(TAG, "  Current Humidity: %.0f%%", this->current_humidity);
+    ESP_LOGV(TAG, "  Current Humidity: %.0f%%", this->current_humidity);
   }
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_TARGET_HUMIDITY)) {
-    ESP_LOGD(TAG, "  Target Humidity: %.0f%%", this->target_humidity);
+    ESP_LOGV(TAG, "  Target Humidity: %.0f%%", this->target_humidity);
   }
 
   // Send state to frontend
diff --git a/esphome/components/cover/cover.cpp b/esphome/components/cover/cover.cpp
index bb5965d861..e98a555fe5 100644
--- a/esphome/components/cover/cover.cpp
+++ b/esphome/components/cover/cover.cpp
@@ -68,24 +68,24 @@ CoverCall &CoverCall::set_tilt(float tilt) {
   return *this;
 }
 void CoverCall::perform() {
-  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+  ESP_LOGV(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
   auto traits = this->parent_->get_traits();
   this->validate_();
   if (this->stop_) {
-    ESP_LOGD(TAG, "  Command: STOP");
+    ESP_LOGV(TAG, "  Command: STOP");
   }
   if (this->position_.has_value()) {
     if (traits.get_supports_position()) {
-      ESP_LOGD(TAG, "  Position: %.0f%%", *this->position_ * 100.0f);
+      ESP_LOGV(TAG, "  Position: %.0f%%", *this->position_ * 100.0f);
     } else {
-      ESP_LOGD(TAG, "  Command: %s", LOG_STR_ARG(cover_command_to_str(*this->position_)));
+      ESP_LOGV(TAG, "  Command: %s", LOG_STR_ARG(cover_command_to_str(*this->position_)));
     }
   }
   if (this->tilt_.has_value()) {
-    ESP_LOGD(TAG, "  Tilt: %.0f%%", *this->tilt_ * 100.0f);
+    ESP_LOGV(TAG, "  Tilt: %.0f%%", *this->tilt_ * 100.0f);
   }
   if (this->toggle_.has_value()) {
-    ESP_LOGD(TAG, "  Command: TOGGLE");
+    ESP_LOGV(TAG, "  Command: TOGGLE");
   }
   this->parent_->control(*this);
 }
@@ -143,23 +143,23 @@ void Cover::publish_state(bool save) {
   this->position = clamp(this->position, 0.0f, 1.0f);
   this->tilt = clamp(this->tilt, 0.0f, 1.0f);
 
-  ESP_LOGD(TAG, "'%s' >>", this->name_.c_str());
+  ESP_LOGV(TAG, "'%s' >>", this->name_.c_str());
   auto traits = this->get_traits();
   if (traits.get_supports_position()) {
-    ESP_LOGD(TAG, "  Position: %.0f%%", this->position * 100.0f);
+    ESP_LOGV(TAG, "  Position: %.0f%%", this->position * 100.0f);
   } else {
     if (this->position == COVER_OPEN) {
-      ESP_LOGD(TAG, "  State: OPEN");
+      ESP_LOGV(TAG, "  State: OPEN");
     } else if (this->position == COVER_CLOSED) {
-      ESP_LOGD(TAG, "  State: CLOSED");
+      ESP_LOGV(TAG, "  State: CLOSED");
     } else {
-      ESP_LOGD(TAG, "  State: UNKNOWN");
+      ESP_LOGV(TAG, "  State: UNKNOWN");
     }
   }
   if (traits.get_supports_tilt()) {
-    ESP_LOGD(TAG, "  Tilt: %.0f%%", this->tilt * 100.0f);
+    ESP_LOGV(TAG, "  Tilt: %.0f%%", this->tilt * 100.0f);
   }
-  ESP_LOGD(TAG, "  Current Operation: %s", LOG_STR_ARG(cover_operation_to_str(this->current_operation)));
+  ESP_LOGV(TAG, "  Current Operation: %s", LOG_STR_ARG(cover_operation_to_str(this->current_operation)));
 
   this->state_callback_.call();
 #if defined(USE_COVER) && defined(USE_CONTROLLER_REGISTRY)
diff --git a/esphome/components/datetime/date_entity.cpp b/esphome/components/datetime/date_entity.cpp
index 3ba488c0aa..997aec3f69 100644
--- a/esphome/components/datetime/date_entity.cpp
+++ b/esphome/components/datetime/date_entity.cpp
@@ -30,7 +30,7 @@ void DateEntity::publish_state() {
     return;
   }
   this->set_has_state(true);
-  ESP_LOGD(TAG, "'%s' >> %d-%d-%d", this->get_name().c_str(), this->year_, this->month_, this->day_);
+  ESP_LOGV(TAG, "'%s' >> %d-%d-%d", this->get_name().c_str(), this->year_, this->month_, this->day_);
   this->state_callback_.call();
 #if defined(USE_DATETIME_DATE) && defined(USE_CONTROLLER_REGISTRY)
   ControllerRegistry::notify_date_update(this);
@@ -83,16 +83,16 @@ void DateCall::validate_() {
 
 void DateCall::perform() {
   this->validate_();
-  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+  ESP_LOGV(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
 
   if (this->year_.has_value()) {
-    ESP_LOGD(TAG, " Year: %d", *this->year_);
+    ESP_LOGV(TAG, " Year: %d", *this->year_);
   }
   if (this->month_.has_value()) {
-    ESP_LOGD(TAG, " Month: %d", *this->month_);
+    ESP_LOGV(TAG, " Month: %d", *this->month_);
   }
   if (this->day_.has_value()) {
-    ESP_LOGD(TAG, " Day: %d", *this->day_);
+    ESP_LOGV(TAG, " Day: %d", *this->day_);
   }
   this->parent_->control(*this);
 }
diff --git a/esphome/components/datetime/datetime_entity.cpp b/esphome/components/datetime/datetime_entity.cpp
index 730abb3ca8..a8e00d6eb3 100644
--- a/esphome/components/datetime/datetime_entity.cpp
+++ b/esphome/components/datetime/datetime_entity.cpp
@@ -45,7 +45,7 @@ void DateTimeEntity::publish_state() {
     return;
   }
   this->set_has_state(true);
-  ESP_LOGD(TAG, "'%s' >> %04u-%02u-%02u %02d:%02d:%02d", this->get_name().c_str(), this->year_, this->month_,
+  ESP_LOGV(TAG, "'%s' >> %04u-%02u-%02u %02d:%02d:%02d", this->get_name().c_str(), this->year_, this->month_,
            this->day_, this->hour_, this->minute_, this->second_);
   this->state_callback_.call();
 #if defined(USE_DATETIME_DATETIME) && defined(USE_CONTROLLER_REGISTRY)
@@ -60,6 +60,9 @@ ESPTime DateTimeEntity::state_as_esptime() const {
   obj.year = this->year_;
   obj.month = this->month_;
   obj.day_of_month = this->day_;
+  obj.day_of_week = 0;
+  obj.day_of_year = 0;
+  obj.is_dst = false;
   obj.hour = this->hour_;
   obj.minute = this->minute_;
   obj.second = this->second_;
@@ -124,25 +127,25 @@ void DateTimeCall::validate_() {
 
 void DateTimeCall::perform() {
   this->validate_();
-  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+  ESP_LOGV(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
 
   if (this->year_.has_value()) {
-    ESP_LOGD(TAG, " Year: %d", *this->year_);
+    ESP_LOGV(TAG, " Year: %d", *this->year_);
   }
   if (this->month_.has_value()) {
-    ESP_LOGD(TAG, " Month: %d", *this->month_);
+    ESP_LOGV(TAG, " Month: %d", *this->month_);
   }
   if (this->day_.has_value()) {
-    ESP_LOGD(TAG, " Day: %d", *this->day_);
+    ESP_LOGV(TAG, " Day: %d", *this->day_);
   }
   if (this->hour_.has_value()) {
-    ESP_LOGD(TAG, " Hour: %d", *this->hour_);
+    ESP_LOGV(TAG, " Hour: %d", *this->hour_);
   }
   if (this->minute_.has_value()) {
-    ESP_LOGD(TAG, " Minute: %d", *this->minute_);
+    ESP_LOGV(TAG, " Minute: %d", *this->minute_);
   }
   if (this->second_.has_value()) {
-    ESP_LOGD(TAG, " Second: %d", *this->second_);
+    ESP_LOGV(TAG, " Second: %d", *this->second_);
   }
   this->parent_->control(*this);
 }
diff --git a/esphome/components/datetime/time_entity.cpp b/esphome/components/datetime/time_entity.cpp
index 74e43fbbe7..1cc9eaf2fb 100644
--- a/esphome/components/datetime/time_entity.cpp
+++ b/esphome/components/datetime/time_entity.cpp
@@ -26,7 +26,7 @@ void TimeEntity::publish_state() {
     return;
   }
   this->set_has_state(true);
-  ESP_LOGD(TAG, "'%s' >> %02d:%02d:%02d", this->get_name().c_str(), this->hour_, this->minute_, this->second_);
+  ESP_LOGV(TAG, "'%s' >> %02d:%02d:%02d", this->get_name().c_str(), this->hour_, this->minute_, this->second_);
   this->state_callback_.call();
 #if defined(USE_DATETIME_TIME) && defined(USE_CONTROLLER_REGISTRY)
   ControllerRegistry::notify_time_update(this);
@@ -52,15 +52,15 @@ void TimeCall::validate_() {
 
 void TimeCall::perform() {
   this->validate_();
-  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+  ESP_LOGV(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
   if (this->hour_.has_value()) {
-    ESP_LOGD(TAG, " Hour: %d", *this->hour_);
+    ESP_LOGV(TAG, " Hour: %d", *this->hour_);
   }
   if (this->minute_.has_value()) {
-    ESP_LOGD(TAG, " Minute: %d", *this->minute_);
+    ESP_LOGV(TAG, " Minute: %d", *this->minute_);
   }
   if (this->second_.has_value()) {
-    ESP_LOGD(TAG, " Second: %d", *this->second_);
+    ESP_LOGV(TAG, " Second: %d", *this->second_);
   }
   this->parent_->control(*this);
 }
diff --git a/esphome/components/ds1307/ds1307.cpp b/esphome/components/ds1307/ds1307.cpp
index 5c0e98290b..8fff4213b4 100644
--- a/esphome/components/ds1307/ds1307.cpp
+++ b/esphome/components/ds1307/ds1307.cpp
@@ -40,11 +40,8 @@ void DS1307Component::read_time() {
       .hour = uint8_t(ds1307_.reg.hour + 10u * ds1307_.reg.hour_10),
       .day_of_week = uint8_t(ds1307_.reg.weekday),
       .day_of_month = uint8_t(ds1307_.reg.day + 10u * ds1307_.reg.day_10),
-      .day_of_year = 1,  // ignored by recalc_timestamp_utc(false)
       .month = uint8_t(ds1307_.reg.month + 10u * ds1307_.reg.month_10),
       .year = uint16_t(ds1307_.reg.year + 10u * ds1307_.reg.year_10 + 2000),
-      .is_dst = false,  // not used
-      .timestamp = 0    // overwritten by recalc_timestamp_utc(false)
   };
   rtc_time.recalc_timestamp_utc(false);
   if (!rtc_time.is_valid()) {
diff --git a/esphome/components/event/event.cpp b/esphome/components/event/event.cpp
index ec63fd9c3e..a5d64a2748 100644
--- a/esphome/components/event/event.cpp
+++ b/esphome/components/event/event.cpp
@@ -22,7 +22,7 @@ void Event::trigger(const std::string &event_type) {
     return;
   }
   this->last_event_type_ = found;
-  ESP_LOGD(TAG, "'%s' >> '%s'", this->get_name().c_str(), this->last_event_type_);
+  ESP_LOGV(TAG, "'%s' >> '%s'", this->get_name().c_str(), this->last_event_type_);
   this->event_callback_.call(StringRef(found));
 #if defined(USE_EVENT) && defined(USE_CONTROLLER_REGISTRY)
   ControllerRegistry::notify_event(this);
diff --git a/esphome/components/fan/fan.cpp b/esphome/components/fan/fan.cpp
index 3f47e47a46..4fe2b1030f 100644
--- a/esphome/components/fan/fan.cpp
+++ b/esphome/components/fan/fan.cpp
@@ -44,22 +44,22 @@ FanCall &FanCall::set_preset_mode(const char *preset_mode, size_t len) {
 }
 
 void FanCall::perform() {
-  ESP_LOGD(TAG, "'%s' - Setting:", this->parent_.get_name().c_str());
+  ESP_LOGV(TAG, "'%s' - Setting:", this->parent_.get_name().c_str());
   this->validate_();
   if (this->binary_state_.has_value()) {
-    ESP_LOGD(TAG, "  State: %s", ONOFF(*this->binary_state_));
+    ESP_LOGV(TAG, "  State: %s", ONOFF(*this->binary_state_));
   }
   if (this->oscillating_.has_value()) {
-    ESP_LOGD(TAG, "  Oscillating: %s", YESNO(*this->oscillating_));
+    ESP_LOGV(TAG, "  Oscillating: %s", YESNO(*this->oscillating_));
   }
   if (this->speed_.has_value()) {
-    ESP_LOGD(TAG, "  Speed: %d", *this->speed_);
+    ESP_LOGV(TAG, "  Speed: %d", *this->speed_);
   }
   if (this->direction_.has_value()) {
-    ESP_LOGD(TAG, "  Direction: %s", LOG_STR_ARG(fan_direction_to_string(*this->direction_)));
+    ESP_LOGV(TAG, "  Direction: %s", LOG_STR_ARG(fan_direction_to_string(*this->direction_)));
   }
   if (this->preset_mode_ != nullptr) {
-    ESP_LOGD(TAG, "  Preset Mode: %s", this->preset_mode_);
+    ESP_LOGV(TAG, "  Preset Mode: %s", this->preset_mode_);
   }
   this->parent_.control(*this);
 }
@@ -196,21 +196,21 @@ void Fan::apply_preset_mode_(const FanCall &call) {
 void Fan::publish_state() {
   auto traits = this->get_traits();
 
-  ESP_LOGD(TAG,
+  ESP_LOGV(TAG,
            "'%s' >>\n"
            "  State: %s",
            this->name_.c_str(), ONOFF(this->state));
   if (traits.supports_speed()) {
-    ESP_LOGD(TAG, "  Speed: %d", this->speed);
+    ESP_LOGV(TAG, "  Speed: %d", this->speed);
   }
   if (traits.supports_oscillation()) {
-    ESP_LOGD(TAG, "  Oscillating: %s", YESNO(this->oscillating));
+    ESP_LOGV(TAG, "  Oscillating: %s", YESNO(this->oscillating));
   }
   if (traits.supports_direction()) {
-    ESP_LOGD(TAG, "  Direction: %s", LOG_STR_ARG(fan_direction_to_string(this->direction)));
+    ESP_LOGV(TAG, "  Direction: %s", LOG_STR_ARG(fan_direction_to_string(this->direction)));
   }
   if (this->preset_mode_ != nullptr) {
-    ESP_LOGD(TAG, "  Preset Mode: %s", this->preset_mode_);
+    ESP_LOGV(TAG, "  Preset Mode: %s", this->preset_mode_);
   }
   this->state_callback_.call();
 #if defined(USE_FAN) && defined(USE_CONTROLLER_REGISTRY)
diff --git a/esphome/components/gps/time/gps_time.cpp b/esphome/components/gps/time/gps_time.cpp
index cff8c1fb07..fb662a3d60 100644
--- a/esphome/components/gps/time/gps_time.cpp
+++ b/esphome/components/gps/time/gps_time.cpp
@@ -16,10 +16,6 @@ void GPSTime::from_tiny_gps_(TinyGPSPlus &tiny_gps) {
   val.year = tiny_gps.date.year();
   val.month = tiny_gps.date.month();
   val.day_of_month = tiny_gps.date.day();
-  // Set these to valid value for  recalc_timestamp_utc - it's not used for calculation
-  val.day_of_week = 1;
-  val.day_of_year = 1;
-
   val.hour = tiny_gps.time.hour();
   val.minute = tiny_gps.time.minute();
   val.second = tiny_gps.time.second();
diff --git a/esphome/components/light/light_call.cpp b/esphome/components/light/light_call.cpp
index 0b2d391fd6..41bd98de7b 100644
--- a/esphome/components/light/light_call.cpp
+++ b/esphome/components/light/light_call.cpp
@@ -62,9 +62,9 @@ static const LogString *color_mode_to_human(ColorMode color_mode) {
 }
 
 // Helper to log percentage values
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
 static void log_percent(const LogString *param, float value) {
-  ESP_LOGD(TAG, "  %s: %.0f%%", LOG_STR_ARG(param), value * 100.0f);
+  ESP_LOGV(TAG, "  %s: %.0f%%", LOG_STR_ARG(param), value * 100.0f);
 }
 #else
 #define log_percent(param, value)
@@ -76,20 +76,20 @@ void LightCall::perform() {
   const bool publish = this->get_publish_();
 
   if (publish) {
-    ESP_LOGD(TAG, "'%s' Setting:", name);
+    ESP_LOGV(TAG, "'%s' Setting:", name);
 
     // Only print color mode when it's being changed
     ColorMode current_color_mode = this->parent_->remote_values.get_color_mode();
     ColorMode target_color_mode = this->has_color_mode() ? this->color_mode_ : current_color_mode;
     if (target_color_mode != current_color_mode) {
-      ESP_LOGD(TAG, "  Color mode: %s", LOG_STR_ARG(color_mode_to_human(v.get_color_mode())));
+      ESP_LOGV(TAG, "  Color mode: %s", LOG_STR_ARG(color_mode_to_human(v.get_color_mode())));
     }
 
     // Only print state when it's being changed
     bool current_state = this->parent_->remote_values.is_on();
     bool target_state = this->has_state() ? this->state_ : current_state;
     if (target_state != current_state) {
-      ESP_LOGD(TAG, "  State: %s", ONOFF(v.is_on()));
+      ESP_LOGV(TAG, "  State: %s", ONOFF(v.is_on()));
     }
 
     if (this->has_brightness()) {
@@ -100,7 +100,7 @@ void LightCall::perform() {
       log_percent(LOG_STR("Color brightness"), v.get_color_brightness());
     }
     if (this->has_red() || this->has_green() || this->has_blue()) {
-      ESP_LOGD(TAG, "  Red: %.0f%%, Green: %.0f%%, Blue: %.0f%%", v.get_red() * 100.0f, v.get_green() * 100.0f,
+      ESP_LOGV(TAG, "  Red: %.0f%%, Green: %.0f%%, Blue: %.0f%%", v.get_red() * 100.0f, v.get_green() * 100.0f,
                v.get_blue() * 100.0f);
     }
 
@@ -108,11 +108,11 @@ void LightCall::perform() {
       log_percent(LOG_STR("White"), v.get_white());
     }
     if (this->has_color_temperature()) {
-      ESP_LOGD(TAG, "  Color temperature: %.1f mireds", v.get_color_temperature());
+      ESP_LOGV(TAG, "  Color temperature: %.1f mireds", v.get_color_temperature());
     }
 
     if (this->has_cold_white() || this->has_warm_white()) {
-      ESP_LOGD(TAG, "  Cold white: %.0f%%, warm white: %.0f%%", v.get_cold_white() * 100.0f,
+      ESP_LOGV(TAG, "  Cold white: %.0f%%, warm white: %.0f%%", v.get_cold_white() * 100.0f,
                v.get_warm_white() * 100.0f);
     }
   }
@@ -120,20 +120,20 @@ void LightCall::perform() {
   if (this->has_flash_()) {
     // FLASH
     if (publish) {
-      ESP_LOGD(TAG, "  Flash length: %.1fs", this->flash_length_ / 1e3f);
+      ESP_LOGV(TAG, "  Flash length: %.1fs", this->flash_length_ / 1e3f);
     }
 
     this->parent_->start_flash_(v, this->flash_length_, publish);
   } else if (this->has_transition_()) {
     // TRANSITION
     if (publish) {
-      ESP_LOGD(TAG, "  Transition length: %.1fs", this->transition_length_ / 1e3f);
+      ESP_LOGV(TAG, "  Transition length: %.1fs", this->transition_length_ / 1e3f);
     }
 
     // Special case: Transition and effect can be set when turning off
     if (this->has_effect_()) {
       if (publish) {
-        ESP_LOGD(TAG, "  Effect: 'None'");
+        ESP_LOGV(TAG, "  Effect: 'None'");
       }
       this->parent_->stop_effect_();
     }
@@ -150,7 +150,7 @@ void LightCall::perform() {
     }
 
     if (publish) {
-      ESP_LOGD(TAG, "  Effect: '%.*s'", (int) effect_s.size(), effect_s.c_str());
+      ESP_LOGV(TAG, "  Effect: '%.*s'", (int) effect_s.size(), effect_s.c_str());
     }
 
     this->parent_->start_effect_(this->effect_);
diff --git a/esphome/components/lock/lock.cpp b/esphome/components/lock/lock.cpp
index 4aa636e998..90937485b9 100644
--- a/esphome/components/lock/lock.cpp
+++ b/esphome/components/lock/lock.cpp
@@ -41,7 +41,7 @@ void Lock::publish_state(LockState state) {
 
   this->state = state;
   this->rtc_.save(&this->state);
-  ESP_LOGD(TAG, "'%s' >> %s", this->name_.c_str(), LOG_STR_ARG(lock_state_to_string(state)));
+  ESP_LOGV(TAG, "'%s' >> %s", this->name_.c_str(), LOG_STR_ARG(lock_state_to_string(state)));
   this->state_callback_.call();
 #if defined(USE_LOCK) && defined(USE_CONTROLLER_REGISTRY)
   ControllerRegistry::notify_lock_update(this);
@@ -49,10 +49,10 @@ void Lock::publish_state(LockState state) {
 }
 
 void LockCall::perform() {
-  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+  ESP_LOGV(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
   this->validate_();
   if (this->state_.has_value()) {
-    ESP_LOGD(TAG, "  State: %s", LOG_STR_ARG(lock_state_to_string(*this->state_)));
+    ESP_LOGV(TAG, "  State: %s", LOG_STR_ARG(lock_state_to_string(*this->state_)));
   }
   this->parent_->control(*this);
 }
diff --git a/esphome/components/media_player/media_player.cpp b/esphome/components/media_player/media_player.cpp
index 70086089ff..a0eb7b5500 100644
--- a/esphome/components/media_player/media_player.cpp
+++ b/esphome/components/media_player/media_player.cpp
@@ -110,20 +110,20 @@ void MediaPlayerCall::validate_() {
 }
 
 void MediaPlayerCall::perform() {
-  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+  ESP_LOGV(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
   this->validate_();
   if (this->command_.has_value()) {
     const char *command_s = media_player_command_to_string(this->command_.value());
-    ESP_LOGD(TAG, "  Command: %s", command_s);
+    ESP_LOGV(TAG, "  Command: %s", command_s);
   }
   if (this->media_url_.has_value()) {
-    ESP_LOGD(TAG, "  Media URL: %s", this->media_url_.value().c_str());
+    ESP_LOGV(TAG, "  Media URL: %s", this->media_url_.value().c_str());
   }
   if (this->volume_.has_value()) {
-    ESP_LOGD(TAG, "  Volume: %.2f", this->volume_.value());
+    ESP_LOGV(TAG, "  Volume: %.2f", this->volume_.value());
   }
   if (this->announcement_.has_value()) {
-    ESP_LOGD(TAG, " Announcement: %s", this->announcement_.value() ? "yes" : "no");
+    ESP_LOGV(TAG, " Announcement: %s", this->announcement_.value() ? "yes" : "no");
   }
   this->parent_->control(*this);
 }
diff --git a/esphome/components/number/number.cpp b/esphome/components/number/number.cpp
index fb5d6e9f28..ca5aab6469 100644
--- a/esphome/components/number/number.cpp
+++ b/esphome/components/number/number.cpp
@@ -22,7 +22,7 @@ void log_number(const char *tag, const char *prefix, const char *type, Number *o
 void Number::publish_state(float state) {
   this->set_has_state(true);
   this->state = state;
-  ESP_LOGD(TAG, "'%s' >> %.2f", this->get_name().c_str(), state);
+  ESP_LOGV(TAG, "'%s' >> %.2f", this->get_name().c_str(), state);
   this->state_callback_.call(state);
 #if defined(USE_NUMBER) && defined(USE_CONTROLLER_REGISTRY)
   ControllerRegistry::notify_number_update(this);
diff --git a/esphome/components/number/number_call.cpp b/esphome/components/number/number_call.cpp
index aac9b2a23d..e300ca72de 100644
--- a/esphome/components/number/number_call.cpp
+++ b/esphome/components/number/number_call.cpp
@@ -61,7 +61,7 @@ void NumberCall::perform() {
   float max_value = traits.get_max_value();
 
   if (this->operation_ == NUMBER_OP_SET) {
-    ESP_LOGD(TAG, "'%s': Setting value", name);
+    ESP_LOGV(TAG, "'%s': Setting value", name);
     if (!this->value_.has_value() || std::isnan(*this->value_)) {
       this->log_perform_warning_(LOG_STR("No value"));
       return;
@@ -80,7 +80,7 @@ void NumberCall::perform() {
       target_value = max_value;
     }
   } else if (this->operation_ == NUMBER_OP_INCREMENT) {
-    ESP_LOGD(TAG, "'%s': Increment with%s cycling", name, this->cycle_ ? LOG_STR_LITERAL("") : LOG_STR_LITERAL("out"));
+    ESP_LOGV(TAG, "'%s': Increment with%s cycling", name, this->cycle_ ? LOG_STR_LITERAL("") : LOG_STR_LITERAL("out"));
     if (!parent->has_state()) {
       this->log_perform_warning_(LOG_STR("Can't increment, no state"));
       return;
@@ -90,7 +90,7 @@ void NumberCall::perform() {
     if (target_value > max_value)
       target_value = this->cycle_or_clamp_(max_value, min_value);
   } else if (this->operation_ == NUMBER_OP_DECREMENT) {
-    ESP_LOGD(TAG, "'%s': Decrement with%s cycling", name, this->cycle_ ? LOG_STR_LITERAL("") : LOG_STR_LITERAL("out"));
+    ESP_LOGV(TAG, "'%s': Decrement with%s cycling", name, this->cycle_ ? LOG_STR_LITERAL("") : LOG_STR_LITERAL("out"));
     if (!parent->has_state()) {
       this->log_perform_warning_(LOG_STR("Can't decrement, no state"));
       return;
@@ -110,7 +110,7 @@ void NumberCall::perform() {
     return;
   }
 
-  ESP_LOGD(TAG, "  New value: %f", target_value);
+  ESP_LOGV(TAG, "  New value: %f", target_value);
   this->parent_->control(target_value);
 }
 
diff --git a/esphome/components/pcf85063/pcf85063.cpp b/esphome/components/pcf85063/pcf85063.cpp
index 03ed78654f..1cf28a4955 100644
--- a/esphome/components/pcf85063/pcf85063.cpp
+++ b/esphome/components/pcf85063/pcf85063.cpp
@@ -40,11 +40,8 @@ void PCF85063Component::read_time() {
       .hour = uint8_t(pcf85063_.reg.hour + 10u * pcf85063_.reg.hour_10),
       .day_of_week = uint8_t(pcf85063_.reg.weekday),
       .day_of_month = uint8_t(pcf85063_.reg.day + 10u * pcf85063_.reg.day_10),
-      .day_of_year = 1,  // ignored by recalc_timestamp_utc(false)
       .month = uint8_t(pcf85063_.reg.month + 10u * pcf85063_.reg.month_10),
       .year = uint16_t(pcf85063_.reg.year + 10u * pcf85063_.reg.year_10 + 2000),
-      .is_dst = false,  // not used
-      .timestamp = 0,   // overwritten by recalc_timestamp_utc(false)
   };
   rtc_time.recalc_timestamp_utc(false);
   if (!rtc_time.is_valid()) {
diff --git a/esphome/components/pcf8563/pcf8563.cpp b/esphome/components/pcf8563/pcf8563.cpp
index dc68807aef..b748f0156a 100644
--- a/esphome/components/pcf8563/pcf8563.cpp
+++ b/esphome/components/pcf8563/pcf8563.cpp
@@ -40,11 +40,8 @@ void PCF8563Component::read_time() {
       .hour = uint8_t(pcf8563_.reg.hour + 10u * pcf8563_.reg.hour_10),
       .day_of_week = uint8_t(pcf8563_.reg.weekday),
       .day_of_month = uint8_t(pcf8563_.reg.day + 10u * pcf8563_.reg.day_10),
-      .day_of_year = 1,  // ignored by recalc_timestamp_utc(false)
       .month = uint8_t(pcf8563_.reg.month + 10u * pcf8563_.reg.month_10),
       .year = uint16_t(pcf8563_.reg.year + 10u * pcf8563_.reg.year_10 + 2000),
-      .is_dst = false,  // not used
-      .timestamp = 0,   // overwritten by recalc_timestamp_utc(false)
   };
   rtc_time.recalc_timestamp_utc(false);
   if (!rtc_time.is_valid()) {
diff --git a/esphome/components/rx8130/rx8130.cpp b/esphome/components/rx8130/rx8130.cpp
index 07ed7acc56..3b704d2551 100644
--- a/esphome/components/rx8130/rx8130.cpp
+++ b/esphome/components/rx8130/rx8130.cpp
@@ -77,11 +77,8 @@ void RX8130Component::read_time() {
       .hour = bcd2dec(date[2] & 0x3f),
       .day_of_week = static_cast<uint8_t>((date[3] & 0x7f) ? __builtin_ctz(date[3] & 0x7f) + 1 : 1),
       .day_of_month = bcd2dec(date[4] & 0x3f),
-      .day_of_year = 1,  // ignored by recalc_timestamp_utc(false)
       .month = bcd2dec(date[5] & 0x1f),
       .year = static_cast<uint16_t>(bcd2dec(date[6]) + 2000),
-      .is_dst = false,  // not used
-      .timestamp = 0    // overwritten by recalc_timestamp_utc(false)
   };
   rtc_time.recalc_timestamp_utc(false);
   if (!rtc_time.is_valid()) {
diff --git a/esphome/components/select/select.cpp b/esphome/components/select/select.cpp
index df90c657e2..7c3dab15ad 100644
--- a/esphome/components/select/select.cpp
+++ b/esphome/components/select/select.cpp
@@ -31,7 +31,7 @@ void Select::publish_state(size_t index) {
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   this->state = option;  // Update deprecated member for backward compatibility
 #pragma GCC diagnostic pop
-  ESP_LOGD(TAG, "'%s' >> %s (%zu)", this->get_name().c_str(), option, index);
+  ESP_LOGV(TAG, "'%s' >> %s (%zu)", this->get_name().c_str(), option, index);
   this->state_callback_.call(index);
 #if defined(USE_SELECT) && defined(USE_CONTROLLER_REGISTRY)
   ControllerRegistry::notify_select_update(this);
diff --git a/esphome/components/select/select_call.cpp b/esphome/components/select/select_call.cpp
index 83f5052fc8..0e14371d00 100644
--- a/esphome/components/select/select_call.cpp
+++ b/esphome/components/select/select_call.cpp
@@ -64,7 +64,7 @@ optional<size_t> SelectCall::calculate_target_index_(const char *name) {
   }
 
   if (this->operation_ == SELECT_OP_SET) {
-    ESP_LOGD(TAG, "'%s' - Setting", name);
+    ESP_LOGV(TAG, "'%s' - Setting", name);
     if (!this->index_.has_value()) {
       ESP_LOGW(TAG, "'%s' - No option set", name);
       return nullopt;
@@ -73,7 +73,7 @@ optional<size_t> SelectCall::calculate_target_index_(const char *name) {
   }
 
   // SELECT_OP_NEXT or SELECT_OP_PREVIOUS
-  ESP_LOGD(TAG, "'%s' - Selecting %s, with%s cycling", name,
+  ESP_LOGV(TAG, "'%s' - Selecting %s, with%s cycling", name,
            this->operation_ == SELECT_OP_NEXT ? LOG_STR_LITERAL("next") : LOG_STR_LITERAL("previous"),
            this->cycle_ ? LOG_STR_LITERAL("") : LOG_STR_LITERAL("out"));
 
diff --git a/esphome/components/sensor/sensor.cpp b/esphome/components/sensor/sensor.cpp
index aad7f86dcf..59e011932b 100644
--- a/esphome/components/sensor/sensor.cpp
+++ b/esphome/components/sensor/sensor.cpp
@@ -122,7 +122,7 @@ void Sensor::clear_filters() {
 void Sensor::internal_send_state_to_frontend(float state) {
   this->set_has_state(true);
   this->state = state;
-  ESP_LOGD(TAG, "'%s' >> %.*f %s", this->get_name().c_str(), std::max(0, (int) this->get_accuracy_decimals()), state,
+  ESP_LOGV(TAG, "'%s' >> %.*f %s", this->get_name().c_str(), std::max(0, (int) this->get_accuracy_decimals()), state,
            this->get_unit_of_measurement_ref().c_str());
   this->callback_.call(state);
 #if defined(USE_SENSOR) && defined(USE_CONTROLLER_REGISTRY)
diff --git a/esphome/components/switch/switch.cpp b/esphome/components/switch/switch.cpp
index df762addbb..11840db3a3 100644
--- a/esphome/components/switch/switch.cpp
+++ b/esphome/components/switch/switch.cpp
@@ -61,7 +61,7 @@ void Switch::publish_state(bool state) {
   if (restore_mode & RESTORE_MODE_PERSISTENT_MASK)
     this->rtc_.save(&this->state);
 
-  ESP_LOGD(TAG, "'%s' >> %s", this->name_.c_str(), ONOFF(this->state));
+  ESP_LOGV(TAG, "'%s' >> %s", this->name_.c_str(), ONOFF(this->state));
   this->state_callback_.call(this->state);
 #if defined(USE_SWITCH) && defined(USE_CONTROLLER_REGISTRY)
   ControllerRegistry::notify_switch_update(this);
diff --git a/esphome/components/text/text.cpp b/esphome/components/text/text.cpp
index 12abc5d939..032ea468e6 100644
--- a/esphome/components/text/text.cpp
+++ b/esphome/components/text/text.cpp
@@ -19,9 +19,9 @@ void Text::publish_state(const char *state, size_t len) {
     this->state.assign(state, len);
   }
   if (this->traits.get_mode() == TEXT_MODE_PASSWORD) {
-    ESP_LOGD(TAG, "'%s' >> " LOG_SECRET("'%s'"), this->get_name().c_str(), this->state.c_str());
+    ESP_LOGV(TAG, "'%s' >> " LOG_SECRET("'%s'"), this->get_name().c_str(), this->state.c_str());
   } else {
-    ESP_LOGD(TAG, "'%s' >> '%s'", this->get_name().c_str(), this->state.c_str());
+    ESP_LOGV(TAG, "'%s' >> '%s'", this->get_name().c_str(), this->state.c_str());
   }
   this->state_callback_.call(this->state);
 #if defined(USE_TEXT) && defined(USE_CONTROLLER_REGISTRY)
diff --git a/esphome/components/text/text_call.cpp b/esphome/components/text/text_call.cpp
index b7aed098c7..b7692658af 100644
--- a/esphome/components/text/text_call.cpp
+++ b/esphome/components/text/text_call.cpp
@@ -48,10 +48,10 @@ void TextCall::perform() {
   std::string target_value = this->value_.value();
 
   if (this->parent_->traits.get_mode() == TEXT_MODE_PASSWORD) {
-    ESP_LOGD(TAG, "'%s' - Setting password value: " LOG_SECRET("'%s'"), this->parent_->get_name().c_str(),
+    ESP_LOGV(TAG, "'%s' - Setting password value: " LOG_SECRET("'%s'"), this->parent_->get_name().c_str(),
              target_value.c_str());
   } else {
-    ESP_LOGD(TAG, "'%s' - Setting text value: %s", this->parent_->get_name().c_str(), target_value.c_str());
+    ESP_LOGV(TAG, "'%s' - Setting text value: %s", this->parent_->get_name().c_str(), target_value.c_str());
   }
   this->parent_->control(target_value);
 }
diff --git a/esphome/components/text_sensor/text_sensor.cpp b/esphome/components/text_sensor/text_sensor.cpp
index 0dc29f9a94..31543117b8 100644
--- a/esphome/components/text_sensor/text_sensor.cpp
+++ b/esphome/components/text_sensor/text_sensor.cpp
@@ -112,7 +112,7 @@ void TextSensor::internal_send_state_to_frontend(const char *state, size_t len)
 
 void TextSensor::notify_frontend_() {
   this->set_has_state(true);
-  ESP_LOGD(TAG, "'%s' >> '%s'", this->name_.c_str(), this->state.c_str());
+  ESP_LOGV(TAG, "'%s' >> '%s'", this->name_.c_str(), this->state.c_str());
   this->callback_.call(this->state);
 #if defined(USE_TEXT_SENSOR) && defined(USE_CONTROLLER_REGISTRY)
   ControllerRegistry::notify_text_sensor_update(this);
diff --git a/esphome/components/update/update_entity.cpp b/esphome/components/update/update_entity.cpp
index 7edea2fe22..1a5a55577f 100644
--- a/esphome/components/update/update_entity.cpp
+++ b/esphome/components/update/update_entity.cpp
@@ -18,28 +18,28 @@ const LogString *update_state_to_string(UpdateState state) {
 }
 
 void UpdateEntity::publish_state() {
-  ESP_LOGD(TAG,
+  ESP_LOGV(TAG,
            "'%s' >>\n"
            "  Current Version: %s",
            this->name_.c_str(), this->update_info_.current_version.c_str());
 
   if (!this->update_info_.md5.empty()) {
-    ESP_LOGD(TAG, "  Latest Version: %s", this->update_info_.latest_version.c_str());
+    ESP_LOGV(TAG, "  Latest Version: %s", this->update_info_.latest_version.c_str());
   }
   if (!this->update_info_.firmware_url.empty()) {
-    ESP_LOGD(TAG, "  Firmware URL: %s", this->update_info_.firmware_url.c_str());
+    ESP_LOGV(TAG, "  Firmware URL: %s", this->update_info_.firmware_url.c_str());
   }
 
-  ESP_LOGD(TAG, "  Title: %s", this->update_info_.title.c_str());
+  ESP_LOGV(TAG, "  Title: %s", this->update_info_.title.c_str());
   if (!this->update_info_.summary.empty()) {
-    ESP_LOGD(TAG, "  Summary: %s", this->update_info_.summary.c_str());
+    ESP_LOGV(TAG, "  Summary: %s", this->update_info_.summary.c_str());
   }
   if (!this->update_info_.release_url.empty()) {
-    ESP_LOGD(TAG, "  Release URL: %s", this->update_info_.release_url.c_str());
+    ESP_LOGV(TAG, "  Release URL: %s", this->update_info_.release_url.c_str());
   }
 
   if (this->update_info_.has_progress) {
-    ESP_LOGD(TAG, "  Progress: %.0f%%", this->update_info_.progress);
+    ESP_LOGV(TAG, "  Progress: %.0f%%", this->update_info_.progress);
   }
 
   this->set_has_state(true);
diff --git a/esphome/components/valve/valve.cpp b/esphome/components/valve/valve.cpp
index 636da1f3c3..9e1ef9da50 100644
--- a/esphome/components/valve/valve.cpp
+++ b/esphome/components/valve/valve.cpp
@@ -68,21 +68,21 @@ ValveCall &ValveCall::set_position(float position) {
   return *this;
 }
 void ValveCall::perform() {
-  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+  ESP_LOGV(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
   auto traits = this->parent_->get_traits();
   this->validate_();
   if (this->stop_) {
-    ESP_LOGD(TAG, "  Command: STOP");
+    ESP_LOGV(TAG, "  Command: STOP");
   }
   if (this->position_.has_value()) {
     if (traits.get_supports_position()) {
-      ESP_LOGD(TAG, "  Position: %.0f%%", *this->position_ * 100.0f);
+      ESP_LOGV(TAG, "  Position: %.0f%%", *this->position_ * 100.0f);
     } else {
-      ESP_LOGD(TAG, "  Command: %s", LOG_STR_ARG(valve_command_to_str(*this->position_)));
+      ESP_LOGV(TAG, "  Command: %s", LOG_STR_ARG(valve_command_to_str(*this->position_)));
     }
   }
   if (this->toggle_.has_value()) {
-    ESP_LOGD(TAG, "  Command: TOGGLE");
+    ESP_LOGV(TAG, "  Command: TOGGLE");
   }
   this->parent_->control(*this);
 }
@@ -128,20 +128,20 @@ ValveCall Valve::make_call() { return {this}; }
 void Valve::publish_state(bool save) {
   this->position = clamp(this->position, 0.0f, 1.0f);
 
-  ESP_LOGD(TAG, "'%s' >>", this->name_.c_str());
+  ESP_LOGV(TAG, "'%s' >>", this->name_.c_str());
   auto traits = this->get_traits();
   if (traits.get_supports_position()) {
-    ESP_LOGD(TAG, "  Position: %.0f%%", this->position * 100.0f);
+    ESP_LOGV(TAG, "  Position: %.0f%%", this->position * 100.0f);
   } else {
     if (this->position == VALVE_OPEN) {
-      ESP_LOGD(TAG, "  State: OPEN");
+      ESP_LOGV(TAG, "  State: OPEN");
     } else if (this->position == VALVE_CLOSED) {
-      ESP_LOGD(TAG, "  State: CLOSED");
+      ESP_LOGV(TAG, "  State: CLOSED");
     } else {
-      ESP_LOGD(TAG, "  State: UNKNOWN");
+      ESP_LOGV(TAG, "  State: UNKNOWN");
     }
   }
-  ESP_LOGD(TAG, "  Current Operation: %s", LOG_STR_ARG(valve_operation_to_str(this->current_operation)));
+  ESP_LOGV(TAG, "  Current Operation: %s", LOG_STR_ARG(valve_operation_to_str(this->current_operation)));
 
   this->state_callback_.call();
 #if defined(USE_VALVE) && defined(USE_CONTROLLER_REGISTRY)
diff --git a/esphome/components/water_heater/water_heater.cpp b/esphome/components/water_heater/water_heater.cpp
index 3989230d2d..9a74877f0a 100644
--- a/esphome/components/water_heater/water_heater.cpp
+++ b/esphome/components/water_heater/water_heater.cpp
@@ -83,25 +83,25 @@ WaterHeaterCall &WaterHeaterCall::set_on(bool on) {
 }
 
 void WaterHeaterCall::perform() {
-  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+  ESP_LOGV(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
   this->validate_();
   if (this->mode_.has_value()) {
-    ESP_LOGD(TAG, "  Mode: %s", LOG_STR_ARG(water_heater_mode_to_string(*this->mode_)));
+    ESP_LOGV(TAG, "  Mode: %s", LOG_STR_ARG(water_heater_mode_to_string(*this->mode_)));
   }
   if (!std::isnan(this->target_temperature_)) {
-    ESP_LOGD(TAG, "  Target Temperature: %.2f", this->target_temperature_);
+    ESP_LOGV(TAG, "  Target Temperature: %.2f", this->target_temperature_);
   }
   if (!std::isnan(this->target_temperature_low_)) {
-    ESP_LOGD(TAG, "  Target Temperature Low: %.2f", this->target_temperature_low_);
+    ESP_LOGV(TAG, "  Target Temperature Low: %.2f", this->target_temperature_low_);
   }
   if (!std::isnan(this->target_temperature_high_)) {
-    ESP_LOGD(TAG, "  Target Temperature High: %.2f", this->target_temperature_high_);
+    ESP_LOGV(TAG, "  Target Temperature High: %.2f", this->target_temperature_high_);
   }
   if (this->state_mask_ & WATER_HEATER_STATE_AWAY) {
-    ESP_LOGD(TAG, "  Away: %s", (this->state_ & WATER_HEATER_STATE_AWAY) ? "YES" : "NO");
+    ESP_LOGV(TAG, "  Away: %s", (this->state_ & WATER_HEATER_STATE_AWAY) ? "YES" : "NO");
   }
   if (this->state_mask_ & WATER_HEATER_STATE_ON) {
-    ESP_LOGD(TAG, "  On: %s", (this->state_ & WATER_HEATER_STATE_ON) ? "YES" : "NO");
+    ESP_LOGV(TAG, "  On: %s", (this->state_ & WATER_HEATER_STATE_ON) ? "YES" : "NO");
   }
   this->parent_->control(*this);
 }
@@ -158,24 +158,24 @@ void WaterHeaterCall::validate_() {
 
 void WaterHeater::publish_state() {
   auto traits = this->get_traits();
-  ESP_LOGD(TAG,
+  ESP_LOGV(TAG,
            "'%s' >>\n"
            "  Mode: %s",
            this->name_.c_str(), LOG_STR_ARG(water_heater_mode_to_string(this->mode_)));
   if (!std::isnan(this->current_temperature_)) {
-    ESP_LOGD(TAG, "  Current Temperature: %.2f°C", this->current_temperature_);
+    ESP_LOGV(TAG, "  Current Temperature: %.2f°C", this->current_temperature_);
   }
   if (traits.get_supports_two_point_target_temperature()) {
-    ESP_LOGD(TAG, "  Target Temperature: Low: %.2f°C High: %.2f°C", this->target_temperature_low_,
+    ESP_LOGV(TAG, "  Target Temperature: Low: %.2f°C High: %.2f°C", this->target_temperature_low_,
              this->target_temperature_high_);
   } else if (!std::isnan(this->target_temperature_)) {
-    ESP_LOGD(TAG, "  Target Temperature: %.2f°C", this->target_temperature_);
+    ESP_LOGV(TAG, "  Target Temperature: %.2f°C", this->target_temperature_);
   }
   if (this->state_ & WATER_HEATER_STATE_AWAY) {
-    ESP_LOGD(TAG, "  Away: YES");
+    ESP_LOGV(TAG, "  Away: YES");
   }
   if (traits.has_feature_flags(WATER_HEATER_SUPPORTS_ON_OFF)) {
-    ESP_LOGD(TAG, "  On: %s", (this->state_ & WATER_HEATER_STATE_ON) ? "YES" : "NO");
+    ESP_LOGV(TAG, "  On: %s", (this->state_ & WATER_HEATER_STATE_ON) ? "YES" : "NO");
   }
 
 #if defined(USE_WATER_HEATER) && defined(USE_CONTROLLER_REGISTRY)
diff --git a/esphome/components/wifi/wifi_component.cpp b/esphome/components/wifi/wifi_component.cpp
index a93016b3d6..f58a9b4a46 100644
--- a/esphome/components/wifi/wifi_component.cpp
+++ b/esphome/components/wifi/wifi_component.cpp
@@ -2223,6 +2223,14 @@ bool WiFiComponent::load_fast_connect_settings_(WiFiAP &params) {
     params.set_hidden(false);
 
     ESP_LOGD(TAG, "Loaded fast_connect settings");
+#if defined(USE_ESP32) && defined(SOC_WIFI_SUPPORT_5G)
+    if ((this->band_mode_ == WIFI_BAND_MODE_5G_ONLY && fast_connect_save.channel < FIRST_5GHZ_CHANNEL) ||
+        (this->band_mode_ == WIFI_BAND_MODE_2G_ONLY && fast_connect_save.channel >= FIRST_5GHZ_CHANNEL)) {
+      ESP_LOGW(TAG, "Saved channel %u not allowed by band mode, ignoring fast_connect", fast_connect_save.channel);
+      this->selected_sta_index_ = -1;
+      return false;
+    }
+#endif
     return true;
   }
 
diff --git a/esphome/components/wifi/wifi_component.h b/esphome/components/wifi/wifi_component.h
index 99b23436f7..55e532c37d 100644
--- a/esphome/components/wifi/wifi_component.h
+++ b/esphome/components/wifi/wifi_component.h
@@ -774,6 +774,8 @@ class WiFiComponent final : public Component {
   SemaphoreHandle_t high_performance_semaphore_{nullptr};
 #endif
 
+  static constexpr uint8_t FIRST_5GHZ_CHANNEL = 36;
+
   // Post-connect roaming constants
   static constexpr uint32_t ROAMING_CHECK_INTERVAL = 5 * 60 * 1000;  // 5 minutes
   static constexpr int8_t ROAMING_MIN_IMPROVEMENT = 10;              // dB
diff --git a/esphome/components/wifi/wifi_component_esp_idf.cpp b/esphome/components/wifi/wifi_component_esp_idf.cpp
index ae1d2160a6..4ddaea4c94 100644
--- a/esphome/components/wifi/wifi_component_esp_idf.cpp
+++ b/esphome/components/wifi/wifi_component_esp_idf.cpp
@@ -987,6 +987,11 @@ bool WiFiComponent::wifi_scan_start_(bool passive) {
     config.scan_time.active.min = 100;
     config.scan_time.active.max = 300;
   }
+  // When scanning while connected (roaming), return to home channel between
+  // each scanned channel to maintain the connection (helps with BLE/WiFi coexistence)
+  if (this->roaming_state_ == RoamingState::SCANNING) {
+    config.coex_background_scan = true;
+  }
 
   esp_err_t err = esp_wifi_scan_start(&config, false);
   if (err != ESP_OK) {
diff --git a/esphome/core/time.cpp b/esphome/core/time.cpp
index 6add82e7d1..650c61d37b 100644
--- a/esphome/core/time.cpp
+++ b/esphome/core/time.cpp
@@ -231,7 +231,7 @@ void ESPTime::increment_day() {
 
 void ESPTime::recalc_timestamp_utc(bool use_day_of_year) {
   time_t res = 0;
-  if (!this->fields_in_range()) {
+  if (!this->fields_in_range(false, use_day_of_year)) {
     this->timestamp = -1;
     return;
   }
diff --git a/esphome/core/time.h b/esphome/core/time.h
index 1716c51ffd..ed47432038 100644
--- a/esphome/core/time.h
+++ b/esphome/core/time.h
@@ -79,11 +79,19 @@ struct ESPTime {
   /// Check if this ESPTime is valid (all fields in range and year is greater than or equal to 2019)
   bool is_valid() const { return this->year >= 2019 && this->fields_in_range(); }
 
-  /// Check if all time fields of this ESPTime are in range.
-  bool fields_in_range() const {
-    return this->second < 61 && this->minute < 60 && this->hour < 24 && this->day_of_week > 0 &&
-           this->day_of_week < 8 && this->day_of_year > 0 && this->day_of_year < 367 && this->month > 0 &&
-           this->month < 13 && this->day_of_month > 0 && this->day_of_month <= days_in_month(this->month, this->year);
+  /// Check if time fields are in range.
+  /// @param check_day_of_week validate day_of_week (not always available when constructing from date/time fields)
+  /// @param check_day_of_year validate day_of_year (not always available when constructing from date/time fields)
+  bool fields_in_range(bool check_day_of_week = true, bool check_day_of_year = true) const {
+    bool valid = this->second < 61 && this->minute < 60 && this->hour < 24 && this->month > 0 && this->month < 13 &&
+                 this->day_of_month > 0 && this->day_of_month <= days_in_month(this->month, this->year);
+    if (check_day_of_week) {
+      valid = valid && this->day_of_week > 0 && this->day_of_week < 8;
+    }
+    if (check_day_of_year) {
+      valid = valid && this->day_of_year > 0 && this->day_of_year < 367;
+    }
+    return valid;
   }
 
   /** Convert a string to ESPTime struct as specified by the format argument.
diff --git a/esphome/writer.py b/esphome/writer.py
index 69a35d00e3..4aac16ffd4 100644
--- a/esphome/writer.py
+++ b/esphome/writer.py
@@ -18,7 +18,6 @@ from esphome.core import CORE, EsphomeError
 from esphome.helpers import (
     copy_file_if_changed,
     cpp_string_escape,
-    get_str_env,
     is_ha_addon,
     read_file,
     rmtree,
@@ -441,18 +440,42 @@ def clean_build(clear_pio_cache: bool = True):
             rmtree(cache_dir)
 
 
+def _get_custom_build_dir(item: Path, data_dir: Path) -> Path | None:
+    """Parse a YAML config to find a custom build directory."""
+    from esphome import yaml_util
+
+    try:
+        raw = yaml_util.load_yaml(item)
+    except (EsphomeError, OSError) as e:
+        _LOGGER.debug("Could not parse %s to find build_path: %s", item, e)
+        return None
+    if not isinstance(raw, dict):
+        return None
+    esphome_conf = raw.get("esphome", {})
+    if not isinstance(esphome_conf, dict):
+        return None
+    if build_path := esphome_conf.get("build_path"):
+        return data_dir / build_path
+    return None
+
+
 def clean_all(configuration: list[str]):
     data_dirs = []
     for config in configuration:
         item = Path(config)
         if item.is_file() and item.suffix in (".yaml", ".yml"):
-            data_dirs.append(item.parent / ".esphome")
+            data_dir = item.parent / ".esphome"
+            data_dirs.append(data_dir)
+            if custom := _get_custom_build_dir(item, data_dir):
+                data_dirs.append(custom)
         else:
             data_dirs.append(item / ".esphome")
     if is_ha_addon():
         data_dirs.append(Path("/data"))
-    if "ESPHOME_DATA_DIR" in os.environ:
-        data_dirs.append(Path(get_str_env("ESPHOME_DATA_DIR", None)))
+    if env_data_dir := os.environ.get("ESPHOME_DATA_DIR"):
+        data_dirs.append(Path(env_data_dir))
+    if env_build_path := os.environ.get("ESPHOME_BUILD_PATH"):
+        data_dirs.append(Path(env_build_path))
 
     # Clean build dir
     for dir in data_dirs:
diff --git a/tests/components/time/posix_tz_parser.cpp b/tests/components/time/posix_tz_parser.cpp
index 2748011bdd..1976a0bfa6 100644
--- a/tests/components/time/posix_tz_parser.cpp
+++ b/tests/components/time/posix_tz_parser.cpp
@@ -593,8 +593,6 @@ static time_t esptime_recalc_local(int year, int month, int day, int hour, int m
   t.hour = hour;
   t.minute = min;
   t.second = sec;
-  t.day_of_week = 1;  // Placeholder for fields_in_range()
-  t.day_of_year = 1;
   t.recalc_timestamp_local();
   return t.timestamp;
 }
@@ -750,6 +748,60 @@ TEST(RecalcTimestampLocal, NonDefaultTransitionTime) {
   EXPECT_EQ(esp_result, libc_result);
 }
 
+TEST(RecalcTimestampLocal, MinimalFieldsWithoutDayOfWeekOrYear) {
+  // Regression test for issue #15115: DateTimeEntity::state_as_esptime() constructs
+  // an ESPTime with only year/month/day/hour/minute/second set (no day_of_week or
+  // day_of_year). recalc_timestamp_local() must work without those fields.
+  const char *tz_str = "CET-1CEST,M3.5.0,M10.5.0";
+  setenv("TZ", tz_str, 1);
+  tzset();
+  time::ParsedTimezone tz{};
+  ASSERT_TRUE(parse_posix_tz(tz_str, tz));
+  set_global_tz(tz);
+
+  // Construct ESPTime with only date/time fields (like state_as_esptime does)
+  ESPTime t{};
+  t.year = 2026;
+  t.month = 3;
+  t.day_of_month = 20;
+  t.hour = 23;
+  t.minute = 14;
+  t.second = 55;
+  // day_of_week and day_of_year are deliberately left as 0
+  t.recalc_timestamp_local();
+
+  // Must NOT return -1 (the bug: fields_in_range() rejected valid times)
+  EXPECT_NE(t.timestamp, -1);
+
+  // Verify against libc
+  time_t libc_result = libc_mktime(2026, 3, 20, 23, 14, 55);
+  EXPECT_EQ(t.timestamp, libc_result);
+}
+
+TEST(RecalcTimestampLocal, MinimalFieldsNoDST) {
+  // Same test but with a timezone that has no DST
+  const char *tz_str = "IST-5:30";
+  setenv("TZ", tz_str, 1);
+  tzset();
+  time::ParsedTimezone tz{};
+  ASSERT_TRUE(parse_posix_tz(tz_str, tz));
+  set_global_tz(tz);
+
+  ESPTime t{};
+  t.year = 2026;
+  t.month = 3;
+  t.day_of_month = 23;
+  t.hour = 10;
+  t.minute = 0;
+  t.second = 0;
+  t.recalc_timestamp_local();
+
+  EXPECT_NE(t.timestamp, -1);
+
+  time_t libc_result = libc_mktime(2026, 3, 23, 10, 0, 0);
+  EXPECT_EQ(t.timestamp, libc_result);
+}
+
 TEST(RecalcTimestampLocal, YearBoundaryDST) {
   // Test southern hemisphere DST across year boundary
   // Australia/Sydney: DST active from October to April (spans Jan 1)
diff --git a/tests/unit_tests/test_writer.py b/tests/unit_tests/test_writer.py
index 884dddbc96..0c86a3193e 100644
--- a/tests/unit_tests/test_writer.py
+++ b/tests/unit_tests/test_writer.py
@@ -867,6 +867,130 @@ def test_clean_all_with_yaml_file(
     assert str(build_dir) in caplog.text
 
 
+@patch("esphome.writer.CORE")
+def test_clean_all_with_yaml_build_path(
+    mock_core: MagicMock,
+    tmp_path: Path,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test clean_all cleans absolute build_path specified in YAML config."""
+    config_dir = tmp_path / "config"
+    config_dir.mkdir()
+
+    # Create an absolute custom build path directory with contents
+    custom_build = tmp_path / "custom_build"
+    custom_build.mkdir()
+    (custom_build / "firmware.bin").write_text("x")
+    sub = custom_build / "subdir"
+    sub.mkdir()
+    (sub / "file.txt").write_text("x")
+
+    yaml_file = config_dir / "test.yaml"
+    # Absolute build_path: data_dir / absolute = absolute (Python Path behavior)
+    yaml_file.write_text(f"esphome:\n  name: test\n  build_path: {custom_build}\n")
+
+    # Also create the normal .esphome dir
+    build_dir = config_dir / ".esphome"
+    build_dir.mkdir()
+    (build_dir / "dummy.txt").write_text("x")
+
+    from esphome.writer import clean_all
+
+    with caplog.at_level("INFO"):
+        clean_all([str(yaml_file)])
+
+    # Both .esphome and custom build_path should be cleaned
+    assert build_dir.exists()
+    assert not (build_dir / "dummy.txt").exists()
+    assert custom_build.exists()
+    assert not (custom_build / "firmware.bin").exists()
+    assert not sub.exists()
+
+
+@patch("esphome.writer.CORE")
+def test_clean_all_with_yaml_parse_error(
+    mock_core: MagicMock,
+    tmp_path: Path,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test clean_all still cleans .esphome when YAML parse fails."""
+    config_dir = tmp_path / "config"
+    config_dir.mkdir()
+    yaml_file = config_dir / "test.yaml"
+    yaml_file.write_text("invalid: yaml: content: [")
+
+    build_dir = config_dir / ".esphome"
+    build_dir.mkdir()
+    (build_dir / "dummy.txt").write_text("x")
+
+    from esphome.writer import clean_all
+
+    with caplog.at_level("INFO"):
+        clean_all([str(yaml_file)])
+
+    # .esphome should still be cleaned despite YAML parse failure
+    assert build_dir.exists()
+    assert not (build_dir / "dummy.txt").exists()
+
+
+@patch("esphome.writer.CORE")
+def test_clean_all_with_env_build_path(
+    mock_core: MagicMock,
+    tmp_path: Path,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test clean_all cleans ESPHOME_BUILD_PATH directory."""
+    config_dir = tmp_path / "config"
+    config_dir.mkdir()
+
+    build_dir = config_dir / ".esphome"
+    build_dir.mkdir()
+    (build_dir / "dummy.txt").write_text("x")
+
+    # Create env build path directory
+    env_build = tmp_path / "env_build"
+    env_build.mkdir()
+    (env_build / "firmware.bin").write_text("x")
+
+    from esphome.writer import clean_all
+
+    with (
+        caplog.at_level("INFO"),
+        patch.dict(os.environ, {"ESPHOME_BUILD_PATH": str(env_build)}),
+    ):
+        clean_all([str(config_dir)])
+
+    # Both should be cleaned
+    assert not (build_dir / "dummy.txt").exists()
+    assert env_build.exists()
+    assert not (env_build / "firmware.bin").exists()
+
+
+@patch("esphome.writer.CORE")
+def test_clean_all_ignores_empty_env_vars(
+    mock_core: MagicMock,
+    tmp_path: Path,
+) -> None:
+    """Test clean_all ignores empty ESPHOME_BUILD_PATH/ESPHOME_DATA_DIR."""
+    config_dir = tmp_path / "config"
+    config_dir.mkdir()
+
+    # Create a file in cwd that must NOT be cleaned
+    marker = tmp_path / "important.txt"
+    marker.write_text("do not delete")
+
+    from esphome.writer import clean_all
+
+    with patch.dict(
+        os.environ,
+        {"ESPHOME_BUILD_PATH": "", "ESPHOME_DATA_DIR": ""},
+    ):
+        clean_all([str(config_dir)])
+
+    # Empty env vars must not cause cwd to be cleaned
+    assert marker.exists()
+
+
 @patch("esphome.writer.CORE")
 def test_clean_all(
     mock_core: MagicMock,