feat(control_plane): apply light standby hardware policy

components/platform/include/platform.h

@@ -301,6 +301,13 @@ esp_err_t platform_read_firmware_version(char *out, size_t out_len);
 esp_err_t platform_stepper_rotate_angle_with_accel_timeout(float angle,
                                                            int target_delay_us,
                                                            int timeout_ms);
+/**
+ * @brief Release stepper holding current with bounded lock acquisition.
+ *
+ * A negative timeout is invalid, zero is non-blocking, and a positive value
+ * bounds the wait for an in-progress movement to finish.
+ */
+esp_err_t platform_stepper_release_hold(int timeout_ms);
 void platform_stepper_power_off(void);
 
 typedef enum {
@@ -425,6 +432,13 @@ esp_err_t platform_multimodal_audio_start_uplink(
 esp_err_t platform_multimodal_audio_stop_uplink(int timeout_ms);
 bool platform_multimodal_audio_is_uplink_running(void);
 bool platform_multimodal_audio_is_initialized(void);
+/**
+ * @brief Gate the speaker power amplifier without stopping microphone capture.
+ *
+ * Disabling first mutes the codec output and then powers down the speaker PA.
+ * Enabling restores the PA while leaving output muted until playback resumes.
+ */
+esp_err_t platform_multimodal_audio_set_speaker_output_enabled(bool enabled);
 /**
  * @brief Register the single mono PCM observer for the active capture path.
  *

components/platform/internal/multimodal/audio_pipeline.h

@@ -39,6 +39,7 @@ esp_err_t multimodal_audio_start_uplink(multimodal_audio_uplink_cb_t cb, void *c
 esp_err_t multimodal_audio_stop_uplink(int timeout_ms);
 bool multimodal_audio_is_uplink_running(void);
 bool multimodal_audio_is_initialized(void);
+esp_err_t multimodal_audio_set_speaker_output_enabled(bool enabled);
 esp_err_t multimodal_audio_register_pcm_observer(
         multimodal_audio_pcm_observer_t observer,
         void *observer_ctx);

components/platform/internal/platform_internal.h

@@ -14,6 +14,7 @@ esp_err_t platform_stepper_driver_init(void);
 esp_err_t platform_stepper_driver_rotate_angle_with_accel(float angle,
                                                           int target_delay_us,
                                                           int timeout_ms);
+esp_err_t platform_stepper_driver_release_hold(int timeout_ms);
 void platform_stepper_driver_power_off(void);
 void platform_power_hold_init(void);
 esp_err_t platform_io_effects_init(void);

components/platform/src/multimodal/audio_pipeline/audio_pipeline_runtime_impl.c

@@ -1369,6 +1369,37 @@ bool multimodal_audio_is_initialized(void)
     return s_audio.initialized;
 }
 
+esp_err_t multimodal_audio_set_speaker_output_enabled(bool enabled)
+{
+    multimodal_audio_ctx_t *ctx = &s_audio;
+    if (!ctx->initialized || ctx->codec_dev == NULL || ctx->gpio_if == NULL ||
+        ctx->gpio_if->set == NULL) {
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    if (!enabled) {
+        esp_err_t mute_err = set_downstream_output_mute_if_needed(
+                ctx,
+                true,
+                "Light standby");
+        if (mute_err != ESP_OK) {
+            return mute_err;
+        }
+    }
+
+    int ret = ctx->gpio_if->set(CONFIG_MULTIMODAL_AUDIO_PA_GPIO, enabled);
+    if (ret != ESP_CODEC_DEV_OK) {
+        ESP_LOGW(TAG,
+                 "Speaker PA power %s failed: 0x%x",
+                 enabled ? "on" : "off",
+                 ret);
+        return (esp_err_t)ret;
+    }
+
+    ESP_LOGI(TAG, "Speaker PA power %s", enabled ? "on" : "off");
+    return ESP_OK;
+}
+
 esp_err_t multimodal_audio_register_downstream_playback_callback(
         multimodal_audio_downstream_playback_callback_t cb,
         void *cb_ctx)

components/platform/src/platform_stepper_driver.c

@@ -404,18 +404,21 @@ esp_err_t platform_stepper_driver_rotate_angle_with_accel(float angle,
     return err;
 }
 
-void platform_stepper_driver_power_off(void)
+esp_err_t platform_stepper_driver_release_hold(int timeout_ms)
 {
+    if (timeout_ms < 0) {
+        return ESP_ERR_INVALID_ARG;
+    }
     if (!ensure_stepper_motion_mutex()) {
-        return;
+        return ESP_ERR_INVALID_STATE;
     }
 
-    TickType_t lock_ticks = pdMS_TO_TICKS(PLATFORM_STEPPER_POWER_OFF_WAIT_MS);
-    if (lock_ticks == 0) {
+    TickType_t lock_ticks = pdMS_TO_TICKS(timeout_ms);
+    if (timeout_ms > 0 && lock_ticks == 0) {
         lock_ticks = 1;
     }
     if (xSemaphoreTake(s_stepper_motion_mutex, lock_ticks) != pdTRUE) {
-        return;
+        return ESP_ERR_TIMEOUT;
     }
 
     portENTER_CRITICAL(&s_stepper_mux);
@@ -423,4 +426,10 @@ void platform_stepper_driver_power_off(void)
     portEXIT_CRITICAL(&s_stepper_mux);
 
     (void)xSemaphoreGive(s_stepper_motion_mutex);
+    return ESP_OK;
+}
+
+void platform_stepper_driver_power_off(void)
+{
+    (void)platform_stepper_driver_release_hold(PLATFORM_STEPPER_POWER_OFF_WAIT_MS);
 }

components/platform/src/runtime/platform_core_runtime.c

@@ -300,6 +300,18 @@ void platform_stepper_power_off(void)
     platform_stepper_driver_power_off();
 }
 
+esp_err_t platform_stepper_release_hold(int timeout_ms)
+{
+    if (timeout_ms < 0) {
+        return ESP_ERR_INVALID_ARG;
+    }
+#if !CONFIG_TQ_STEPPER_ENABLE
+    return ESP_OK;
+#else
+    return platform_stepper_driver_release_hold(timeout_ms);
+#endif
+}
+
 esp_err_t platform_configure_digital_input(const platform_digital_input_config_t *config)
 {
     return platform_digital_input_driver_configure(config);

components/platform/src/runtime/platform_multimodal_runtime.c

@@ -210,6 +210,11 @@ bool platform_multimodal_audio_is_initialized(void)
     return multimodal_audio_is_initialized();
 }
 
+esp_err_t platform_multimodal_audio_set_speaker_output_enabled(bool enabled)
+{
+    return multimodal_audio_set_speaker_output_enabled(enabled);
+}
+
 esp_err_t platform_multimodal_audio_register_pcm_observer(
         platform_multimodal_audio_pcm_observer_t observer,
         void *user_data)