diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1a5f3524..7722ec0c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -97,7 +97,9 @@ jobs:
         run: python3 scripts/check_reticulum_runtime_budget_policy.py
 
       - name: Verify track file streaming
-        run: python3 scripts/check_track_file_streaming.py
+        run: |
+          python3 tests/test_track_file_streaming_guard.py
+          python3 scripts/check_track_file_streaming.py
 
       - name: Verify repository root has no build artifacts
         run: python3 scripts/check_root_build_artifacts.py
diff --git a/modules/core_chat/include/chat/ports/i_geocaching_transport.h b/modules/core_chat/include/chat/ports/i_geocaching_transport.h
index 2faab24d..2501c49b 100644
--- a/modules/core_chat/include/chat/ports/i_geocaching_transport.h
+++ b/modules/core_chat/include/chat/ports/i_geocaching_transport.h
@@ -1,8 +1,8 @@
 #pragma once
 #include "chat/domain/chat_types.h"
 #include "chat/infra/lxmf/lxmf_wire.h"
-#include <cstring>
 #include <array>
+#include <cstring>
 
 namespace chat
 {
@@ -28,7 +28,7 @@ struct GeocachingAnnouncementView
     ByteSpan app_data;
 };
 using GeocachingAnnouncementHandler = void (*)(const GeocachingAnnouncementView&, void*);
-}
+} // namespace lxmf
 // Optional application transport capability; unrelated adapters need not
 // implement it. The owning router controls lifetime and serializes access.
 class IGeocachingTransport
@@ -36,9 +36,15 @@ class IGeocachingTransport
   public:
     virtual ~IGeocachingTransport() = default;
     virtual bool getGeocachingAuthorKey(uint8_t out[64])
-    { if (out) std::memset(out, 0, 64); return false; }
+    {
+        if (out) std::memset(out, 0, 64);
+        return false;
+    }
     virtual bool signGeocachingRecord(lxmf::ByteSpan, uint8_t*, size_t, uint8_t*, size_t, size_t& written)
-    { written = 0; return false; }
+    {
+        written = 0;
+        return false;
+    }
     // Input bytes are borrowed for this call only; deferred transport work must
     // own its encoded payload and must not retain the caller's pointer.
     virtual MeshSendResult sendGeocachingData(const uint8_t destination_hash[16],
diff --git a/modules/core_geocaching/include/geocaching/gpx/write_record.h b/modules/core_geocaching/include/geocaching/gpx/write_record.h
index b6c0ee17..0d3f93a5 100644
--- a/modules/core_geocaching/include/geocaching/gpx/write_record.h
+++ b/modules/core_geocaching/include/geocaching/gpx/write_record.h
@@ -1,12 +1,12 @@
 #pragma once
-#include "gps/gpx/text_writer.h"
 #include "geocaching/protocol/verify_record.h"
+#include "gps/gpx/text_writer.h"
 #include <ctime>
 
 namespace geocaching::gpx
 {
-using gps::gpx::OutputSink;
 using gps::gpx::GpxTextWriter;
+using gps::gpx::OutputSink;
 inline bool writeGeocacheGpx(const protocol::VerifiedRecordView& verified,
                              protocol::RecordCrypto& crypto, OutputSink& sink)
 {
diff --git a/modules/core_geocaching/include/geocaching/protocol/verify_record.h b/modules/core_geocaching/include/geocaching/protocol/verify_record.h
index 2f19c599..87176718 100644
--- a/modules/core_geocaching/include/geocaching/protocol/verify_record.h
+++ b/modules/core_geocaching/include/geocaching/protocol/verify_record.h
@@ -41,14 +41,16 @@ inline VerificationResult deriveGeocacheHashes(ByteView encoded, RecordCrypto& c
                                                uint8_t* workspace, size_t capacity,
                                                GeocacheId& id, RevisionHash& hash)
 {
-    id = {}; hash = {};
+    id = {};
+    hash = {};
     RecordView record;
     if (!decodeGeocacheRecord(encoded, record)) return VerificationResult::InvalidRecord;
     constexpr char id_domain[] = "trailmate.geocache/id/v1";
     constexpr char revision_domain[] = "trailmate.geocache/revision/v1";
     const auto required = sizeof(revision_domain) + encoded.size;
     if (!workspace || capacity < required || capacity < sizeof(id_domain) + 80) return VerificationResult::WorkspaceTooSmall;
-    GeocacheId candidate_id; RevisionHash candidate_hash;
+    GeocacheId candidate_id;
+    RevisionHash candidate_hash;
     std::memcpy(workspace, id_domain, sizeof(id_domain));
     std::memcpy(workspace + sizeof(id_domain), record.author_public_key.data, 64);
     std::memcpy(workspace + sizeof(id_domain) + 64, record.creation_nonce.data, 16);
@@ -56,7 +58,8 @@ inline VerificationResult deriveGeocacheHashes(ByteView encoded, RecordCrypto& c
     std::memcpy(workspace, revision_domain, sizeof(revision_domain));
     std::memcpy(workspace + sizeof(revision_domain), encoded.data, encoded.size);
     if (!crypto.sha256({workspace, required}, candidate_hash.bytes.data())) return VerificationResult::CryptoUnavailable;
-    id = candidate_id; hash = candidate_hash;
+    id = candidate_id;
+    hash = candidate_hash;
     return VerificationResult::Valid;
 }
 
diff --git a/modules/core_geocaching/include/geocaching/storage/attempt_references.h b/modules/core_geocaching/include/geocaching/storage/attempt_references.h
index f0efcbbe..bd08a0d5 100644
--- a/modules/core_geocaching/include/geocaching/storage/attempt_references.h
+++ b/modules/core_geocaching/include/geocaching/storage/attempt_references.h
@@ -1,17 +1,20 @@
 #pragma once
-#include "geocaching/storage/tx_attempt.h"
 #include "geocaching/storage/logical_state.h"
 #include "geocaching/storage/outgoing_record.h"
+#include "geocaching/storage/tx_attempt.h"
 
 namespace geocaching::storage
 {
 inline bool validateAttemptReferences(const LogicalState::View& state)
 {
-    size_t cursor = 0; MutationView entry;
+    size_t cursor = 0;
+    MutationView entry;
     while (state.next(cursor, entry))
     {
         if (entry.table != 13) continue;
-        TxAttemptView attempt; ByteView outgoing_bytes; OutgoingView outgoing;
+        TxAttemptView attempt;
+        ByteView outgoing_bytes;
+        OutgoingView outgoing;
         if (!decodeTxAttempt(entry.key, entry.value, attempt) || !state.find(5, attempt.request_key, outgoing_bytes) ||
             !decodeOutgoing(attempt.request_key, outgoing_bytes, outgoing)) return false;
     }
diff --git a/modules/core_geocaching/include/geocaching/storage/attempt_timeout.h b/modules/core_geocaching/include/geocaching/storage/attempt_timeout.h
index 59f40f86..dbe549d5 100644
--- a/modules/core_geocaching/include/geocaching/storage/attempt_timeout.h
+++ b/modules/core_geocaching/include/geocaching/storage/attempt_timeout.h
@@ -6,7 +6,7 @@ namespace geocaching::storage
 // Expiry means outcome unknown and eligible for policy-controlled retry, not
 // proof that the remote side did not receive it. Never reuse the old LXMF hash.
 inline bool attemptTimeoutReached(const TxAttemptView& attempt, const StoredTime& now,
-                                   uint64_t recovery_started_ms, uint64_t timeout_ms)
+                                  uint64_t recovery_started_ms, uint64_t timeout_ms)
 {
     if (!timeout_ms || attempt.has_finished) return false;
     if (attempt.submitted.boot_id == now.boot_id)
diff --git a/modules/core_geocaching/include/geocaching/storage/author_history.h b/modules/core_geocaching/include/geocaching/storage/author_history.h
index 04b4340f..13846ce9 100644
--- a/modules/core_geocaching/include/geocaching/storage/author_history.h
+++ b/modules/core_geocaching/include/geocaching/storage/author_history.h
@@ -9,7 +9,8 @@ namespace geocaching::storage
 // deleting a reservation would permit a second signed version at the same key.
 inline bool validateAuthorHistory(const LogicalState::View& before, const LogicalState::View& candidate)
 {
-    size_t cursor = 0; MutationView entry;
+    size_t cursor = 0;
+    MutationView entry;
     while (candidate.next(cursor, entry))
     {
         if (entry.table != 3) continue;
diff --git a/modules/core_geocaching/include/geocaching/storage/author_issued.h b/modules/core_geocaching/include/geocaching/storage/author_issued.h
index 13f56a22..c0ddeee8 100644
--- a/modules/core_geocaching/include/geocaching/storage/author_issued.h
+++ b/modules/core_geocaching/include/geocaching/storage/author_issued.h
@@ -19,20 +19,23 @@ inline bool decodeAuthorIssued(ByteView key, ByteView value, AuthorIssuedView& o
     candidate.cache_id = {key.data, 32};
     for (unsigned i = 0; i < 4; ++i) candidate.revision = (candidate.revision << 8) | key.data[32 + i];
     if (!candidate.revision) return false;
-    protocol::CmpReader reader(value); size_t fields = 0;
+    protocol::CmpReader reader(value);
+    size_t fields = 0;
     if (!reader.array(fields, 3) || fields != 3 || !reader.binary(candidate.revision_hash, 32) || candidate.revision_hash.size != 32 ||
         !reader.binary(candidate.author_public_key, 64) || candidate.author_public_key.size != 64 ||
         !decodeStoredTime(reader, candidate.issued_at) || !reader.finished()) return false;
-    out = candidate; return true;
+    out = candidate;
+    return true;
 }
 inline bool encodeAuthorIssued(const RevisionHash& hash, ByteView public_key, const StoredTime& issued_at,
-                                uint8_t* output, size_t capacity, size_t& written)
+                               uint8_t* output, size_t capacity, size_t& written)
 {
     written = 0;
     if (!public_key.data || public_key.size != 64) return false;
     protocol::CmpWriter writer(output, capacity);
     if (!writer.array(3) || !writer.binary({hash.bytes.data(), 32}) || !writer.binary(public_key) ||
         !encodeStoredTime(writer, issued_at)) return false;
-    written = writer.size(); return true;
+    written = writer.size();
+    return true;
 }
 } // namespace geocaching::storage
diff --git a/modules/core_geocaching/include/geocaching/storage/checkpoint_selection.h b/modules/core_geocaching/include/geocaching/storage/checkpoint_selection.h
index 8fcb06ef..2b0e449e 100644
--- a/modules/core_geocaching/include/geocaching/storage/checkpoint_selection.h
+++ b/modules/core_geocaching/include/geocaching/storage/checkpoint_selection.h
@@ -4,7 +4,13 @@
 
 namespace geocaching::storage
 {
-enum class CheckpointCandidateState : uint8_t { Missing, Unavailable, Invalid, Verified };
+enum class CheckpointCandidateState : uint8_t
+{
+    Missing,
+    Unavailable,
+    Invalid,
+    Verified
+};
 struct CheckpointCandidate
 {
     // Verified may be set only after full file framing, tail and EOF checks.
@@ -12,7 +18,14 @@ struct CheckpointCandidate
     uint64_t sequence = 0;
     std::array<uint8_t, 32> digest{};
 };
-enum class CheckpointChoice : uint8_t { NoCheckpoint, SlotA, SlotB, RetryLater, Corrupt };
+enum class CheckpointChoice : uint8_t
+{
+    NoCheckpoint,
+    SlotA,
+    SlotB,
+    RetryLater,
+    Corrupt
+};
 
 inline CheckpointChoice selectCheckpoint(const CheckpointCandidate& a, const CheckpointCandidate& b)
 {
diff --git a/modules/core_geocaching/include/geocaching/storage/outgoing_record.h b/modules/core_geocaching/include/geocaching/storage/outgoing_record.h
index 4abc2644..395d8b57 100644
--- a/modules/core_geocaching/include/geocaching/storage/outgoing_record.h
+++ b/modules/core_geocaching/include/geocaching/storage/outgoing_record.h
@@ -48,7 +48,7 @@ inline bool decodeOutgoing(ByteView key, ByteView value, OutgoingView& out)
 }
 // Updates reuse original request/time views. Input views must not overlap output.
 inline bool encodeOutgoing(ByteView key, const OutgoingView& value,
-                            uint8_t* output, size_t capacity, size_t& written)
+                           uint8_t* output, size_t capacity, size_t& written)
 {
     written = 0;
     if (!value.request.data || value.request.size > 8192 || value.terminal_data.size > 8192) return false;
@@ -60,6 +60,7 @@ inline bool encodeOutgoing(ByteView key, const OutgoingView& value,
         !(value.terminal_data.size ? writer.binary(value.terminal_data) : writer.nil())) return false;
     OutgoingView checked;
     if (!decodeOutgoing(key, {output, writer.size()}, checked)) return false;
-    written = writer.size(); return true;
+    written = writer.size();
+    return true;
 }
 } // namespace geocaching::storage
diff --git a/modules/core_geocaching/include/geocaching/storage/pending_request.h b/modules/core_geocaching/include/geocaching/storage/pending_request.h
index 5b98f51e..f36ee43c 100644
--- a/modules/core_geocaching/include/geocaching/storage/pending_request.h
+++ b/modules/core_geocaching/include/geocaching/storage/pending_request.h
@@ -1,11 +1,16 @@
 #pragma once
+#include "geocaching/storage/cache_head.h"
 #include "geocaching/storage/logical_state.h"
 #include "geocaching/storage/task_record.h"
-#include "geocaching/storage/cache_head.h"
 
 namespace geocaching::storage
 {
-enum class PendingRequestResult : uint8_t { Ready, None, Corrupt };
+enum class PendingRequestResult : uint8_t
+{
+    Ready,
+    None,
+    Corrupt
+};
 struct PendingRequestView
 {
     std::array<uint8_t, 48> key{};
@@ -16,27 +21,30 @@ struct PendingRequestView
 };
 
 inline PendingRequestResult inspectPendingRequest(const LogicalState::View& state, const Destination& local,
-                                                   ByteView key, ByteView value, PendingRequestView& out)
+                                                  ByteView key, ByteView value, PendingRequestView& out)
 {
     out = {};
     OutgoingView outgoing;
     if (!decodeOutgoing(key, value, outgoing)) return PendingRequestResult::Corrupt;
     if (!outgoing.continue_intent || (outgoing.state != 0 && outgoing.state != 3) ||
         std::memcmp(key.data, local.bytes.data(), 16)) return PendingRequestResult::None;
-    ByteView task_bytes; TaskView task;
+    ByteView task_bytes;
+    TaskView task;
     if (!state.find(10, outgoing.task_id, task_bytes) || !decodeTask(outgoing.task_id, task_bytes, task) ||
         !requestBelongsToTask(outgoing.task_id, task, key, outgoing)) return PendingRequestResult::Corrupt;
     if (!task.continue_intent || task.state > 2) return PendingRequestResult::None;
     if ((task.kind == 2 || task.kind == 4) && outgoing.install_generation)
     {
-        ByteView head_bytes; CacheHeadView head;
+        ByteView head_bytes;
+        CacheHeadView head;
         if (!state.find(2, task.cache_id, head_bytes) || !decodeCacheHead(task.cache_id, head_bytes, head)) return PendingRequestResult::Corrupt;
         if (head.install_generation != outgoing.install_generation) return PendingRequestResult::None;
     }
     std::memcpy(out.key.data(), key.data, 48);
     std::memcpy(out.destination.bytes.data(), key.data + 16, 16);
     std::memcpy(out.request_id.bytes.data(), key.data + 32, 16);
-    out.request = outgoing.request; out.task_id = outgoing.task_id;
+    out.request = outgoing.request;
+    out.task_id = outgoing.task_id;
     return PendingRequestResult::Ready;
 }
 
@@ -49,16 +57,22 @@ inline PendingRequestResult nextPendingRequest(const LogicalState::View& state,
     out = {};
     if (after_key.size && (!after_key.data || after_key.size != 48)) return PendingRequestResult::Corrupt;
     bool found = false;
-    size_t cursor = 0; MutationView entry;
+    size_t cursor = 0;
+    MutationView entry;
     while (state.next(cursor, entry))
     {
         if (entry.table != 5) continue;
         PendingRequestView candidate;
         const auto result = inspectPendingRequest(state, local, entry.key, entry.value, candidate);
-        if (result == PendingRequestResult::Corrupt) { out = {}; return result; }
+        if (result == PendingRequestResult::Corrupt)
+        {
+            out = {};
+            return result;
+        }
         if (result != PendingRequestResult::Ready || (after_key.size && std::memcmp(entry.key.data, after_key.data, 48) <= 0)) continue;
         if (found && std::memcmp(entry.key.data, out.key.data(), 48) >= 0) continue;
-        out = candidate; found = true;
+        out = candidate;
+        found = true;
     }
     return found ? PendingRequestResult::Ready : PendingRequestResult::None;
 }
diff --git a/modules/core_geocaching/include/geocaching/storage/stored_time.h b/modules/core_geocaching/include/geocaching/storage/stored_time.h
index a62d426c..787d2edc 100644
--- a/modules/core_geocaching/include/geocaching/storage/stored_time.h
+++ b/modules/core_geocaching/include/geocaching/storage/stored_time.h
@@ -21,7 +21,10 @@ inline bool encodeStoredTime(protocol::CmpWriter& writer, const StoredTime& time
 inline bool decodeStoredTime(protocol::CmpReader& reader, StoredTime& out)
 {
     out = {};
-    StoredTime candidate; ByteView boot; size_t fields = 0; uint64_t trusted = 0;
+    StoredTime candidate;
+    ByteView boot;
+    size_t fields = 0;
+    uint64_t trusted = 0;
     if (!reader.array(fields, 4) || fields != 4 || !reader.binary(boot, 16) || boot.size != 16 ||
         !reader.unsignedInteger(candidate.monotonic_ms)) return false;
     std::memcpy(candidate.boot_id.data(), boot.data, 16);
@@ -34,6 +37,7 @@ inline bool decodeStoredTime(protocol::CmpReader& reader, StoredTime& out)
     }
     if (!reader.unsignedInteger(trusted) || trusted > 1 || (trusted && !candidate.has_utc)) return false;
     candidate.utc_trusted = trusted != 0;
-    out = candidate; return true;
+    out = candidate;
+    return true;
 }
 } // namespace geocaching::storage
diff --git a/modules/core_geocaching/include/geocaching/storage/summary_cache.h b/modules/core_geocaching/include/geocaching/storage/summary_cache.h
index 58dcd59a..d1a21d82 100644
--- a/modules/core_geocaching/include/geocaching/storage/summary_cache.h
+++ b/modules/core_geocaching/include/geocaching/storage/summary_cache.h
@@ -14,14 +14,17 @@ inline bool decodeSummaryCache(ByteView key, ByteView value, SummaryCacheView& o
 {
     out = {};
     if (!key.data || key.size != 48 || !value.data || value.size > 32768) return false;
-    protocol::CmpReader reader(value); size_t fields = 0; SummaryCacheView candidate;
+    protocol::CmpReader reader(value);
+    size_t fields = 0;
+    SummaryCacheView candidate;
     if (!reader.array(fields, 3) || fields != 3 || !protocol::decodeSummary(reader, candidate.summary) ||
         std::memcmp(key.data + 16, candidate.summary.id.bytes.data(), 32) || !reader.binary(candidate.snapshot_id, 16) ||
         candidate.snapshot_id.size != 16 || !decodeStoredTime(reader, candidate.received) || !reader.finished()) return false;
-    out = candidate; return true;
+    out = candidate;
+    return true;
 }
 inline bool encodeSummaryCache(ByteView key, const protocol::SummaryView& item, ByteView snapshot_id, const StoredTime& received,
-                                uint8_t* output, size_t capacity, size_t& written)
+                               uint8_t* output, size_t capacity, size_t& written)
 {
     written = 0;
     protocol::CmpWriter writer(output, capacity);
@@ -33,6 +36,7 @@ inline bool encodeSummaryCache(ByteView key, const protocol::SummaryView& item,
         !writer.binary(snapshot_id) || !encodeStoredTime(writer, received)) return false;
     SummaryCacheView checked;
     if (!decodeSummaryCache(key, {output, writer.size()}, checked)) return false;
-    written = writer.size(); return true;
+    written = writer.size();
+    return true;
 }
 } // namespace geocaching::storage
diff --git a/modules/core_geocaching/include/geocaching/storage/task_record.h b/modules/core_geocaching/include/geocaching/storage/task_record.h
index 45fb3667..a358543f 100644
--- a/modules/core_geocaching/include/geocaching/storage/task_record.h
+++ b/modules/core_geocaching/include/geocaching/storage/task_record.h
@@ -56,10 +56,12 @@ inline bool encodeTask(ByteView key, const TaskView& task, uint8_t* output, size
         !(task.revision_hash.size ? writer.binary(task.revision_hash) : writer.nil()) ||
         !writer.unsignedInteger(task.state) || !writer.unsignedInteger(task.continue_intent ? 1 : 0) ||
         !writer.array(static_cast<uint32_t>(task.request_count))) return false;
-    for (size_t i = 0; i < task.request_count; ++i) if (!writer.binary(task.requests[i])) return false;
+    for (size_t i = 0; i < task.request_count; ++i)
+        if (!writer.binary(task.requests[i])) return false;
     TaskView checked;
     if (!decodeTask(key, {output, writer.size()}, checked)) return false;
-    written = writer.size(); return true;
+    written = writer.size();
+    return true;
 }
 
 // Both records must first pass their decoders. Recovery checks every task child
diff --git a/modules/core_geocaching/include/geocaching/storage/volume_format.h b/modules/core_geocaching/include/geocaching/storage/volume_format.h
index c3ae7ffe..78efceec 100644
--- a/modules/core_geocaching/include/geocaching/storage/volume_format.h
+++ b/modules/core_geocaching/include/geocaching/storage/volume_format.h
@@ -8,7 +8,12 @@ namespace geocaching::storage
 {
 using VolumeInstance = std::array<uint8_t, 16>;
 using VolumeHeader = std::array<uint8_t, 28>;
-enum class VolumeFormatResult : uint8_t { Supported, Unsupported, Corrupt };
+enum class VolumeFormatResult : uint8_t
+{
+    Supported,
+    Unsupported,
+    Corrupt
+};
 
 inline VolumeHeader encodeVolumeHeader(const VolumeInstance& instance)
 {
diff --git a/modules/core_geocaching/tests/fakes/platform/esp/arduino_common/chat/infra/mesh_adapter_router.h b/modules/core_geocaching/tests/fakes/platform/esp/arduino_common/chat/infra/mesh_adapter_router.h
index 063fd755..c1ca902c 100644
--- a/modules/core_geocaching/tests/fakes/platform/esp/arduino_common/chat/infra/mesh_adapter_router.h
+++ b/modules/core_geocaching/tests/fakes/platform/esp/arduino_common/chat/infra/mesh_adapter_router.h
@@ -23,7 +23,7 @@ class MeshAdapterRouter
         return true;
     }
     MeshSendResult sendGeocachingData(const uint8_t[16], lxmf::ByteSpan bytes, bool,
-                                     std::array<uint8_t, 32>* hash, const uint8_t expected[16])
+                                      std::array<uint8_t, 32>* hash, const uint8_t expected[16])
     {
         ++sends;
         if (!ready || std::memcmp(expected, local.data(), 16)) return MeshSendResult::fail(MeshOperationFailure::NotReady);
diff --git a/modules/core_geocaching/tests/test_attempt_timeout.cpp b/modules/core_geocaching/tests/test_attempt_timeout.cpp
index 799649b5..08f1c3d0 100644
--- a/modules/core_geocaching/tests/test_attempt_timeout.cpp
+++ b/modules/core_geocaching/tests/test_attempt_timeout.cpp
@@ -2,18 +2,21 @@
 int main()
 {
     using namespace geocaching::storage;
-    TxAttemptView attempt; StoredTime now;
+    TxAttemptView attempt;
+    StoredTime now;
     attempt.submitted.monotonic_ms = 100;
     now.monotonic_ms = 1099;
     if (attemptTimeoutReached(attempt, now, 0, 1000)) return 1;
     now.monotonic_ms = 1100;
     if (!attemptTimeoutReached(attempt, now, 0, 1000)) return 2;
-    now.boot_id[0] = 1; now.monotonic_ms = 5000;
+    now.boot_id[0] = 1;
+    now.monotonic_ms = 5000;
     if (attemptTimeoutReached(attempt, now, 4500, 1000)) return 3;
     now.monotonic_ms = 5500;
     if (!attemptTimeoutReached(attempt, now, 4500, 1000)) return 4;
     attempt.submitted.has_utc = attempt.submitted.utc_trusted = now.has_utc = now.utc_trusted = true;
-    attempt.submitted.utc_seconds = 100; now.utc_seconds = 101;
+    attempt.submitted.utc_seconds = 100;
+    now.utc_seconds = 101;
     if (attemptTimeoutReached(attempt, now, 0, 1001)) return 5;
     now.utc_seconds = 102;
     if (!attemptTimeoutReached(attempt, now, 0, 1001)) return 6;
diff --git a/modules/core_geocaching/tests/test_author_issued.cpp b/modules/core_geocaching/tests/test_author_issued.cpp
index 076440c1..050c81b2 100644
--- a/modules/core_geocaching/tests/test_author_issued.cpp
+++ b/modules/core_geocaching/tests/test_author_issued.cpp
@@ -3,9 +3,12 @@ int main()
 {
     using namespace geocaching;
     uint8_t key[36]{}, public_key[64]{}, bytes[192]{};
-    key[35] = 1; public_key[0] = 7;
-    RevisionHash hash; hash.bytes[0] = 9;
-    storage::StoredTime time; time.monotonic_ms = 123;
+    key[35] = 1;
+    public_key[0] = 7;
+    RevisionHash hash;
+    hash.bytes[0] = 9;
+    storage::StoredTime time;
+    time.monotonic_ms = 123;
     size_t size = 0;
     if (!storage::encodeAuthorIssued(hash, {public_key, 64}, time, bytes, sizeof(bytes), size)) return 1;
     storage::AuthorIssuedView out;
diff --git a/modules/core_geocaching/tests/test_cache_head.cpp b/modules/core_geocaching/tests/test_cache_head.cpp
index b33ae67f..88ecf45f 100644
--- a/modules/core_geocaching/tests/test_cache_head.cpp
+++ b/modules/core_geocaching/tests/test_cache_head.cpp
@@ -1,5 +1,5 @@
-#include "geocaching/storage/cache_head.h"
 #include "geocaching/protocol/cmp_writer.h"
+#include "geocaching/storage/cache_head.h"
 int main()
 {
     using namespace geocaching;
@@ -15,7 +15,8 @@ int main()
     if (!storage::decodeCacheHead({key, 32}, {empty, sizeof(empty)}, head) || head.current_hash.size) return 4;
     empty[3] = 0;
     if (storage::decodeCacheHead({key, 32}, {empty, sizeof(empty)}, head)) return 5;
-    empty[3] = 1; empty[2] = 3;
+    empty[3] = 1;
+    empty[2] = 3;
     if (storage::decodeCacheHead({key, 32}, {empty, sizeof(empty)}, head)) return 6;
     return 0;
 }
diff --git a/modules/core_geocaching/tests/test_checkpoint_selection.cpp b/modules/core_geocaching/tests/test_checkpoint_selection.cpp
index 1ac35a53..e1a8c929 100644
--- a/modules/core_geocaching/tests/test_checkpoint_selection.cpp
+++ b/modules/core_geocaching/tests/test_checkpoint_selection.cpp
@@ -8,9 +8,11 @@ int main()
     if (selectCheckpoint(a, b) != CheckpointChoice::NoCheckpoint) return 2;
     a.state = CheckpointCandidateState::Invalid;
     if (selectCheckpoint(a, b) != CheckpointChoice::Corrupt) return 3;
-    b.state = CheckpointCandidateState::Verified; b.sequence = 4;
+    b.state = CheckpointCandidateState::Verified;
+    b.sequence = 4;
     if (selectCheckpoint(a, b) != CheckpointChoice::SlotB) return 4;
-    a.state = CheckpointCandidateState::Verified; a.sequence = 5;
+    a.state = CheckpointCandidateState::Verified;
+    a.sequence = 5;
     if (selectCheckpoint(a, b) != CheckpointChoice::SlotA) return 5;
     a.sequence = 4;
     if (selectCheckpoint(a, b) != CheckpointChoice::SlotA) return 6;
diff --git a/modules/core_geocaching/tests/test_crypto_pipeline.cpp b/modules/core_geocaching/tests/test_crypto_pipeline.cpp
index 6134d6de..48926101 100644
--- a/modules/core_geocaching/tests/test_crypto_pipeline.cpp
+++ b/modules/core_geocaching/tests/test_crypto_pipeline.cpp
@@ -1,6 +1,6 @@
-#include "geocaching/protocol/verify_record.h"
-#include "chat/infra/reticulum/reticulum_wire.h"
 #include "chat/infra/meshcore/crypto/ed25519/ed_25519.h"
+#include "chat/infra/reticulum/reticulum_wire.h"
+#include "geocaching/protocol/verify_record.h"
 #include <cassert>
 #include <fstream>
 #include <iterator>
@@ -9,7 +9,10 @@
 struct NativeCrypto : geocaching::protocol::RecordCrypto
 {
     bool sha256(geocaching::ByteView in, std::uint8_t out[32]) override
-    { chat::reticulum::fullHash(in.data, in.size, out); return true; }
+    {
+        chat::reticulum::fullHash(in.data, in.size, out);
+        return true;
+    }
     geocaching::protocol::VerificationResult verifyEd25519(geocaching::ByteView key, geocaching::ByteView sig, geocaching::ByteView msg) override
     {
         using R = geocaching::protocol::VerificationResult;
diff --git a/modules/core_geocaching/tests/test_download_task_record.cpp b/modules/core_geocaching/tests/test_download_task_record.cpp
index 4f16a279..ca85eade 100644
--- a/modules/core_geocaching/tests/test_download_task_record.cpp
+++ b/modules/core_geocaching/tests/test_download_task_record.cpp
@@ -3,26 +3,35 @@
 int main()
 {
     using namespace geocaching;
-    RequestId request_id; Destination local, remote; GeocacheId cache; RevisionHash hash;
+    RequestId request_id;
+    Destination local, remote;
+    GeocacheId cache;
+    RevisionHash hash;
     std::array<uint8_t, 16> task{};
-    uint8_t request[256]{}; size_t request_size = 0;
+    uint8_t request[256]{};
+    size_t request_size = 0;
     if (!protocol::encodeGetRequest(request_id, cache, &hash, nullptr, 8192, request, sizeof(request), request_size)) return 1;
     std::array<uint8_t, 512> value_buffer{};
     auto workspace = std::make_unique<storage::QueuedRequestWorkspace>(value_buffer.data(), value_buffer.size());
-    std::array<uint8_t, 9000> output{}; size_t size = 0;
+    std::array<uint8_t, 9000> output{};
+    size_t size = 0;
     storage::RequestTaskTarget target{{cache.bytes.data(), 32}, {hash.bytes.data(), 32}, 1};
     if (!storage::encodeNewRequestTask(0, local, remote, request_id, task, 2, {request, request_size}, {},
-                                      *workspace, output.data(), output.size(), size, target)) return 2;
-    storage::MutationView mutations[2]; storage::TransactionView transaction;
+                                       *workspace, output.data(), output.size(), size, target)) return 2;
+    storage::MutationView mutations[2];
+    storage::TransactionView transaction;
     if (!storage::decodeTransaction({output.data(), size}, 0, mutations, 2, transaction)) return 3;
-    protocol::CmpReader record(mutations[1].value); size_t fields = 0; uint64_t kind = 0; ByteView stored_id, stored_hash;
+    protocol::CmpReader record(mutations[1].value);
+    size_t fields = 0;
+    uint64_t kind = 0;
+    ByteView stored_id, stored_hash;
     if (!record.array(fields, 6) || fields != 6 || !record.unsignedInteger(kind) || kind != 2 ||
         !record.binary(stored_id, 32) || stored_id.size != 32 || !record.binary(stored_hash, 32) || stored_hash.size != 32) return 4;
     target.install_generation = 0;
     if (storage::encodeNewRequestTask(0, local, remote, request_id, task, 2, {request, request_size}, {},
-                                     *workspace, output.data(), output.size(), size, target)) return 5;
+                                      *workspace, output.data(), output.size(), size, target)) return 5;
     target.install_generation = 1;
     if (storage::encodeNewRequestTask(0, local, remote, request_id, task, 1, {request, request_size}, {},
-                                     *workspace, output.data(), output.size(), size, target)) return 6;
+                                      *workspace, output.data(), output.size(), size, target)) return 6;
     return 0;
 }
diff --git a/modules/core_geocaching/tests/test_gpx_hash.cpp b/modules/core_geocaching/tests/test_gpx_hash.cpp
index 15af0f3a..8f2aac93 100644
--- a/modules/core_geocaching/tests/test_gpx_hash.cpp
+++ b/modules/core_geocaching/tests/test_gpx_hash.cpp
@@ -1,41 +1,61 @@
-#include "platform/esp/arduino_common/geocaching/sd_gpx_hash.h"
 #include "chat/infra/reticulum/reticulum_wire.h"
-#include <vector>
+#include "platform/esp/arduino_common/geocaching/sd_gpx_hash.h"
 #include <cstring>
+#include <vector>
 std::vector<uint8_t> bytes(1025, 7);
 namespace platform::esp::arduino_common::storage
 {
-class SdRuntimeFile::Impl { public: bool open = false; size_t offset = 0; };
+class SdRuntimeFile::Impl
+{
+  public:
+    bool open = false;
+    size_t offset = 0;
+};
 SdRuntimeFile::SdRuntimeFile() : impl_(new Impl) {}
 SdRuntimeFile::~SdRuntimeFile() { delete impl_; }
-bool SdRuntimeFile::open(const char*, const char*) { impl_->open = true; impl_->offset = 0; return true; }
+bool SdRuntimeFile::open(const char*, const char*)
+{
+    impl_->open = true;
+    impl_->offset = 0;
+    return true;
+}
 void SdRuntimeFile::close() { impl_->open = false; }
 bool SdRuntimeFile::is_open() const { return impl_->open; }
 uint64_t SdRuntimeFile::size() const { return bytes.size(); }
 int SdRuntimeFile::read(void* out, size_t count)
 {
     const auto n = std::min(count, bytes.size() - impl_->offset);
-    std::memcpy(out, bytes.data() + impl_->offset, n); impl_->offset += n; return static_cast<int>(n);
-}
+    std::memcpy(out, bytes.data() + impl_->offset, n);
+    impl_->offset += n;
+    return static_cast<int>(n);
 }
+} // namespace platform::esp::arduino_common::storage
 struct Digest
 {
     std::vector<uint8_t> data;
     void update(const uint8_t* bytes, size_t size) { data.insert(data.end(), bytes, bytes + size); }
-    bool finalize(uint8_t* out, size_t) { chat::reticulum::fullHash(data.data(), data.size(), out); return true; }
+    bool finalize(uint8_t* out, size_t)
+    {
+        chat::reticulum::fullHash(data.data(), data.size(), out);
+        return true;
+    }
 };
 int main()
 {
     using namespace platform::esp::arduino_common::geocaching;
-    Digest digest; SdGpxHash<Digest> reader(digest);
+    Digest digest;
+    SdGpxHash<Digest> reader(digest);
     std::array<uint8_t, 32> actual, expected;
     chat::reticulum::fullHash(bytes.data(), bytes.size(), expected.data());
     if (!reader.open("local.gpx") || reader.result(actual)) return 1;
-    for (unsigned i = 0; i < 3; ++i) if (reader.step() != GpxHashStep::Reading) return 2;
+    for (unsigned i = 0; i < 3; ++i)
+        if (reader.step() != GpxHashStep::Reading) return 2;
     if (reader.step() != GpxHashStep::Complete || !reader.result(actual) || actual != expected) return 3;
-    Digest growing_digest; SdGpxHash<Digest> growing(growing_digest);
+    Digest growing_digest;
+    SdGpxHash<Digest> growing(growing_digest);
     if (!growing.open("local.gpx")) return 4;
-    for (unsigned i = 0; i < 3; ++i) if (growing.step() != GpxHashStep::Reading) return 5;
+    for (unsigned i = 0; i < 3; ++i)
+        if (growing.step() != GpxHashStep::Reading) return 5;
     bytes.push_back(9);
     if (growing.step() != GpxHashStep::IoError || growing.result(actual)) return 6;
     return 0;
diff --git a/modules/core_geocaching/tests/test_gpx_record.cpp b/modules/core_geocaching/tests/test_gpx_record.cpp
index 662eaf43..5248f6e0 100644
--- a/modules/core_geocaching/tests/test_gpx_record.cpp
+++ b/modules/core_geocaching/tests/test_gpx_record.cpp
@@ -8,7 +8,11 @@ struct FileSink : geocaching::gpx::OutputSink
 {
     std::ofstream file;
     explicit FileSink(const char* path) : file(path, std::ios::binary) {}
-    bool write(std::string_view bytes) override { file.write(bytes.data(), bytes.size()); return file.good(); }
+    bool write(std::string_view bytes) override
+    {
+        file.write(bytes.data(), bytes.size());
+        return file.good();
+    }
 };
 struct FixtureCrypto : geocaching::protocol::RecordCrypto
 {
@@ -16,10 +20,13 @@ struct FixtureCrypto : geocaching::protocol::RecordCrypto
     bool sha256(geocaching::ByteView input, std::uint8_t output[32]) override
     {
         if (input.size != 64) return false;
-        std::memcpy(output, author_hash.data(), 32); return true;
+        std::memcpy(output, author_hash.data(), 32);
+        return true;
     }
     geocaching::protocol::VerificationResult verifyEd25519(geocaching::ByteView, geocaching::ByteView, geocaching::ByteView) override
-    { return geocaching::protocol::VerificationResult::CryptoUnavailable; }
+    {
+        return geocaching::protocol::VerificationResult::CryptoUnavailable;
+    }
 };
 int main(int argc, char** argv)
 {
diff --git a/modules/core_geocaching/tests/test_install_record.cpp b/modules/core_geocaching/tests/test_install_record.cpp
index ffcb7314..685c7370 100644
--- a/modules/core_geocaching/tests/test_install_record.cpp
+++ b/modules/core_geocaching/tests/test_install_record.cpp
@@ -1,23 +1,27 @@
-#include "geocaching/storage/install_record.h"
 #include "geocaching/protocol/cmp_writer.h"
+#include "geocaching/storage/install_record.h"
 int main()
 {
     using namespace geocaching;
     uint8_t key[16]{}, cache[32]{}, revision[32]{}, file_hash[32]{}, bytes[256]{};
-    revision[0] = 1; file_hash[0] = 2;
+    revision[0] = 1;
+    file_hash[0] = 2;
     protocol::CmpWriter writer(bytes, sizeof(bytes));
     if (!writer.array(6) || !writer.binary({cache, 32}) || !writer.binary({revision, 32}) || !writer.binary({file_hash, 32}) ||
         !writer.nil() || !writer.unsignedInteger(1) || !writer.unsignedInteger(0)) return 1;
     storage::InstallRecordView record;
     if (!storage::decodeInstallRecord({key, 16}, {bytes, writer.size()}, record) || record.new_file_hash.data[0] != 2) return 2;
-    storage::CacheHeadView head; head.install_generation = 1;
+    storage::CacheHeadView head;
+    head.install_generation = 1;
     using Action = storage::InstallRecoveryAction;
     if (storage::classifyInstallRecovery({cache, 32}, head, record) != Action::VerifyFiles) return 3;
     head.install_generation = 2;
     if (storage::classifyInstallRecovery({cache, 32}, head, record) != Action::Superseded) return 4;
-    head.install_generation = 1; record.generation = 2;
+    head.install_generation = 1;
+    record.generation = 2;
     if (storage::classifyInstallRecovery({cache, 32}, head, record) != Action::Inconsistent) return 5;
-    record.generation = 1; record.phase = storage::InstallPhase::ConflictExternal;
+    record.generation = 1;
+    record.phase = storage::InstallPhase::ConflictExternal;
     if (storage::classifyInstallRecovery({cache, 32}, head, record) != Action::ExternalConflict) return 6;
     record.phase = storage::InstallPhase::Installed;
     if (storage::classifyInstallRecovery({cache, 32}, head, record) != Action::Inconsistent) return 7;
diff --git a/modules/core_geocaching/tests/test_journal_inventory.cpp b/modules/core_geocaching/tests/test_journal_inventory.cpp
index 0c31b784..879c7759 100644
--- a/modules/core_geocaching/tests/test_journal_inventory.cpp
+++ b/modules/core_geocaching/tests/test_journal_inventory.cpp
@@ -1,22 +1,36 @@
 #include "platform/esp/arduino_common/geocaching/sd_journal_inventory.h"
-#include <vector>
-#include <string>
 #include <algorithm>
+#include <string>
+#include <vector>
 
 std::vector<std::string> names;
 bool busy_once = false;
 bool fail_after_first = false;
 namespace platform::esp::arduino_common::storage
 {
-class SdRuntimeDir::Impl { public: bool open = false; size_t index = 0; };
+class SdRuntimeDir::Impl
+{
+  public:
+    bool open = false;
+    size_t index = 0;
+};
 SdRuntimeDir::SdRuntimeDir() : impl_(new Impl) {}
 SdRuntimeDir::~SdRuntimeDir() { delete impl_; }
-bool SdRuntimeDir::open(const char*) { impl_->open = true; impl_->index = 0; return true; }
+bool SdRuntimeDir::open(const char*)
+{
+    impl_->open = true;
+    impl_->index = 0;
+    return true;
+}
 void SdRuntimeDir::close() { impl_->open = false; }
 bool SdRuntimeDir::is_open() const { return impl_->open; }
 SdDirReadStatus SdRuntimeDir::read_next_status(char* name, size_t capacity, bool* is_dir)
 {
-    if (busy_once) { busy_once = false; return SdDirReadStatus::Busy; }
+    if (busy_once)
+    {
+        busy_once = false;
+        return SdDirReadStatus::Busy;
+    }
     if (fail_after_first && impl_->index == 1)
     {
         fail_after_first = false;
@@ -24,17 +38,21 @@ SdDirReadStatus SdRuntimeDir::read_next_status(char* name, size_t capacity, bool
         return SdDirReadStatus::IoError;
     }
     if (impl_->index == names.size()) return SdDirReadStatus::End;
-    std::snprintf(name, capacity, "%s", names[impl_->index++].c_str()); *is_dir = false;
+    std::snprintf(name, capacity, "%s", names[impl_->index++].c_str());
+    *is_dir = false;
     return SdDirReadStatus::Entry;
 }
 SdFileReadResult sd_read_file(const char*, uint8_t* buffer, size_t capacity)
 {
     const auto header = ::geocaching::storage::encodeVolumeHeader({});
-    SdFileReadResult result; result.status = SdFileReadStatus::Ready;
-    result.file_size = header.size(); result.bytes_read = std::min(capacity, header.size());
-    std::memcpy(buffer, header.data(), result.bytes_read); return result;
-}
+    SdFileReadResult result;
+    result.status = SdFileReadStatus::Ready;
+    result.file_size = header.size();
+    result.bytes_read = std::min(capacity, header.size());
+    std::memcpy(buffer, header.data(), result.bytes_read);
+    return result;
 }
+} // namespace platform::esp::arduino_common::storage
 int main()
 {
     using namespace platform::esp::arduino_common::geocaching;
diff --git a/modules/core_geocaching/tests/test_journal_read.cpp b/modules/core_geocaching/tests/test_journal_read.cpp
index 93b10749..581bdd85 100644
--- a/modules/core_geocaching/tests/test_journal_read.cpp
+++ b/modules/core_geocaching/tests/test_journal_read.cpp
@@ -13,14 +13,15 @@ SdFileReadResult sd_read_file(const char*, uint8_t* buffer, size_t capacity)
     if (result.bytes_read) std::memcpy(buffer, disk.data(), result.bytes_read);
     return result;
 }
-}
+} // namespace platform::esp::arduino_common::storage
 int main()
 {
     using namespace platform::esp::arduino_common::geocaching;
     const uint8_t payload[] = {0x93, 1, 0, 0x91, 0x93, 5, 0xc4, 1, 0xab, 0xc0};
     ::geocaching::storage::RecordHeader header;
     if (!::geocaching::storage::makeRecordHeader(::geocaching::storage::RecordKind::Transaction, 1, {payload, sizeof(payload)}, header)) return 1;
-    disk.assign(header.begin(), header.end()); disk.insert(disk.end(), payload, payload + sizeof(payload));
+    disk.assign(header.begin(), header.end());
+    disk.insert(disk.end(), payload, payload + sizeof(payload));
     std::array<uint8_t, 128> buffer{};
     ::geocaching::storage::MutationView scratch;
     ::geocaching::storage::TransactionView out;
diff --git a/modules/core_geocaching/tests/test_journal_segment.cpp b/modules/core_geocaching/tests/test_journal_segment.cpp
index 2e541b28..6456ac7d 100644
--- a/modules/core_geocaching/tests/test_journal_segment.cpp
+++ b/modules/core_geocaching/tests/test_journal_segment.cpp
@@ -3,19 +3,31 @@
 std::vector<uint8_t> data;
 namespace platform::esp::arduino_common::storage
 {
-class SdRuntimeFile::Impl { public: size_t offset = 0; bool open = false; };
+class SdRuntimeFile::Impl
+{
+  public:
+    size_t offset = 0;
+    bool open = false;
+};
 SdRuntimeFile::SdRuntimeFile() : impl_(new Impl) {}
 SdRuntimeFile::~SdRuntimeFile() { delete impl_; }
-bool SdRuntimeFile::open(const char*, const char*) { impl_->open = true; impl_->offset = 0; return true; }
+bool SdRuntimeFile::open(const char*, const char*)
+{
+    impl_->open = true;
+    impl_->offset = 0;
+    return true;
+}
 void SdRuntimeFile::close() { impl_->open = false; }
 bool SdRuntimeFile::is_open() const { return impl_->open; }
 uint64_t SdRuntimeFile::size() const { return data.size(); }
 int SdRuntimeFile::read(void* buffer, size_t count)
 {
     const auto n = std::min(count, data.size() - impl_->offset);
-    std::memcpy(buffer, data.data() + impl_->offset, n); impl_->offset += n; return static_cast<int>(n);
-}
+    std::memcpy(buffer, data.data() + impl_->offset, n);
+    impl_->offset += n;
+    return static_cast<int>(n);
 }
+} // namespace platform::esp::arduino_common::storage
 int main()
 {
     using namespace platform::esp::arduino_common::geocaching;
@@ -24,9 +36,12 @@ int main()
     {
         ::geocaching::storage::RecordHeader header;
         if (!::geocaching::storage::makeRecordHeader(::geocaching::storage::RecordKind::Transaction, sequence, {payload, sizeof(payload)}, header)) return 1;
-        data.insert(data.end(), header.begin(), header.end()); data.insert(data.end(), payload, payload + sizeof(payload));
+        data.insert(data.end(), header.begin(), header.end());
+        data.insert(data.end(), payload, payload + sizeof(payload));
     }
-    SdJournalSegment segment; uint8_t buffer[128]; ::geocaching::storage::RecordFrameView frame;
+    SdJournalSegment segment;
+    uint8_t buffer[128];
+    ::geocaching::storage::RecordFrameView frame;
     if (!segment.open(1) || segment.next(buffer, sizeof(buffer), frame) != SegmentReadResult::Record || frame.sequence != 1 ||
         segment.next(buffer, sizeof(buffer), frame) != SegmentReadResult::Record || frame.sequence != 2 ||
         segment.next(buffer, sizeof(buffer), frame) != SegmentReadResult::End) return 2;
diff --git a/modules/core_geocaching/tests/test_logical_state.cpp b/modules/core_geocaching/tests/test_logical_state.cpp
index 96029274..68c5db27 100644
--- a/modules/core_geocaching/tests/test_logical_state.cpp
+++ b/modules/core_geocaching/tests/test_logical_state.cpp
@@ -6,15 +6,18 @@ int main()
     LogicalState state(first, second, sizeof(first));
     uint8_t key = 1, other_key = 2, value = 9;
     MutationView initial{5, {&key, 1}, {&value, 1}, false};
-    auto accept = [](const LogicalState::View&) { return true; };
+    auto accept = [](const LogicalState::View&)
+    { return true; };
     if (!state.apply(&initial, 1, accept)) return 1;
     MutationView changes[] = {{5, {&key, 1}, {}, true}, {5, {&other_key, 1}, {&value, 1}, false}};
-    if (state.apply(changes, 2, [](const LogicalState::View&) { return false; })) return 2;
+    if (state.apply(changes, 2, [](const LogicalState::View&)
+                    { return false; })) return 2;
     geocaching::ByteView found;
     if (!state.view().find(5, {&key, 1}, found) || found.size != 1 || found.data[0] != 9 || state.view().size() != 1) return 3;
     if (!state.apply(changes, 2, accept) || state.view().find(5, {&key, 1}, found) ||
         !state.view().find(5, {&other_key, 1}, found)) return 4;
-    uint8_t large[32]{}; MutationView overflow{5, {&key, 1}, {large, sizeof(large)}, false};
+    uint8_t large[32]{};
+    MutationView overflow{5, {&key, 1}, {large, sizeof(large)}, false};
     if (state.apply(&overflow, 1, accept) || state.view().size() != 1 || !state.view().find(5, {&other_key, 1}, found)) return 5;
     return 0;
 }
diff --git a/modules/core_geocaching/tests/test_lxmf_custom.cpp b/modules/core_geocaching/tests/test_lxmf_custom.cpp
index db17e92b..aa3b2b21 100644
--- a/modules/core_geocaching/tests/test_lxmf_custom.cpp
+++ b/modules/core_geocaching/tests/test_lxmf_custom.cpp
@@ -1,9 +1,9 @@
 #include "chat/infra/lxmf/lxmf_wire.h"
 #include "geocaching/protocol/cmp_reader.h"
 #include <cassert>
+#include <cstdlib>
 #include <cstring>
 #include <vector>
-#include <cstdlib>
 #ifdef _MSC_VER
 #include <crtdbg.h>
 #endif
diff --git a/modules/core_geocaching/tests/test_outgoing_record.cpp b/modules/core_geocaching/tests/test_outgoing_record.cpp
index 4cf5aabb..f2fc2531 100644
--- a/modules/core_geocaching/tests/test_outgoing_record.cpp
+++ b/modules/core_geocaching/tests/test_outgoing_record.cpp
@@ -1,20 +1,26 @@
+#include "geocaching/protocol/query_request.h"
 #include "geocaching/storage/outgoing_record.h"
 #include "geocaching/storage/queued_request.h"
-#include "geocaching/protocol/query_request.h"
 #include <memory>
 int main()
 {
     using namespace geocaching;
-    RequestId id; id.bytes[0] = 1;
-    uint8_t request[64]; size_t request_size = 0;
+    RequestId id;
+    id.bytes[0] = 1;
+    uint8_t request[64];
+    size_t request_size = 0;
     if (!protocol::encodeCapabilitiesRequest(id, request, sizeof(request), request_size)) return 1;
     std::array<uint8_t, 512> value_buffer{};
     auto scratch = std::make_unique<storage::QueuedRequestWorkspace>(value_buffer.data(), value_buffer.size());
-    std::array<uint8_t, 9000> bytes; size_t size = 0;
-    storage::StoredTime time; time.monotonic_ms = 123; time.boot_id[0] = 7;
+    std::array<uint8_t, 9000> bytes;
+    size_t size = 0;
+    storage::StoredTime time;
+    time.monotonic_ms = 123;
+    time.boot_id[0] = 7;
     if (!storage::encodeNewRequestTask(0, {}, {}, id, {}, 3, {request, request_size}, time,
                                        *scratch, bytes.data(), bytes.size(), size)) return 2;
-    storage::MutationView mutations[2]; storage::TransactionView transaction;
+    storage::MutationView mutations[2];
+    storage::TransactionView transaction;
     if (!storage::decodeTransaction({bytes.data(), size}, 0, mutations, 2, transaction)) return 3;
     storage::OutgoingView out;
     if (!storage::decodeOutgoing(mutations[0].key, mutations[0].value, out) || out.state != 0 ||
diff --git a/modules/core_geocaching/tests/test_paging.cpp b/modules/core_geocaching/tests/test_paging.cpp
index 759dd454..a6ce85a2 100644
--- a/modules/core_geocaching/tests/test_paging.cpp
+++ b/modules/core_geocaching/tests/test_paging.cpp
@@ -26,7 +26,7 @@ struct PagingPort : geocaching::QueryClientPort
     geocaching::QueryPersistence cancel(const geocaching::Destination&, const geocaching::RequestId&) override { return geocaching::QueryPersistence::Committed; }
     geocaching::QueryPersistence commitCapabilities(const geocaching::Destination&, const geocaching::RequestId&, geocaching::ByteView) override { return geocaching::QueryPersistence::Committed; }
     geocaching::QueryPersistence commitPage(const geocaching::Destination&, const geocaching::RequestId&, geocaching::ByteView,
-                    const geocaching::protocol::QueryPageView&) override
+                                            const geocaching::protocol::QueryPageView&) override
     {
         if (fail_commit) return geocaching::QueryPersistence::Rejected;
         ++commits;
diff --git a/modules/core_geocaching/tests/test_pending_request.cpp b/modules/core_geocaching/tests/test_pending_request.cpp
index a595f873..a07172bf 100644
--- a/modules/core_geocaching/tests/test_pending_request.cpp
+++ b/modules/core_geocaching/tests/test_pending_request.cpp
@@ -1,31 +1,41 @@
+#include "geocaching/protocol/query_request.h"
 #include "geocaching/storage/pending_request.h"
 #include "geocaching/storage/queued_request.h"
 #include "geocaching/storage/task_references.h"
-#include "geocaching/protocol/query_request.h"
 #include <memory>
 int main()
 {
     using namespace geocaching;
-    Destination local, remote; local.bytes[0] = 1; remote.bytes[0] = 2;
-    RequestId id; id.bytes[0] = 3;
-    uint8_t request[64]; size_t request_size = 0;
+    Destination local, remote;
+    local.bytes[0] = 1;
+    remote.bytes[0] = 2;
+    RequestId id;
+    id.bytes[0] = 3;
+    uint8_t request[64];
+    size_t request_size = 0;
     if (!protocol::encodeCapabilitiesRequest(id, request, sizeof(request), request_size)) return 1;
     std::array<uint8_t, 512> value_buffer{};
     auto workspace = std::make_unique<storage::QueuedRequestWorkspace>(value_buffer.data(), value_buffer.size());
-    uint8_t encoded[512]{}; size_t size = 0;
+    uint8_t encoded[512]{};
+    size_t size = 0;
     if (!storage::encodeNewRequestTask(0, local, remote, id, {}, 3, {request, request_size}, {},
-                                      *workspace, encoded, sizeof(encoded), size)) return 2;
-    storage::MutationView mutations[2]; storage::TransactionView transaction;
+                                       *workspace, encoded, sizeof(encoded), size)) return 2;
+    storage::MutationView mutations[2];
+    storage::TransactionView transaction;
     if (!storage::decodeTransaction({encoded, size}, 0, mutations, 2, transaction)) return 3;
-    uint8_t a[512]{}, b[512]{}; storage::LogicalState state(a, b, sizeof(a));
+    uint8_t a[512]{}, b[512]{};
+    storage::LogicalState state(a, b, sizeof(a));
     if (!state.apply(mutations, 2, storage::validateTaskReferences)) return 4;
     storage::PendingRequestView pending;
     if (storage::nextPendingRequest(state.view(), local, {}, pending) != storage::PendingRequestResult::Ready ||
         pending.destination.bytes != remote.bytes || pending.request_id.bytes != id.bytes || pending.request.size != request_size) return 5;
     if (storage::nextPendingRequest(state.view(), remote, {}, pending) != storage::PendingRequestResult::None) return 6;
-    uint8_t task_key[16]{}; ByteView task_bytes; storage::TaskView task;
+    uint8_t task_key[16]{};
+    ByteView task_bytes;
+    storage::TaskView task;
     if (!state.view().find(10, {task_key, 16}, task_bytes) || !storage::decodeTask({task_key, 16}, task_bytes, task)) return 7;
-    task.state = 5; task.continue_intent = false;
+    task.state = 5;
+    task.continue_intent = false;
     uint8_t stopped[256]{};
     if (!storage::encodeTask({task_key, 16}, task, stopped, sizeof(stopped), size)) return 8;
     storage::MutationView stop{10, {task_key, 16}, {stopped, size}, false};
diff --git a/modules/core_geocaching/tests/test_query_client.cpp b/modules/core_geocaching/tests/test_query_client.cpp
index d9fdd612..d8bfa9d5 100644
--- a/modules/core_geocaching/tests/test_query_client.cpp
+++ b/modules/core_geocaching/tests/test_query_client.cpp
@@ -21,7 +21,7 @@ struct Port : geocaching::QueryClientPort
     geocaching::QueryPersistence cancel(const geocaching::Destination&, const geocaching::RequestId&) override { return geocaching::QueryPersistence::Committed; }
     geocaching::QueryPersistence commitCapabilities(const geocaching::Destination&, const geocaching::RequestId&, geocaching::ByteView) override { return geocaching::QueryPersistence::Committed; }
     geocaching::QueryPersistence commitPage(const geocaching::Destination&, const geocaching::RequestId&, geocaching::ByteView,
-                    const geocaching::protocol::QueryPageView& page) override
+                                            const geocaching::protocol::QueryPageView& page) override
     {
         geocaching::protocol::CmpReader rows(page.encoded_items);
         geocaching::protocol::SummaryView item;
diff --git a/modules/core_geocaching/tests/test_queued_request.cpp b/modules/core_geocaching/tests/test_queued_request.cpp
index 10d91463..bb9c697e 100644
--- a/modules/core_geocaching/tests/test_queued_request.cpp
+++ b/modules/core_geocaching/tests/test_queued_request.cpp
@@ -1,29 +1,40 @@
-#include "geocaching/storage/queued_request.h"
 #include "geocaching/protocol/query_request.h"
+#include "geocaching/storage/queued_request.h"
 #include <memory>
 
 int main()
 {
     using namespace geocaching;
-    RequestId request_id; request_id.bytes[0] = 1;
-    Destination local, remote; local.bytes[0] = 2; remote.bytes[0] = 3;
-    std::array<uint8_t, 16> task_id{}; task_id[0] = 4;
-    uint8_t request[128]{}; size_t request_size = 0;
+    RequestId request_id;
+    request_id.bytes[0] = 1;
+    Destination local, remote;
+    local.bytes[0] = 2;
+    remote.bytes[0] = 3;
+    std::array<uint8_t, 16> task_id{};
+    task_id[0] = 4;
+    uint8_t request[128]{};
+    size_t request_size = 0;
     if (!protocol::encodeCapabilitiesRequest(request_id, request, sizeof(request), request_size)) return 1;
     std::array<uint8_t, 512> value_buffer{};
     auto scratch = std::make_unique<storage::QueuedRequestWorkspace>(value_buffer.data(), value_buffer.size());
-    std::array<uint8_t, 9000> output{}; size_t size = 0;
-    storage::StoredTime time; time.boot_id[0] = 5;
+    std::array<uint8_t, 9000> output{};
+    size_t size = 0;
+    storage::StoredTime time;
+    time.boot_id[0] = 5;
     if (!storage::encodeNewRequestTask(7, local, remote, request_id, task_id, 3,
                                        {request, request_size}, time, *scratch, output.data(), output.size(), size)) return 2;
-    storage::MutationView mutations[2]; storage::TransactionView transaction;
+    storage::MutationView mutations[2];
+    storage::TransactionView transaction;
     if (!storage::decodeTransaction({output.data(), size}, 7, mutations, 2, transaction) || transaction.count != 2 ||
         mutations[0].table != 5 || mutations[0].key.size != 48 || mutations[1].table != 10 || mutations[1].key.size != 16) return 3;
-    protocol::CmpReader outgoing(mutations[0].value); size_t count = 0; ByteView stored_request;
+    protocol::CmpReader outgoing(mutations[0].value);
+    size_t count = 0;
+    ByteView stored_request;
     if (!outgoing.array(count, 7) || count != 7 || !outgoing.binary(stored_request, 8192) ||
         stored_request.size != request_size || std::memcmp(stored_request.data, request, request_size)) return 4;
     request_id.bytes[0] = 9;
     if (storage::encodeNewRequestTask(7, local, remote, request_id, task_id, 3,
-                                      {request, request_size}, time, *scratch, output.data(), output.size(), size) || size) return 5;
+                                      {request, request_size}, time, *scratch, output.data(), output.size(), size) ||
+        size) return 5;
     return 0;
 }
diff --git a/modules/core_geocaching/tests/test_record_encoder.cpp b/modules/core_geocaching/tests/test_record_encoder.cpp
index c57d0af1..64cd9036 100644
--- a/modules/core_geocaching/tests/test_record_encoder.cpp
+++ b/modules/core_geocaching/tests/test_record_encoder.cpp
@@ -8,16 +8,20 @@ int main(int argc, char** argv)
     if (argc != 2) return 1;
     std::ifstream file(argv[1], std::ios::binary);
     std::vector<uint8_t> data((std::istreambuf_iterator<char>(file)), {});
-    protocol::CmpReader reader({data.data(), data.size()}); size_t fields = 0; ByteView encoded;
+    protocol::CmpReader reader({data.data(), data.size()});
+    size_t fields = 0;
+    ByteView encoded;
     if (!reader.array(fields, 2) || !reader.binary(encoded, 4096)) return 2;
     RecordView record;
     if (!protocol::decodeGeocacheRecord(encoded, record)) return 3;
-    std::array<uint8_t, 4096> output{}; size_t written = 0;
+    std::array<uint8_t, 4096> output{};
+    size_t written = 0;
     if (!protocol::encodeGeocacheRecord(record, output.data(), output.size(), written) || written != encoded.size ||
         std::memcmp(output.data(), encoded.data, written)) return 4;
     record.name = "   ";
     if (protocol::encodeGeocacheRecord(record, output.data(), output.size(), written) || written) return 5;
-    record.name = "A"; record.longitude_e7 = 1800000000;
+    record.name = "A";
+    record.longitude_e7 = 1800000000;
     if (protocol::encodeGeocacheRecord(record, output.data(), output.size(), written) || written) return 6;
     return 0;
 }
diff --git a/modules/core_geocaching/tests/test_record_read_budget.cpp b/modules/core_geocaching/tests/test_record_read_budget.cpp
index d7a9e3c1..ca090813 100644
--- a/modules/core_geocaching/tests/test_record_read_budget.cpp
+++ b/modules/core_geocaching/tests/test_record_read_budget.cpp
@@ -5,10 +5,20 @@ std::vector<uint8_t> data;
 size_t bytes_read = 0, calls = 0, short_limit = SIZE_MAX;
 namespace platform::esp::arduino_common::storage
 {
-class SdRuntimeFile::Impl { public: bool open = false; size_t offset = 0; };
+class SdRuntimeFile::Impl
+{
+  public:
+    bool open = false;
+    size_t offset = 0;
+};
 SdRuntimeFile::SdRuntimeFile() : impl_(new Impl) {}
 SdRuntimeFile::~SdRuntimeFile() { delete impl_; }
-bool SdRuntimeFile::open(const char*, const char*) { impl_->open = true; impl_->offset = 0; return true; }
+bool SdRuntimeFile::open(const char*, const char*)
+{
+    impl_->open = true;
+    impl_->offset = 0;
+    return true;
+}
 void SdRuntimeFile::close() { impl_->open = false; }
 bool SdRuntimeFile::is_open() const { return impl_->open; }
 uint64_t SdRuntimeFile::size() const { return data.size(); }
@@ -16,18 +26,22 @@ int SdRuntimeFile::read(void* out, size_t count)
 {
     ++calls;
     const auto n = std::min(std::min(count, short_limit), data.size() - impl_->offset);
-    std::memcpy(out, data.data() + impl_->offset, n); impl_->offset += n; bytes_read += n;
+    std::memcpy(out, data.data() + impl_->offset, n);
+    impl_->offset += n;
+    bytes_read += n;
     return static_cast<int>(n);
 }
-}
+} // namespace platform::esp::arduino_common::storage
 bool exercise(size_t size, size_t read_limit)
 {
     using namespace platform::esp::arduino_common::geocaching;
     std::vector<uint8_t> payload(size, 7), output(size + 24);
     ::geocaching::storage::RecordHeader header;
     if (!::geocaching::storage::makeRecordHeader(::geocaching::storage::RecordKind::Transaction, 1, {payload.data(), payload.size()}, header)) return false;
-    data.assign(header.begin(), header.end()); data.insert(data.end(), payload.begin(), payload.end());
-    bytes_read = calls = 0; short_limit = read_limit;
+    data.assign(header.begin(), header.end());
+    data.insert(data.end(), payload.begin(), payload.end());
+    bytes_read = calls = 0;
+    short_limit = read_limit;
     SdJournalSegment segment;
     if (!segment.open(1)) return false;
     bool yielded = false;
@@ -40,10 +54,11 @@ bool exercise(size_t size, size_t read_limit)
         if (result == SegmentReadResult::InProgress)
         {
             if (frame.payload.data || frame.payload.size) return false;
-            yielded = true; continue;
+            yielded = true;
+            continue;
         }
         return result == SegmentReadResult::Record && yielded && frame.payload.size == payload.size() &&
-            !std::memcmp(frame.payload.data, payload.data(), payload.size()) && bytes_read == data.size();
+               !std::memcmp(frame.payload.data, payload.data(), payload.size()) && bytes_read == data.size();
     }
     return false;
 }
diff --git a/modules/core_geocaching/tests/test_sd_volume.cpp b/modules/core_geocaching/tests/test_sd_volume.cpp
index 6a0a734a..119b1bb5 100644
--- a/modules/core_geocaching/tests/test_sd_volume.cpp
+++ b/modules/core_geocaching/tests/test_sd_volume.cpp
@@ -1,39 +1,60 @@
 #include "platform/esp/arduino_common/geocaching/sd_volume.h"
+#include <algorithm>
 #include <map>
 #include <set>
 #include <string>
-#include <algorithm>
 
 std::map<std::string, std::string> files;
 std::set<std::string> directories;
 unsigned writes = 0;
 namespace platform::esp::arduino_common::storage
 {
-class SdRuntimeFile::Impl { public: std::string path; };
+class SdRuntimeFile::Impl
+{
+  public:
+    std::string path;
+};
 SdRuntimeFile::SdRuntimeFile() : impl_(new Impl) {}
 SdRuntimeFile::~SdRuntimeFile() { delete impl_; }
-bool SdRuntimeFile::open(const char* path, const char*) { impl_->path = path; files[path].clear(); return true; }
+bool SdRuntimeFile::open(const char* path, const char*)
+{
+    impl_->path = path;
+    files[path].clear();
+    return true;
+}
 void SdRuntimeFile::close() {}
 size_t SdRuntimeFile::write(const void* data, size_t count)
 {
-    ++writes; files[impl_->path].append(static_cast<const char*>(data), count); return count;
+    ++writes;
+    files[impl_->path].append(static_cast<const char*>(data), count);
+    return count;
 }
 bool SdRuntimeFile::flush() { return true; }
 bool sd_card_ready() { return true; }
 bool sd_external_block_owner_active() { return false; }
 bool sd_exists(const char* path) { return directories.count(path) || files.count(path); }
 bool sd_is_directory(const char* path) { return directories.count(path) != 0; }
-bool sd_mkdir(const char* path) { directories.insert(path); return true; }
+bool sd_mkdir(const char* path)
+{
+    directories.insert(path);
+    return true;
+}
 SdFileReadResult sd_read_file(const char* path, uint8_t* buffer, size_t capacity)
 {
     SdFileReadResult result;
     auto found = files.find(path);
-    if (found == files.end()) { result.status = SdFileReadStatus::Missing; return result; }
-    result.file_size = found->second.size(); result.bytes_read = std::min(capacity, found->second.size());
+    if (found == files.end())
+    {
+        result.status = SdFileReadStatus::Missing;
+        return result;
+    }
+    result.file_size = found->second.size();
+    result.bytes_read = std::min(capacity, found->second.size());
     std::memcpy(buffer, found->second.data(), result.bytes_read);
-    result.status = SdFileReadStatus::Ready; return result;
-}
+    result.status = SdFileReadStatus::Ready;
+    return result;
 }
+} // namespace platform::esp::arduino_common::storage
 int main()
 {
     using namespace platform::esp::arduino_common::geocaching;
diff --git a/modules/core_geocaching/tests/test_shared_track.cpp b/modules/core_geocaching/tests/test_shared_track.cpp
index 24552c8c..a649178b 100644
--- a/modules/core_geocaching/tests/test_shared_track.cpp
+++ b/modules/core_geocaching/tests/test_shared_track.cpp
@@ -1,12 +1,14 @@
-#include "gps/gpx/track_writer.h"
 #include "gps/gpx/ostream_sink.h"
+#include "gps/gpx/track_writer.h"
 #include <cassert>
 #include <sstream>
 int main()
 {
-    std::ostringstream stream;gps::gpx::OstreamSink sink(stream);
-    assert(gps::gpx::writeTrackPoint(sink,30.25,120.15,"2026-09-16T00:00:00Z",8));
-    assert(stream.str()=="<trkpt lat=\"30.250000\" lon=\"120.150000\">\n  <ele>0.0</ele>\n  <time>2026-09-16T00:00:00Z</time>\n  <extensions>\n    <speed>0.00</speed>\n    <course>0.0</course>\n    <hdop>0.0</hdop>\n    <sat>8</sat>\n  </extensions>\n</trkpt>\n");
-    stream.str("");assert(gps::gpx::writeTrackPoint(sink,30.25,120.15,"",0,7));
-    assert(stream.str().find("30.2500000")!=std::string::npos && stream.str().find("<time>")==std::string::npos);
+    std::ostringstream stream;
+    gps::gpx::OstreamSink sink(stream);
+    assert(gps::gpx::writeTrackPoint(sink, 30.25, 120.15, "2026-09-16T00:00:00Z", 8));
+    assert(stream.str() == "<trkpt lat=\"30.250000\" lon=\"120.150000\">\n  <ele>0.0</ele>\n  <time>2026-09-16T00:00:00Z</time>\n  <extensions>\n    <speed>0.00</speed>\n    <course>0.0</course>\n    <hdop>0.0</hdop>\n    <sat>8</sat>\n  </extensions>\n</trkpt>\n");
+    stream.str("");
+    assert(gps::gpx::writeTrackPoint(sink, 30.25, 120.15, "", 0, 7));
+    assert(stream.str().find("30.2500000") != std::string::npos && stream.str().find("<time>") == std::string::npos);
 }
diff --git a/modules/core_geocaching/tests/test_snapshot_state.cpp b/modules/core_geocaching/tests/test_snapshot_state.cpp
index 7aad1687..5b284e14 100644
--- a/modules/core_geocaching/tests/test_snapshot_state.cpp
+++ b/modules/core_geocaching/tests/test_snapshot_state.cpp
@@ -5,11 +5,13 @@ int main()
     uint8_t a[64]{}, b[64]{}, key = 1, next_key = 2, value = 9;
     LogicalState state(a, b, sizeof(a));
     MutationView first{5, {&key, 1}, {&value, 1}, false}, second{5, {&next_key, 1}, {}, false};
-    auto accept = [](const auto&) { return true; };
+    auto accept = [](const auto&)
+    { return true; };
     if (!state.apply(&first, 1, accept) || !state.beginSnapshot() || !state.appendSnapshot(&second, 1)) return 1;
     geocaching::ByteView found;
     if (!state.view().find(5, {&key, 1}, found) || state.apply(&second, 1, accept) ||
-        state.commitSnapshot([](const auto&) { return false; })) return 2;
+        state.commitSnapshot([](const auto&)
+                             { return false; })) return 2;
     if (!state.commitSnapshot(accept) || state.view().find(5, {&key, 1}, found) || !state.view().find(5, {&next_key, 1}, found)) return 3;
     if (!state.beginSnapshot() || !state.appendSnapshot(&second, 1) || state.appendSnapshot(&first, 1) || state.commitSnapshot(accept)) return 4;
     state.discardSnapshot();
diff --git a/modules/core_geocaching/tests/test_task_record.cpp b/modules/core_geocaching/tests/test_task_record.cpp
index fcfe2f8f..94f345fa 100644
--- a/modules/core_geocaching/tests/test_task_record.cpp
+++ b/modules/core_geocaching/tests/test_task_record.cpp
@@ -1,20 +1,26 @@
-#include "geocaching/storage/task_record.h"
-#include "geocaching/storage/queued_request.h"
 #include "geocaching/protocol/query_request.h"
+#include "geocaching/storage/queued_request.h"
+#include "geocaching/storage/task_record.h"
 #include <memory>
 int main()
 {
     using namespace geocaching;
-    RequestId id; uint8_t request[64]; size_t request_size = 0;
+    RequestId id;
+    uint8_t request[64];
+    size_t request_size = 0;
     if (!protocol::encodeCapabilitiesRequest(id, request, sizeof(request), request_size)) return 1;
     std::array<uint8_t, 512> value_buffer{};
     auto workspace = std::make_unique<storage::QueuedRequestWorkspace>(value_buffer.data(), value_buffer.size());
-    std::array<uint8_t, 9000> bytes{}; size_t size = 0;
-    std::array<uint8_t, 16> task_id{}; task_id[0] = 7;
+    std::array<uint8_t, 9000> bytes{};
+    size_t size = 0;
+    std::array<uint8_t, 16> task_id{};
+    task_id[0] = 7;
     if (!storage::encodeNewRequestTask(0, {}, {}, id, task_id, 3, {request, request_size}, {},
-                                      *workspace, bytes.data(), bytes.size(), size)) return 2;
-    storage::MutationView mutations[2]; storage::TransactionView transaction;
-    storage::OutgoingView outgoing; storage::TaskView task;
+                                       *workspace, bytes.data(), bytes.size(), size)) return 2;
+    storage::MutationView mutations[2];
+    storage::TransactionView transaction;
+    storage::OutgoingView outgoing;
+    storage::TaskView task;
     if (!storage::decodeTransaction({bytes.data(), size}, 0, mutations, 2, transaction) ||
         !storage::decodeOutgoing(mutations[0].key, mutations[0].value, outgoing) ||
         !storage::decodeTask(mutations[1].key, mutations[1].value, task) ||
diff --git a/modules/core_geocaching/tests/test_track_motion.cpp b/modules/core_geocaching/tests/test_track_motion.cpp
index 2c053884..99f5cff9 100644
--- a/modules/core_geocaching/tests/test_track_motion.cpp
+++ b/modules/core_geocaching/tests/test_track_motion.cpp
@@ -1,5 +1,5 @@
-#include "gps/gpx/track_writer.h"
 #include "gps/gpx/ostream_sink.h"
+#include "gps/gpx/track_writer.h"
 #include <cassert>
 #include <fstream>
 #include <sstream>
diff --git a/modules/core_geocaching/tests/test_track_options.cpp b/modules/core_geocaching/tests/test_track_options.cpp
index 5260ba9f..fe58772a 100644
--- a/modules/core_geocaching/tests/test_track_options.cpp
+++ b/modules/core_geocaching/tests/test_track_options.cpp
@@ -1,15 +1,20 @@
-#include "gps/gpx/track_writer.h"
 #include "gps/gpx/ostream_sink.h"
+#include "gps/gpx/track_writer.h"
 #include <cassert>
 #include <sstream>
 int main()
 {
-    std::ostringstream stream; gps::gpx::OstreamSink sink(stream);
+    std::ostringstream stream;
+    gps::gpx::OstreamSink sink(stream);
     gps::gpx::TrackPointOptions options;
-    options.has_elevation = false; options.legacy_extensions = false;
-    assert(gps::gpx::writeTrackPoint(sink,1,2,"",0,7,options));
-    assert(stream.str().find("<ele>")==std::string::npos && stream.str().find("<extensions>")==std::string::npos);
-    stream.str("");options.has_elevation=true;options.elevation=123.25;options.elevation_precision=2;
-    assert(gps::gpx::writeTrackPoint(sink,1,2,"2026-09-16T00:00:00Z",0,7,options));
-    assert(stream.str().find("<ele>123.25</ele>")!=std::string::npos && stream.str().find("<time>2026-09-16T00:00:00Z</time>")!=std::string::npos);
+    options.has_elevation = false;
+    options.legacy_extensions = false;
+    assert(gps::gpx::writeTrackPoint(sink, 1, 2, "", 0, 7, options));
+    assert(stream.str().find("<ele>") == std::string::npos && stream.str().find("<extensions>") == std::string::npos);
+    stream.str("");
+    options.has_elevation = true;
+    options.elevation = 123.25;
+    options.elevation_precision = 2;
+    assert(gps::gpx::writeTrackPoint(sink, 1, 2, "2026-09-16T00:00:00Z", 0, 7, options));
+    assert(stream.str().find("<ele>123.25</ele>") != std::string::npos && stream.str().find("<time>2026-09-16T00:00:00Z</time>") != std::string::npos);
 }
diff --git a/modules/core_geocaching/tests/test_transaction.cpp b/modules/core_geocaching/tests/test_transaction.cpp
index 089f3084..17804237 100644
--- a/modules/core_geocaching/tests/test_transaction.cpp
+++ b/modules/core_geocaching/tests/test_transaction.cpp
@@ -1,7 +1,7 @@
 #include "geocaching/storage/transaction.h"
 #include <array>
-#include <vector>
 #include <cstring>
+#include <vector>
 
 int main()
 {
@@ -11,7 +11,7 @@ int main()
     std::array<uint8_t, 64> output{};
     size_t written = 99;
     const uint8_t expected[] = {0x93, 1, 0, 0x92, 0x93, 5, 0xc4, 1, 0xab, 0xc4, 0,
-                               0x93, 6, 0xc4, 1, 0xab, 0xc0};
+                                0x93, 6, 0xc4, 1, 0xab, 0xc0};
     if (!storage::encodeTransaction(0, mutations, 2, output.data(), output.size(), written) ||
         written != sizeof(expected) || std::memcmp(output.data(), expected, written)) return 1;
     mutations[1].table = 5;
@@ -24,7 +24,8 @@ int main()
     std::vector<uint8_t> value(32768, 0);
     std::vector<uint8_t> large(70000);
     mutations[0].value = {value.data(), value.size()};
-    mutations[1].value = mutations[0].value; mutations[1].erase = false;
+    mutations[1].value = mutations[0].value;
+    mutations[1].erase = false;
     if (storage::encodeTransaction(0, mutations, 2, large.data(), large.size(), written) || written) return 5;
     if (!storage::encodeTransaction(UINT64_MAX, mutations, 1, large.data(), large.size(), written)) return 6;
     return 0;
diff --git a/modules/core_geocaching/tests/test_transaction_decode.cpp b/modules/core_geocaching/tests/test_transaction_decode.cpp
index fe918a0c..b23fdd5b 100644
--- a/modules/core_geocaching/tests/test_transaction_decode.cpp
+++ b/modules/core_geocaching/tests/test_transaction_decode.cpp
@@ -8,7 +8,8 @@ int main()
                        0x93, 6, 0xc4, 1, 0xab, 0xc0};
     std::array<storage::MutationView, 2> scratch;
     storage::TransactionView transaction;
-    auto decode = [&](size_t size, uint64_t previous = 7, size_t capacity = 2) {
+    auto decode = [&](size_t size, uint64_t previous = 7, size_t capacity = 2)
+    {
         return storage::decodeTransaction({bytes, size}, previous, scratch.data(), capacity, transaction);
     };
     if (!decode(sizeof(bytes)) || transaction.count != 2 || scratch[0].erase ||
@@ -20,7 +21,8 @@ int main()
     if (decode(sizeof(bytes))) return 4;
     bytes[12] = 14;
     if (decode(sizeof(bytes))) return 5;
-    bytes[12] = 6; bytes[1] = 2;
+    bytes[12] = 6;
+    bytes[1] = 2;
     if (decode(sizeof(bytes))) return 6;
     bytes[1] = 1;
     std::array<uint8_t, sizeof(bytes) + 1> trailing{};
diff --git a/modules/core_geocaching/tests/test_transaction_validation.cpp b/modules/core_geocaching/tests/test_transaction_validation.cpp
index 30d2d374..1578651c 100644
--- a/modules/core_geocaching/tests/test_transaction_validation.cpp
+++ b/modules/core_geocaching/tests/test_transaction_validation.cpp
@@ -5,8 +5,13 @@ int main()
     using namespace geocaching::storage;
     std::array<uint8_t, 64> keys{};
     std::array<MutationView, 64> mutations{}, decoded{};
-    for (size_t i = 0; i < keys.size(); ++i) { keys[i] = static_cast<uint8_t>(i); mutations[i] = {5, {&keys[i], 1}, {}, true}; }
-    std::array<uint8_t, 1024> encoded{}; size_t size = 0;
+    for (size_t i = 0; i < keys.size(); ++i)
+    {
+        keys[i] = static_cast<uint8_t>(i);
+        mutations[i] = {5, {&keys[i], 1}, {}, true};
+    }
+    std::array<uint8_t, 1024> encoded{};
+    size_t size = 0;
     if (!encodeTransaction(7, mutations.data(), mutations.size(), encoded.data(), encoded.size(), size)) return 1;
     TransactionView view;
     if (!validateTransaction({encoded.data(), size}, 7) || !decodeTransaction({encoded.data(), size}, 7, decoded.data(), decoded.size(), view)) return 2;
diff --git a/modules/core_geocaching/tests/test_tx_attempt.cpp b/modules/core_geocaching/tests/test_tx_attempt.cpp
index 331a9ed2..227f4be0 100644
--- a/modules/core_geocaching/tests/test_tx_attempt.cpp
+++ b/modules/core_geocaching/tests/test_tx_attempt.cpp
@@ -2,7 +2,8 @@
 int main()
 {
     using namespace geocaching::storage;
-    uint8_t key[64]{}, bytes[192]{}, hash[32]{}; size_t size = 0;
+    uint8_t key[64]{}, bytes[192]{}, hash[32]{};
+    size_t size = 0;
     key[48] = 3;
     TxAttemptView value, out;
     value.submitted.monotonic_ms = 100;
@@ -10,7 +11,9 @@ int main()
         !decodeTxAttempt({key, 64}, {bytes, size}, out) || out.attempt_id.data[0] != 3 || out.has_finished) return 1;
     value.state = TxAttemptState::Delivered;
     if (encodeTxAttempt({key, 64}, value, bytes, sizeof(bytes), size) || size) return 2;
-    value.has_finished = true; value.finished.monotonic_ms = 200; value.lxmf_hash = {hash, 32};
+    value.has_finished = true;
+    value.finished.monotonic_ms = 200;
+    value.lxmf_hash = {hash, 32};
     if (!encodeTxAttempt({key, 64}, value, bytes, sizeof(bytes), size) ||
         !decodeTxAttempt({key, 64}, {bytes, size}, out) || !out.has_finished || out.lxmf_hash.size != 32) return 3;
     for (size_t n = 0; n < size; ++n)
diff --git a/modules/core_geocaching/tests/test_volume_format.cpp b/modules/core_geocaching/tests/test_volume_format.cpp
index 11169bf5..d4f4de91 100644
--- a/modules/core_geocaching/tests/test_volume_format.cpp
+++ b/modules/core_geocaching/tests/test_volume_format.cpp
@@ -3,7 +3,9 @@
 int main()
 {
     using namespace geocaching::storage;
-    VolumeInstance id{}; id[0] = 9; id[15] = 17;
+    VolumeInstance id{};
+    id[0] = 9;
+    id[15] = 17;
     auto header = encodeVolumeHeader(id);
     VolumeInstance decoded;
     if (decodeVolumeHeader({header.data(), header.size()}, decoded) != VolumeFormatResult::Supported || decoded != id) return 1;
diff --git a/modules/core_gps/include/gps/gpx/ostream_sink.h b/modules/core_gps/include/gps/gpx/ostream_sink.h
index 3ea62e60..68c244e1 100644
--- a/modules/core_gps/include/gps/gpx/ostream_sink.h
+++ b/modules/core_gps/include/gps/gpx/ostream_sink.h
@@ -13,6 +13,7 @@ class OstreamSink final : public OutputSink
         stream_.write(bytes.data(), static_cast<std::streamsize>(bytes.size()));
         return stream_.good();
     }
+
   private:
     std::ostream& stream_;
 };
diff --git a/modules/core_gps/include/gps/gpx/text_writer.h b/modules/core_gps/include/gps/gpx/text_writer.h
index 0f756a61..bcc206ee 100644
--- a/modules/core_gps/include/gps/gpx/text_writer.h
+++ b/modules/core_gps/include/gps/gpx/text_writer.h
@@ -1,12 +1,16 @@
 #pragma once
 #include <cstddef>
 #include <cstdint>
-#include <string_view>
 #include <cstdio>
+#include <string_view>
 
 namespace gps::gpx
 {
-struct ByteView { const std::uint8_t* data = nullptr; std::size_t size = 0; };
+struct ByteView
+{
+    const std::uint8_t* data = nullptr;
+    std::size_t size = 0;
+};
 class OutputSink
 {
   public:
diff --git a/modules/ui_shared/src/ui/app_catalog_builder.cpp b/modules/ui_shared/src/ui/app_catalog_builder.cpp
index 7e07bc09..7ede061d 100644
--- a/modules/ui_shared/src/ui/app_catalog_builder.cpp
+++ b/modules/ui_shared/src/ui/app_catalog_builder.cpp
@@ -74,7 +74,7 @@
 namespace
 {
 
-constexpr size_t kMaxMenuApps = 16;
+constexpr size_t kMaxMenuApps = 17;
 
 #define APP_CATALOG_LOG(...) std::printf("[UI][Catalog] " __VA_ARGS__)
 
diff --git a/modules/ui_shared/src/ui/menu/menu_layout.cpp b/modules/ui_shared/src/ui/menu/menu_layout.cpp
index 48ec64ab..f6934574 100644
--- a/modules/ui_shared/src/ui/menu/menu_layout.cpp
+++ b/modules/ui_shared/src/ui/menu/menu_layout.cpp
@@ -45,7 +45,7 @@ constexpr const char* kTag = "ui-menu-layout";
 #define MENU_LAYOUT_DIAG(...)
 #endif
 
-constexpr size_t kMaxMenuApps = 16;
+constexpr size_t kMaxMenuApps = 17;
 constexpr const char* kBottomHelpPlainPrefix = "H Help";
 constexpr const char* kBottomHelpRichPrefix = "#D6403A H#elp";
 
diff --git a/modules/ui_shared/tests/agenda/CMakeLists.txt b/modules/ui_shared/tests/agenda/CMakeLists.txt
index 009b40ce..44dd3039 100644
--- a/modules/ui_shared/tests/agenda/CMakeLists.txt
+++ b/modules/ui_shared/tests/agenda/CMakeLists.txt
@@ -118,6 +118,7 @@ add_executable(agenda_catalog_test test_catalog.cpp test_support.cpp
     "${REPO_ROOT}/modules/ui_shared/src/ui/page/page_profile.cpp"
     "${REPO_ROOT}/modules/ui_shared/src/ui/app_catalog_builder.cpp")
 target_include_directories(agenda_catalog_test PRIVATE catalog_stubs
+    "${REPO_ROOT}/modules/ui_presentation/include"
     "${REPO_ROOT}/modules/ui_lvgl_ux_packs/include"
     "${REPO_ROOT}/modules/ui_shared/include")
 target_compile_definitions(agenda_catalog_test PRIVATE ESP_PLATFORM=1 ARDUINO_T_LORA_PAGER=1)
diff --git a/modules/ui_shared/tests/agenda/test_catalog.cpp b/modules/ui_shared/tests/agenda/test_catalog.cpp
index 0ab84655..09d4f2de 100644
--- a/modules/ui_shared/tests/agenda/test_catalog.cpp
+++ b/modules/ui_shared/tests/agenda/test_catalog.cpp
@@ -24,6 +24,7 @@ bool show_notice(const char*, uint32_t) { return true; }
     }
 STUB_PAGE(chat::ui::shell)
 STUB_PAGE(calculator::ui::shell)
+STUB_PAGE(geocaching::ui::shell)
 STUB_PAGE(gps::ui::shell)
 namespace gps::ui::shell
 {
@@ -67,6 +68,11 @@ extern "C"
 #undef STUB_ICON
 }
 
+namespace catalog_icons
+{
+extern "C" const lv_image_dsc_t geocaching = {};
+}
+
 int main()
 {
     ui::CallbackAppScreen calendar("calendar", "Calendar", nullptr,
@@ -74,27 +80,28 @@ int main()
     ui::app_catalog_builder::FeatureFlags flags;
     flags.include_usb = flags.include_network = flags.include_walkie_talkie = flags.include_power_off = true;
     auto catalog = ui::app_catalog_builder::build(flags);
-    assert(ui::catalogCount(catalog) == 15);
+    assert(ui::catalogCount(catalog) == 16);
     flags.calendar_app = &calendar;
     catalog = ui::app_catalog_builder::build(flags);
-    assert(ui::catalogCount(catalog) == 16);
+    assert(ui::catalogCount(catalog) == 17);
     assert(ui::catalogAt(catalog, 0) == &calendar);
-    bool settings = false, shutdown = false;
+    bool settings = false, shutdown = false, geocaching = false;
     for (std::size_t i = 0; i < ui::catalogCount(catalog); ++i)
     {
         auto* app = ui::catalogAt(catalog, i);
         assert(app);
         settings |= std::strcmp(app->stable_id(), "settings") == 0;
         shutdown |= std::strcmp(app->stable_id(), "shutdown") == 0;
+        geocaching |= std::strcmp(app->stable_id(), "geocaching") == 0;
         for (std::size_t j = i + 1; j < ui::catalogCount(catalog); ++j)
             assert(std::strcmp(app->stable_id(), ui::catalogAt(catalog, j)->stable_id()) != 0);
     }
-    assert(settings && shutdown && !ui::catalogAt(catalog, 16));
+    assert(settings && shutdown && geocaching && !ui::catalogAt(catalog, 17));
     // The IDF catalog and callers that do not inject Agenda retain their shape.
     flags.calendar_app = nullptr;
     flags.profile = ui::app_catalog_builder::CatalogProfile::IdfDefault;
     catalog = ui::app_catalog_builder::build(flags);
-    assert(ui::catalogCount(catalog) == 15);
+    assert(ui::catalogCount(catalog) == 16);
     for (std::size_t i = 0; i < ui::catalogCount(catalog); ++i)
         assert(std::strcmp(ui::catalogAt(catalog, i)->stable_id(), "calendar") != 0);
 }
diff --git a/modules/ui_shared/tests/geocaching/stubs/ui/assets/fonts/font_utils.h b/modules/ui_shared/tests/geocaching/stubs/ui/assets/fonts/font_utils.h
index 30907515..d2a24ea6 100644
--- a/modules/ui_shared/tests/geocaching/stubs/ui/assets/fonts/font_utils.h
+++ b/modules/ui_shared/tests/geocaching/stubs/ui/assets/fonts/font_utils.h
@@ -3,7 +3,11 @@
 namespace ui::fonts
 {
 inline void apply_content_font(lv_obj_t* object, const char*, const lv_font_t* font)
-{ lv_obj_set_style_text_font(object, font, 0); }
-inline void apply_font(lv_obj_t* object, const lv_font_t* font)
-{ lv_obj_set_style_text_font(object, font, 0); }
+{
+    lv_obj_set_style_text_font(object, font, 0);
 }
+inline void apply_font(lv_obj_t* object, const lv_font_t* font)
+{
+    lv_obj_set_style_text_font(object, font, 0);
+}
+} // namespace ui::fonts
diff --git a/platform/esp/arduino_common/include/platform/esp/arduino_common/chat/infra/mesh_adapter_router.h b/platform/esp/arduino_common/include/platform/esp/arduino_common/chat/infra/mesh_adapter_router.h
index 39af951a..e44f5411 100644
--- a/platform/esp/arduino_common/include/platform/esp/arduino_common/chat/infra/mesh_adapter_router.h
+++ b/platform/esp/arduino_common/include/platform/esp/arduino_common/chat/infra/mesh_adapter_router.h
@@ -6,13 +6,13 @@
 #pragma once
 
 #include "chat/domain/chat_types.h"
-#include "chat/infra/mesh_adapter_router_core.h"
 #include "chat/infra/lxmf/lxmf_wire.h"
-#include <array>
+#include "chat/infra/mesh_adapter_router_core.h"
 #include "chat/ports/i_incoming_delivery_commit_port.h"
 #include "chat/ports/i_mesh_adapter.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/semphr.h"
+#include <array>
 
 namespace chat
 {
@@ -20,7 +20,7 @@ namespace lxmf
 {
 struct GeocachingAnnouncementView;
 struct CustomDeliveryView;
-}
+} // namespace lxmf
 
 class MeshAdapterRouter : public IMeshAdapter,
                           public IIncomingDeliveryCommitPort
diff --git a/platform/esp/arduino_common/include/platform/esp/arduino_common/chat/infra/reticulum/reticulum_adapter.h b/platform/esp/arduino_common/include/platform/esp/arduino_common/chat/infra/reticulum/reticulum_adapter.h
index efb7a15e..8ab0f9ad 100644
--- a/platform/esp/arduino_common/include/platform/esp/arduino_common/chat/infra/reticulum/reticulum_adapter.h
+++ b/platform/esp/arduino_common/include/platform/esp/arduino_common/chat/infra/reticulum/reticulum_adapter.h
@@ -10,11 +10,11 @@
 
 #pragma once
 
+#include "chat/infra/lxmf/lxmf_wire.h"
+#include "chat/ports/i_geocaching_transport.h"
 #include "chat/ports/i_incoming_delivery_commit_port.h"
 #include "chat/ports/i_mesh_adapter.h"
-#include "chat/ports/i_geocaching_transport.h"
 #include "chat/ports/i_mesh_peer_directory.h"
-#include "chat/infra/lxmf/lxmf_wire.h"
 
 #include <memory>
 
@@ -25,7 +25,7 @@ namespace chat::lxmf
 class LxmfAdapter;
 struct CustomDeliveryView;
 struct GeocachingAnnouncementView;
-}
+} // namespace chat::lxmf
 
 namespace chat::reticulum
 {
diff --git a/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_gpx_hash.h b/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_gpx_hash.h
index 08cf5495..a6261061 100644
--- a/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_gpx_hash.h
+++ b/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_gpx_hash.h
@@ -1,17 +1,23 @@
 #pragma once
 #include "geocaching/domain/record.h"
 #include "platform/esp/arduino_common/storage/sd_card_runtime.h"
-#include <array>
 #include <algorithm>
+#include <array>
 
 namespace platform::esp::arduino_common::geocaching
 {
-enum class GpxHashStep : uint8_t { Reading, Complete, InvalidSize, IoError };
+enum class GpxHashStep : uint8_t
+{
+    Reading,
+    Complete,
+    InvalidSize,
+    IoError
+};
 
 // One-shot worker operation with a fresh platform Sha256Digest. Path must be
 // locally derived by the store, never taken from a remote name or request.
 // Computes exact file bytes only; it does not parse GPX or verify signatures.
-template<class Digest>
+template <class Digest>
 class SdGpxHash
 {
   public:
@@ -20,10 +26,18 @@ class SdGpxHash
     {
         if (started_ || !path) return false;
         started_ = true;
-        if (!file_.open(path, "r")) { state_ = GpxHashStep::IoError; return false; }
+        if (!file_.open(path, "r"))
+        {
+            state_ = GpxHashStep::IoError;
+            return false;
+        }
         length_ = file_.size();
         if (!length_ || length_ > ::geocaching::kMaxGpxBytes)
-        { file_.close(); state_ = GpxHashStep::InvalidSize; return false; }
+        {
+            file_.close();
+            state_ = GpxHashStep::InvalidSize;
+            return false;
+        }
         return true;
     }
     GpxHashStep step()
@@ -42,7 +56,10 @@ class SdGpxHash
         const auto requested = static_cast<size_t>(std::min<uint64_t>(buffer_.size(), length_ - offset_));
         const int count = file_.read(buffer_.data(), requested);
         if (count <= 0 || static_cast<size_t>(count) > requested)
-        { file_.close(); return state_ = GpxHashStep::IoError; }
+        {
+            file_.close();
+            return state_ = GpxHashStep::IoError;
+        }
         digest_.update(buffer_.data(), static_cast<size_t>(count));
         offset_ += static_cast<size_t>(count);
         return state_;
@@ -51,7 +68,8 @@ class SdGpxHash
     {
         out = {};
         if (state_ != GpxHashStep::Complete) return false;
-        out = hash_; return true;
+        out = hash_;
+        return true;
     }
 
   private:
diff --git a/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_journal_inventory.h b/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_journal_inventory.h
index 5cdabb06..e9ba0970 100644
--- a/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_journal_inventory.h
+++ b/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_journal_inventory.h
@@ -4,7 +4,14 @@
 
 namespace platform::esp::arduino_common::geocaching
 {
-enum class InventoryStep : uint8_t { Scanning, Complete, RetryLater, Corrupt, VolumeChanged };
+enum class InventoryStep : uint8_t
+{
+    Scanning,
+    Complete,
+    RetryLater,
+    Corrupt,
+    VolumeChanged
+};
 
 struct JournalSegmentRange
 {
@@ -36,7 +43,8 @@ class SdJournalInventory
         if (volume != SdVolumeResult::Ready) return finish(InventoryStep::Corrupt);
         if (current != volume_) return finish(InventoryStep::VolumeChanged);
         if (!directory_.is_open() && !directory_.open("/trailmate/geocaching/.state/journal")) return restart();
-        char name[128]{}; bool is_dir = false;
+        char name[128]{};
+        bool is_dir = false;
         const auto result = directory_.read_next_status(name, sizeof(name), &is_dir);
         if (result == storage::SdDirReadStatus::Busy) return InventoryStep::RetryLater;
         if (result == storage::SdDirReadStatus::IoError || result == storage::SdDirReadStatus::Unavailable) return restart();
@@ -59,10 +67,16 @@ class SdJournalInventory
     }
 
   private:
-    InventoryStep finish(InventoryStep state) { directory_.close(); return state_ = state; }
+    InventoryStep finish(InventoryStep state)
+    {
+        directory_.close();
+        return state_ = state;
+    }
     InventoryStep restart()
     {
-        directory_.close(); first_ = 0; last_ = 0;
+        directory_.close();
+        first_ = 0;
+        last_ = 0;
         return state_ = InventoryStep::RetryLater;
     }
     const ::geocaching::storage::VolumeInstance volume_;
diff --git a/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_record_reader.h b/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_record_reader.h
index cfd73b6a..a9fa2048 100644
--- a/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_record_reader.h
+++ b/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_record_reader.h
@@ -5,7 +5,16 @@
 
 namespace platform::esp::arduino_common::geocaching
 {
-enum class SegmentReadResult : uint8_t { Record, End, Truncated, Corrupt, IoError, WorkspaceTooSmall, InProgress };
+enum class SegmentReadResult : uint8_t
+{
+    Record,
+    End,
+    Truncated,
+    Corrupt,
+    IoError,
+    WorkspaceTooSmall,
+    InProgress
+};
 
 struct SdRecordReadCursor
 {
@@ -40,7 +49,9 @@ inline SegmentReadResult readSdRecord(storage::SdRuntimeFile& file, uint64_t len
         const int n = file.read(buffer + cursor.header_read, needed);
         if (n == 0) return SegmentReadResult::Truncated;
         if (n < 0 || static_cast<size_t>(n) > needed) return SegmentReadResult::IoError;
-        cursor.header_read += static_cast<uint8_t>(n); offset += static_cast<size_t>(n); budget -= static_cast<size_t>(n);
+        cursor.header_read += static_cast<uint8_t>(n);
+        offset += static_cast<size_t>(n);
+        budget -= static_cast<size_t>(n);
         if (cursor.header_read != 24) return SegmentReadResult::InProgress;
         if (std::memcmp(buffer, "GCR1", 4) || buffer[4] < 2 || buffer[4] > 4 || buffer[5] || buffer[6] || buffer[7] != 24)
             return SegmentReadResult::Corrupt;
@@ -63,7 +74,8 @@ inline SegmentReadResult readSdRecord(storage::SdRuntimeFile& file, uint64_t len
     if (n == 0) return SegmentReadResult::Truncated;
     if (n < 0 || static_cast<size_t>(n) > requested) return SegmentReadResult::IoError;
     cursor.crc = ::sys::crc32(destination, static_cast<size_t>(n), cursor.crc);
-    cursor.payload_read += static_cast<uint32_t>(n); offset += static_cast<size_t>(n);
+    cursor.payload_read += static_cast<uint32_t>(n);
+    offset += static_cast<size_t>(n);
     if (cursor.payload_read != cursor.payload_size) return SegmentReadResult::InProgress;
     if (cursor.crc != cursor.expected_crc) return SegmentReadResult::Corrupt;
     out = {cursor.kind, cursor.sequence, {buffer + 24, cursor.payload_size}};
diff --git a/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_state_recovery.h b/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_state_recovery.h
index 5699aece..2d1c1182 100644
--- a/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_state_recovery.h
+++ b/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_state_recovery.h
@@ -1,46 +1,63 @@
 #pragma once
-#include "platform/esp/arduino_common/geocaching/sd_checkpoint_selection.h"
 #include "platform/esp/arduino_common/geocaching/sd_checkpoint_loader.h"
+#include "platform/esp/arduino_common/geocaching/sd_checkpoint_selection.h"
 #include "platform/esp/arduino_common/geocaching/sd_journal_replay.h"
 #include <optional>
 
 namespace platform::esp::arduino_common::geocaching
 {
-enum class StateRecoveryStep : uint8_t { Working, JournalRestored, RetryRequired, Corrupt, VolumeChanged, StateRejected, TailNeedsRepair };
+enum class StateRecoveryStep : uint8_t
+{
+    Working,
+    JournalRestored,
+    RetryRequired,
+    Corrupt,
+    VolumeChanged,
+    StateRejected,
+    TailNeedsRepair
+};
 
 // The supplied state is an isolated recovery state, never the UI's live state.
 // A fresh object is required after RetryRequired. One step advances one existing
 // component; the storage owner supplies operation budgeting and cancellation.
 // JournalRestored is followed by GPX/install validation before business readiness.
-template<class Digest>
+template <class Digest>
 class SdStateRecovery
 {
   public:
     SdStateRecovery(const ::geocaching::storage::VolumeInstance& volume,
-                      ::geocaching::storage::LogicalState& recovery_state)
+                    ::geocaching::storage::LogicalState& recovery_state)
         : volume_(volume), state_(recovery_state), selection_(volume) {}
     uint64_t replayedSequence() const { return sequence_; }
 
-    template<class Validate>
+    template <class Validate>
     StateRecoveryStep step(uint8_t* bytes, size_t capacity,
-                            ::geocaching::storage::MutationView* entries, size_t entry_capacity, Validate validate)
+                           ::geocaching::storage::MutationView* entries, size_t entry_capacity, Validate validate)
     {
         if (result_ != StateRecoveryStep::Working) return result_;
         if (phase_ == Phase::Select)
         {
             switch (selection_.step(bytes, capacity, entries, entry_capacity))
             {
-            case CheckpointSelectionStep::Reading: return result_;
-            case CheckpointSelectionStep::RetryLater: return result_ = StateRecoveryStep::RetryRequired;
-            case CheckpointSelectionStep::Corrupt: return result_ = StateRecoveryStep::Corrupt;
-            case CheckpointSelectionStep::VolumeChanged: return result_ = StateRecoveryStep::VolumeChanged;
+            case CheckpointSelectionStep::Reading:
+                return result_;
+            case CheckpointSelectionStep::RetryLater:
+                return result_ = StateRecoveryStep::RetryRequired;
+            case CheckpointSelectionStep::Corrupt:
+                return result_ = StateRecoveryStep::Corrupt;
+            case CheckpointSelectionStep::VolumeChanged:
+                return result_ = StateRecoveryStep::VolumeChanged;
             case CheckpointSelectionStep::NoCheckpoint:
                 if (!state_.beginSnapshot() || !state_.commitSnapshot(validate))
-                { state_.discardSnapshot(); return result_ = StateRecoveryStep::StateRejected; }
+                {
+                    state_.discardSnapshot();
+                    return result_ = StateRecoveryStep::StateRejected;
+                }
                 inventory_.emplace(volume_, 0);
                 phase_ = Phase::Inventory;
                 return result_;
-            case CheckpointSelectionStep::Selected: break;
+            case CheckpointSelectionStep::Selected:
+                break;
             }
             const bool slot_b = selection_.choice() == ::geocaching::storage::CheckpointChoice::SlotB;
             const auto& selected = selection_.candidate(slot_b);
@@ -53,12 +70,18 @@ class SdStateRecovery
         {
             switch (loader_->step(bytes, capacity, entries, entry_capacity, validate))
             {
-            case CheckpointLoadStep::Loading: return result_;
-            case CheckpointLoadStep::IoError: return result_ = StateRecoveryStep::RetryRequired;
-            case CheckpointLoadStep::Invalid: return result_ = StateRecoveryStep::Corrupt;
-            case CheckpointLoadStep::StateRejected: return result_ = StateRecoveryStep::StateRejected;
-            case CheckpointLoadStep::VolumeChanged: return result_ = StateRecoveryStep::VolumeChanged;
-            case CheckpointLoadStep::Applied: break;
+            case CheckpointLoadStep::Loading:
+                return result_;
+            case CheckpointLoadStep::IoError:
+                return result_ = StateRecoveryStep::RetryRequired;
+            case CheckpointLoadStep::Invalid:
+                return result_ = StateRecoveryStep::Corrupt;
+            case CheckpointLoadStep::StateRejected:
+                return result_ = StateRecoveryStep::StateRejected;
+            case CheckpointLoadStep::VolumeChanged:
+                return result_ = StateRecoveryStep::VolumeChanged;
+            case CheckpointLoadStep::Applied:
+                break;
             }
             loader_.reset();
             inventory_.emplace(volume_, sequence_);
@@ -70,10 +93,14 @@ class SdStateRecovery
             switch (inventory_->step())
             {
             case InventoryStep::Scanning:
-            case InventoryStep::RetryLater: return result_;
-            case InventoryStep::Corrupt: return result_ = StateRecoveryStep::Corrupt;
-            case InventoryStep::VolumeChanged: return result_ = StateRecoveryStep::VolumeChanged;
-            case InventoryStep::Complete: break;
+            case InventoryStep::RetryLater:
+                return result_;
+            case InventoryStep::Corrupt:
+                return result_ = StateRecoveryStep::Corrupt;
+            case InventoryStep::VolumeChanged:
+                return result_ = StateRecoveryStep::VolumeChanged;
+            case InventoryStep::Complete:
+                break;
             }
             replay_.emplace(volume_, sequence_, inventory_->range(), bytes, capacity, entries, entry_capacity);
             inventory_.reset();
@@ -85,20 +112,33 @@ class SdStateRecovery
         case ReplayStep::Applied:
             sequence_ = replay_->appliedSequence();
             return result_;
-        case ReplayStep::Advancing: return result_;
-        case ReplayStep::JournalComplete: return result_ = StateRecoveryStep::JournalRestored;
-        case ReplayStep::RetryLater: return result_ = StateRecoveryStep::RetryRequired;
-        case ReplayStep::VolumeChanged: return result_ = StateRecoveryStep::VolumeChanged;
-        case ReplayStep::ApplicationRejected: return result_ = StateRecoveryStep::StateRejected;
-        case ReplayStep::TailTruncated: return result_ = StateRecoveryStep::TailNeedsRepair;
+        case ReplayStep::Advancing:
+            return result_;
+        case ReplayStep::JournalComplete:
+            return result_ = StateRecoveryStep::JournalRestored;
+        case ReplayStep::RetryLater:
+            return result_ = StateRecoveryStep::RetryRequired;
+        case ReplayStep::VolumeChanged:
+            return result_ = StateRecoveryStep::VolumeChanged;
+        case ReplayStep::ApplicationRejected:
+            return result_ = StateRecoveryStep::StateRejected;
+        case ReplayStep::TailTruncated:
+            return result_ = StateRecoveryStep::TailNeedsRepair;
         case ReplayStep::Transaction:
-        case ReplayStep::Corrupt: return result_ = StateRecoveryStep::Corrupt;
+        case ReplayStep::Corrupt:
+            return result_ = StateRecoveryStep::Corrupt;
         }
         return result_ = StateRecoveryStep::Corrupt;
     }
 
   private:
-    enum class Phase : uint8_t { Select, Load, Inventory, Replay };
+    enum class Phase : uint8_t
+    {
+        Select,
+        Load,
+        Inventory,
+        Replay
+    };
     const ::geocaching::storage::VolumeInstance volume_;
     ::geocaching::storage::LogicalState& state_;
     SdCheckpointSelection<Digest> selection_;
diff --git a/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_volume.h b/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_volume.h
index b3e67d65..4fb49825 100644
--- a/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_volume.h
+++ b/platform/esp/arduino_common/include/platform/esp/arduino_common/geocaching/sd_volume.h
@@ -4,7 +4,15 @@
 
 namespace platform::esp::arduino_common::geocaching
 {
-enum class SdVolumeResult : uint8_t { Ready, Missing, Unavailable, Unsupported, Corrupt, IoError };
+enum class SdVolumeResult : uint8_t
+{
+    Ready,
+    Missing,
+    Unavailable,
+    Unsupported,
+    Corrupt,
+    IoError
+};
 
 inline SdVolumeResult inspectSdVolume(::geocaching::storage::VolumeInstance& instance)
 {
@@ -13,19 +21,27 @@ inline SdVolumeResult inspectSdVolume(::geocaching::storage::VolumeInstance& ins
     const auto result = storage::sd_read_file("/trailmate/geocaching/.state/format.bin", header.data(), header.size());
     switch (result.status)
     {
-    case storage::SdFileReadStatus::Missing: return SdVolumeResult::Missing;
+    case storage::SdFileReadStatus::Missing:
+        return SdVolumeResult::Missing;
     case storage::SdFileReadStatus::Busy:
-    case storage::SdFileReadStatus::Unavailable: return SdVolumeResult::Unavailable;
-    case storage::SdFileReadStatus::IoError: return SdVolumeResult::IoError;
-    case storage::SdFileReadStatus::Invalid: return SdVolumeResult::Corrupt;
-    case storage::SdFileReadStatus::Ready: break;
+    case storage::SdFileReadStatus::Unavailable:
+        return SdVolumeResult::Unavailable;
+    case storage::SdFileReadStatus::IoError:
+        return SdVolumeResult::IoError;
+    case storage::SdFileReadStatus::Invalid:
+        return SdVolumeResult::Corrupt;
+    case storage::SdFileReadStatus::Ready:
+        break;
     }
     if (result.bytes_read != result.file_size || result.bytes_read > header.size()) return SdVolumeResult::Corrupt;
     switch (::geocaching::storage::decodeVolumeHeader({header.data(), result.bytes_read}, instance))
     {
-    case ::geocaching::storage::VolumeFormatResult::Supported: return SdVolumeResult::Ready;
-    case ::geocaching::storage::VolumeFormatResult::Unsupported: return SdVolumeResult::Unsupported;
-    case ::geocaching::storage::VolumeFormatResult::Corrupt: return SdVolumeResult::Corrupt;
+    case ::geocaching::storage::VolumeFormatResult::Supported:
+        return SdVolumeResult::Ready;
+    case ::geocaching::storage::VolumeFormatResult::Unsupported:
+        return SdVolumeResult::Unsupported;
+    case ::geocaching::storage::VolumeFormatResult::Corrupt:
+        return SdVolumeResult::Corrupt;
     }
     return SdVolumeResult::Corrupt;
 }
diff --git a/platform/esp/arduino_common/include/platform/esp/arduino_common/storage/sd_card_runtime.h b/platform/esp/arduino_common/include/platform/esp/arduino_common/storage/sd_card_runtime.h
index 2e9a0553..210f5a5e 100644
--- a/platform/esp/arduino_common/include/platform/esp/arduino_common/storage/sd_card_runtime.h
+++ b/platform/esp/arduino_common/include/platform/esp/arduino_common/storage/sd_card_runtime.h
@@ -178,7 +178,15 @@ class SdRuntimeFile
     Impl* impl_;
 };
 
-enum class SdDirReadStatus : uint8_t { Entry, End, Busy, Unavailable, Invalid, IoError };
+enum class SdDirReadStatus : uint8_t
+{
+    Entry,
+    End,
+    Busy,
+    Unavailable,
+    Invalid,
+    IoError
+};
 
 class SdRuntimeDir
 {
diff --git a/platform/esp/arduino_common/src/app_context_platform_bindings.cpp b/platform/esp/arduino_common/src/app_context_platform_bindings.cpp
index fc6c1691..f101cdd2 100644
--- a/platform/esp/arduino_common/src/app_context_platform_bindings.cpp
+++ b/platform/esp/arduino_common/src/app_context_platform_bindings.cpp
@@ -15,11 +15,11 @@
 #include "platform/esp/arduino_common/chat/infra/store/sd_protocol_peer_repository.h"
 #include "platform/esp/arduino_common/chat/infra/store/sd_store.h"
 #include "platform/esp/arduino_common/device_identity.h"
+#include "platform/esp/arduino_common/geocaching/browse_runtime.h"
 #include "platform/esp/arduino_common/gps/gps_service.h"
 #include "platform/esp/arduino_common/gps/track_recorder.h"
 #include "platform/esp/arduino_common/storage/sd_card_runtime.h"
 #include "platform/esp/arduino_common/storage/storage_runtime.h"
-#include "platform/esp/arduino_common/geocaching/browse_runtime.h"
 #include "platform/esp/arduino_common/team/crypto/team_crypto.h"
 #include "platform/esp/arduino_common/team/event/team_app_data_event_bus_bridge.h"
 #include "platform/esp/arduino_common/team/event/team_event_bus_sink.h"
@@ -278,7 +278,6 @@ app::ChatServicesBundle create_chat_services(const app::AppConfig& config,
         }
     }
 
-
     bundle.service = std::unique_ptr<chat::ChatService>(
         new chat::ChatService(*bundle.model, *bundle.mesh_runtime, *bundle.store, config.mesh_protocol));
     if (!bundle.service)
diff --git a/platform/esp/arduino_common/src/gps/track_recorder.cpp b/platform/esp/arduino_common/src/gps/track_recorder.cpp
index 4996a841..09997c2b 100644
--- a/platform/esp/arduino_common/src/gps/track_recorder.cpp
+++ b/platform/esp/arduino_common/src/gps/track_recorder.cpp
@@ -1,7 +1,7 @@
 #include "platform/esp/arduino_common/gps/track_recorder.h"
-#include "platform/esp/arduino_common/storage/sd_card_runtime.h"
-#include "platform/esp/arduino_common/gps/sd_gpx_output.h"
 #include "gps/gpx/track_writer.h"
+#include "platform/esp/arduino_common/gps/sd_gpx_output.h"
+#include "platform/esp/arduino_common/storage/sd_card_runtime.h"
 
 #include <cmath>
 #include <esp_heap_caps.h>
diff --git a/platform/esp/idf_common/src/platform_ui_tracker_runtime.cpp b/platform/esp/idf_common/src/platform_ui_tracker_runtime.cpp
index 29c7aecb..a3a25de8 100644
--- a/platform/esp/idf_common/src/platform_ui_tracker_runtime.cpp
+++ b/platform/esp/idf_common/src/platform_ui_tracker_runtime.cpp
@@ -1,6 +1,6 @@
-#include "platform/ui/tracker_runtime.h"
 #include "gps/gpx/track_writer.h"
 #include "platform/esp/arduino_common/gps/sd_gpx_output.h"
+#include "platform/ui/tracker_runtime.h"
 
 #include "esp_timer.h"
 #include "platform/esp/arduino_common/storage/sd_card_runtime.h"
diff --git a/platform/linux/common/src/platform/ui/team_ui_store_runtime.cpp b/platform/linux/common/src/platform/ui/team_ui_store_runtime.cpp
index 8b26d509..70c65d58 100644
--- a/platform/linux/common/src/platform/ui/team_ui_store_runtime.cpp
+++ b/platform/linux/common/src/platform/ui/team_ui_store_runtime.cpp
@@ -1,6 +1,6 @@
 #include "platform/ui/team_ui_store_runtime.h"
-#include "gps/gpx/track_writer.h"
 #include "gps/gpx/ostream_sink.h"
+#include "gps/gpx/track_writer.h"
 
 #include "platform/linux/runtime_paths.h"
 #include <algorithm>
diff --git a/platform/linux/common/src/platform/ui/tracker_runtime.cpp b/platform/linux/common/src/platform/ui/tracker_runtime.cpp
index 3e2edd3d..3ab938b4 100644
--- a/platform/linux/common/src/platform/ui/tracker_runtime.cpp
+++ b/platform/linux/common/src/platform/ui/tracker_runtime.cpp
@@ -1,6 +1,6 @@
 #include "platform/ui/tracker_runtime.h"
-#include "gps/gpx/track_writer.h"
 #include "gps/gpx/ostream_sink.h"
+#include "gps/gpx/track_writer.h"
 #include <ctime>
 
 #include <algorithm>
diff --git a/scripts/check_track_file_streaming.py b/scripts/check_track_file_streaming.py
index f8e55bab..b4a136d6 100644
--- a/scripts/check_track_file_streaming.py
+++ b/scripts/check_track_file_streaming.py
@@ -43,7 +43,8 @@ FORBIDDEN_LINE_PATTERNS = (
     ("rdbuf_slurp", re.compile(r"<<\s*[^;]+\.rdbuf\s*\(")),
 )
 
-SIZE_READ_PATTERN = re.compile(r"\b(?:size|available)\s*\(\s*\)")
+SIZE_READ_PATTERN = re.compile(r"\b(?:(?P<receiver>\w+)\s*\.\s*)?(?:size|available)\s*\(\s*\)")
+FIXED_ARRAY_PATTERN = re.compile(r"\bstd::array\s*<[^;{}]+>\s+(\w+)\s*(?:\{|;|=)")
 READ_CALL_PATTERN = re.compile(r"\.read\s*\(")
 
 
@@ -118,6 +119,7 @@ def collect_violations() -> list[Violation]:
             continue
 
         lines = text.splitlines()
+        fixed_arrays = set(FIXED_ARRAY_PATTERN.findall(text))
         for line_number, line in enumerate(lines, start=1):
             for rule, pattern in FORBIDDEN_LINE_PATTERNS:
                 if pattern.search(line) and local_track_context(lines, line_number - 1):
@@ -132,7 +134,10 @@ def collect_violations() -> list[Violation]:
                     )
 
         for index, line in enumerate(lines):
-            if not SIZE_READ_PATTERN.search(line):
+            # Fixed array capacity is a streaming bound, not a file length.
+            # Keep all other size/available calls subject to the original rule.
+            if not any(match.group("receiver") not in fixed_arrays
+                       for match in SIZE_READ_PATTERN.finditer(line)):
                 continue
             window = lines[index : min(index + 6, len(lines))]
             if any(READ_CALL_PATTERN.search(candidate) for candidate in window) and local_track_context(
diff --git a/tests/test_track_file_streaming_guard.py b/tests/test_track_file_streaming_guard.py
new file mode 100644
index 00000000..8cc7e82b
--- /dev/null
+++ b/tests/test_track_file_streaming_guard.py
@@ -0,0 +1,52 @@
+"""Regression cases for file-size reads versus bounded array capacity."""
+import importlib.util
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+spec = importlib.util.spec_from_file_location(
+    "track_guard", Path(__file__).resolve().parents[1] / "scripts/check_track_file_streaming.py")
+guard = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = guard
+spec.loader.exec_module(guard)
+
+
+class StreamingGuardTests(unittest.TestCase):
+    def check_source(self, source):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            source_file = root / "gpx.cpp"
+            source_file.write_text("// GPX reader\n" + source, encoding="utf-8")
+            with patch.object(guard, "REPO_ROOT", root), patch.object(
+                    guard, "walk_source_files", return_value=[source_file]):
+                return guard.collect_violations()
+
+    def test_fixed_chunk_and_digest_capacity(self):
+        self.assertEqual([], self.check_source(
+            "std::array<uint8_t, 512> buffer_{};\n"
+            "std::array<uint8_t, 32> hash_{};\n"
+            "digest.finalize(hash_.data(), hash_.size());\n"
+            "auto count = std::min(buffer_.size(), remaining);\n"
+            "file.read(buffer_.data(), count);\n"))
+
+    def test_file_size_remains_forbidden(self):
+        self.assertTrue(self.check_source(
+            "std::array<uint8_t, 512> buffer_{};\n"
+            "auto count = file.size();\n"
+            "file.read(buffer_.data(), count);\n"))
+
+    def test_dynamic_capacity_is_not_exempt(self):
+        self.assertTrue(self.check_source(
+            "std::vector<uint8_t> buffer_;\n"
+            "auto count = buffer_.size();\n"
+            "file.read(buffer_.data(), count);\n"))
+
+    def test_available_and_slurp_remain_forbidden(self):
+        self.assertTrue(self.check_source("auto count = file.available();\nfile.read(data, count);"))
+        self.assertTrue(self.check_source("auto text = file.readString();"))
+
+
+if __name__ == "__main__":
+    unittest.main()