M1 step 3: Log writing and Storage Clean-up

- lib/storage_model (host-tested): FAT-safe names, daily Log paths,
  dates from Log/Capture file names, CleanupPlan by category and age,
  byte formatting
- StorageService does all card I/O on its task: queued Log lines are
  written in batches each second (dropped while Logs are paused),
  plus file listing and deletion jobs
- Settings > Storage moves into StoragePage: usage, Clean up
  (category, age with size preview, confirmation), Erase SD card
- Clock: local date for Log names
- Serial: log <text>, sd list

Verified on the device: lines land in /irc/dev/#test/2026-10-02.log
with folders created as needed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EhqxQ49eCju4CzKYNjZzwT

src/services/storage_service.h

@@ -3,13 +3,20 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
 
+#include <deque>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "cleanup_plan.h"
 #include "service.h"
 #include "storage_monitor.h"
 
 namespace roro {
 
-// Mounts the microSD card (retrying while absent) and feeds its usage to the StorageMonitor.
-// Runs on its own task: a failed mount blocks for seconds and must never stall the UI.
+// Owns the microSD card. All card access happens on this Service's own task (the SD driver isn't
+// safe across tasks, and a failed mount blocks for seconds): it mounts and watches usage, writes
+// queued Log lines in batches, lists files for Storage Clean-up, deletes, and formats.
 class StorageService : public Service {
    public:
     explicit StorageService(EventBus& bus) : monitor_(bus), bus_(bus) {}
@@ -19,24 +26,52 @@ class StorageService : public Service {
 
     StorageState state() const;
 
-    // Erases the whole card: one partition spanning the card, formatted FAT32. Runs on the storage
-    // task; the result arrives as a Notification. Returns false if a format is already pending.
+    // Queues one line for a Log file (created with its folders as needed). Dropped while Logs are
+    // paused (over 90 % full, or no card) or if too much is already waiting.
+    void appendLine(const std::string& path, const std::string& line);
+    uint32_t droppedLines() const { return dropped_; }
+
+    // Storage Clean-up: list every file of every category, then delete a selection.
+    void requestListing();
+    bool listingReady() const;
+    std::vector<std::vector<StoredFile>> listing() const;  // one vector per kCleanupCategories entry
+    void requestDelete(std::vector<std::string> paths);
+
+    // Erases the whole card: one partition spanning the card, formatted FAT32.
     bool requestFormat();
     bool formatting() const { return formatRequested_; }
 
    private:
-    static constexpr uint32_t kPollMs = 15000;
+    static constexpr uint32_t kWakeMs = 1000;
+    static constexpr uint32_t kPollEvery = 15;  // wake-ups between usage checks
+    static constexpr size_t kMaxPendingBytes = 16 * 1024;
+
     static void taskEntry(void* self);
+    void loop();
     void poll();
     bool mount();
     void format();
+    void writePending();
+    void list();
+    void remove(const std::vector<std::string>& paths);
+    void lock() const { xSemaphoreTake(lock_, portMAX_DELAY); }
+    void unlock() const { xSemaphoreGive(lock_); }
 
     StorageMonitor monitor_;
-    bool mounted_ = false;
     EventBus& bus_;
-    volatile bool formatRequested_ = false;
+    bool mounted_ = false;
     TaskHandle_t task_ = nullptr;
     mutable SemaphoreHandle_t lock_ = nullptr;
+
+    // Shared with other tasks, guarded by lock_.
+    std::deque<std::pair<std::string, std::string>> pending_;
+    size_t pendingBytes_ = 0;
+    uint32_t dropped_ = 0;
+    bool listingRequested_ = false;
+    bool listingReady_ = false;
+    std::vector<std::vector<StoredFile>> listing_;
+    std::vector<std::string> toDelete_;
+    volatile bool formatRequested_ = false;
 };
 
 }  // namespace roro