From 08ac61ae9424821ac868d817971313d1e8508394 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sat, 18 Apr 2026 06:58:54 -0500
Subject: [PATCH] [core] Feed WDT unconditionally in main loop to fix
 empty-config panic (#15830)

---
 esphome/core/application.h | 26 +++++++++++++++++---------
 esphome/core/scheduler.cpp |  5 ++++-
 esphome/core/scheduler.h   |  3 ++-
 3 files changed, 23 insertions(+), 11 deletions(-)

diff --git a/esphome/core/application.h b/esphome/core/application.h
index 60087d527d2..db8af735bd4 100644
--- a/esphome/core/application.h
+++ b/esphome/core/application.h
@@ -641,7 +641,7 @@ class Application {
   void enable_component_loop_(Component *component);
   void enable_pending_loops_();
   void activate_looping_component_(uint16_t index);
-  inline void ESPHOME_ALWAYS_INLINE before_loop_tasks_(uint32_t loop_start_time);
+  inline uint32_t ESPHOME_ALWAYS_INLINE before_loop_tasks_(uint32_t loop_start_time);
   inline void ESPHOME_ALWAYS_INLINE after_loop_tasks_() { this->in_loop_ = false; }
 
   /// Process dump_config output one component per loop iteration.
@@ -845,18 +845,15 @@ inline void Application::drain_wake_notifications_() {
 }
 #endif  // USE_HOST
 
-inline void ESPHOME_ALWAYS_INLINE Application::before_loop_tasks_(uint32_t loop_start_time) {
+inline uint32_t ESPHOME_ALWAYS_INLINE Application::before_loop_tasks_(uint32_t loop_start_time) {
 #ifdef USE_HOST
   // Drain wake notifications first to clear socket for next wake
   this->drain_wake_notifications_();
 #endif
 
-  // Process scheduled tasks. Scheduler::call now feeds the watchdog itself
-  // after each scheduled item that actually runs, so we no longer need an
-  // unconditional feed here — when Scheduler::call has no work to do, the
-  // only elapsed time is a sleep wake + a few instructions, and when it does
-  // have work, it fed the wdt as it went.
-  this->scheduler.call(loop_start_time);
+  // Scheduler::call feeds the WDT per item and returns the timestamp of the
+  // last fired item, or the input unchanged when nothing ran.
+  uint32_t last_op_end_time = this->scheduler.call(loop_start_time);
 
   // Process any pending enable_loop requests from ISRs
   // This must be done before marking in_loop_ = true to avoid race conditions
@@ -874,13 +871,24 @@ inline void ESPHOME_ALWAYS_INLINE Application::before_loop_tasks_(uint32_t loop_
 
   // Mark that we're in the loop for safe reentrant modifications
   this->in_loop_ = true;
+  return last_op_end_time;
 }
 
 inline void ESPHOME_ALWAYS_INLINE Application::loop() {
   // Get the initial loop time at the start
   uint32_t last_op_end_time = millis();
 
-  this->before_loop_tasks_(last_op_end_time);
+  // Returned timestamp keeps us monotonic with last_wdt_feed_ (advanced by
+  // the scheduler's per-item feeds) without an extra millis() call.
+  last_op_end_time = this->before_loop_tasks_(last_op_end_time);
+  // Guarantee a WDT touch every tick — covers configs with no looping
+  // components and no scheduler work, where the per-item / per-component
+  // feeds never fire. Rate-limited inline fast path, ~free when unneeded.
+  this->feed_wdt_with_time(last_op_end_time);
+#ifdef USE_RUNTIME_STATS
+  uint32_t loop_before_end_us = micros();
+  uint64_t loop_before_scheduled_us = ComponentRuntimeStats::global_recorded_us - loop_recorded_snap;
+#endif
 
   for (this->current_loop_index_ = 0; this->current_loop_index_ < this->looping_components_active_end_;
        this->current_loop_index_++) {
diff --git a/esphome/core/scheduler.cpp b/esphome/core/scheduler.cpp
index 7e6ad19ac70..b0eaa670ac2 100644
--- a/esphome/core/scheduler.cpp
+++ b/esphome/core/scheduler.cpp
@@ -533,7 +533,7 @@ void HOT Scheduler::process_defer_queue_slow_path_(uint32_t &now) {
 }
 #endif /* not ESPHOME_THREAD_SINGLE */
 
-void HOT Scheduler::call(uint32_t now) {
+uint32_t HOT Scheduler::call(uint32_t now) {
 #ifndef ESPHOME_THREAD_SINGLE
   this->process_defer_queue_(now);
 #endif /* not ESPHOME_THREAD_SINGLE */
@@ -703,6 +703,9 @@ void HOT Scheduler::call(uint32_t now) {
     this->debug_verify_no_leak_();
   }
 #endif
+  // execute_item_() advances `now` as items fire; return it so the caller
+  // stays monotonic with last_wdt_feed_.
+  return now;
 }
 void HOT Scheduler::process_to_add_slow_path_() {
   LockGuard guard{this->lock_};
diff --git a/esphome/core/scheduler.h b/esphome/core/scheduler.h
index 43a3ec7049b..00a7f269538 100644
--- a/esphome/core/scheduler.h
+++ b/esphome/core/scheduler.h
@@ -129,7 +129,8 @@ class Scheduler {
 
   // Execute all scheduled items that are ready
   // @param now Fresh timestamp from millis() - must not be stale/cached
-  void call(uint32_t now);
+  // @return Timestamp of the last item that ran, or `now` unchanged if none ran.
+  uint32_t call(uint32_t now);
 
   // Move items from to_add_ into the main heap.
   // IMPORTANT: This method should only be called from the main thread (loop task).