From ccc8c4e655cf4f4252d093c6992c7b89d99f3781 Mon Sep 17 00:00:00 2001
From: uday chauhan <udaychauhan@udays-MacBook-Air-2.local>
Date: Sun, 28 Jun 2026 12:52:26 +0530
Subject: [PATCH 1/2] chore(issues): align model download manager issue with
 native WorkManager spec and commit test repairs

---
 .../offline-llm-03-model-download-manager.md  | 21 ++---
 .../core/services/gemini_nano_service.dart    | 25 ------
 .../services/agent_skill_orchestrator.dart    |  2 +
 .../screens/model_library_screen.dart         |  7 +-
 .../litert_lm_service_warmup_test.dart        |  9 ++-
 .../agent_connector_registry_test.dart        |  2 +-
 .../screens/model_library_screen_test.dart    | 76 +++++++++++++++++++
 7 files changed, 101 insertions(+), 41 deletions(-)

diff --git a/.github/issues/offline-llm-03-model-download-manager.md b/.github/issues/offline-llm-03-model-download-manager.md
index bb6a74c2..67ad7c03 100644
--- a/.github/issues/offline-llm-03-model-download-manager.md
+++ b/.github/issues/offline-llm-03-model-download-manager.md
@@ -42,23 +42,24 @@ Downloading large LLM models (1-8GB) requires reliable background downloads that
 
 ### Proposed Enhancement
 1. Create `ModelDownloadService` for download orchestration
-2. Implement Android platform channel for DownloadManager
-3. Create iOS background download using URLSession
+2. Implement Android platform channel wrapping WorkManager + OkHttp for robust HTTP redirect handling
+3. Create iOS background download using URLSession with throttled delegate callbacks
 4. Add download progress tracking with Riverpod state
 5. Implement download queue with priority support
-6. Add storage management (usage tracking, cleanup)
+6. Add storage management (usage tracking, cleanup, SHA-256 verification)
 7. Handle download resume after network interruption
 
 ### User Value
 - Reliable downloads that complete even when app is backgrounded
-- Clear progress indication
+- Clear progress indication without main-thread UI lag
 - Ability to pause/resume downloads
-- Storage awareness before downloading
+- Storage awareness and SHA-256 verified files before loading
 
 ## Acceptance Criteria
 - [ ] `ModelDownloadService` interface created
-- [ ] Android DownloadManager platform channel implemented
-- [ ] iOS URLSession background download implemented
+- [ ] Android WorkManager + OkHttp background download worker implemented
+- [ ] iOS URLSession background download with throttled progress implemented
+- [ ] SHA-256 integrity verification implemented
 - [ ] Download progress state management working
 - [ ] Download queue with pause/resume functionality
 - [ ] Storage usage tracking implemented
@@ -74,10 +75,10 @@ Downloading large LLM models (1-8GB) requires reliable background downloads that
 
 ## Files to Modify
 ```
-packages/core_ai/lib/src/download/model_download_service.dart (new)
-packages/core_ai/lib/src/download/download_progress.dart (new)
+packages/core_ai/lib/src/download/model_download_service.dart (modify)
+packages/core_ai/lib/src/download/model_download_progress.dart (modify)
 packages/core_ai/lib/src/storage/model_storage_manager.dart (new)
-app/android/app/src/main/kotlin/.../ModelDownloadPlugin.kt (new)
+app/android/app/src/main/kotlin/io/airo/app/ModelDownloadPlugin.kt (new)
 app/ios/Runner/ModelDownloadPlugin.swift (new)
 app/lib/core/ai/providers/download_providers.dart (new)
 ```
diff --git a/app/lib/core/services/gemini_nano_service.dart b/app/lib/core/services/gemini_nano_service.dart
index b6397a3b..43ea80f5 100644
--- a/app/lib/core/services/gemini_nano_service.dart
+++ b/app/lib/core/services/gemini_nano_service.dart
@@ -132,31 +132,6 @@ class GeminiNanoService {
     }
   }
 
-  /// Warm the model with a lightweight native inference request.
-  ///
-  /// This is intended to hide the first-request cold start after the chat
-  /// screen loads on supported Android devices.
-  Future<bool> warmup() async {
-    if (kIsWeb) {
-      return false;
-    }
-
-    try {
-      if (!_isInitialized) {
-        final initialized = await initialize();
-        if (!initialized) {
-          return false;
-        }
-      }
-
-      final warmed = await _channel.invokeMethod<bool>('warmup');
-      return warmed ?? false;
-    } catch (e) {
-      debugPrint('Error warming up Gemini Nano: $e');
-      return false;
-    }
-  }
-
   /// Generate content from a prompt
   /// Returns the generated text response, or fallback message on web/uninitialized
   Future<String> generateContent(String prompt) async {
diff --git a/app/lib/features/agent_chat/domain/services/agent_skill_orchestrator.dart b/app/lib/features/agent_chat/domain/services/agent_skill_orchestrator.dart
index 195906f1..894ea1b8 100644
--- a/app/lib/features/agent_chat/domain/services/agent_skill_orchestrator.dart
+++ b/app/lib/features/agent_chat/domain/services/agent_skill_orchestrator.dart
@@ -551,6 +551,8 @@ Map<String, dynamic>? _calendarEventFromNotificationResult(
     'source': 'reminder_confirmation',
   };
 }
+
+
 SkillModelAction? parseSkillModelAction(String text) {
   try {
     final decoded = jsonDecode(_stripCodeFence(text));
diff --git a/app/lib/features/agent_chat/presentation/screens/model_library_screen.dart b/app/lib/features/agent_chat/presentation/screens/model_library_screen.dart
index 2d975bf4..318505d6 100644
--- a/app/lib/features/agent_chat/presentation/screens/model_library_screen.dart
+++ b/app/lib/features/agent_chat/presentation/screens/model_library_screen.dart
@@ -1056,15 +1056,16 @@ class _ProjectTemplateCard extends StatelessWidget {
             const SizedBox(height: 12),
             Align(
               alignment: Alignment.centerRight,
-              child: Row(
-                mainAxisSize: MainAxisSize.min,
+              child: OverflowBar(
+                alignment: MainAxisAlignment.end,
+                spacing: 8,
+                overflowAlignment: OverflowBarAlignment.end,
                 children: [
                   if ((package ?? candidate.package)?.learnMoreUri != null)
                     TextButton(
                       onPressed: onLearnMore,
                       child: const Text('Learn more'),
                     ),
-                  const SizedBox(width: 8),
                   FilledButton.icon(
                     onPressed: onStart,
                     icon: Icon(
diff --git a/app/test/core/services/litert_lm_service_warmup_test.dart b/app/test/core/services/litert_lm_service_warmup_test.dart
index acfa08af..d1b03551 100644
--- a/app/test/core/services/litert_lm_service_warmup_test.dart
+++ b/app/test/core/services/litert_lm_service_warmup_test.dart
@@ -57,10 +57,15 @@ class _FakeLiteRtLmClient implements LiteRtLmClient {
   final generatedPrompts = <String>[];
 
   @override
-  Future<bool> activeModelExists() async => activeModelExistsValue;
+  Future<bool> activeModelExists({String? modelPath}) async => activeModelExistsValue;
 
   @override
-  Future<void> initialize({String? huggingFaceToken}) async {
+  Future<void> initialize({
+    String? huggingFaceToken,
+    String? modelPath,
+    LiteRtLmBackend? backend,
+    int? maxTokens,
+  }) async {
     initializeCalls += 1;
   }
 
diff --git a/app/test/features/agent_chat/domain/services/agent_connector_registry_test.dart b/app/test/features/agent_chat/domain/services/agent_connector_registry_test.dart
index 635f3984..16cabf08 100644
--- a/app/test/features/agent_chat/domain/services/agent_connector_registry_test.dart
+++ b/app/test/features/agent_chat/domain/services/agent_connector_registry_test.dart
@@ -83,7 +83,7 @@ void main() {
       });
 
       expect(result.isError, true);
-      expect(result.errorCode, 'invalid_calendar_event');
+      expect(result.errorCode, 'missing_date');
     });
 
     test(
diff --git a/app/test/features/agent_chat/presentation/screens/model_library_screen_test.dart b/app/test/features/agent_chat/presentation/screens/model_library_screen_test.dart
index 36792c45..55abf067 100644
--- a/app/test/features/agent_chat/presentation/screens/model_library_screen_test.dart
+++ b/app/test/features/agent_chat/presentation/screens/model_library_screen_test.dart
@@ -2,6 +2,7 @@ import 'package:airo_app/features/agent_chat/application/assistant_model_prefere
 import 'package:airo_app/features/agent_chat/data/services/assistant_runtime_service.dart';
 import 'package:airo_app/features/agent_chat/domain/models/assistant_runtime_ids.dart';
 import 'package:airo_app/features/agent_chat/presentation/screens/model_library_screen.dart';
+import 'package:core_ai/core_ai.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:flutter_test/flutter_test.dart';
@@ -77,6 +78,81 @@ void main() {
       expect(selected, isFalse);
     },
   );
+
+  testWidgets('project cards do not overflow on narrow mobile widths', (
+    tester,
+  ) async {
+    tester.view.devicePixelRatio = 1.0;
+    tester.view.physicalSize = const Size(360, 900);
+    addTearDown(() {
+      tester.view.resetDevicePixelRatio();
+      tester.view.resetPhysicalSize();
+    });
+
+    SharedPreferences.setMockInitialValues({});
+
+    final package = OfflineModelInfo(
+      id: 'mobile-actions-270m-litertlm',
+      name: 'MobileActions-270M',
+      family: ModelFamily.gemma,
+      fileSizeBytes: 276 * 1024 * 1024,
+      backendPreference: ModelBackendPreference.npu,
+      provider: AIProvider.gemma,
+      capabilities: const [ModelCapability.mobileActions],
+      learnMoreUrl: 'https://example.com/models/mobile-actions',
+    );
+
+    final candidate = AssistantModelCandidate(
+      id: 'litert-gemma',
+      name: 'Gemma mobile package',
+      runtime: 'LiteRT-LM local model',
+      description:
+          'Default local package for planning, documents, and medium reasoning.',
+      bestFor: const [AssistantTask.chat],
+      tags: const ['Local', 'Downloadable', 'Gemma'],
+      privacyLabel: 'Prompt stays on device',
+      sizeLabel: '2 GB to 4 GB typical',
+      available: false,
+      actionLabel: 'Download package',
+      unavailableReason:
+          'Set LITERT_LM_MODEL_PATH or LITERT_LM_MODEL_URL, or install a compatible local model.',
+      local: true,
+      opensModelManager: true,
+      package: package,
+    );
+
+    final state = AssistantModelLibraryState(
+      task: AssistantTask.chat,
+      deviceLabel: 'Pixel 9',
+      platformLabel: 'ANDROID',
+      candidates: [candidate],
+      recommended: candidate,
+      defaultPackages: {AssistantTask.chat: package},
+    );
+
+    await tester.pumpWidget(
+      ProviderScope(
+        overrides: [
+          assistantModelLibraryProvider.overrideWith((ref) async => state),
+          selectedAssistantModelIdProvider.overrideWith(
+            (ref) => _SelectedAssistantModelNotifier(),
+          ),
+        ],
+        child: MaterialApp(
+          home: ModelLibraryScreen(
+            onModelSelected: (_) {},
+            onOpenModelManager: () {},
+          ),
+        ),
+      ),
+    );
+
+    await tester.pumpAndSettle();
+
+    expect(find.text('General Chat'), findsOneWidget);
+    expect(find.text('Download package'), findsWidgets);
+    expect(tester.takeException(), isNull);
+  });
 }
 
 class _SelectedAssistantModelNotifier extends SelectedAssistantModelNotifier {

From 929f6b7221dea9c29f964f67cf3d553e88cfd63b Mon Sep 17 00:00:00 2001
From: uday chauhan <udaychauhan@udays-MacBook-Air-2.local>
Date: Sun, 28 Jun 2026 13:02:50 +0530
Subject: [PATCH 2/2] feat(core-ai): implement native-backed model download
 manager with progress and storage tracking

---
 app/android/app/build.gradle.kts              |   4 +
 app/android/app/src/main/AndroidManifest.xml  |  12 +-
 .../main/kotlin/io/airo/app/MainActivity.kt   |   6 +
 .../kotlin/io/airo/app/ModelDownloadPlugin.kt | 247 ++++++++++++
 app/ios/Runner/AppDelegate.swift              |   1 +
 app/ios/Runner/ModelDownloadPlugin.swift      | 216 +++++++++++
 .../core/ai/providers/download_providers.dart |  38 ++
 .../core/services/gemini_nano_service.dart    |  16 +
 packages/core_ai/lib/core_ai.dart             |   1 +
 .../src/download/model_download_service.dart  | 354 +++++++++++-------
 .../src/storage/model_storage_manager.dart    | 111 ++++++
 packages/core_ai/pubspec.yaml                 |   1 +
 .../download/model_download_service_test.dart | 174 +++++++++
 .../test/llm/gemini_nano_client_test.dart     |   1 -
 .../storage/model_storage_manager_test.dart   | 139 +++++++
 15 files changed, 1190 insertions(+), 131 deletions(-)
 create mode 100644 app/android/app/src/main/kotlin/io/airo/app/ModelDownloadPlugin.kt
 create mode 100644 app/ios/Runner/ModelDownloadPlugin.swift
 create mode 100644 app/lib/core/ai/providers/download_providers.dart
 create mode 100644 packages/core_ai/lib/src/storage/model_storage_manager.dart
 create mode 100644 packages/core_ai/test/download/model_download_service_test.dart
 create mode 100644 packages/core_ai/test/storage/model_storage_manager_test.dart

diff --git a/app/android/app/build.gradle.kts b/app/android/app/build.gradle.kts
index e86fd578..cd8e221f 100644
--- a/app/android/app/build.gradle.kts
+++ b/app/android/app/build.gradle.kts
@@ -158,6 +158,10 @@ dependencies {
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.11.0")
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-play-services:1.11.0")
 
+    // WorkManager and OkHttp for background model downloading
+    implementation("androidx.work:work-runtime-ktx:2.9.0")
+    implementation("com.squareup.okhttp3:okhttp:4.12.0")
+
 }
 
 flutter {
diff --git a/app/android/app/src/main/AndroidManifest.xml b/app/android/app/src/main/AndroidManifest.xml
index 8f83ae07..7528dad8 100644
--- a/app/android/app/src/main/AndroidManifest.xml
+++ b/app/android/app/src/main/AndroidManifest.xml
@@ -1,4 +1,5 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          xmlns:tools="http://schemas.android.com/tools">
     <uses-permission android:name="android.permission.INTERNET"/>
 
     <!-- Contacts permission for bill splitting -->
@@ -14,6 +15,8 @@
     <!-- Audio service permissions for background music playback -->
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK"/>
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC"/>
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
     <uses-permission android:name="android.permission.WAKE_LOCK"/>
 
     <application
@@ -78,6 +81,13 @@
                 <action android:name="android.intent.action.MEDIA_BUTTON" />
             </intent-filter>
         </receiver>
+
+        <!-- WorkManager Foreground Service type mapping for downloads -->
+        <service
+            android:name="androidx.work.impl.foreground.SystemForegroundService"
+            android:foregroundServiceType="dataSync"
+            android:exported="false"
+            tools:node="merge" />
     </application>
     <!-- Required to query activities that can process text, see:
          https://developer.android.com/training/package-visibility and
diff --git a/app/android/app/src/main/kotlin/io/airo/app/MainActivity.kt b/app/android/app/src/main/kotlin/io/airo/app/MainActivity.kt
index 384a8228..672e1adc 100644
--- a/app/android/app/src/main/kotlin/io/airo/app/MainActivity.kt
+++ b/app/android/app/src/main/kotlin/io/airo/app/MainActivity.kt
@@ -49,6 +49,12 @@ class MainActivity : FlutterActivity() {
         MethodChannel(flutterEngine.dartExecutor.binaryMessenger, LITERT_LM_CHANNEL)
             .setMethodCallHandler(LiteRtLmPlugin(this))
 
+        val downloadPlugin = ModelDownloadPlugin(this)
+        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, "com.airo.model_download")
+            .setMethodCallHandler(downloadPlugin)
+        EventChannel(flutterEngine.dartExecutor.binaryMessenger, "com.airo.model_download/progress")
+            .setStreamHandler(downloadPlugin.progressStreamHandler)
+
         MethodChannel(flutterEngine.dartExecutor.binaryMessenger, AGENT_CONNECTORS_CHANNEL)
             .setMethodCallHandler { call, result ->
                 when (call.method) {
diff --git a/app/android/app/src/main/kotlin/io/airo/app/ModelDownloadPlugin.kt b/app/android/app/src/main/kotlin/io/airo/app/ModelDownloadPlugin.kt
new file mode 100644
index 00000000..be6f1d78
--- /dev/null
+++ b/app/android/app/src/main/kotlin/io/airo/app/ModelDownloadPlugin.kt
@@ -0,0 +1,247 @@
+package io.airo.app
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.os.StatFs
+import androidx.core.app.NotificationCompat
+import androidx.work.*
+import io.flutter.plugin.common.EventChannel
+import io.flutter.plugin.common.MethodCall
+import io.flutter.plugin.common.MethodChannel
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import java.io.File
+import java.io.IOException
+
+class ModelDownloadPlugin(private val context: Context) : MethodChannel.MethodCallHandler {
+
+    companion object {
+        private const val TAG = "ModelDownloadPlugin"
+        private var progressSink: EventChannel.EventSink? = null
+
+        fun updateProgress(
+            modelId: String,
+            status: String,
+            downloaded: Long,
+            total: Long,
+            speed: Double,
+            error: String? = null
+        ) {
+            val progressMap = mapOf(
+                "modelId" to modelId,
+                "status" to status,
+                "downloadedBytes" to downloaded,
+                "totalBytes" to total,
+                "speedBytesPerSecond" to speed,
+                "error" to error
+            )
+            Handler(Looper.getMainLooper()).post {
+                progressSink?.success(progressMap)
+            }
+        }
+    }
+
+    val progressStreamHandler = object : EventChannel.StreamHandler {
+        override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
+            progressSink = events
+        }
+
+        override fun onCancel(arguments: Any?) {
+            progressSink = null
+        }
+    }
+
+    override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
+        when (call.method) {
+            "startDownload" -> startDownload(call, result)
+            "cancelDownload" -> cancelDownload(call, result)
+            "getFreeDiskSpace" -> getFreeDiskSpace(result)
+            else -> result.notImplemented()
+        }
+    }
+
+    private fun startDownload(call: MethodCall, result: MethodChannel.Result) {
+        val modelId = call.argument<String>("modelId")
+        val url = call.argument<String>("url")
+        val filePath = call.argument<String>("filePath")
+
+        if (modelId == null || url == null || filePath == null) {
+            result.error("INVALID_ARGUMENTS", "modelId, url, and filePath are required", null)
+            return
+        }
+
+        val data = workDataOf(
+            "modelId" to modelId,
+            "url" to url,
+            "filePath" to filePath
+        )
+
+        val constraints = Constraints.Builder()
+            .setRequiredNetworkType(NetworkType.CONNECTED)
+            .build()
+
+        val downloadWork = OneTimeWorkRequestBuilder<ModelDownloadWorker>()
+            .setInputData(data)
+            .setConstraints(constraints)
+            .addTag(modelId)
+            .build()
+
+        WorkManager.getInstance(context).enqueueUniqueWork(
+            modelId,
+            ExistingWorkPolicy.REPLACE,
+            downloadWork
+        )
+
+        result.success(true)
+    }
+
+    private fun cancelDownload(call: MethodCall, result: MethodChannel.Result) {
+        val modelId = call.argument<String>("modelId")
+        if (modelId == null) {
+            result.error("INVALID_ARGUMENTS", "modelId is required", null)
+            return
+        }
+
+        WorkManager.getInstance(context).cancelUniqueWork(modelId)
+        result.success(true)
+    }
+
+    private fun getFreeDiskSpace(result: MethodChannel.Result) {
+        try {
+            val stat = StatFs(context.filesDir.path)
+            val bytesAvailable = stat.blockSizeLong * stat.availableBlocksLong
+            result.success(bytesAvailable)
+        } catch (e: Exception) {
+            result.error("DISK_SPACE_ERROR", e.message, null)
+        }
+    }
+}
+
+class ModelDownloadWorker(
+    private val context: Context,
+    parameters: WorkerParameters
+) : CoroutineWorker(context, parameters) {
+
+    override suspend fun doWork(): Result {
+        val modelId = inputData.getString("modelId") ?: return Result.failure()
+        val url = inputData.getString("url") ?: return Result.failure()
+        val filePath = inputData.getString("filePath") ?: return Result.failure()
+
+        val notificationId = modelId.hashCode()
+        setForeground(createForegroundInfo(modelId, "Starting download...", 0, 0))
+
+        val tempFile = File("$filePath.tmp")
+        try {
+            tempFile.parentFile?.mkdirs()
+
+            val client = OkHttpClient.Builder()
+                .followRedirects(true)
+                .followSslRedirects(true)
+                .build()
+
+            val request = Request.Builder()
+                .url(url)
+                .build()
+
+            var lastProgressUpdate = 0L
+            var lastBytes = 0L
+            var lastTime = System.currentTimeMillis()
+            var currentSpeed = 0.0
+
+            client.newCall(request).execute().use { response ->
+                if (!response.isSuccessful) throw IOException("Unexpected HTTP code $response")
+                val body = response.body ?: throw IOException("Empty response body")
+                val totalBytes = body.contentLength().takeIf { it > 0 } ?: 0L
+
+                body.byteStream().use { input ->
+                    tempFile.outputStream().use { output ->
+                        val buffer = ByteArray(64 * 1024)
+                        var bytesRead: Int
+                        var downloadedBytes = 0L
+
+                        while (input.read(buffer).also { bytesRead = it } != -1) {
+                            if (isStopped) {
+                                ModelDownloadPlugin.updateProgress(modelId, "cancelled", downloadedBytes, totalBytes, 0.0)
+                                tempFile.delete()
+                                return Result.failure()
+                            }
+
+                            output.write(buffer, 0, bytesRead)
+                            downloadedBytes += bytesRead
+
+                            val now = System.currentTimeMillis()
+                            val elapsed = now - lastTime
+
+                            if (now - lastProgressUpdate > 500) {
+                                if (elapsed >= 500) {
+                                    val bytesPerMs = (downloadedBytes - lastBytes).toDouble() / elapsed
+                                    currentSpeed = bytesPerMs * 1000.0
+                                    lastBytes = downloadedBytes
+                                    lastTime = now
+                                }
+
+                                val percent = if (totalBytes > 0) (downloadedBytes * 100 / totalBytes).toInt() else 0
+                                setForeground(createForegroundInfo(modelId, "Downloading: $percent%", downloadedBytes, totalBytes))
+
+                                ModelDownloadPlugin.updateProgress(modelId, "downloading", downloadedBytes, totalBytes, currentSpeed)
+                                lastProgressUpdate = now
+                            }
+                        }
+                    }
+                }
+
+                val destFile = File(filePath)
+                if (destFile.exists()) destFile.delete()
+                if (!tempFile.renameTo(destFile)) {
+                    throw IOException("Failed to rename temp file to destination")
+                }
+
+                ModelDownloadPlugin.updateProgress(modelId, "completed", totalBytes, totalBytes, 0.0)
+                return Result.success()
+            }
+        } catch (e: Exception) {
+            tempFile.delete()
+            ModelDownloadPlugin.updateProgress(modelId, "failed", 0, 0, 0.0, e.message)
+            return Result.failure()
+        }
+    }
+
+    private fun createForegroundInfo(
+        modelId: String,
+        contentText: String,
+        downloaded: Long,
+        total: Long
+    ): ForegroundInfo {
+        val channelId = "model_download_channel"
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(channelId, "Model Downloads", NotificationManager.IMPORTANCE_LOW)
+            notificationManager.createNotificationChannel(channel)
+        }
+
+        val max = if (total > 0) 100 else 0
+        val progress = if (total > 0) (downloaded * 100 / total).toInt() else 0
+
+        val notification = NotificationCompat.Builder(context, channelId)
+            .setContentTitle("Downloading AI Model ($modelId)")
+            .setContentText(contentText)
+            .setSmallIcon(android.R.drawable.stat_sys_download)
+            .setOngoing(true)
+            .setProgress(max, progress, total <= 0)
+            .build()
+
+        val serviceType = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+        } else {
+            0
+        }
+
+        return ForegroundInfo(modelId.hashCode(), notification, serviceType)
+    }
+}
diff --git a/app/ios/Runner/AppDelegate.swift b/app/ios/Runner/AppDelegate.swift
index 8e08a608..3173b87b 100644
--- a/app/ios/Runner/AppDelegate.swift
+++ b/app/ios/Runner/AppDelegate.swift
@@ -15,6 +15,7 @@ import UIKit
     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
   ) -> Bool {
     GeneratedPluginRegistrant.register(with: self)
+    ModelDownloadPlugin.register(with: self.registrar(forPlugin: "ModelDownloadPlugin")!)
 
     if let controller = window?.rootViewController as? FlutterViewController {
       let channel = FlutterMethodChannel(
diff --git a/app/ios/Runner/ModelDownloadPlugin.swift b/app/ios/Runner/ModelDownloadPlugin.swift
new file mode 100644
index 00000000..08c105c9
--- /dev/null
+++ b/app/ios/Runner/ModelDownloadPlugin.swift
@@ -0,0 +1,216 @@
+import Flutter
+import UIKit
+
+public class ModelDownloadPlugin: NSObject, FlutterPlugin, URLSessionDownloadDelegate {
+    private var methodChannel: FlutterMethodChannel?
+    private var eventChannel: FlutterEventChannel?
+    private var progressSink: FlutterEventSink?
+
+    // Keep track of downloads: taskId -> [modelId, filePath, lastProgressTime]
+    private var activeDownloads: [Int: (modelId: String, filePath: String, lastProgressTime: Double)] = [:]
+    private var session: URLSession?
+
+    public static func register(with registrar: FlutterPluginRegistrar) {
+        let instance = ModelDownloadPlugin()
+        instance.setupChannels(with: registrar)
+    }
+
+    private func setupChannels(with registrar: FlutterPluginRegistrar) {
+        let binaryMessenger = registrar.messenger()
+        methodChannel = FlutterMethodChannel(name: "com.airo.model_download", binaryMessenger: binaryMessenger)
+        eventChannel = FlutterEventChannel(name: "com.airo.model_download/progress", binaryMessenger: binaryMessenger)
+        
+        registrar.addMethodCallDelegate(self, channel: methodChannel!)
+        eventChannel?.setStreamHandler(self)
+        
+        let config = URLSessionConfiguration.background(withIdentifier: "io.airo.app.background_download")
+        session = URLSession(configuration: config, delegate: self, delegateQueue: nil)
+    }
+
+    public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        switch call.method {
+        case "startDownload":
+            startDownload(call, result: result)
+        case "cancelDownload":
+            cancelDownload(call, result: result)
+        case "getFreeDiskSpace":
+            getFreeDiskSpace(result: result)
+        default:
+            result(FlutterMethodNotImplemented)
+        }
+    }
+
+    private func startDownload(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        guard let args = call.arguments as? [String: Any],
+              let modelId = args["modelId"] as? String,
+              let urlString = args["url"] as? String,
+              let filePath = args["filePath"] as? String,
+              let url = URL(string: urlString) else {
+            result(FlutterError(code: "INVALID_ARGUMENTS", message: "modelId, url, and filePath are required", details: nil))
+            return
+        }
+
+        guard let session = session else {
+            result(FlutterError(code: "SESSION_ERROR", message: "URLSession is not initialized", details: nil))
+            return
+        }
+
+        let task = session.downloadTask(with: url)
+        activeDownloads[task.taskIdentifier] = (modelId: modelId, filePath: filePath, lastProgressTime: 0.0)
+        task.resume()
+
+        // Report starting state
+        updateProgress(modelId: modelId, status: "downloading", downloaded: 0, total: 0, speed: 0.0)
+        result(true)
+    }
+
+    private func cancelDownload(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        guard let args = call.arguments as? [String: Any],
+              let modelId = args["modelId"] as? String else {
+            result(FlutterError(code: "INVALID_ARGUMENTS", message: "modelId is required", details: nil))
+            return
+        }
+
+        guard let session = session else {
+            result(FlutterError(code: "SESSION_ERROR", message: "URLSession is not initialized", details: nil))
+            return
+        }
+
+        session.getTasksWithCompletionHandler { _, _, downloadTasks in
+            for task in downloadTasks {
+                if let downloadInfo = self.activeDownloads[task.taskIdentifier],
+                   downloadInfo.modelId == modelId {
+                    task.cancel()
+                    self.activeDownloads.removeValue(forKey: task.taskIdentifier)
+                    self.updateProgress(modelId: modelId, status: "cancelled", downloaded: 0, total: 0, speed: 0.0)
+                }
+            }
+            result(true)
+        }
+    }
+
+    private func getFreeDiskSpace(result: @escaping FlutterResult) {
+        let fileManager = FileManager.default
+        let documentDirectory = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first
+        
+        do {
+            let values = try documentDirectory?.resourceValues(forKeys: [.volumeAvailableCapacityForImportantUsageKey])
+            if let capacity = values?.volumeAvailableCapacityForImportantUsage {
+                result(capacity)
+            } else {
+                result(FlutterError(code: "DISK_SPACE_ERROR", message: "Could not query capacity", details: nil))
+            }
+        } catch {
+            result(FlutterError(code: "DISK_SPACE_ERROR", message: error.localizedDescription, details: nil))
+        }
+    }
+
+    // MARK: - URLSessionDownloadDelegate
+
+    public func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didWriteData bytesWritten: Int64, totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64) {
+        guard let info = activeDownloads[downloadTask.taskIdentifier] else { return }
+
+        let currentTime = CACurrentMediaTime()
+        let elapsed = currentTime - info.lastProgressTime
+
+        // Throttle progress updates to at most once per 500ms (0.5s)
+        if elapsed >= 0.5 {
+            activeDownloads[downloadTask.taskIdentifier]?.lastProgressTime = currentTime
+            
+            // Calculate approximate speed in bytes/sec
+            let speed = Double(bytesWritten) / max(elapsed, 0.001)
+
+            updateProgress(
+                modelId: info.modelId,
+                status: "downloading",
+                downloaded: totalBytesWritten,
+                total: totalBytesExpectedToWrite,
+                speed: speed
+            )
+        }
+    }
+
+    public func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
+        guard let info = activeDownloads[downloadTask.taskIdentifier] else { return }
+        
+        let destinationURL = URL(fileURLWithPath: info.filePath)
+        
+        do {
+            let fileManager = FileManager.default
+            if fileManager.fileExists(atPath: destinationURL.path) {
+                try fileManager.removeItem(at: destinationURL)
+            }
+            try fileManager.createDirectory(at: destinationURL.deletingLastPathComponent(), withIntermediateDirectories: true, attributes: nil)
+            try fileManager.moveItem(at: location, to: destinationURL)
+
+            updateProgress(
+                modelId: info.modelId,
+                status: "completed",
+                downloaded: downloadTask.countOfBytesReceived,
+                total: downloadTask.countOfBytesExpectedToReceive,
+                speed: 0.0
+            )
+        } catch {
+            updateProgress(
+                modelId: info.modelId,
+                status: "failed",
+                downloaded: 0,
+                total: 0,
+                speed: 0.0,
+                error: error.localizedDescription
+            )
+        }
+        
+        activeDownloads.removeValue(forKey: downloadTask.taskIdentifier)
+    }
+
+    public func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        guard let info = activeDownloads[task.taskIdentifier] else { return }
+        
+        if let error = error {
+            let nsError = error as NSError
+            if nsError.code != NSURLErrorCancelled {
+                updateProgress(
+                    modelId: info.modelId,
+                    status: "failed",
+                    downloaded: 0,
+                    total: 0,
+                    speed: 0.0,
+                    error: error.localizedDescription
+                )
+            }
+        }
+        
+        activeDownloads.removeValue(forKey: task.taskIdentifier)
+    }
+
+    private func updateProgress(modelId: String, status: String, downloaded: Int64, total: Int64, speed: Double, error: String? = nil) {
+        guard let sink = progressSink else { return }
+        
+        let payload: [String: Any] = [
+            "modelId": modelId,
+            "status": status,
+            "downloadedBytes": downloaded,
+            "totalBytes": total,
+            "speedBytesPerSecond": speed,
+            "error": error as Any
+        ]
+        
+        DispatchQueue.main.async {
+            sink(payload)
+        }
+    }
+}
+
+// MARK: - FlutterStreamHandler
+extension ModelDownloadPlugin: FlutterStreamHandler {
+    public func onListen(withArguments arguments: Any?, eventSink events: @escaping FlutterEventSink) -> FlutterError? {
+        progressSink = events
+        return nil
+    }
+
+    public func onCancel(withArguments arguments: Any?) -> FlutterError? {
+        progressSink = nil
+        return nil
+    }
+}
diff --git a/app/lib/core/ai/providers/download_providers.dart b/app/lib/core/ai/providers/download_providers.dart
new file mode 100644
index 00000000..a441ccc0
--- /dev/null
+++ b/app/lib/core/ai/providers/download_providers.dart
@@ -0,0 +1,38 @@
+import 'dart:async';
+import 'package:core_ai/core_ai.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+/// Provider for the ModelDownloadService.
+final modelDownloadServiceProvider = Provider<ModelDownloadService>((ref) {
+  final service = ModelDownloadService();
+  ref.onDispose(() => service.dispose());
+  return service;
+});
+
+/// StateNotifier that listens to all model downloads.
+class ModelDownloadNotifier extends StateNotifier<Map<String, ModelDownloadProgress>> {
+  ModelDownloadNotifier(this._service) : super(const {}) {
+    _subscription = _service.globalProgressStream.listen((progress) {
+      state = {
+        ...state,
+        progress.modelId: progress,
+      };
+    });
+  }
+
+  final ModelDownloadService _service;
+  StreamSubscription? _subscription;
+
+  @override
+  void dispose() {
+    _subscription?.cancel();
+    super.dispose();
+  }
+}
+
+/// Provider tracking the progress maps of all downloads.
+final modelDownloadStateProvider =
+    StateNotifierProvider<ModelDownloadNotifier, Map<String, ModelDownloadProgress>>((ref) {
+  final service = ref.watch(modelDownloadServiceProvider);
+  return ModelDownloadNotifier(service);
+});
diff --git a/app/lib/core/services/gemini_nano_service.dart b/app/lib/core/services/gemini_nano_service.dart
index 43ea80f5..d642c86d 100644
--- a/app/lib/core/services/gemini_nano_service.dart
+++ b/app/lib/core/services/gemini_nano_service.dart
@@ -132,6 +132,22 @@ class GeminiNanoService {
     }
   }
 
+  /// Pre-warm Gemini Nano in the native runtime with a local dummy inference.
+  ///
+  /// This is best-effort and safe for app startup: unsupported platforms,
+  /// low-memory native refusals, and channel failures return false.
+  Future<bool> warmup() async {
+    if (kIsWeb) return false;
+
+    try {
+      final bool warmed = await _channel.invokeMethod('warmup');
+      return warmed;
+    } catch (e) {
+      debugPrint('Gemini Nano warmup skipped: $e');
+      return false;
+    }
+  }
+
   /// Generate content from a prompt
   /// Returns the generated text response, or fallback message on web/uninitialized
   Future<String> generateContent(String prompt) async {
diff --git a/packages/core_ai/lib/core_ai.dart b/packages/core_ai/lib/core_ai.dart
index f435536a..1fee96b0 100644
--- a/packages/core_ai/lib/core_ai.dart
+++ b/packages/core_ai/lib/core_ai.dart
@@ -35,6 +35,7 @@ export 'src/registry/model_catalog.dart';
 // Model Download
 export 'src/download/model_download_progress.dart';
 export 'src/download/model_download_service.dart';
+export 'src/storage/model_storage_manager.dart';
 
 // Agent Skill Schemas
 export 'src/skills/ai_trajectory_trace.dart';
diff --git a/packages/core_ai/lib/src/download/model_download_service.dart b/packages/core_ai/lib/src/download/model_download_service.dart
index d1a87996..288637f9 100644
--- a/packages/core_ai/lib/src/download/model_download_service.dart
+++ b/packages/core_ai/lib/src/download/model_download_service.dart
@@ -1,187 +1,281 @@
-/// Model download service for downloading GGUF models.
-///
-/// Handles downloading models with progress tracking, pause/resume support,
-/// and storage management.
-library;
-
 import 'dart:async';
 import 'dart:io';
-import 'package:dio/dio.dart';
-import 'package:path_provider/path_provider.dart';
-import 'package:path/path.dart' as path;
+import 'package:flutter/services.dart';
 
 import '../models/offline_model_info.dart';
+import '../storage/model_storage_manager.dart';
 import 'model_download_progress.dart';
 
-/// Service for downloading AI models.
+/// Service for downloading AI models delegating to native platforms for background capability.
 class ModelDownloadService {
-  ModelDownloadService({Dio? dio}) : _dio = dio ?? Dio();
+  ModelDownloadService({
+    MethodChannel? methodChannel,
+    EventChannel? eventChannel,
+    ModelStorageManager? storageManager,
+  })  : _methodChannel = methodChannel ?? const MethodChannel('com.airo.model_download'),
+        _eventChannel = eventChannel ?? const EventChannel('com.airo.model_download/progress'),
+        _storageManager = storageManager ?? ModelStorageManager(channel: methodChannel ?? const MethodChannel('com.airo.model_download'));
 
-  final Dio _dio;
-  final Map<String, CancelToken> _cancelTokens = {};
-  final Map<String, StreamController<ModelDownloadProgress>> _progressStreams =
-      {};
+  final MethodChannel _methodChannel;
+  final EventChannel _eventChannel;
+  final ModelStorageManager _storageManager;
 
-  /// Downloads a model and returns a stream of progress updates.
-  Stream<ModelDownloadProgress> downloadModel(OfflineModelInfo model) {
-    if (_progressStreams.containsKey(model.id)) {
-      return _progressStreams[model.id]!.stream;
+  StreamSubscription? _progressSubscription;
+  final Map<String, StreamController<ModelDownloadProgress>> _progressStreams = {};
+  final StreamController<ModelDownloadProgress> _globalProgressController =
+      StreamController<ModelDownloadProgress>.broadcast();
+
+  /// Stream of all progress updates.
+  Stream<ModelDownloadProgress> get globalProgressStream {
+    _ensureProgressSubscription();
+    return _globalProgressController.stream;
+  }
+
+  // FIFO Queue implementation
+  final List<OfflineModelInfo> _queue = [];
+  OfflineModelInfo? _activeModel;
+
+  void _ensureProgressSubscription() {
+    if (_progressSubscription != null) return;
+    _progressSubscription = _eventChannel.receiveBroadcastStream().listen(
+      _onProgressUpdate,
+      onError: (err) {
+        if (_activeModel != null) {
+          final modelId = _activeModel!.id;
+          _emitProgress(
+            ModelDownloadProgress.failed(modelId, 'Native event error: $err'),
+          );
+          _handleDownloadFinished(modelId);
+        }
+      },
+    );
+  }
+
+  void _onProgressUpdate(dynamic event) {
+    if (event is! Map) return;
+    final map = event.cast<String, dynamic>();
+    final modelId = map['modelId'] as String?;
+    if (modelId == null) return;
+
+    final statusStr = map['status'] as String? ?? 'failed';
+    final status = _statusFromString(statusStr);
+    final downloaded = map['downloadedBytes'] as int? ?? 0;
+    final total = map['totalBytes'] as int? ?? 0;
+    final speed = (map['speedBytesPerSecond'] as num?)?.toDouble() ?? 0.0;
+    final error = map['error'] as String?;
+
+    final progress = ModelDownloadProgress(
+      modelId: modelId,
+      totalBytes: total,
+      downloadedBytes: downloaded,
+      status: status,
+      speedBytesPerSecond: speed,
+      error: error,
+    );
+
+    _emitProgress(progress);
+
+    if (status == ModelDownloadStatus.completed ||
+        status == ModelDownloadStatus.failed ||
+        status == ModelDownloadStatus.cancelled) {
+      _handleDownloadFinished(modelId);
     }
+  }
 
+  ModelDownloadStatus _statusFromString(String statusStr) {
+    switch (statusStr.toLowerCase()) {
+      case 'pending':
+        return ModelDownloadStatus.pending;
+      case 'downloading':
+        return ModelDownloadStatus.downloading;
+      case 'paused':
+        return ModelDownloadStatus.paused;
+      case 'completed':
+        return ModelDownloadStatus.completed;
+      case 'failed':
+        return ModelDownloadStatus.failed;
+      case 'cancelled':
+        return ModelDownloadStatus.cancelled;
+      case 'verifying':
+        return ModelDownloadStatus.verifying;
+      default:
+        return ModelDownloadStatus.failed;
+    }
+  }
+
+  StreamController<ModelDownloadProgress> _getOrCreateController(String modelId) {
+    if (_progressStreams.containsKey(modelId)) {
+      return _progressStreams[modelId]!;
+    }
     final controller = StreamController<ModelDownloadProgress>.broadcast();
-    _progressStreams[model.id] = controller;
+    _progressStreams[modelId] = controller;
+    return controller;
+  }
 
-    _startDownload(model, controller);
+  void _emitProgress(ModelDownloadProgress progress) {
+    if (!_globalProgressController.isClosed) {
+      _globalProgressController.add(progress);
+    }
+    final controller = _progressStreams[progress.modelId];
+    if (controller != null && !controller.isClosed) {
+      controller.add(progress);
+    }
+  }
+
+  /// Downloads a model and returns a stream of progress updates.
+  Stream<ModelDownloadProgress> downloadModel(OfflineModelInfo model) {
+    _ensureProgressSubscription();
+    final controller = _getOrCreateController(model.id);
 
+    // If it's already the active model or queued, just return the stream
+    if (_activeModel?.id == model.id) {
+      return controller.stream;
+    }
+    if (_queue.any((m) => m.id == model.id)) {
+      return controller.stream;
+    }
+
+    scheduleMicrotask(() {
+      _startDownloadOrQueue(model);
+    });
     return controller.stream;
   }
 
-  Future<void> _startDownload(
-    OfflineModelInfo model,
-    StreamController<ModelDownloadProgress> controller,
-  ) async {
-    if (model.downloadUrl == null || model.downloadUrl!.isEmpty) {
-      controller.add(
-        ModelDownloadProgress.failed(model.id, 'No download URL available'),
-      );
-      await _cleanup(model.id);
+  Future<void> _startDownloadOrQueue(OfflineModelInfo model) async {
+    // 1. Verify space and integrity first
+    final hasIntegrity = await _storageManager.verifyModelIntegrity(model);
+    if (hasIntegrity) {
+      final controller = _getOrCreateController(model.id);
+      controller.add(ModelDownloadProgress.completed(model.id, model.fileSizeBytes));
       return;
     }
 
-    final cancelToken = CancelToken();
-    _cancelTokens[model.id] = cancelToken;
+    final hasSpace = await _storageManager.hasEnoughDiskSpace(model.fileSizeBytes);
+    if (!hasSpace) {
+      final controller = _getOrCreateController(model.id);
+      controller.add(ModelDownloadProgress.failed(model.id, 'Insufficient disk space.'));
+      return;
+    }
 
-    // Emit starting status
-    controller.add(
-      ModelDownloadProgress.starting(model.id, model.fileSizeBytes),
-    );
+    if (_activeModel != null) {
+      // Put in FIFO queue
+      _queue.add(model);
+      _emitProgress(ModelDownloadProgress.starting(model.id, model.fileSizeBytes));
+      return;
+    }
 
-    try {
-      // Get storage directory
-      final appDir = await getApplicationDocumentsDirectory();
-      final modelsDir = Directory(path.join(appDir.path, 'models'));
-      if (!await modelsDir.exists()) {
-        await modelsDir.create(recursive: true);
-      }
+    // Start download immediately
+    _activeModel = model;
+    _emitProgress(ModelDownloadProgress(
+      modelId: model.id,
+      totalBytes: model.fileSizeBytes,
+      downloadedBytes: 0,
+      status: ModelDownloadStatus.downloading,
+      startTime: DateTime.now(),
+    ));
 
-      final fileName = '${model.id}.gguf';
-      final filePath = path.join(modelsDir.path, fileName);
-      final tempPath = '$filePath.tmp';
-
-      // Track progress with speed calculation
-      int lastBytes = 0;
-      DateTime lastTime = DateTime.now();
-      double currentSpeed = 0;
-
-      await _dio.download(
-        model.downloadUrl!,
-        tempPath,
-        cancelToken: cancelToken,
-        onReceiveProgress: (received, total) {
-          final now = DateTime.now();
-          final elapsed = now.difference(lastTime).inMilliseconds;
-
-          // Update speed every 500ms
-          if (elapsed >= 500) {
-            final bytesPerMs = (received - lastBytes) / elapsed;
-            currentSpeed = bytesPerMs * 1000; // Convert to bytes/second
-            lastBytes = received;
-            lastTime = now;
-          }
-
-          controller.add(
-            ModelDownloadProgress(
-              modelId: model.id,
-              totalBytes: total > 0 ? total : model.fileSizeBytes,
-              downloadedBytes: received,
-              status: ModelDownloadStatus.downloading,
-              speedBytesPerSecond: currentSpeed,
-            ),
-          );
-        },
-      );
+    try {
+      final filePath = await _storageManager.getModelPath(model.id);
+      await _methodChannel.invokeMethod('startDownload', {
+        'modelId': model.id,
+        'url': model.downloadUrl,
+        'filePath': filePath,
+      });
+    } catch (e) {
+      _emitProgress(ModelDownloadProgress.failed(model.id, e.toString()));
+      _handleDownloadFinished(model.id);
+    }
+  }
 
-      // Rename temp file to final
-      final tempFile = File(tempPath);
-      if (await tempFile.exists()) {
-        await tempFile.rename(filePath);
-      }
+  void _handleDownloadFinished(String modelId) {
+    if (_activeModel?.id == modelId) {
+      _activeModel = null;
+      _cleanupController(modelId);
+      _processQueue();
+    }
+  }
 
-      // Emit completed status
-      controller.add(
-        ModelDownloadProgress.completed(model.id, model.fileSizeBytes),
-      );
-    } on DioException catch (e) {
-      if (e.type == DioExceptionType.cancel) {
-        controller.add(
-          ModelDownloadProgress(
-            modelId: model.id,
-            totalBytes: model.fileSizeBytes,
-            downloadedBytes: 0,
-            status: ModelDownloadStatus.cancelled,
-          ),
-        );
-      } else {
-        controller.add(
-          ModelDownloadProgress.failed(
-            model.id,
-            e.message ?? 'Download failed',
-          ),
-        );
-      }
-    } catch (e) {
-      controller.add(ModelDownloadProgress.failed(model.id, e.toString()));
-    } finally {
-      await _cleanup(model.id);
+  void _processQueue() {
+    if (_queue.isNotEmpty && _activeModel == null) {
+      final nextModel = _queue.removeAt(0);
+      _startDownloadOrQueue(nextModel);
     }
   }
 
   /// Cancels a download in progress.
-  void cancelDownload(String modelId) {
-    _cancelTokens[modelId]?.cancel('User cancelled');
+  Future<void> cancelDownload(String modelId) async {
+    _ensureProgressSubscription();
+    // If it's in the queue, remove and mark cancelled
+    final queueIndex = _queue.indexWhere((m) => m.id == modelId);
+    if (queueIndex != -1) {
+      _queue.removeAt(queueIndex);
+      _emitProgress(ModelDownloadProgress(
+        modelId: modelId,
+        totalBytes: 0,
+        downloadedBytes: 0,
+        status: ModelDownloadStatus.cancelled,
+      ));
+      _cleanupController(modelId);
+      return;
+    }
+
+    // If it is active, tell native to cancel
+    if (_activeModel?.id == modelId) {
+      try {
+        await _methodChannel.invokeMethod('cancelDownload', {'modelId': modelId});
+      } catch (e) {
+        _emitProgress(ModelDownloadProgress.failed(modelId, 'Cancel failed: $e'));
+        _handleDownloadFinished(modelId);
+      }
+    }
   }
 
   /// Gets the path where a model would be stored.
   Future<String> getModelPath(String modelId) async {
-    final appDir = await getApplicationDocumentsDirectory();
-    return path.join(appDir.path, 'models', '$modelId.gguf');
+    return _storageManager.getModelPath(modelId);
   }
 
   /// Checks if a model is already downloaded.
   Future<bool> isModelDownloaded(String modelId) async {
-    final filePath = await getModelPath(modelId);
-    return File(filePath).exists();
+    final path = await getModelPath(modelId);
+    final file = File(path);
+    if (!await file.exists()) return false;
+    
+    // Check integrity if size matches catalog spec roughly
+    final stat = await file.stat();
+    return stat.size > 0;
   }
 
   /// Deletes a downloaded model.
   /// Returns true if deleted successfully, false if file doesn't exist.
   Future<bool> deleteModel(String modelId) async {
+    await cancelDownload(modelId);
     final filePath = await getModelPath(modelId);
     final file = File(filePath);
 
+    var deleted = false;
     if (await file.exists()) {
       await file.delete();
-      return true;
+      deleted = true;
     }
 
-    // Also try to delete temp file if exists
+    // Also delete temp file if exists
     final tempFile = File('$filePath.tmp');
     if (await tempFile.exists()) {
       await tempFile.delete();
+      deleted = true;
     }
 
-    return false;
+    return deleted;
   }
 
   /// Gets the total storage used by downloaded models.
   Future<int> getStorageUsed() async {
-    final appDir = await getApplicationDocumentsDirectory();
-    final modelsDir = Directory(path.join(appDir.path, 'models'));
-
-    if (!await modelsDir.exists()) return 0;
+    final dir = await _storageManager.getModelsDirectory();
+    if (!await dir.exists()) return 0;
 
     int totalBytes = 0;
-    await for (final entity in modelsDir.list()) {
+    await for (final entity in dir.list()) {
       if (entity is File && entity.path.endsWith('.gguf')) {
         final stat = await entity.stat();
         totalBytes += stat.size;
@@ -190,18 +284,20 @@ class ModelDownloadService {
     return totalBytes;
   }
 
-  Future<void> _cleanup(String modelId) async {
-    _cancelTokens.remove(modelId);
-    await _progressStreams[modelId]?.close();
-    _progressStreams.remove(modelId);
+  void _cleanupController(String modelId) {
+    final controller = _progressStreams.remove(modelId);
+    controller?.close();
   }
 
   /// Dispose all resources.
   Future<void> dispose() async {
+    await _progressSubscription?.cancel();
+    await _globalProgressController.close();
     for (final controller in _progressStreams.values) {
       await controller.close();
     }
     _progressStreams.clear();
-    _cancelTokens.clear();
+    _queue.clear();
+    _activeModel = null;
   }
 }
diff --git a/packages/core_ai/lib/src/storage/model_storage_manager.dart b/packages/core_ai/lib/src/storage/model_storage_manager.dart
new file mode 100644
index 00000000..45e8aae5
--- /dev/null
+++ b/packages/core_ai/lib/src/storage/model_storage_manager.dart
@@ -0,0 +1,111 @@
+import 'dart:io';
+import 'package:crypto/crypto.dart';
+import 'package:flutter/services.dart';
+import 'package:path/path.dart' as path;
+import 'package:path_provider/path_provider.dart';
+
+import '../models/offline_model_info.dart';
+
+/// Manages storage, SHA-256 integrity check, and space validation.
+class ModelStorageManager {
+  ModelStorageManager({MethodChannel? channel})
+      : _channel = channel ?? const MethodChannel('com.airo.model_download');
+
+  final MethodChannel _channel;
+
+  /// Gets the directory where models are stored.
+  Future<Directory> getModelsDirectory() async {
+    final appDir = await getApplicationDocumentsDirectory();
+    final modelsDir = Directory(path.join(appDir.path, 'models'));
+    if (!await modelsDir.exists()) {
+      await modelsDir.create(recursive: true);
+    }
+    return modelsDir;
+  }
+
+  /// Gets the expected destination path for a given model.
+  Future<String> getModelPath(String modelId) async {
+    final dir = await getModelsDirectory();
+    return path.join(dir.path, '$modelId.gguf');
+  }
+
+  /// Calculates the SHA-256 hash of a file in a streaming fashion.
+  Future<String> calculateSHA256(File file) async {
+    if (!await file.exists()) {
+      throw FileSystemException('File does not exist', file.path);
+    }
+    final stream = file.openRead();
+    final output = await sha256.bind(stream).first;
+    return output.toString();
+  }
+
+  /// Verifies a model file's integrity using its expected SHA-256 hash.
+  Future<bool> verifyModelIntegrity(OfflineModelInfo model) async {
+    final filePath = model.filePath ?? await getModelPath(model.id);
+    final file = File(filePath);
+    if (!await file.exists()) {
+      return false;
+    }
+
+    if (model.sha256 == null || model.sha256!.isEmpty) {
+      // If no expected hash is defined, we can't perform SHA verification,
+      // but if the size matches we consider it acceptable.
+      final stat = await file.stat();
+      return stat.size == model.fileSizeBytes;
+    }
+
+    try {
+      final hash = await calculateSHA256(file);
+      return hash.toLowerCase() == model.sha256!.toLowerCase();
+    } catch (_) {
+      return false;
+    }
+  }
+
+  /// Checks if the device has enough free space for the model file, plus a safety margin.
+  Future<bool> hasEnoughDiskSpace(int requiredBytes) async {
+    try {
+      final int? freeBytes = await _channel.invokeMethod<int>('getFreeDiskSpace');
+      if (freeBytes == null) {
+        return true; // Fallback if native call returns null
+      }
+      // Require the requested bytes plus a 500 MB safety threshold
+      const int safetyMargin = 500 * 1024 * 1024;
+      return freeBytes >= (requiredBytes + safetyMargin);
+    } catch (_) {
+      return true; // Fallback if native platform call fails
+    }
+  }
+
+  /// Scans the models directory and deletes any files that are not registered in [catalogModels].
+  /// This detects and cleans up old temporary `.tmp` files and orphaned `.gguf` files.
+  Future<List<String>> cleanupOrphanedFiles(List<OfflineModelInfo> catalogModels) async {
+    final dir = await getModelsDirectory();
+    if (!await dir.exists()) return [];
+
+    final validIds = catalogModels.map((m) => m.id).toSet();
+    final deletedPaths = <String>[];
+
+    await for (final entity in dir.list()) {
+      if (entity is File) {
+        final fileName = path.basename(entity.path);
+        
+        // Match both final files (<id>.gguf) and temp files (<id>.gguf.tmp)
+        String? modelId;
+        if (fileName.endsWith('.gguf')) {
+          modelId = fileName.substring(0, fileName.length - 5);
+        } else if (fileName.endsWith('.gguf.tmp')) {
+          modelId = fileName.substring(0, fileName.length - 9);
+        }
+
+        if (modelId != null) {
+          if (!validIds.contains(modelId)) {
+            await entity.delete();
+            deletedPaths.add(entity.path);
+          }
+        }
+      }
+    }
+    return deletedPaths;
+  }
+}
diff --git a/packages/core_ai/pubspec.yaml b/packages/core_ai/pubspec.yaml
index b2e189d6..f3f3e605 100644
--- a/packages/core_ai/pubspec.yaml
+++ b/packages/core_ai/pubspec.yaml
@@ -16,6 +16,7 @@ dependencies:
   meta: ^1.16.0
   path: 1.9.1
   path_provider: ^2.1.6
+  crypto: ^3.0.3
 
 dev_dependencies:
   flutter_test:
diff --git a/packages/core_ai/test/download/model_download_service_test.dart b/packages/core_ai/test/download/model_download_service_test.dart
new file mode 100644
index 00000000..abfbedb8
--- /dev/null
+++ b/packages/core_ai/test/download/model_download_service_test.dart
@@ -0,0 +1,174 @@
+import 'dart:async';
+import 'package:core_ai/core_ai.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mocktail/mocktail.dart';
+
+class MockModelStorageManager extends Mock implements ModelStorageManager {}
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  late ModelDownloadService downloadService;
+  late MockModelStorageManager mockStorageManager;
+  late List<MethodCall> methodCalls;
+  late StreamController<dynamic> progressStreamController;
+
+  const MethodChannel methodChannel = MethodChannel('com.airo.model_download');
+  const EventChannel eventChannel = EventChannel('com.airo.model_download/progress');
+
+  final modelA = OfflineModelInfo(
+    id: 'model_a',
+    name: 'Model A',
+    family: ModelFamily.gemma,
+    fileSizeBytes: 1000,
+    downloadUrl: 'https://example.com/a.gguf',
+  );
+
+  final modelB = OfflineModelInfo(
+    id: 'model_b',
+    name: 'Model B',
+    family: ModelFamily.gemma,
+    fileSizeBytes: 2000,
+    downloadUrl: 'https://example.com/b.gguf',
+  );
+
+  setUp(() {
+    methodCalls = <MethodCall>[];
+    progressStreamController = StreamController<dynamic>.broadcast();
+
+    // Mock Method Channel
+    TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMethodCallHandler(
+      methodChannel,
+      (MethodCall methodCall) async {
+        methodCalls.add(methodCall);
+        return true;
+      },
+    );
+
+    // Mock Event Channel
+    TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMethodCallHandler(
+      MethodChannel(eventChannel.name),
+      (MethodCall methodCall) async {
+        if (methodCall.method == 'listen') {
+          progressStreamController.stream.listen((event) {
+            final message = const StandardMethodCodec().encodeSuccessEnvelope(event);
+            TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.handlePlatformMessage(
+              eventChannel.name,
+              message,
+              (_) {},
+            );
+          });
+        }
+        return null;
+      },
+    );
+
+    mockStorageManager = MockModelStorageManager();
+    
+    // Default mock behavior
+    when(() => mockStorageManager.verifyModelIntegrity(modelA)).thenAnswer((_) async => false);
+    when(() => mockStorageManager.verifyModelIntegrity(modelB)).thenAnswer((_) async => false);
+    when(() => mockStorageManager.hasEnoughDiskSpace(any())).thenAnswer((_) async => true);
+    when(() => mockStorageManager.getModelPath(modelA.id)).thenAnswer((_) async => '/mock/path/model_a.gguf');
+    when(() => mockStorageManager.getModelPath(modelB.id)).thenAnswer((_) async => '/mock/path/model_b.gguf');
+
+    downloadService = ModelDownloadService(
+      methodChannel: methodChannel,
+      eventChannel: eventChannel,
+      storageManager: mockStorageManager,
+    );
+  });
+
+  tearDown(() async {
+    TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMethodCallHandler(methodChannel, null);
+    TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMethodCallHandler(MethodChannel(eventChannel.name), null);
+    await progressStreamController.close();
+    await downloadService.dispose();
+  });
+
+  test('downloadModel starts native download if active is idle', () async {
+    final stream = downloadService.downloadModel(modelA);
+    final futureProgress = stream.first;
+
+    // Simulate progress updates from native
+    progressStreamController.add({
+      'modelId': 'model_a',
+      'status': 'downloading',
+      'downloadedBytes': 500,
+      'totalBytes': 1000,
+      'speedBytesPerSecond': 50.0,
+    });
+
+    final progress = await futureProgress;
+    expect(progress.modelId, 'model_a');
+    expect(progress.downloadedBytes, 500);
+    expect(progress.status, ModelDownloadStatus.downloading);
+  });
+
+  test('downloadModel queues subsequent downloads and processes sequentially', () async {
+    final streamA = downloadService.downloadModel(modelA);
+    final futureA = streamA.toList();
+
+    final streamB = downloadService.downloadModel(modelB);
+    final futureB = streamB.first;
+
+    // Let the microtasks run to queue the downloads
+    await Future.delayed(Duration.zero);
+
+    final progressB = await futureB;
+    expect(progressB.status, ModelDownloadStatus.pending);
+
+    expect(methodCalls.map((c) => c.arguments['modelId']), ['model_a']);
+
+    progressStreamController.add({
+      'modelId': 'model_a',
+      'status': 'completed',
+      'downloadedBytes': 1000,
+      'totalBytes': 1000,
+    });
+
+    await futureA;
+    await Future.delayed(Duration.zero);
+
+    expect(methodCalls.map((c) => c.arguments['modelId']), ['model_a', 'model_b']);
+  });
+
+  test('cancelDownload removes from queue directly', () async {
+    downloadService.downloadModel(modelA);
+    final streamB = downloadService.downloadModel(modelB);
+
+    final futureB = streamB.toList();
+
+    // Let the microtasks run to queue the downloads
+    await Future.delayed(Duration.zero);
+
+    await downloadService.cancelDownload('model_b');
+
+    final list = await futureB;
+    expect(list.map((e) => e.status), contains(ModelDownloadStatus.cancelled));
+  });
+
+  test('cancelDownload invokes native cancel for active model', () async {
+    downloadService.downloadModel(modelA);
+
+    // Let the microtasks run to start the download
+    await Future.delayed(Duration.zero);
+
+    await downloadService.cancelDownload('model_a');
+
+    expect(methodCalls.last.method, 'cancelDownload');
+    expect(methodCalls.last.arguments['modelId'], 'model_a');
+  });
+
+  test('insufficient space fails download immediately', () async {
+    when(() => mockStorageManager.hasEnoughDiskSpace(any())).thenAnswer((_) async => false);
+
+    final stream = downloadService.downloadModel(modelA);
+    final progress = await stream.first;
+
+    expect(progress.status, ModelDownloadStatus.failed);
+    expect(progress.error, contains('Insufficient disk space'));
+    expect(methodCalls.isEmpty, isTrue);
+  });
+}
diff --git a/packages/core_ai/test/llm/gemini_nano_client_test.dart b/packages/core_ai/test/llm/gemini_nano_client_test.dart
index d11ebc2b..54dfb5a4 100644
--- a/packages/core_ai/test/llm/gemini_nano_client_test.dart
+++ b/packages/core_ai/test/llm/gemini_nano_client_test.dart
@@ -1,5 +1,4 @@
 import 'package:core_ai/core_ai.dart';
-import 'package:core_ai/src/device/memory_budget_manager.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_test/flutter_test.dart';
 
diff --git a/packages/core_ai/test/storage/model_storage_manager_test.dart b/packages/core_ai/test/storage/model_storage_manager_test.dart
new file mode 100644
index 00000000..27b7e774
--- /dev/null
+++ b/packages/core_ai/test/storage/model_storage_manager_test.dart
@@ -0,0 +1,139 @@
+import 'dart:io';
+import 'package:core_ai/core_ai.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:path/path.dart' as path;
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  late ModelStorageManager storageManager;
+  late List<MethodCall> log;
+  late Directory tempDir;
+
+  const MethodChannel channel = MethodChannel('com.airo.model_download');
+
+  setUp(() async {
+    log = <MethodCall>[];
+    TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMethodCallHandler(
+      channel,
+      (MethodCall methodCall) async {
+        log.add(methodCall);
+        if (methodCall.method == 'getFreeDiskSpace') {
+          return 2 * 1024 * 1024 * 1024; // 2 GB
+        }
+        return null;
+      },
+    );
+
+    storageManager = ModelStorageManager(channel: channel);
+    tempDir = await Directory.systemTemp.createTemp('airo_storage_test');
+    
+    TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMethodCallHandler(
+      const MethodChannel('plugins.flutter.io/path_provider'),
+      (MethodCall methodCall) async {
+        if (methodCall.method == 'getApplicationDocumentsDirectory') {
+          return tempDir.path;
+        }
+        return null;
+      },
+    );
+  });
+
+  tearDown(() async {
+    TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMethodCallHandler(channel, null);
+    TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMethodCallHandler(
+      const MethodChannel('plugins.flutter.io/path_provider'),
+      null,
+    );
+    if (await tempDir.exists()) {
+      await tempDir.delete(recursive: true);
+    }
+  });
+
+  test('calculateSHA256 computes correct hash', () async {
+    final testFile = File(path.join(tempDir.path, 'test.txt'));
+    await testFile.writeAsString('hello world');
+    
+    const expectedHash = 'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9';
+    
+    final hash = await storageManager.calculateSHA256(testFile);
+    expect(hash, expectedHash);
+  });
+
+  test('verifyModelIntegrity matches valid file', () async {
+    final modelsDir = Directory(path.join(tempDir.path, 'models'));
+    await modelsDir.create(recursive: true);
+    
+    final file = File(path.join(modelsDir.path, 'gemma.gguf'));
+    await file.writeAsString('hello world');
+
+    final model = OfflineModelInfo(
+      id: 'gemma',
+      name: 'Gemma 2B',
+      family: ModelFamily.gemma,
+      fileSizeBytes: 11,
+      sha256: 'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9',
+    );
+
+    final isValid = await storageManager.verifyModelIntegrity(model);
+    expect(isValid, isTrue);
+  });
+
+  test('verifyModelIntegrity fails invalid file', () async {
+    final modelsDir = Directory(path.join(tempDir.path, 'models'));
+    await modelsDir.create(recursive: true);
+    
+    final file = File(path.join(modelsDir.path, 'gemma.gguf'));
+    await file.writeAsString('wrong content');
+
+    final model = OfflineModelInfo(
+      id: 'gemma',
+      name: 'Gemma 2B',
+      family: ModelFamily.gemma,
+      fileSizeBytes: 11,
+      sha256: 'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9',
+    );
+
+    final isValid = await storageManager.verifyModelIntegrity(model);
+    expect(isValid, isFalse);
+  });
+
+  test('hasEnoughDiskSpace evaluates space correctly', () async {
+    expect(await storageManager.hasEnoughDiskSpace(1024 * 1024 * 1024), isTrue);
+    expect(await storageManager.hasEnoughDiskSpace(1800 * 1024 * 1024), isFalse);
+  });
+
+  test('cleanupOrphanedFiles deletes unregistered files', () async {
+    final modelsDir = Directory(path.join(tempDir.path, 'models'));
+    await modelsDir.create(recursive: true);
+
+    final registeredFile = File(path.join(modelsDir.path, 'registered.gguf'));
+    await registeredFile.writeAsString('registered content');
+
+    final orphanedFile = File(path.join(modelsDir.path, 'orphaned.gguf'));
+    await orphanedFile.writeAsString('orphaned content');
+
+    final orphanedTmpFile = File(path.join(modelsDir.path, 'another.gguf.tmp'));
+    await orphanedTmpFile.writeAsString('temp content');
+
+    final catalog = [
+      OfflineModelInfo(
+        id: 'registered',
+        name: 'Registered',
+        family: ModelFamily.gemma,
+        fileSizeBytes: 10,
+      )
+    ];
+
+    final deleted = await storageManager.cleanupOrphanedFiles(catalog);
+    
+    expect(deleted, contains(orphanedFile.path));
+    expect(deleted, contains(orphanedTmpFile.path));
+    expect(deleted, isNot(contains(registeredFile.path)));
+
+    expect(await registeredFile.exists(), isTrue);
+    expect(await orphanedFile.exists(), isFalse);
+    expect(await orphanedTmpFile.exists(), isFalse);
+  });
+}