chore: Upgrade to Room 3.0 and refactor related components

conductor/tracks/extract_database_manager_kmp_20260320/index.md

@@ -0,0 +1,9 @@
+# Track: Extract DatabaseManager to KMP
+
+## Documents
+- [Specification](./spec.md)
+- [Implementation Plan](./plan.md)
+- [Metadata](./metadata.json)
+
+## Context
+Meshtastic-Android is designed to support per-node databases. Currently, the logic for managing these databases is in `androidMain`, and the desktop module stubs this out, which leads to a lack of feature parity. This track aims to extract that logic into `commonMain`.

conductor/tracks/extract_database_manager_kmp_20260320/metadata.json

@@ -0,0 +1,8 @@
+{
+  "id": "extract_database_manager_kmp_20260320",
+  "name": "Extract DatabaseManager to KMP",
+  "description": "Move core database management logic (per-node databases, LRU) to commonMain for target parity.",
+  "status": "completed",
+  "tags": ["core", "database", "kmp", "desktop"],
+  "created_at": "2026-03-20T12:00:00Z"
+}

conductor/tracks/extract_database_manager_kmp_20260320/plan.md

@@ -0,0 +1,25 @@
+# Implementation Plan - Extract DatabaseManager to KMP
+
+## Phase 1: Multiplatform Database Abstraction
+- [x] Define `expect fun buildRoomDb(dbName: String): MeshtasticDatabase` in `commonMain`.
+- [x] Implement `actual fun buildRoomDb` for Android (using `Application.getDatabasePath`).
+- [x] Implement `actual fun buildRoomDb` for JVM/Desktop (using the established `~/.meshtastic` data directory).
+- [x] Implement `actual fun buildRoomDb` for iOS (using `NSDocumentDirectory`).
+- [x] Update `DatabaseConstants` with shared keys and default values.
+
+## Phase 2: KMP DataStore & File I/O
+- [x] Replace Android `SharedPreferences` in `DatabaseManager` with a KMP-ready `DataStore<Preferences>` instance named `DatabasePrefs`.
+- [x] Introduce an `expect fun deleteDatabase(dbName: String)` or similar Okio-based deletion helper.
+- [x] Refactor database file listing to use `okio.FileSystem.SYSTEM` instead of `java.io.File`.
+
+## Phase 3: Logic Extraction
+- [x] Move `DatabaseManager.kt` from `core:database/androidMain` to `core:database/commonMain`.
+- [x] Refactor `DatabaseManager` to use the new `buildRoomDb`, `DataStore`, and `FileSystem` abstractions.
+- [x] Ensure `DatabaseManager` is annotated with Koin `@Single` and correctly binds to `DatabaseProvider` and `SharedDatabaseManager` (from `core:common`).
+- [x] Remove `DesktopDatabaseManager` from `desktop` module.
+- [x] Update the DI (Koin) graph in `app` and `desktop` to wire the new shared `DatabaseManager`.
+
+## Phase 4: Verification
+- [x] Add unit tests in `core:database/commonTest` to verify that `switchActiveDatabase` correctly swaps databases and that the LRU eviction limit is respected.
+- [x] Perform manual verification on Desktop to ensure that connecting to different nodes creates separate `.db` files in `~/.meshtastic/`.
+- [x] Verify that the `core:database` module still compiles for Android and iOS targets.

conductor/tracks/extract_database_manager_kmp_20260320/spec.md

@@ -0,0 +1,24 @@
+# Specification - Extract DatabaseManager to KMP
+
+## Overview
+Meshtastic-Android is designed to support per-node databases (e.g., `db_!1234abcd.db`). Currently, the logic for managing these databases (switching, LRU caching, eviction) is trapped in `core:database/androidMain`. The Desktop implementation stubs this out, forcing all nodes to share a single database, which is a major architectural regression and leads to data pollution across different devices.
+
+This track will move the core `DatabaseManager` logic to `commonMain`, enabling full feature parity for database management on Android, Desktop, and iOS.
+
+## Functional Requirements
+- **Per-Node Databases**: Desktop and iOS must support creating and switching between separate databases based on the connected device's address.
+- **LRU Eviction**: Implement an LRU (Least Recently Used) cache for database instances on all platforms.
+- **Cache Limits**: The database cache limit must be configurable and respected across all platforms.
+- **Legacy Cleanup**: Maintain logic for cleaning up legacy databases where applicable.
+
+## Non-Functional Requirements
+- **KMP Purity**: Use only Kotlin Multiplatform-ready libraries (`kotlinx-coroutines`, `okio`, `androidx-datastore`).
+- **Dependency Injection**: Use Koin to wire the shared `DatabaseManager` into all app targets.
+- **Platform Specifics**: Isolate platform-specific path resolution (e.g., Android `getDatabasePath` vs. JVM `user.home`) using the `expect`/`actual` pattern.
+
+## Acceptance Criteria
+1. `DatabaseManager` resides in `core:database/commonMain`.
+2. `DesktopDatabaseManager` (the stub) is deleted.
+3. Desktop creates unique database files when connecting to different nodes.
+4. Unit tests in `commonTest` verify the LRU eviction logic using an Okio in-memory filesystem (or temporary test directory).
+5. No `android.*` or `java.*` imports remain in the shared database management logic.

conductor/tracks/extract_radio_interface_kmp_20260320/index.md

@@ -0,0 +1,9 @@
+# Track: Extract RadioInterfaceService to KMP
+
+## Documents
+- [Specification](./spec.md)
+- [Implementation Plan](./plan.md)
+- [Metadata](./metadata.json)
+
+## Context
+Meshtastic-Android and Desktop orchestrate their hardware connections (TCP, Serial, BLE) independently using `AndroidRadioInterfaceService` and `DesktopRadioInterfaceService`. This duplicates complex logic like reconnect loops and state emission. This track aims to unify that logic into `commonMain`.

conductor/tracks/extract_radio_interface_kmp_20260320/metadata.json

@@ -0,0 +1,8 @@
+{
+  "id": "extract_radio_interface_kmp_20260320",
+  "name": "Extract RadioInterfaceService to KMP",
+  "description": "Unify the connection orchestration lifecycle (TCP, Serial, BLE) into a shared multiplatform service.",
+  "status": "in_progress",
+  "tags": ["core", "service", "kmp", "desktop", "radio", "connection"],
+  "created_at": "2026-03-20T12:00:00Z"
+}

conductor/tracks/extract_radio_interface_kmp_20260320/plan.md

@@ -0,0 +1,20 @@
+# Implementation Plan - Extract RadioInterfaceService to KMP
+
+## Phase 1: Research & Abstraction
+- [ ] Review `AndroidRadioInterfaceService` and `DesktopRadioInterfaceService` to identify identical connection loop logic.
+- [ ] Identify platform-specific dependencies in both implementations (e.g., Android `BluetoothDevice`, notifications).
+- [ ] Define shared abstractions (e.g., `TransportFactory`, `NotificationDelegate`) if needed to decouple platform-specific side effects.
+
+## Phase 2: Logic Extraction
+- [ ] Create `SharedRadioInterfaceService` in `core:service/commonMain`.
+- [ ] Move the core connection loop, state management, and retry logic into the shared service.
+- [ ] Adapt Android and Desktop to use the new shared service.
+
+## Phase 3: Cleanup & Wiring
+- [ ] Remove `DesktopRadioInterfaceService`.
+- [ ] Refactor or remove `AndroidRadioInterfaceService` if entirely superseded.
+- [ ] Update Koin DI graph in `core:service/commonMain` to provide the unified service.
+
+## Phase 4: Verification
+- [ ] Verify that `core:service` and `:app` compile cleanly for Android and Desktop.
+- [ ] Write or update unit tests in `commonTest` to cover the shared connection lifecycle logic.

conductor/tracks/extract_radio_interface_kmp_20260320/spec.md

@@ -0,0 +1,20 @@
+# Specification - Extract RadioInterfaceService to KMP
+
+## Overview
+Currently, the connection orchestration logic for establishing, monitoring, and tearing down connections with Meshtastic radios is duplicated. Android uses `AndroidRadioInterfaceService` in `core:service/androidMain`, and Desktop uses `DesktopRadioInterfaceService` in the `desktop` module. This duplicates core state management (connecting, connected, disconnecting) and the interactions with the shared `TcpTransport`, `SerialTransport`, and `BleTransport`.
+
+This track aims to abstract the remaining platform-specific connection logic (if any) and move the bulk of `RadioInterfaceService` into `core:repository/commonMain` or `core:service/commonMain`, unifying the connection lifecycle across all targets.
+
+## Functional Requirements
+- **Unified Connection Lifecycle**: A single `RadioInterfaceService` implementation in `commonMain` should handle connection state management (connecting, active, disconnect, reconnect loops).
+- **Transport Abstraction**: The service must interact with connections via a multiplatform interface, presumably standardizing around `RadioTransport` or `ConnectionFactory`.
+- **Platform Parity**: Desktop and Android must use the exact same logic for detecting disconnects and issuing reconnects.
+
+## Non-Functional Requirements
+- **KMP Purity**: The unified service must not depend on `android.*` or `java.*` specific APIs for its core lifecycle management.
+- **Dependency Injection**: Utilize Koin in `commonMain` to provide the unified service.
+
+## Acceptance Criteria
+1. `DesktopRadioInterfaceService` is removed.
+2. `AndroidRadioInterfaceService` is replaced by a shared implementation in `commonMain` (e.g., `SharedRadioInterfaceService`).
+3. Both Android and Desktop can successfully connect, disconnect, and handle unexpected drops using the shared logic.