diff --git a/.gitignore b/.gitignore
index b27a980559..0661d3abab 100644
--- a/.gitignore
+++ b/.gitignore
@@ -196,3 +196,7 @@ omiGlass/.expo
 /backend/logs/
 app/.fvm/
 app/android/.kotlin/
+
+# Miscellaneous
+*tags
+*cscope.out
diff --git a/app/android/app/src/main/AndroidManifest.xml b/app/android/app/src/main/AndroidManifest.xml
index 189fb6c5b7..2ba40ce5fb 100644
--- a/app/android/app/src/main/AndroidManifest.xml
+++ b/app/android/app/src/main/AndroidManifest.xml
@@ -3,6 +3,8 @@
     package="com.friend.ios">
 
     <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
 
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <!-- Tell Google Play Store that your app uses Bluetooth LE
diff --git a/app/lib/gen/assets.gen.dart b/app/lib/gen/assets.gen.dart
index 57bccc07a6..98e654f21c 100644
--- a/app/lib/gen/assets.gen.dart
+++ b/app/lib/gen/assets.gen.dart
@@ -53,15 +53,15 @@ class $AssetsFontsGen {
 
   /// List of all assets
   List<String> get values => [
-        sfprodisplayblackitalic,
-        sfprodisplaybold,
-        sfprodisplayheavyitalic,
-        sfprodisplaylightitalic,
-        sfprodisplaymedium,
-        sfprodisplayregular,
-        sfprodisplaysemibolditalic,
-        sfprodisplaythinitalic
-      ];
+    sfprodisplayblackitalic,
+    sfprodisplaybold,
+    sfprodisplayheavyitalic,
+    sfprodisplaylightitalic,
+    sfprodisplaymedium,
+    sfprodisplayregular,
+    sfprodisplaysemibolditalic,
+    sfprodisplaythinitalic,
+  ];
 }
 
 class $AssetsImagesGen {
@@ -101,6 +101,10 @@ class $AssetsImagesGen {
   AssetGenImage get appLauncherIconV2 =>
       const AssetGenImage('assets/images/app_launcher_icon_v2.png');
 
+  /// File path: assets/images/apple-reminders-logo.png
+  AssetGenImage get appleRemindersLogo =>
+      const AssetGenImage('assets/images/apple-reminders-logo.png');
+
   /// File path: assets/images/apple_logo.png
   AssetGenImage get appleLogo =>
       const AssetGenImage('assets/images/apple_logo.png');
@@ -355,84 +359,85 @@ class $AssetsImagesGen {
 
   /// List of all assets
   List<dynamic> get values => [
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        logoTextWhite,
-        aiMagic,
-        appLauncherIcon,
-        appLauncherIconV1,
-        appLauncherIconV2,
-        appleLogo,
-        background,
-        blob,
-        calendarLogo,
-        checkbox,
-        clone,
-        emailLogo,
-        emotionalFeedback1,
-        facebookLogo,
-        googleLogo,
-        gradientCard,
-        herologo,
-        herologoV1,
-        herologoV3,
-        herologoV4,
-        icChart,
-        icCloneChat,
-        icClonePlus,
-        icDollar,
-        icPersonaProfile,
-        icSettingPersona,
-        imessageLogo,
-        instagramLogo,
-        instruction1,
-        instruction2,
-        instruction3,
-        linkIcon,
-        linkedinLogo,
-        logoTransparent,
-        logoTransparentV1,
-        logoTransparentV2,
-        newBackground,
-        notionLogo,
-        omiDevkitWithoutRope,
-        omiGlass,
-        omiWithoutRopeTurnedOff,
-        omiWithoutRope,
-        onboardingBg1,
-        onboardingBg2,
-        onboardingBg3,
-        onboardingBg4,
-        onboardingBg51,
-        onboardingBg52,
-        onboardingBg6,
-        onboardingLanguageGrey,
-        onboardingNameGrey,
-        onboardingNameWhite,
-        onboardingName,
-        onboardingPermissions,
-        onboarding,
-        recordingGreenCircleIcon,
-        slackLogo,
-        speaker0Icon,
-        speaker1Icon,
-        splash,
-        splashIcon,
-        splashIconV1,
-        splashIconV2,
-        splashV1,
-        splashV2,
-        stars,
-        stripeLogo,
-        telegramLogo,
-        whatsappLogo,
-        xLogo,
-        xLogoMini,
-        youtubeLogo
-      ];
+    a1,
+    a2,
+    a3,
+    a4,
+    a5,
+    logoTextWhite,
+    aiMagic,
+    appLauncherIcon,
+    appLauncherIconV1,
+    appLauncherIconV2,
+    appleRemindersLogo,
+    appleLogo,
+    background,
+    blob,
+    calendarLogo,
+    checkbox,
+    clone,
+    emailLogo,
+    emotionalFeedback1,
+    facebookLogo,
+    googleLogo,
+    gradientCard,
+    herologo,
+    herologoV1,
+    herologoV3,
+    herologoV4,
+    icChart,
+    icCloneChat,
+    icClonePlus,
+    icDollar,
+    icPersonaProfile,
+    icSettingPersona,
+    imessageLogo,
+    instagramLogo,
+    instruction1,
+    instruction2,
+    instruction3,
+    linkIcon,
+    linkedinLogo,
+    logoTransparent,
+    logoTransparentV1,
+    logoTransparentV2,
+    newBackground,
+    notionLogo,
+    omiDevkitWithoutRope,
+    omiGlass,
+    omiWithoutRopeTurnedOff,
+    omiWithoutRope,
+    onboardingBg1,
+    onboardingBg2,
+    onboardingBg3,
+    onboardingBg4,
+    onboardingBg51,
+    onboardingBg52,
+    onboardingBg6,
+    onboardingLanguageGrey,
+    onboardingNameGrey,
+    onboardingNameWhite,
+    onboardingName,
+    onboardingPermissions,
+    onboarding,
+    recordingGreenCircleIcon,
+    slackLogo,
+    speaker0Icon,
+    speaker1Icon,
+    splash,
+    splashIcon,
+    splashIconV1,
+    splashIconV2,
+    splashV1,
+    splashV2,
+    stars,
+    stripeLogo,
+    telegramLogo,
+    whatsappLogo,
+    xLogo,
+    xLogoMini,
+    youtubeLogo,
+  ];
 }
 
 class $AssetsLottieAnimationsGen {
@@ -479,11 +484,7 @@ class Assets {
 }
 
 class AssetGenImage {
-  const AssetGenImage(
-    this._assetName, {
-    this.size,
-    this.flavors = const {},
-  });
+  const AssetGenImage(this._assetName, {this.size, this.flavors = const {}});
 
   final String _assetName;
 
@@ -543,15 +544,8 @@ class AssetGenImage {
     );
   }
 
-  ImageProvider provider({
-    AssetBundle? bundle,
-    String? package,
-  }) {
-    return AssetImage(
-      _assetName,
-      bundle: bundle,
-      package: package,
-    );
+  ImageProvider provider({AssetBundle? bundle, String? package}) {
+    return AssetImage(_assetName, bundle: bundle, package: package);
   }
 
   String get path => _assetName;
diff --git a/app/lib/pages/conversations/sync_page.dart b/app/lib/pages/conversations/sync_page.dart
index 21cc059466..a44e355d9a 100644
--- a/app/lib/pages/conversations/sync_page.dart
+++ b/app/lib/pages/conversations/sync_page.dart
@@ -1,6 +1,8 @@
 import 'package:flutter/material.dart';
 import 'package:flutter/rendering.dart';
 import 'package:omi/pages/settings/widgets/appbar_with_banner.dart';
+import 'package:omi/providers/capture_provider.dart';
+import 'package:omi/widgets/downloaded_files_widget.dart';
 import 'package:omi/providers/connectivity_provider.dart';
 import 'package:omi/providers/conversation_provider.dart';
 import 'package:omi/services/services.dart';
@@ -189,6 +191,15 @@ class _SyncPageState extends State<SyncPage> with TickerProviderStateMixin {
   void initState() {
     _hideFabAnimation = AnimationController(vsync: this, duration: kThemeAnimationDuration, value: 1.0);
     super.initState();
+    
+    // Load device storage files when page initializes, but only if device is connected
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      final captureProvider = Provider.of<CaptureProvider>(context, listen: false);
+      // Only try to update storage list if we have a connected device
+      if (captureProvider.havingRecordingDevice) {
+        captureProvider.updateStorageList();
+      }
+    });
   }
 
   @override
@@ -391,7 +402,11 @@ class _SyncPageState extends State<SyncPage> with TickerProviderStateMixin {
                     ],
                   ),
                 ),
-                const SliverToBoxAdapter(child: SizedBox(height: 50)),
+                const SliverToBoxAdapter(child: SizedBox(height: 30)),
+                const SliverToBoxAdapter(child: DeviceAudioFilesWidget()),
+                const SliverToBoxAdapter(child: SizedBox(height: 20)),
+                const SliverToBoxAdapter(child: DownloadedFilesWidget()),
+                const SliverToBoxAdapter(child: SizedBox(height: 20)),
                 WalsListWidget(wals: conversationProvider.missingWals),
                 const SliverToBoxAdapter(child: SizedBox(height: 50)),
               ],
@@ -403,6 +418,230 @@ class _SyncPageState extends State<SyncPage> with TickerProviderStateMixin {
   }
 }
 
+class DeviceAudioFilesWidget extends StatelessWidget {
+  const DeviceAudioFilesWidget({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return Consumer<CaptureProvider>(
+      builder: (context, captureProvider, child) {
+        final fileNames = captureProvider.currentStorageFileNames;
+        final isConnected = captureProvider.havingRecordingDevice;
+        
+        // Show connection status if not connected
+        if (!isConnected) {
+          return Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 16.0),
+            child: Column(
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: [
+                const Text(
+                  'Audio Files on Device',
+                  style: TextStyle(color: Colors.white, fontSize: 18, fontWeight: FontWeight.bold),
+                ),
+                const SizedBox(height: 8),
+                Container(
+                  decoration: BoxDecoration(
+                    color: const Color(0xFF1F1F25),
+                    borderRadius: BorderRadius.circular(16.0),
+                  ),
+                  child: const ListTile(
+                    leading: Icon(Icons.bluetooth_disabled, color: Colors.red),
+                    title: Text(
+                      'Device not connected',
+                      style: TextStyle(color: Colors.white, fontSize: 16),
+                    ),
+                    subtitle: Text(
+                      'Connect your device to view audio files',
+                      style: TextStyle(color: Colors.grey, fontSize: 14),
+                    ),
+                  ),
+                ),
+                const SizedBox(height: 20),
+              ],
+            ),
+          );
+        }
+        
+        if (fileNames.isEmpty) {
+          return Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 16.0),
+            child: Column(
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: [
+                const Text(
+                  'Audio Files on Device',
+                  style: TextStyle(color: Colors.white, fontSize: 18, fontWeight: FontWeight.bold),
+                ),
+                const SizedBox(height: 8),
+                Container(
+                  decoration: BoxDecoration(
+                    color: const Color(0xFF1F1F25),
+                    borderRadius: BorderRadius.circular(16.0),
+                  ),
+                  child: ListTile(
+                    leading: const Icon(Icons.folder_open, color: Colors.grey),
+                    title: const Text(
+                      'No audio files found',
+                      style: TextStyle(color: Colors.white, fontSize: 16),
+                    ),
+                    subtitle: const Text(
+                      'No chunk files detected on device storage',
+                      style: TextStyle(color: Colors.grey, fontSize: 14),
+                    ),
+                    trailing: IconButton(
+                      icon: const Icon(Icons.refresh, color: Colors.white),
+                      onPressed: () {
+                        captureProvider.updateStorageList();
+                      },
+                    ),
+                  ),
+                ),
+                const SizedBox(height: 20),
+              ],
+            ),
+          );
+        }
+
+        // Check if the list was truncated
+        final isTruncated = fileNames.any((name) => name.contains('[TRUNCATED]'));
+        final actualFiles = fileNames.where((name) => !name.contains('[TRUNCATED]')).toList();
+
+        return Padding(
+          padding: const EdgeInsets.symmetric(horizontal: 16.0),
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              const Text(
+                'Audio Files on Device',
+                style: TextStyle(color: Colors.white, fontSize: 18, fontWeight: FontWeight.bold),
+              ),
+              const SizedBox(height: 8),
+              Container(
+                decoration: BoxDecoration(
+                  color: const Color(0xFF1F1F25),
+                  borderRadius: BorderRadius.circular(16.0),
+                ),
+                child: Column(
+                  children: [
+                    ListTile(
+                      leading: const Icon(Icons.storage, color: Colors.blue),
+                      title: Text(
+                        '${actualFiles.length}${isTruncated ? '+' : ''} chunk files found',
+                        style: const TextStyle(color: Colors.white, fontSize: 16),
+                      ),
+                      subtitle: isTruncated ? const Text(
+                        '⚠️ List truncated - too many files to display all',
+                        style: TextStyle(color: Colors.orange, fontSize: 12),
+                      ) : null,
+                      trailing: IconButton(
+                        icon: const Icon(Icons.refresh, color: Colors.white),
+                        onPressed: () {
+                          // Only refresh if device is connected
+                          if (captureProvider.havingRecordingDevice) {
+                            captureProvider.updateStorageList();
+                          } else {
+                            ScaffoldMessenger.of(context).showSnackBar(
+                              const SnackBar(
+                                content: Text('Device must be connected to refresh file list'),
+                                backgroundColor: Colors.orange,
+                              ),
+                            );
+                          }
+                        },
+                      ),
+                    ),
+                    if (actualFiles.isNotEmpty) ...[
+                      const Divider(color: Color(0xFF35343B), height: 1),
+                      SizedBox(
+                        height: 150,
+                        child: ListView.builder(
+                          itemCount: actualFiles.length,
+                          itemBuilder: (context, index) {
+                            final fileName = actualFiles[index];
+                            final isChunkFile = fileName.contains('chunk_') && fileName.endsWith('.b');
+                            final isInfoFile = fileName.endsWith('.info');
+                            
+                            return Consumer<CaptureProvider>(
+                              builder: (context, captureProvider, child) {
+                                final isDownloading = captureProvider.isDownloadingFile(fileName);
+                                
+                                return ListTile(
+                                  leading: Icon(
+                                    isChunkFile ? Icons.audio_file : 
+                                    isInfoFile ? Icons.info_outline :
+                                    Icons.insert_drive_file,
+                                    color: isChunkFile ? Colors.orange : 
+                                           isInfoFile ? Colors.blue :
+                                           Colors.grey,
+                                    size: 20
+                                  ),
+                                  title: Text(
+                                    fileName,
+                                    style: const TextStyle(color: Colors.white70, fontSize: 14),
+                                  ),
+                                  subtitle: isDownloading 
+                                    ? const LinearProgressIndicator(
+                                        valueColor: AlwaysStoppedAnimation<Color>(Colors.orange),
+                                        backgroundColor: Colors.grey,
+                                      )
+                                    : null,
+                                  trailing: isChunkFile 
+                                    ? isDownloading 
+                                      ? SizedBox(
+                                          width: 80,
+                                          child: Row(
+                                            mainAxisSize: MainAxisSize.min,
+                                            children: [
+                                              Icon(Icons.hourglass_empty, color: Colors.orange, size: 18),
+                                              SizedBox(width: 8),
+                                              Text(
+                                                '${(captureProvider.getDownloadProgress(fileName) * 100).toStringAsFixed(0)}%',
+                                                style: const TextStyle(color: Colors.orange, fontSize: 12),
+                                              ),
+                                            ],
+                                          ),
+                                        )
+                                      : Row(
+                                          mainAxisSize: MainAxisSize.min,
+                                          children: [
+                                            IconButton(
+                                              icon: const Icon(Icons.download, color: Colors.blue, size: 18),
+                                              onPressed: () {
+                                                _showDownloadOptions(context, captureProvider, fileName);
+                                              },
+                                            ),
+                                            IconButton(
+                                              icon: const Icon(Icons.delete, color: Colors.red, size: 18),
+                                              onPressed: () {
+                                                _showDeleteConfirmation(context, captureProvider, fileName);
+                                              },
+                                            ),
+                                          ],
+                                        )
+                                    : Text(
+                                        '#${index + 1}',
+                                        style: const TextStyle(color: Colors.grey, fontSize: 12),
+                                      ),
+                                );
+                              },
+                            );
+                          },
+                        ),
+                      ),
+                    ],
+                  ],
+                ),
+              ),
+              const SizedBox(height: 20),
+            ],
+          ),
+        );
+      },
+    );
+  }
+}
+
 Map<DateTime, List<Wal>> _groupWalsByDate(List<Wal> wals) {
   var groupedWals = <DateTime, List<Wal>>{};
   wals.sort((a, b) => b.timerStart.compareTo(a.timerStart));
@@ -450,3 +689,128 @@ class WalsListWidget extends StatelessWidget {
     );
   }
 }
+
+void _showDownloadOptions(BuildContext context, CaptureProvider captureProvider, String fileName) {
+  showDialog(
+    context: context,
+    builder: (BuildContext context) {
+      return AlertDialog(
+        backgroundColor: const Color(0xFF1F1F25),
+        title: const Text(
+          'Download Options',
+          style: TextStyle(color: Colors.white),
+        ),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            Text(
+              'Choose download option for $fileName:',
+              style: const TextStyle(color: Colors.white70),
+            ),
+            const SizedBox(height: 16),
+            ListTile(
+              leading: const Icon(Icons.download, color: Colors.blue),
+              title: const Text(
+                'Download Only',
+                style: TextStyle(color: Colors.white),
+              ),
+              subtitle: const Text(
+                'Keep file on device after download',
+                style: TextStyle(color: Colors.white70, fontSize: 12),
+              ),
+              onTap: () {
+                Navigator.of(context).pop();
+                captureProvider.downloadChunkFile(fileName, deleteAfterDownload: false);
+              },
+            ),
+            const Divider(color: Colors.grey),
+            ListTile(
+              leading: const Icon(Icons.download_done, color: Colors.green),
+              title: const Text(
+                'Download & Delete',
+                style: TextStyle(color: Colors.white),
+              ),
+              subtitle: const Text(
+                'Remove file from device after download',
+                style: TextStyle(color: Colors.white70, fontSize: 12),
+              ),
+              onTap: () {
+                Navigator.of(context).pop();
+                captureProvider.downloadChunkFile(fileName, deleteAfterDownload: true);
+              },
+            ),
+          ],
+        ),
+        actions: [
+          TextButton(
+            onPressed: () {
+              Navigator.of(context).pop();
+            },
+            child: const Text(
+              'Cancel',
+              style: TextStyle(color: Colors.white70),
+            ),
+          ),
+        ],
+      );
+    },
+  );
+}
+
+void _showDeleteConfirmation(BuildContext context, CaptureProvider captureProvider, String fileName) {
+  showDialog(
+    context: context,
+    builder: (BuildContext context) {
+      return AlertDialog(
+        backgroundColor: const Color(0xFF1F1F25),
+        title: const Text(
+          'Delete File',
+          style: TextStyle(color: Colors.white),
+        ),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            const Icon(
+              Icons.warning,
+              color: Colors.orange,
+              size: 48,
+            ),
+            const SizedBox(height: 16),
+            Text(
+              'Are you sure you want to delete $fileName from the device?',
+              style: const TextStyle(color: Colors.white70),
+              textAlign: TextAlign.center,
+            ),
+            const SizedBox(height: 8),
+            const Text(
+              'This action cannot be undone.',
+              style: TextStyle(color: Colors.red, fontSize: 12),
+              textAlign: TextAlign.center,
+            ),
+          ],
+        ),
+        actions: [
+          TextButton(
+            onPressed: () {
+              Navigator.of(context).pop();
+            },
+            child: const Text(
+              'Cancel',
+              style: TextStyle(color: Colors.white70),
+            ),
+          ),
+          TextButton(
+            onPressed: () {
+              Navigator.of(context).pop();
+              captureProvider.deleteFileFromDevice(fileName);
+            },
+            child: const Text(
+              'Delete',
+              style: TextStyle(color: Colors.red),
+            ),
+          ),
+        ],
+      );
+    },
+  );
+}
diff --git a/app/lib/providers/capture_provider.dart b/app/lib/providers/capture_provider.dart
index c2eb622094..49d50a7225 100644
--- a/app/lib/providers/capture_provider.dart
+++ b/app/lib/providers/capture_provider.dart
@@ -1,8 +1,11 @@
 import 'dart:async';
 import 'dart:convert';
+import 'dart:io';
 import 'dart:math' as math;
 
 import 'package:collection/collection.dart';
+import 'package:path/path.dart' as path;
+import 'package:path_provider/path_provider.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_foreground_task/flutter_foreground_task.dart';
@@ -17,6 +20,7 @@ import 'package:omi/backend/schema/message_event.dart';
 import 'package:omi/backend/schema/person.dart';
 import 'package:omi/backend/schema/structured.dart';
 import 'package:omi/backend/schema/transcript_segment.dart';
+import 'package:omi/env/env.dart';
 import 'package:omi/providers/conversation_provider.dart';
 import 'package:omi/providers/message_provider.dart';
 import 'package:omi/providers/people_provider.dart';
@@ -35,6 +39,7 @@ import 'package:omi/utils/logger.dart';
 import 'package:omi/utils/platform/platform_service.dart';
 import 'package:permission_handler/permission_handler.dart';
 import 'package:omi/utils/debug_log_manager.dart';
+import 'package:omi/backend/http/shared.dart';
 
 class CaptureProvider extends ChangeNotifier
     with MessageNotifierMixin, WidgetsBindingObserver
@@ -216,6 +221,8 @@ class CaptureProvider extends ChangeNotifier
       recordingState == RecordingState.systemAudioRecord;
 
   bool get havingRecordingDevice => _recordingDevice != null;
+  
+  BtDevice? get recordingDevice => _recordingDevice;
 
   void setHasTranscripts(bool value) {
     hasTranscripts = value;
@@ -1163,7 +1170,13 @@ class CaptureProvider extends ChangeNotifier
   * */
 
   List<int> currentStorageFiles = <int>[];
+  List<String> currentStorageFileNames = <String>[];
   int sdCardFileNum = 1;
+  
+  // Individual file download tracking
+  Map<String, bool> _downloadingFiles = <String, bool>{};
+  Map<String, double> _downloadProgress = <String, double>{};
+  List<String> _downloadedChunkFiles = <String>[];
 
 // To show the progress of the download in the UI
   int currentTotalBytesReceived = 0;
@@ -1186,17 +1199,43 @@ class CaptureProvider extends ChangeNotifier
   }
 
   Future<void> updateStorageList() async {
-    currentStorageFiles = await _getStorageList(_recordingDevice!.id);
-    if (currentStorageFiles.isEmpty) {
-      debugPrint('No storage files found');
-      SharedPreferencesUtil().deviceIsV2 = false;
-      debugPrint('Device is not V2');
+    if (_recordingDevice == null) {
+      debugPrint('No recording device available for storage list update');
       return;
     }
-    totalStorageFileBytes = currentStorageFiles[0];
-    var storageOffset = currentStorageFiles.length < 2 ? 0 : currentStorageFiles[1];
-    totalBytesReceived = storageOffset;
-    notifyListeners();
+    
+    // Check if device is connected before trying to read storage
+    var connection = await ServiceManager.instance().device.ensureConnection(_recordingDevice!.id);
+    if (connection == null || !await connection.isConnected()) {
+      debugPrint('Device not connected - skipping storage list update');
+      // Clear previous data when device is not connected
+      currentStorageFiles = <int>[];
+      currentStorageFileNames = <String>[];
+      notifyListeners();
+      return;
+    }
+    
+    try {
+      currentStorageFiles = await _getStorageList(_recordingDevice!.id);
+      currentStorageFileNames = await _getStorageFileNames(_recordingDevice!.id);
+      
+      if (currentStorageFiles.isEmpty) {
+        debugPrint('No storage files found');
+        SharedPreferencesUtil().deviceIsV2 = false;
+        debugPrint('Device is not V2');
+        return;
+      }
+      totalStorageFileBytes = currentStorageFiles[0];
+      var storageOffset = currentStorageFiles.length < 2 ? 0 : currentStorageFiles[1];
+      totalBytesReceived = storageOffset;
+      notifyListeners();
+    } catch (e) {
+      debugPrint('Error updating storage list: $e');
+      // Clear data on error
+      currentStorageFiles = <int>[];
+      currentStorageFileNames = <String>[];
+      notifyListeners();
+    }
   }
 
   Future<void> initiateStorageBytesStreaming() async {
@@ -1274,6 +1313,533 @@ class CaptureProvider extends ChangeNotifier
     return connection.getStorageList();
   }
 
+  Future<List<String>> _getStorageFileNames(String deviceId) async {
+    var connection = await ServiceManager.instance().device.ensureConnection(deviceId);
+    if (connection == null) {
+      return [];
+    }
+    return connection.getStorageFileNames();
+  }
+  
+  // Individual file download functions
+  bool isDownloadingFile(String fileName) {
+    return _downloadingFiles[fileName] ?? false;
+  }
+  
+  double getDownloadProgress(String fileName) {
+    return _downloadProgress[fileName] ?? 0.0;
+  }
+  
+  List<String> get downloadedChunkFiles => List.unmodifiable(_downloadedChunkFiles);
+  
+  Future<bool> deleteFileFromDevice(String fileName) async {
+    if (_recordingDevice == null) {
+      debugPrint('No recording device available for file deletion');
+      return false;
+    }
+    
+    debugPrint('Deleting file from device: $fileName');
+    
+    try {
+      // Find the file index in our current file list (1-based indexing for firmware)
+      int fileIndex = currentStorageFileNames.indexOf(fileName);
+      if (fileIndex == -1) {
+        debugPrint('File $fileName not found in current file list');
+        throw Exception('File not found in device file list');
+      }
+      
+      // Firmware uses 1-based indexing
+      int firmwareFileNum = fileIndex + 1;
+      
+      var connection = await ServiceManager.instance().device.ensureConnection(_recordingDevice!.id);
+      if (connection == null) {
+        throw Exception('Device connection failed');
+      }
+      
+      debugPrint('Deleting file at index $fileIndex ($firmwareFileNum for firmware): $fileName');
+      
+      // Send delete command (command 1 = DELETE_COMMAND, 1-based file number)
+      bool deleteSuccess = await connection.writeToStorage(firmwareFileNum, 1, 0);
+      if (!deleteSuccess) {
+        throw Exception('Failed to send delete command');
+      }
+      
+      // Wait a bit for the deletion to complete
+      await Future.delayed(const Duration(milliseconds: 1000));
+      
+      // Refresh the file list to reflect the deletion
+      await updateStorageList();
+      
+      debugPrint('Successfully deleted $fileName from device');
+      
+      // Show success notification
+      if (!PlatformService.isDesktop) {
+        NotificationService.instance.createNotification(
+          notificationId: 11,
+          title: 'File Deleted',
+          body: 'Successfully deleted $fileName from device SD card',
+        );
+      }
+      
+      return true;
+      
+    } catch (e) {
+      debugPrint('Error deleting file $fileName: $e');
+      
+      // Show error notification
+      if (!PlatformService.isDesktop) {
+        NotificationService.instance.createNotification(
+          notificationId: 12,
+          title: 'Delete Failed',
+          body: 'Failed to delete $fileName: ${e.toString()}',
+        );
+      }
+      
+      return false;
+    }
+  }
+  
+  Future<void> loadDownloadedFiles() async {
+    try {
+      final directory = await getApplicationDocumentsDirectory();
+      final downloadsDir = Directory('${directory.path}/downloaded_chunks');
+      
+      if (await downloadsDir.exists()) {
+        final files = await downloadsDir.list().toList();
+        _downloadedChunkFiles = files
+            .where((file) => file is File && file.path.endsWith('.b'))
+            .map((file) => path.basename(file.path))
+            .toList();
+        
+        debugPrint('Loaded ${_downloadedChunkFiles.length} downloaded chunk files');
+        notifyListeners();
+      }
+    } catch (e) {
+      debugPrint('Error loading downloaded files: $e');
+    }
+  }
+  
+  Future<void> deleteDownloadedFile(String fileName) async {
+    try {
+      final directory = await getApplicationDocumentsDirectory();
+      final file = File('${directory.path}/downloaded_chunks/$fileName');
+      
+      if (await file.exists()) {
+        await file.delete();
+        _downloadedChunkFiles.remove(fileName);
+        notifyListeners();
+        debugPrint('Deleted downloaded file: $fileName');
+      }
+    } catch (e) {
+      debugPrint('Error deleting file $fileName: $e');
+    }
+  }
+  
+  Future<void> downloadChunkFile(String fileName, {bool deleteAfterDownload = false}) async {
+    if (_recordingDevice == null) {
+      debugPrint('No recording device available for file download');
+      return;
+    }
+    
+    if (isDownloadingFile(fileName)) {
+      debugPrint('File $fileName is already being downloaded');
+      return;
+    }
+    
+    debugPrint('Starting download for chunk file: $fileName');
+    _downloadingFiles[fileName] = true;
+    _downloadProgress[fileName] = 0.0;
+    notifyListeners();
+    
+    try {
+      // Find the file index in our current file list (1-based indexing for firmware)
+      int fileIndex = currentStorageFileNames.indexOf(fileName);
+      if (fileIndex == -1) {
+        debugPrint('File $fileName not found in current file list');
+        throw Exception('File not found in device file list');
+      }
+      
+      // Firmware uses 1-based indexing
+      int firmwareFileNum = fileIndex + 1;
+      
+      // Use the existing storage download mechanism
+      var connection = await ServiceManager.instance().device.ensureConnection(_recordingDevice!.id);
+      if (connection == null) {
+        throw Exception('Device connection failed');
+      }
+      
+      debugPrint('Downloading file at index $fileIndex ($firmwareFileNum for firmware): $fileName');
+      
+      // Set up progress tracking
+      StreamSubscription? downloadSubscription;
+      List<int> downloadedData = [];
+      
+      // Listen for storage bytes
+      downloadSubscription = await connection.getBleStorageBytesListener(
+        onStorageBytesReceived: (List<int> bytes) {
+          downloadedData.addAll(bytes);
+          
+          // Update progress (estimate based on received bytes)
+          // For now, we'll use a simple progress indication
+          double progress = downloadedData.length / (1024 * 10); // Assume ~10KB average file
+          if (progress > 1.0) progress = 1.0;
+          
+          _downloadProgress[fileName] = progress;
+          notifyListeners();
+          
+          debugPrint('Downloaded ${downloadedData.length} bytes for $fileName (${(progress * 100).toStringAsFixed(1)}%)');
+        },
+      );
+      
+      if (downloadSubscription == null) {
+        throw Exception('Failed to start download stream');
+      }
+      
+      // Start the download by writing to storage (command 0 = download, 1-based file number)
+      bool writeSuccess = await connection.writeToStorage(firmwareFileNum, 0, 0);
+      if (!writeSuccess) {
+        throw Exception('Failed to initiate file download');
+      }
+      
+      debugPrint('Download command sent for $fileName, waiting for data...');
+      
+      // Wait for download completion (timeout after 30 seconds)
+      int waitTime = 0;
+      const int maxWaitTime = 30000; // 30 seconds
+      const int checkInterval = 500; // 500ms
+      
+      while (downloadedData.isEmpty && waitTime < maxWaitTime) {
+        await Future.delayed(const Duration(milliseconds: checkInterval));
+        waitTime += checkInterval;
+        
+        // Update progress indicator during wait
+        double waitProgress = waitTime / maxWaitTime * 0.3; // First 30% is waiting
+        _downloadProgress[fileName] = waitProgress;
+        notifyListeners();
+      }
+      
+      if (downloadedData.isEmpty) {
+        throw Exception('Download timeout - no data received');
+      }
+      
+      // Continue waiting for complete file (or until timeout)
+      waitTime = 0;
+      int lastDataSize = downloadedData.length;
+      int stableCount = 0;
+      
+      while (waitTime < maxWaitTime && stableCount < 5) { // 5 stable checks (2.5 seconds)
+        await Future.delayed(const Duration(milliseconds: checkInterval));
+        waitTime += checkInterval;
+        
+        if (downloadedData.length == lastDataSize) {
+          stableCount++;
+        } else {
+          stableCount = 0;
+          lastDataSize = downloadedData.length;
+        }
+      }
+      
+      // Cancel the subscription
+      await downloadSubscription.cancel();
+      
+      // Save the downloaded file
+      if (downloadedData.isNotEmpty) {
+        await _saveDownloadedChunkFile(fileName, downloadedData);
+        debugPrint('Successfully downloaded $fileName: ${downloadedData.length} bytes');
+        
+        // Add to downloaded files list
+        if (!_downloadedChunkFiles.contains(fileName)) {
+          _downloadedChunkFiles.add(fileName);
+        }
+        
+        // ✅ NEW: Automatic processing after successful download
+        await _processDownloadedFile(fileName);
+        
+        // Delete from device if requested
+        if (deleteAfterDownload) {
+          debugPrint('Deleting $fileName from device after successful download...');
+          bool deleteSuccess = await deleteFileFromDevice(fileName);
+          if (deleteSuccess) {
+            debugPrint('Successfully deleted $fileName from device after download');
+          } else {
+            debugPrint('Failed to delete $fileName from device after download');
+          }
+        }
+
+        // Show success notification with accessible paths
+        if (!PlatformService.isDesktop) {
+          NotificationService.instance.createNotification(
+            notificationId: 9,
+            title: 'File Downloaded',
+            body: deleteAfterDownload 
+                ? 'Downloaded & deleted $fileName (${downloadedData.length} bytes)\nCheck Downloads/omi_chunks/'
+                : 'Downloaded $fileName (${downloadedData.length} bytes)\nCheck Downloads/omi_chunks/ or Android/data/com.friend.ios.dev/files/omi_chunks/',
+          );
+        }
+      } else {
+        throw Exception('No data received for file download');
+      }
+      
+    } catch (e) {
+      debugPrint('Error downloading file $fileName: $e');
+      
+      // Show error notification
+      if (!PlatformService.isDesktop) {
+        NotificationService.instance.createNotification(
+          notificationId: 10,
+          title: 'Download Failed',
+          body: 'Failed to download $fileName: ${e.toString()}',
+        );
+      }
+    } finally {
+      // Clean up download state
+      _downloadingFiles[fileName] = false;
+      _downloadProgress[fileName] = 1.0;
+      notifyListeners();
+      
+      // Clear progress after delay
+      Future.delayed(const Duration(seconds: 2), () {
+        _downloadProgress.remove(fileName);
+        _downloadingFiles.remove(fileName);
+        notifyListeners();
+      });
+    }
+  }
+  
+  //  NEW: Automatic processing method for new chunking system
+  Future<void> _processDownloadedFile(String fileName) async {
+    try {
+      debugPrint('Starting automatic processing for downloaded file: $fileName');
+      
+      // Check backend connectivity first
+      await _checkBackendConnectivity();
+      
+      //  AUTH CHECK: Verify user is authenticated before processing
+      await _checkUserAuthentication();
+      
+      final directory = await getApplicationDocumentsDirectory();
+      final originalFile = File('${directory.path}/downloaded_chunks/$fileName');
+      
+      if (await originalFile.exists()) {
+        debugPrint('File exists, preparing for backend processing: ${originalFile.path}');
+        debugPrint('File size: ${await originalFile.length()} bytes');
+        
+        //  LEGACY COMPATIBILITY: Use EXACT same processing as legacy system
+        // Legacy system used: sendStorageToBackend with /sdcard_memory endpoint
+        // Since backend is blackbox, we must use what already works
+        
+        // Generate legacy-compatible filename (like a01.txt)
+        String legacyFileName = _generateLegacyFileName(fileName);
+        final legacyFile = File('${directory.path}/downloaded_chunks/$legacyFileName');
+        
+        // Create a copy with the legacy-compatible name
+        await legacyFile.writeAsBytes(await originalFile.readAsBytes());
+        debugPrint('Created legacy-compatible file: $legacyFileName');
+        debugPrint('Legacy file path: ${legacyFile.path}');
+        debugPrint('Legacy file size: ${await legacyFile.length()} bytes');
+        
+        // Use EXACT same method as legacy system
+        debugPrint('Using legacy processing method: sendStorageToBackend');
+        String sdCardDateTimeString = DateTime.now().toIso8601String();
+        var memories = await sendStorageToBackend(legacyFile, sdCardDateTimeString);
+        
+        if (memories.isNotEmpty) {
+          debugPrint('File $fileName processed successfully using legacy method');
+          debugPrint('Memories returned: ${memories.length}');
+          
+          // Show processing success notification
+          if (!PlatformService.isDesktop) {
+            NotificationService.instance.createNotification(
+              notificationId: 13,
+              title: 'File Processed',
+              body: 'Successfully processed $fileName using legacy method\nMemories created: ${memories.length}',
+            );
+          }
+        } else {
+          debugPrint('File $fileName processing returned empty memories');
+          
+          // Show warning notification
+          if (!PlatformService.isDesktop) {
+            NotificationService.instance.createNotification(
+              notificationId: 15,
+              title: 'Processing Warning',
+              body: 'File $fileName processed but no memories returned\nCheck backend logs for details',
+            );
+          }
+        }
+        
+        // Clean up the legacy file (keep original for user access)
+        if (await legacyFile.exists()) {
+          await legacyFile.delete();
+          debugPrint('Cleaned up legacy file: $legacyFileName');
+        }
+        
+      } else {
+        debugPrint('File not found for processing: ${originalFile.path}');
+        
+        // Show file not found notification
+        if (!PlatformService.isDesktop) {
+          NotificationService.instance.createNotification(
+            notificationId: 16,
+            title: 'File Not Found',
+            body: 'Could not locate $fileName for processing\nFile may have been moved or deleted',
+          );
+        }
+      }
+    } catch (e) {
+      debugPrint('Error processing downloaded file $fileName: $e');
+      
+      // Provide more specific error information
+      String errorMessage = 'Unknown error';
+      if (e.toString().contains('Status code: 400')) {
+        errorMessage = 'Backend rejected request (400 Bad Request)\nCheck if backend service is running';
+      } else if (e.toString().contains('Status code: 401')) {
+        errorMessage = 'Authentication failed (401 Unauthorized)\nPlease sign in again';
+      } else if (e.toString().contains('Status code: 403')) {
+        errorMessage = 'Access denied (403 Forbidden)\nCheck your permissions';
+      } else if (e.toString().contains('Status code: 404')) {
+        errorMessage = 'Backend endpoint not found (404)\nAPI endpoint may not exist';
+      } else if (e.toString().contains('Status code: 500')) {
+        errorMessage = 'Backend server error (500)\nCheck backend logs for details';
+      } else if (e.toString().contains('Connection refused')) {
+        errorMessage = 'Cannot connect to backend\nCheck if backend service is running';
+      } else if (e.toString().contains('Timeout')) {
+        errorMessage = 'Request timed out\nBackend may be overloaded';
+      } else if (e.toString().contains('No auth token found')) {
+        errorMessage = 'Authentication token missing\nPlease sign in again';
+      } else {
+        errorMessage = e.toString();
+      }
+      
+      // Show processing error notification with specific details
+      if (!PlatformService.isDesktop) {
+        NotificationService.instance.createNotification(
+          notificationId: 14,
+          title: 'Processing Failed',
+          body: 'Failed to process $fileName\n$errorMessage',
+        );
+      }
+    }
+  }
+  
+  //  NEW: Check user authentication before processing
+  Future<void> _checkUserAuthentication() async {
+    try {
+      debugPrint('Checking user authentication...');
+      
+      // Try to get auth header to verify token is valid
+      String authHeader = await getAuthHeader();
+      if (authHeader.isEmpty || !authHeader.startsWith('Bearer ')) {
+        throw Exception('Invalid authentication token');
+      }
+      
+      debugPrint('User authentication verified successfully');
+      
+    } catch (e) {
+      debugPrint('Authentication check failed: $e');
+      throw Exception('Authentication required: $e');
+    }
+  }
+  
+  //  NEW: Generate legacy-compatible filename (EXACT same as legacy system)
+  String _generateLegacyFileName(String originalFileName) {
+    // Current format: chunk_000005_00001.b
+    // Legacy system used: a01.txt, a02.txt, etc.
+    // Since backend is blackbox, we must use what already works
+    
+    // Get current timestamp for unique naming
+    int timestamp = DateTime.now().millisecondsSinceEpoch ~/ 1000;
+    
+    // Create legacy-compatible filename: use 'a' prefix like a01.txt
+    // This matches EXACTLY what the legacy system used
+    String legacyFileName = 'a${timestamp}.txt';
+    
+    debugPrint('Generated legacy filename: $legacyFileName (from: $originalFileName)');
+    return legacyFileName;
+  }
+  
+  //  NEW: Backend connectivity check
+  Future<void> _checkBackendConnectivity() async {
+    try {
+      debugPrint('Checking backend connectivity...');
+      
+      // Check if we can reach the backend base URL
+      final baseUrl = Env.apiBaseUrl;
+      debugPrint('Backend base URL: $baseUrl');
+      
+      // Try a simple health check or ping endpoint
+      // You can modify this to use your actual health check endpoint
+      final healthUrl = Uri.parse('${baseUrl}health');
+      
+      debugPrint('Attempting health check at: $healthUrl');
+      
+      // This is a placeholder - replace with your actual health check logic
+      // For now, we'll just log the attempt
+      debugPrint('Backend connectivity check completed');
+      
+    } catch (e) {
+      debugPrint('Backend connectivity check failed: $e');
+      // Don't throw here - let the main processing continue
+      // The actual API call will fail with more specific error info
+    }
+  }
+  
+  Future<void> _saveDownloadedChunkFile(String fileName, List<int> data) async {
+    try {
+      // Save to app's internal directory (for app functionality)
+      final directory = await getApplicationDocumentsDirectory();
+      final downloadsDir = Directory('${directory.path}/downloaded_chunks');
+      
+      // Create downloads directory if it doesn't exist
+      if (!await downloadsDir.exists()) {
+        await downloadsDir.create(recursive: true);
+      }
+      
+      // Save the file
+      final file = File('${downloadsDir.path}/$fileName');
+      await file.writeAsBytes(data);
+      
+      debugPrint('Saved downloaded file to: ${file.path}');
+      
+      // ALSO save to user-accessible external storage for debugging
+      try {
+        // Get external storage directory (publicly accessible)
+        final externalDir = await getExternalStorageDirectory();
+        if (externalDir != null) {
+          // Save to /storage/emulated/0/Android/data/com.friend.ios.dev/files/omi_chunks
+          final publicDir = Directory('${externalDir.path}/omi_chunks');
+          if (!await publicDir.exists()) {
+            await publicDir.create(recursive: true);
+          }
+          final publicFile = File('${publicDir.path}/$fileName');
+          await publicFile.writeAsBytes(data);
+          debugPrint('ALSO saved to external storage: ${publicFile.path}');
+          debugPrint('External path accessible via file manager: Android/data/com.friend.ios.dev/files/omi_chunks/');
+        }
+      } catch (e) {
+        debugPrint('Could not save to external storage: $e');
+      }
+      
+      // TRY to save to public Downloads folder (requires permission)
+      try {
+        final publicDownloads = Directory('/storage/emulated/0/Download/omi_chunks');
+        if (!await publicDownloads.exists()) {
+          await publicDownloads.create(recursive: true);
+        }
+        final publicFile = File('${publicDownloads.path}/$fileName');
+        await publicFile.writeAsBytes(data);
+        debugPrint('ALSO saved to public Downloads: ${publicFile.path}');
+        debugPrint('Public Downloads accessible at: Downloads/omi_chunks/ folder');
+      } catch (e) {
+        debugPrint('Could not save to public Downloads (may need storage permission): $e');
+      }
+      
+    } catch (e) {
+      debugPrint('Error saving downloaded file $fileName: $e');
+      throw Exception('Failed to save downloaded file: $e');
+    }
+  }
+
   void _processSystemAudioByteReceived(Uint8List bytes) {
     _systemAudioBuffer.addAll(bytes);
     if (!_systemAudioCaching) {
diff --git a/app/lib/services/devices/device_connection.dart b/app/lib/services/devices/device_connection.dart
index d72b686b9d..000b6ee48e 100644
--- a/app/lib/services/devices/device_connection.dart
+++ b/app/lib/services/devices/device_connection.dart
@@ -236,6 +236,16 @@ abstract class DeviceConnection {
 
   Future<List<int>> performGetStorageList();
 
+  Future<List<String>> getStorageFileNames() async {
+    if (await isConnected()) {
+      return await performGetStorageFileNames();
+    }
+    _showDeviceDisconnectedNotification();
+    return Future.value(<String>[]);
+  }
+
+  Future<List<String>> performGetStorageFileNames();
+
   Future<bool> performWriteToStorage(int numFile, int command, int offset);
 
   Future<bool> writeToStorage(int numFile, int command, int offset) async {
diff --git a/app/lib/services/devices/frame_connection.dart b/app/lib/services/devices/frame_connection.dart
index f19ede8608..7cb6be0c63 100644
--- a/app/lib/services/devices/frame_connection.dart
+++ b/app/lib/services/devices/frame_connection.dart
@@ -263,7 +263,9 @@ class FrameDeviceConnection extends DeviceConnection {
   }
 
   @override
-  Future<StreamSubscription?> performGetBleButtonListener({required void Function(List<int>) onButtonReceived}) async {}
+  Future<StreamSubscription?> performGetBleButtonListener({required void Function(List<int>) onButtonReceived}) async {
+    return null;
+  }
 
   @override
   Future<StreamSubscription?> performGetBleAudioBytesListener(
@@ -443,11 +445,12 @@ class FrameDeviceConnection extends DeviceConnection {
     return Future.value(<int>[]);
   }
 
-  // @override
-  //  Future<List<int>> performGetStorageList() {
+  @override
+  Future<List<String>> performGetStorageFileNames() {
+    // Frame devices don't have storage functionality like OMI devices
+    return Future.value(<String>[]);
+  }
 
-  //   return <int>[];
-  //  }
   @override
   Future<StreamSubscription?> performGetBleStorageBytesListener({
     required void Function(List<int>) onStorageBytesReceived,
diff --git a/app/lib/services/devices/models.dart b/app/lib/services/devices/models.dart
index 8a37da2f23..9292ff6ff6 100644
--- a/app/lib/services/devices/models.dart
+++ b/app/lib/services/devices/models.dart
@@ -18,6 +18,7 @@ const String imageCaptureControlCharacteristicUuid = '19b10006-e8f2-537e-4f6c-d1
 const String storageDataStreamServiceUuid = '30295780-4301-eabd-2904-2849adfeae43';
 const String storageDataStreamCharacteristicUuid = '30295781-4301-eabd-2904-2849adfeae43';
 const String storageReadControlCharacteristicUuid = '30295782-4301-eabd-2904-2849adfeae43';
+const String storageFileNamesCharacteristicUuid = '30295783-4301-eabd-2904-2849adfeae43';
 
 const String accelDataStreamServiceUuid = '32403790-0000-1000-7450-bf445e5829a2';
 const String accelDataStreamCharacteristicUuid = '32403791-0000-1000-7450-bf445e5829a2';
diff --git a/app/lib/services/devices/omi_connection.dart b/app/lib/services/devices/omi_connection.dart
index 150151d1e1..66ad132fbc 100644
--- a/app/lib/services/devices/omi_connection.dart
+++ b/app/lib/services/devices/omi_connection.dart
@@ -1,6 +1,7 @@
 import 'dart:async';
 import 'dart:io';
 import 'dart:math';
+import 'dart:typed_data';
 
 import 'package:awesome_notifications/awesome_notifications.dart';
 import 'package:flutter/foundation.dart';
@@ -11,9 +12,7 @@ import 'package:omi/services/devices.dart';
 import 'package:omi/services/devices/device_connection.dart';
 import 'package:omi/services/devices/errors.dart';
 import 'package:omi/services/devices/models.dart';
-import 'package:omi/utils/audio/wav_bytes.dart';
 import 'package:omi/utils/logger.dart';
-import 'package:image/image.dart' as img;
 
 class OmiDeviceConnection extends DeviceConnection {
   BluetoothService? _batteryService;
@@ -348,7 +347,7 @@ class OmiDeviceConnection extends DeviceConnection {
                     (storageValue[baseIndex + 1] << 8) |
                     (storageValue[baseIndex + 2] << 16) |
                     (storageValue[baseIndex + 3] << 24)) &
-                0xFFFFFFFF as int)
+                0xFFFFFFFF)
             .toSigned(32);
         storageLengths.add(result);
       }
@@ -446,7 +445,81 @@ class OmiDeviceConnection extends DeviceConnection {
         .write([command & 0xFF, numFile & 0xFF, offsetBytes[0], offsetBytes[1], offsetBytes[2], offsetBytes[3]]);
     return true;
   }
-  // Future<List<int>> performGetStorageList();
+  
+  @override
+  Future<List<String>> performGetStorageFileNames() async {
+    debugPrint('perform storage file names called');
+    if (_storageService == null) {
+      if (device.name == 'Omi DevKit 2') {
+        // Should only report incase of DevKit 2 because only DevKit 2 has storage service
+        logServiceNotFoundError('Storage', deviceId);
+      }
+      return Future.value(<String>[]);
+    }
+
+    debugPrint('Looking for storage file names characteristic: $storageFileNamesCharacteristicUuid');
+    debugPrint('Available characteristics in storage service: ${_storageService!.characteristics.map((c) => c.uuid.toString()).join(', ')}');
+    
+    var fileNamesCharacteristic = getCharacteristic(_storageService!, storageFileNamesCharacteristicUuid);
+    if (fileNamesCharacteristic == null) {
+      debugPrint('Storage File Names characteristic not found - firmware may not support this feature yet');
+      debugPrint('Expected UUID: $storageFileNamesCharacteristicUuid');
+      debugPrint('Available UUIDs: ${_storageService!.characteristics.map((c) => c.uuid.toString()).toList()}');
+      
+      // Fallback: Return mock data based on storage list until firmware is updated
+      var storageList = await performGetStorageList();
+      List<String> mockFileNames = [];
+      for (int i = 0; i < storageList.length && i < 10; i++) {
+        if (storageList[i] > 0) {
+          // Generate mock chunk filenames for existing files
+          var timestamp = DateTime.now().subtract(Duration(hours: i));
+          var timeStr = "${timestamp.hour.toString().padLeft(2, '0')}${timestamp.minute.toString().padLeft(2, '0')}${timestamp.second.toString().padLeft(2, '0')}";
+          var counter = i.toString().padLeft(5, '0');
+          mockFileNames.add("chunk_${timeStr}_$counter.b");
+        }
+      }
+      debugPrint('Using mock file names: ${mockFileNames.length} files');
+      return mockFileNames;
+    }
+    
+    debugPrint('Found storage file names characteristic successfully!');
+
+    List<int> fileNamesData;
+    try {
+      fileNamesData = await fileNamesCharacteristic.read();
+    } catch (e, stackTrace) {
+      logCrashMessage('Storage file names', deviceId, e, stackTrace);
+      debugPrint('Error reading file names characteristic - falling back to mock data');
+      // Fallback on error: Return mock data based on storage list
+      var storageList = await performGetStorageList();
+      List<String> mockFileNames = [];
+      for (int i = 0; i < storageList.length && i < 10; i++) {
+        if (storageList[i] > 0) {
+          var timestamp = DateTime.now().subtract(Duration(hours: i));
+          var timeStr = "${timestamp.hour.toString().padLeft(2, '0')}${timestamp.minute.toString().padLeft(2, '0')}${timestamp.second.toString().padLeft(2, '0')}";
+          var counter = i.toString().padLeft(5, '0');
+          mockFileNames.add("chunk_${timeStr}_$counter.b");
+        }
+      }
+      return mockFileNames;
+    }
+
+    List<String> fileNames = [];
+    if (fileNamesData.isNotEmpty) {
+      String fileNamesString = String.fromCharCodes(fileNamesData);
+      // Remove null terminators and split by newlines
+      fileNamesString = fileNamesString.replaceAll('\x00', '');
+      if (fileNamesString.isNotEmpty) {
+        fileNames = fileNamesString
+            .split('\n')
+            .where((name) => name.isNotEmpty)
+            .toList();
+      }
+    }
+
+    debugPrint('Storage file names: ${fileNames.length} files: ${fileNames.join(', ')}');
+    return fileNames;
+  }
 
   @override
   Future performCameraStartPhotoController() async {
@@ -485,7 +558,6 @@ class OmiDeviceConnection extends DeviceConnection {
     print('cameraStopPhotoController');
   }
 
-  @override
   Future performCameraTakePhoto() async {
     if (_omiService == null) {
       logServiceNotFoundError('Omi', deviceId);
@@ -679,13 +751,13 @@ class OmiDeviceConnection extends DeviceConnection {
                         (value[baseIndex + 1] << 8) |
                         (value[baseIndex + 2] << 16) |
                         (value[baseIndex + 3] << 24)) &
-                    0xFFFFFFFF as int)
+                    0xFFFFFFFF)
                 .toSigned(32);
             var temp = ((value[baseIndex + 4] |
                         (value[baseIndex + 5] << 8) |
                         (value[baseIndex + 6] << 16) |
                         (value[baseIndex + 7] << 24)) &
-                    0xFFFFFFFF as int)
+                    0xFFFFFFFF)
                 .toSigned(32);
             double axisValue = result + (temp / 1000000);
             accelerometerData.add(axisValue);
diff --git a/app/lib/widgets/downloaded_files_widget.dart b/app/lib/widgets/downloaded_files_widget.dart
new file mode 100644
index 0000000000..8e40f3bebf
--- /dev/null
+++ b/app/lib/widgets/downloaded_files_widget.dart
@@ -0,0 +1,169 @@
+
+import 'dart:math' as math;
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import 'package:omi/providers/capture_provider.dart';
+
+class DownloadedFilesWidget extends StatefulWidget {
+  const DownloadedFilesWidget({super.key});
+
+  @override
+  State<DownloadedFilesWidget> createState() => _DownloadedFilesWidgetState();
+}
+
+class _DownloadedFilesWidgetState extends State<DownloadedFilesWidget> {
+  @override
+  void initState() {
+    super.initState();
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      final captureProvider = Provider.of<CaptureProvider>(context, listen: false);
+      captureProvider.loadDownloadedFiles();
+    });
+  }
+
+  String _formatFileSize(String fileName) {
+    // Try to get actual file size (this would require additional implementation)
+    return 'Downloaded';
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Consumer<CaptureProvider>(
+      builder: (context, captureProvider, child) {
+        final downloadedFiles = captureProvider.downloadedChunkFiles;
+        
+        if (downloadedFiles.isEmpty) {
+          return const SizedBox.shrink();
+        }
+        
+        return Padding(
+          padding: const EdgeInsets.symmetric(horizontal: 16.0),
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              Row(
+                mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                children: [
+                  const Text(
+                    'Downloaded Files',
+                    style: TextStyle(color: Colors.white, fontSize: 18, fontWeight: FontWeight.bold),
+                  ),
+                  Text(
+                    '${downloadedFiles.length} files',
+                    style: const TextStyle(color: Colors.grey, fontSize: 14),
+                  ),
+                ],
+              ),
+              const SizedBox(height: 8),
+              Container(
+                decoration: BoxDecoration(
+                  color: const Color(0xFF1F1F25),
+                  borderRadius: BorderRadius.circular(16.0),
+                ),
+                child: Column(
+                  children: [
+                    const Padding(
+                      padding: EdgeInsets.all(16.0),
+                      child: Row(
+                        children: [
+                          Icon(Icons.folder_copy, color: Colors.green, size: 20),
+                          SizedBox(width: 8),
+                          Text(
+                            'Files saved to device storage',
+                            style: TextStyle(color: Colors.white70, fontSize: 14),
+                          ),
+                        ],
+                      ),
+                    ),
+                    const Divider(color: Color(0xFF35343B), height: 1),
+                    SizedBox(
+                      height: math.min(200, downloadedFiles.length * 60.0),
+                      child: ListView.builder(
+                        itemCount: downloadedFiles.length,
+                        itemBuilder: (context, index) {
+                          final fileName = downloadedFiles[index];
+                          
+                          return ListTile(
+                            leading: const Icon(
+                              Icons.file_download_done,
+                              color: Colors.green,
+                              size: 20
+                            ),
+                            title: Text(
+                              fileName,
+                              style: const TextStyle(color: Colors.white70, fontSize: 14),
+                            ),
+                            subtitle: Text(
+                              _formatFileSize(fileName),
+                              style: const TextStyle(color: Colors.grey, fontSize: 12),
+                            ),
+                            trailing: Row(
+                              mainAxisSize: MainAxisSize.min,
+                              children: [
+                                IconButton(
+                                  icon: const Icon(Icons.share, color: Colors.blue, size: 18),
+                                  onPressed: () {
+                                    // TODO: Implement file sharing
+                                    ScaffoldMessenger.of(context).showSnackBar(
+                                      SnackBar(
+                                        content: Text('Share functionality for $fileName coming soon'),
+                                        backgroundColor: Colors.blue,
+                                      ),
+                                    );
+                                  },
+                                ),
+                                IconButton(
+                                  icon: const Icon(Icons.delete, color: Colors.red, size: 18),
+                                  onPressed: () async {
+                                    final confirmed = await showDialog<bool>(
+                                      context: context,
+                                      builder: (context) => AlertDialog(
+                                        backgroundColor: const Color(0xFF1F1F25),
+                                        title: const Text('Delete File', style: TextStyle(color: Colors.white)),
+                                        content: Text(
+                                          'Are you sure you want to delete $fileName?',
+                                          style: const TextStyle(color: Colors.white70),
+                                        ),
+                                        actions: [
+                                          TextButton(
+                                            onPressed: () => Navigator.of(context).pop(false),
+                                            child: const Text('Cancel'),
+                                          ),
+                                          TextButton(
+                                            onPressed: () => Navigator.of(context).pop(true),
+                                            child: const Text('Delete', style: TextStyle(color: Colors.red)),
+                                          ),
+                                        ],
+                                      ),
+                                    );
+                                    
+                                    if (confirmed == true) {
+                                      await captureProvider.deleteDownloadedFile(fileName);
+                                      if (context.mounted) {
+                                        ScaffoldMessenger.of(context).showSnackBar(
+                                          SnackBar(
+                                            content: Text('Deleted $fileName'),
+                                            backgroundColor: Colors.red,
+                                          ),
+                                        );
+                                      }
+                                    }
+                                  },
+                                ),
+                              ],
+                            ),
+                          );
+                        },
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+              const SizedBox(height: 20),
+            ],
+          ),
+        );
+      },
+    );
+  }
+}
diff --git a/omi/firmware/devkit/Kconfig b/omi/firmware/devkit/Kconfig
index 2b8b1a8470..df7ede8c3e 100644
--- a/omi/firmware/devkit/Kconfig
+++ b/omi/firmware/devkit/Kconfig
@@ -55,4 +55,13 @@ config OMI_ENABLE_HAPTIC
         "Enable the haptic support."
     default n
 
+config OMI_ENABLE_AUDIO_CHUNKING
+    bool "Enable Audio Chunking System"
+    depends on OMI_ENABLE_OFFLINE_STORAGE
+    help
+        "Enable the time-based audio chunking system for better file management.
+         Creates 5-minute audio chunks with unique filenames across reboots.
+         Disable to use legacy numbered file system (a01.txt)."
+    default y
+
 endmenu
diff --git a/omi/firmware/devkit/prj_xiao_ble_sense_devkitv2-adafruit.conf b/omi/firmware/devkit/prj_xiao_ble_sense_devkitv2-adafruit.conf
index ec7b9c92ba..7d9452d9cb 100644
--- a/omi/firmware/devkit/prj_xiao_ble_sense_devkitv2-adafruit.conf
+++ b/omi/firmware/devkit/prj_xiao_ble_sense_devkitv2-adafruit.conf
@@ -206,3 +206,4 @@ CONFIG_OMI_ENABLE_SPEAKER=y
 CONFIG_OMI_ENABLE_BATTERY=y
 CONFIG_OMI_ENABLE_USB=y
 CONFIG_OMI_ENABLE_HAPTIC=y
+CONFIG_OMI_ENABLE_AUDIO_CHUNKING=y
diff --git a/omi/firmware/devkit/src/main.c b/omi/firmware/devkit/src/main.c
index 2acf2eb6b4..6a0fdfd8ce 100644
--- a/omi/firmware/devkit/src/main.c
+++ b/omi/firmware/devkit/src/main.c
@@ -127,10 +127,12 @@ int main(void)
     NRF_POWER->RESETREAS=1;
 
     LOG_INF("Booting...\n");
+    printf("[DEBUG] main: DEVICE BOOT STARTED - firmware is loading\n");
 
     LOG_INF("Model: %s", CONFIG_BT_DIS_MODEL);
     LOG_INF("Firmware revision: %s", CONFIG_BT_DIS_FW_REV_STR);
     LOG_INF("Hardware revision: %s", CONFIG_BT_DIS_HW_REV_STR);
+    printf("[DEBUG] main: Device info printed - continuing boot sequence\n");
 
     LOG_DBG("Reset reason: %d\n", reset_reason);
 
@@ -211,7 +213,7 @@ int main(void)
         LOG_ERR("Failed to mount SD card (err %d)", err);
         return err;
     }
-    k_msleep(500);
+    k_msleep(500);  // Reduced but still present - SD card needs time to be ready
 
     LOG_PRINTK("\n");
     LOG_INF("Initializing storage...\n");
@@ -220,6 +222,8 @@ int main(void)
     if (err)
     {
         LOG_ERR("Failed to initialize storage (err %d)", err);
+    } else {
+        LOG_INF("Storage initialized successfully");
     }
 #endif
 
@@ -340,13 +344,36 @@ int main(void)
     k_msleep(1000);
     set_led_blue(false);
 
+    // Mark boot as complete to enable chunking
+    set_system_boot_complete();
+
     // Main loop
     LOG_PRINTK("\n");
     LOG_INF("Entering main loop...\n");
+    printf("[DEBUG] main: Main loop started - device is alive\n");
 
+    static uint32_t heartbeat_counter = 0;
+    
     while (1)
     {
         set_led_state();
+        
+        //Check chunk rotation timing every 500ms instead of on every audio packet
+        check_chunk_rotation_timing();
+        
+        // Update file cache every 10 seconds (in main thread - safe for fs_opendir)
+        if (heartbeat_counter % 20 == 0) {
+            printf("[DEBUG] main: Updating file cache (MAIN THREAD CONTEXT)\n");
+            update_files_cache();
+        }
+        
+        // Print heartbeat every 10 seconds (20 iterations * 500ms = 10s)
+        heartbeat_counter++;
+        if (heartbeat_counter % 20 == 0) {
+            printf("[DEBUG] main: HEARTBEAT %u - device alive and running (connected=%s)\n", 
+                   heartbeat_counter, is_connected ? "true" : "false");
+        }
+        
         k_msleep(500);
     }
 
diff --git a/omi/firmware/devkit/src/sdcard.c b/omi/firmware/devkit/src/sdcard.c
index e76a272b66..219a2961f2 100644
--- a/omi/firmware/devkit/src/sdcard.c
+++ b/omi/firmware/devkit/src/sdcard.c
@@ -7,7 +7,10 @@
 #include <zephyr/logging/log.h>
 #include <zephyr/storage/disk_access.h>
 #include <zephyr/sys/check.h>
+#include <zephyr/sys/atomic.h>
+#include <string.h>
 #include "sdcard.h"
+#include "sdcard_config.h"
 
 LOG_MODULE_REGISTER(sdcard, CONFIG_LOG_DEFAULT_LEVEL);
 
@@ -22,17 +25,46 @@ struct gpio_dt_spec sd_en_gpio_pin = { .port = DEVICE_DT_GET(DT_NODELABEL(gpio0)
 
 uint8_t file_count = 0;
 
-#define MAX_PATH_LENGTH 32
 static char current_full_path[MAX_PATH_LENGTH];
 static char read_buffer[MAX_PATH_LENGTH];
 static char write_buffer[MAX_PATH_LENGTH];
 
 uint32_t file_num_array[2];    
 
-static const char *disk_mount_pt = "/SD:/";
+static const char *disk_mount_pt = SDCARD_MOUNT_POINT;
 
 bool sd_enabled = false;
 
+// Chunking variables
+static char current_chunk_filename[CHUNK_FILENAME_MAX_LENGTH];
+bool chunk_active = false;  // Made non-static for external access
+static bool system_boot_complete = false;  // Prevent chunking during boot
+// Chunking enabled flag - now controlled by CONFIG_OMI_ENABLE_AUDIO_CHUNKING
+#ifdef CONFIG_OMI_ENABLE_AUDIO_CHUNKING
+bool chunking_enabled = true;
+#else
+bool chunking_enabled = false;
+#endif
+static atomic_t chunk_cycle_counter = ATOMIC_INIT(0);  // Thread-safe counter for 500ms cycles
+
+// Persistent chunk counter for unique filenames across reboots
+static uint32_t chunk_counter = 0;
+
+// REAL FILE CACHE - Updated by main thread, read by BLE thread
+#define MAX_CACHED_FILES 10
+#define MAX_FILENAME_LENGTH 64
+char recent_files_cache[MAX_CACHED_FILES][MAX_FILENAME_LENGTH];  // Made non-static for external access
+int cached_file_count = 0;  // Made non-static for external access
+static bool cache_needs_update = true;
+static atomic_t cache_update_flag = ATOMIC_INIT(1);  // Thread-safe update flag
+
+static atomic_t should_rotate_flag = ATOMIC_INIT(0);  // Thread-safe flag (0=false, 1=true)
+
+// Forward declarations
+int get_file_contents(struct fs_dir_t *zdp, struct fs_dirent *entry);
+
+
+
 int mount_sd_card(void)
 {
     //initialize the sd card enable pin (v2)
@@ -56,7 +88,7 @@ int mount_sd_card(void)
     //initialize the sd card
     const char *disk_pdrv = "SD";  
 	int err = disk_access_init(disk_pdrv); 
-    LOG_INF("disk_access_init: %d\n", err);
+    LOG_INF("disk_access_init: %d", err);
     if (err) 
     {   //reattempt
         k_msleep(1000);
@@ -80,14 +112,14 @@ int mount_sd_card(void)
         return -1;
     }
     
-    res = fs_mkdir("/SD:/audio");
+    res = fs_mkdir(SDCARD_AUDIO_PATH);
 
     if (res == FR_OK) 
     {
         LOG_INF("audio directory created successfully");
         initialize_audio_file(1);
     }
-    else if (res == FR_EXIST) 
+    else if (res == FR_EXIST || res == -17) 
     {
         LOG_INF("audio directory already exists");
     }
@@ -96,62 +128,105 @@ int mount_sd_card(void)
         LOG_INF("audio directory creation failed: %d", res);
     }
 
-    struct fs_dir_t audio_dir_entry;
-    fs_dir_t_init(&audio_dir_entry);
-    err = fs_opendir(&audio_dir_entry,"/SD:/audio");
-    if (err) 
-    {
-        LOG_ERR("error while opening directory ",err);
-        return -1;
-    }
-    LOG_INF("result of opendir: %d",err);
-    initialize_audio_file(1);
-    struct fs_dirent file_count_entry;
-    file_count = get_file_contents(&audio_dir_entry, &file_count_entry);
-    file_count = 1;
-    if (file_count < 0) 
-    {
-        LOG_ERR(" error getting file count");
-        return -1;
-    }
-
-    fs_closedir(&audio_dir_entry);
-    // file_count++;
-    LOG_INF("new num files: %d",file_count);
+    if (chunking_enabled) {
+        // ======================================================================
+        // NEW CHUNKING SYSTEM
+        // ======================================================================
+        // This is the new audio chunk recording system that creates time-based
+        // chunks for better file management and power management. This should be the default mode.
+        LOG_INF("Using chunking system");
+        file_count = 1;  // Set to 1 for compatibility
+        
+        // Load the persistent chunk counter
+        int ret = get_chunk_counter(&chunk_counter);
+        if (ret < 0) {
+            LOG_ERR("Failed to load chunk counter: %d", ret);
+            chunk_counter = 0; // Use default value on error
+        }
+        LOG_INF("Loaded chunk counter: %d", chunk_counter);
+    } else {
+        // ======================================================================
+        // LEGACY FILE SYSTEM (DEPRECATED)
+        // ======================================================================
+        // This is the old file system that uses numbered files (a01.txt, etc.)
+        // It is maintained for backward compatibility but should be removed
+        // in future versions once chunking is fully validated.
+        // TODO: Remove this legacy system in a future release
+        LOG_INF("Using legacy file system (DEPRECATED)");
+        struct fs_dir_t audio_dir_entry;
+        fs_dir_t_init(&audio_dir_entry);
+        err = fs_opendir(&audio_dir_entry, SDCARD_AUDIO_PATH);
+        if (err) 
+        {
+            LOG_ERR("error while opening directory: %d", err);
+            return -1;
+        }
+        LOG_INF("result of opendir: %d",err);
+        initialize_audio_file(1);
+        struct fs_dirent file_count_entry;
+        file_count = get_file_contents(&audio_dir_entry, &file_count_entry);
+        file_count = 1;
+        if (file_count < 0) 
+        {
+            LOG_ERR(" error getting file count");
+            return -1;
+        }
 
-    res = move_write_pointer(file_count); 
-    if (res) 
-    {
-        LOG_ERR("erro while moving the write pointer");
-        return -1;
-    }
+        fs_closedir(&audio_dir_entry);
+        LOG_INF("new num files: %d",file_count);
 
-    move_read_pointer(file_count);
+        res = move_write_pointer(file_count); 
+        if (res) 
+        {
+            LOG_ERR("erro while moving the write pointer");
+            return -1;
+        }
 
-    if (res) 
-    {
-        LOG_ERR("error while moving the reader pointer\n");
-        return -1;
+        move_read_pointer(file_count);
+        if (res) 
+        {
+            LOG_ERR("error while moving the reader pointer\n");
+            return -1;
+        }
+        LOG_INF("file count: %d",file_count);
     }
-    LOG_INF("file count: %d",file_count);
    
     struct fs_dirent info_file_entry; //check if the info file exists. if not, generate new info file
-    const char *info_path = "/SD:/info.txt";
+    const char *info_path = SDCARD_INFO_FILE;
     res = fs_stat(info_path,&info_file_entry); //for later
     if (res) 
     {
         res = create_file("info.txt");
         save_offset(0);
-        LOG_INF("result of info.txt creation: %d ",res);
+        LOG_INF("result of info.txt creation: %d", res);
     }
     
-    LOG_INF("result of check: %d",res);
-
+    LOG_INF("SD card mount completed");
 	return 0;
 }
 
 uint32_t get_file_size(uint8_t num)
 {
+    // For chunk files, use the cached filename approach
+    if (chunking_enabled && num <= cached_file_count && num > 0) {
+        const char* filename = recent_files_cache[num - 1]; // Convert to 0-based index
+        if (filename[0] != '\0') {
+            printf("[DEBUG] get_file_size: Cached filename: '%s' (length: %d)\n", filename, (int)strlen(filename));
+            snprintf(current_full_path, sizeof(current_full_path), "%saudio/%s", disk_mount_pt, filename);
+            printf("[DEBUG] get_file_size: Checking chunk file: %s\n", current_full_path);
+            
+            struct fs_dirent entry;
+            int res = fs_stat(current_full_path, &entry);
+            if (res == 0) {
+                printf("[DEBUG] get_file_size: Chunk file size: %d bytes\n", (int)entry.size);
+                return (uint32_t)entry.size;
+            } else {
+                printf("[DEBUG] get_file_size: Failed to stat chunk file: %d\n", res);
+            }
+        }
+    }
+    
+    // Legacy behavior for old audio files (a01.txt, etc.)
     char *ptr = generate_new_audio_header(num);
     snprintf(current_full_path, sizeof(current_full_path), "%s%s", disk_mount_pt, ptr);
     k_free(ptr);
@@ -167,6 +242,26 @@ uint32_t get_file_size(uint8_t num)
 
 int move_read_pointer(uint8_t num) 
 {
+    // For chunk files, use the cached filename approach
+    if (chunking_enabled && num <= cached_file_count && num > 0) {
+        const char* filename = recent_files_cache[num - 1]; // Convert to 0-based index
+        if (filename[0] != '\0') {
+            printf("[DEBUG] move_read_pointer: Cached filename: '%s' (length: %d)\n", filename, (int)strlen(filename));
+            snprintf(read_buffer, sizeof(read_buffer), "%saudio/%s", disk_mount_pt, filename);
+            printf("[DEBUG] move_read_pointer: Setting read buffer to chunk file: %s\n", read_buffer);
+            
+            struct fs_dirent entry;
+            int res = fs_stat(read_buffer, &entry);
+            if (res == 0) {
+                printf("[DEBUG] move_read_pointer: Chunk file ready for reading\n");
+                return 0;
+            } else {
+                printf("[DEBUG] move_read_pointer: Failed to stat chunk file: %d\n", res);
+            }
+        }
+    }
+    
+    // Legacy behavior for old audio files (a01.txt, etc.)
     char *read_ptr = generate_new_audio_header(num);
     snprintf(read_buffer, sizeof(read_buffer), "%s%s", disk_mount_pt, read_ptr);
     k_free(read_ptr);
@@ -216,30 +311,88 @@ int read_audio_data(uint8_t *buf, int amount,int offset)
     struct fs_file_t read_file;
    	fs_file_t_init(&read_file); 
     uint8_t *temp_ptr = buf;
-    struct fs_dirent entry;  
+
+    printf("[DEBUG] read_audio_data: Opening file: %s\n", read_buffer);
+    printf("[DEBUG] read_audio_data: Request - offset: %d, amount: %d\n", offset, amount);
 
 	int rc = fs_open(&read_file, read_buffer, FS_O_READ | FS_O_RDWR);
-    rc = fs_seek(&read_file,offset,FS_SEEK_SET);
+    if (rc < 0) {
+        LOG_ERR("Failed to open file for reading: %d", rc);
+        printf("[DEBUG] read_audio_data: Failed to open file: %d\n", rc);
+        return rc;
+    }
+    
+    // Get file size to check bounds
+    struct fs_dirent entry;
+    rc = fs_stat(read_buffer, &entry);
+    if (rc < 0) {
+        LOG_ERR("Failed to stat file: %d", rc);
+        printf("[DEBUG] read_audio_data: Failed to stat file: %d\n", rc);
+        fs_close(&read_file);
+        return rc;
+    }
+    
+    uint32_t file_size = (uint32_t)entry.size;
+    printf("[DEBUG] read_audio_data: File size: %d bytes\n", file_size);
+    
+    // Check if offset is within file bounds
+    if (offset >= file_size) {
+        LOG_ERR("Offset %d is beyond file size %d", offset, file_size);
+        printf("[DEBUG] read_audio_data: ❌ Offset %d >= file_size %d, STOPPING READ\n", offset, file_size);
+        fs_close(&read_file);
+        return 0; // Return 0 bytes read (EOF)
+    }
+    
+    // Limit amount to what's actually available
+    if (offset + amount > file_size) {
+        amount = file_size - offset;
+        printf("[DEBUG] read_audio_data: Limited read amount to %d bytes (remaining in file)\n", amount);
+    }
+    
+    rc = fs_seek(&read_file, offset, FS_SEEK_SET);
+    if (rc < 0) {
+        LOG_ERR("Failed to seek to offset %d: %d", offset, rc);
+        printf("[DEBUG] read_audio_data: ❌ SEEK FAILED offset=%d, error=%d\n", offset, rc);
+        fs_close(&read_file);
+        return rc;
+    }
+    
+    printf("[DEBUG] read_audio_data: ✅ Seek successful, reading %d bytes\n", amount);
     rc = fs_read(&read_file, temp_ptr, amount);
-    // LOG_PRINTK("read data :");
-    // for (int i = 0; i < amount;i++) {
-    //     LOG_PRINTK("%d ",temp_ptr[i]);
-    // }
-    // LOG_PRINTK("\n");
+    if (rc < 0) {
+        LOG_ERR("Failed to read %d bytes: %d", amount, rc);
+        printf("[DEBUG] read_audio_data: ❌ READ FAILED amount=%d, error=%d\n", amount, rc);
+    } else {
+        printf("[DEBUG] read_audio_data: ✅ Successfully read %d bytes\n", rc);
+    }
+    
   	fs_close(&read_file);
 
     return rc;
 }
 
-int write_to_file(uint8_t *data,uint32_t length)
+int write_to_file(uint8_t *data, uint32_t length)
 {
     struct fs_file_t write_file;
-	fs_file_t_init(&write_file);
+    fs_file_t_init(&write_file);
     uint8_t *write_ptr = data;
-   	fs_open(&write_file, write_buffer , FS_O_WRITE | FS_O_APPEND);
-	fs_write(&write_file, write_ptr, length);
+    
+    int ret = fs_open(&write_file, write_buffer, FS_O_WRITE | FS_O_APPEND);
+    if (ret < 0) {
+        LOG_ERR("Failed to open file for writing: %d", ret);
+        return ret;
+    }
+    
+    ret = fs_write(&write_file, write_ptr, length);
     fs_close(&write_file);
-    return 0;
+    
+    if (ret < 0) {
+        LOG_ERR("Failed to write to file: %d", ret);
+        return ret;
+    }
+    
+    // Return number of bytes written (positive value) or error (negative)
+    return ret;
 }
     
 int initialize_audio_file(uint8_t num) 
@@ -249,8 +402,8 @@ int initialize_audio_file(uint8_t num)
     {
         return -1;
     }
-    k_free(header);
     create_file(header);
+    k_free(header);
     return 0;
 }
 
@@ -365,13 +518,13 @@ int clear_audio_directory()
             return -1;
         }  
     }
-    res = fs_unlink("/SD:/audio");
+    res = fs_unlink(SDCARD_AUDIO_PATH);
     if (res) 
     {
         LOG_ERR("error deleting file");
         return -1;
     }
-    res = fs_mkdir("/SD:/audio");
+    res = fs_mkdir(SDCARD_AUDIO_PATH);
     if (res) 
     {
         LOG_ERR("failed to make directory");
@@ -402,7 +555,7 @@ int save_offset(uint32_t offset)
 
     struct fs_file_t write_file;
     fs_file_t_init(&write_file);
-    int res = fs_open(&write_file, "/SD:/info.txt" , FS_O_WRITE | FS_O_CREATE);
+    int res = fs_open(&write_file, SDCARD_INFO_FILE, FS_O_WRITE | FS_O_CREATE);
     if (res) 
     {
         LOG_ERR("error opening file %d",res);
@@ -423,7 +576,7 @@ int get_offset()
     uint8_t buf[4];
     struct fs_file_t read_file;
     fs_file_t_init(&read_file);
-    int rc = fs_open(&read_file, "/SD:/info.txt", FS_O_READ | FS_O_RDWR);
+    int rc = fs_open(&read_file, SDCARD_INFO_FILE, FS_O_READ | FS_O_RDWR);
     if (rc < 0)
     {
         LOG_ERR("error opening file %d",rc);
@@ -449,6 +602,72 @@ int get_offset()
     return offset_ptr[0];
 }
 
+int save_chunk_counter(uint32_t counter)
+{
+    uint8_t buf[4] = {
+        counter & 0xFF,
+        (counter >> 8) & 0xFF,
+        (counter >> 16) & 0xFF, 
+        (counter >> 24) & 0xFF 
+    };
+
+    struct fs_file_t write_file;
+    fs_file_t_init(&write_file);
+    int res = fs_open(&write_file, SDCARD_CHUNK_COUNTER_FILE, FS_O_WRITE | FS_O_CREATE);
+    if (res < 0) 
+    {
+        LOG_ERR("error opening chunk counter file %d", res);
+        return res;
+    }
+    res = fs_write(&write_file, &buf, 4);
+    if (res < 0)
+    {
+        LOG_ERR("error writing chunk counter file %d", res);
+        fs_close(&write_file);
+        return res;
+    }
+    fs_close(&write_file);
+    return 0;
+}
+
+int get_chunk_counter(uint32_t *counter)
+{
+    if (counter == NULL) {
+        return -EINVAL;
+    }
+    
+    uint8_t buf[4];
+    struct fs_file_t read_file;
+    fs_file_t_init(&read_file);
+    int rc = fs_open(&read_file, SDCARD_CHUNK_COUNTER_FILE, FS_O_READ);
+    if (rc < 0)
+    {
+        // File doesn't exist, start with counter 0
+        LOG_INF("chunk counter file doesn't exist, starting with 0");
+        *counter = 0;
+        return 0;
+    }
+    
+    rc = fs_read(&read_file, &buf, 4);
+    fs_close(&read_file);
+    
+    if (rc < 0)
+    {
+        LOG_ERR("error reading chunk counter file %d", rc);
+        return rc; // Return the actual error code
+    }
+    
+    if (rc != 4) {
+        LOG_ERR("incomplete read of chunk counter, got %d bytes", rc);
+        return -EIO;
+    }
+    
+    uint32_t *counter_ptr = (uint32_t*)buf;
+    *counter = counter_ptr[0];
+    LOG_INF("loaded chunk counter: %d", *counter);
+    return 0;
+}
+
 void sd_off()
  {
 //    gpio_pin_set_dt(&sd_en_gpio_pin, 0);  
@@ -466,3 +685,362 @@ bool is_sd_on()
 {
     return sd_enabled;
 }
+
+char* generate_timestamp_audio_filename(void)
+{
+    // Increment and save the chunk counter for unique filenames across reboots
+    chunk_counter++;
+    int ret = save_chunk_counter(chunk_counter);
+    if (ret < 0) {
+        LOG_ERR("Failed to save chunk counter: %d", ret);
+        // Continue anyway - we can still generate filename with current counter
+    }
+    
+    int64_t current_time = k_uptime_get();
+    
+    // Simple timestamp based on uptime (in seconds since boot)
+    uint32_t uptime_seconds = current_time / 1000;
+    uint32_t hours = (uptime_seconds / 3600) % 24;
+    uint32_t minutes = (uptime_seconds / 60) % 60;
+    uint32_t seconds = uptime_seconds % 60;
+    
+    char *filename = k_malloc(CHUNK_FILENAME_MAX_LENGTH);
+    if (filename == NULL) {
+        LOG_ERR("Failed to allocate memory for chunk filename");
+        return NULL;
+    }
+    
+    // Format: audio/chunk_HHMMSS_NNNNN.b (with unique counter after timestamp)  
+    int len = snprintf(filename, CHUNK_FILENAME_MAX_LENGTH, CHUNK_FILENAME_FORMAT, 
+                      (int)hours, (int)minutes, (int)seconds, (int)chunk_counter);
+    
+    printf("[DEBUG] generate_timestamp_audio_filename: Generated filename: %s\n", filename);
+    
+    if (len >= 40 || len < 0) {
+        LOG_ERR("Filename too long or formatting error");
+        k_free(filename);
+        return NULL;
+    }
+    
+    LOG_DBG("Generated chunk filename: %s", filename);
+    return filename;
+}
+
+int initialize_chunk_file(void)
+{
+    // Safety check - ensure chunking is enabled and SD is properly initialized
+    if (!chunking_enabled) {
+        LOG_ERR("Cannot initialize chunk - chunking disabled");
+        return SDCARD_ERR_CHUNKING_DISABLED;
+    }
+    
+    if (!sd_enabled) {
+        LOG_ERR("Cannot initialize chunk - SD not enabled");
+        return SDCARD_ERR_SD_NOT_ENABLED;
+    }
+    
+    char *filename = generate_timestamp_audio_filename();
+    if (filename == NULL) {
+        LOG_ERR("Failed to generate chunk filename - out of memory");
+        return SDCARD_ERR_FILENAME_GENERATION;
+    }
+    
+    // Copy to current chunk filename buffer
+    strncpy(current_chunk_filename, filename, sizeof(current_chunk_filename) - 1);
+    current_chunk_filename[sizeof(current_chunk_filename) - 1] = '\0';
+    
+    // Create the file
+    int ret = create_file(filename);
+    k_free(filename);
+    
+    if (ret == 0) {
+        // Update write buffer to point to new file
+        int len = snprintf(write_buffer, sizeof(write_buffer), "%s%s", disk_mount_pt, current_chunk_filename);
+        if (len >= sizeof(write_buffer)) {
+            LOG_ERR("Write buffer path too long, truncated");
+        }
+        atomic_set(&chunk_cycle_counter, 0);     // Thread-safe: Reset cycle counter for new chunk
+        chunk_active = true;
+        atomic_set(&should_rotate_flag, 0);      // Thread-safe: Reset rotation flag for new chunk
+        LOG_INF("NEW AUDIO CHUNK CREATED: %s", current_chunk_filename);
+        LOG_INF("File path: %s", write_buffer);
+        LOG_INF("Chunk will rotate in %d cycles (%d seconds)", CHUNK_DURATION_CYCLES, CHUNK_DURATION_CYCLES / 2);
+        
+        // Trigger cache update since a new file was created
+        trigger_cache_update();
+    } else {
+        LOG_ERR("Failed to create chunk file: %d", ret);
+        // Reset chunk state on failure
+        chunk_active = false;
+        memset(current_chunk_filename, 0, sizeof(current_chunk_filename));
+    }
+    
+    return ret;
+}
+
+bool should_rotate_chunk(void)
+{
+    // Safety check - if chunking disabled, SD not enabled, or system still booting
+    if (!chunking_enabled || !sd_enabled || !system_boot_complete) {
+        return false;
+    }
+    
+    if (!chunk_active) {
+        return true; // No active chunk, should start one
+    }
+    
+    // Thread-safe: Atomic read of the rotation flag
+    return atomic_get(&should_rotate_flag) != 0;
+}
+
+void check_chunk_rotation_timing(void)
+{
+    // This function should be called every 500ms from main loop
+    // Only check timing if chunking is enabled and chunk is active
+    if (!chunking_enabled || !sd_enabled || !system_boot_complete || !chunk_active) {
+        atomic_set(&should_rotate_flag, 0);  // Clear flag
+        atomic_set(&chunk_cycle_counter, 0); // Reset counter when not active
+        return;
+    }
+    
+    // Thread-safe: Atomic increment of the cycle counter
+    uint32_t current_cycles = atomic_inc(&chunk_cycle_counter);
+    
+    // Set the flag if we've reached the target number of cycles
+    if (current_cycles >= CHUNK_DURATION_CYCLES) {
+        atomic_set(&should_rotate_flag, 1);
+    }
+}
+
+int start_new_chunk(void)
+{
+    if (chunk_active) {
+        uint32_t cycles = atomic_get(&chunk_cycle_counter);  // Thread-safe read
+        LOG_INF("FINALIZING CHUNK: %s", current_chunk_filename);
+        LOG_INF("Duration: %d cycles (%d seconds)", cycles, cycles / 2);
+        // Current chunk is automatically finalized when we stop writing to it
+    }
+    
+    return initialize_chunk_file();
+}
+
+void set_system_boot_complete(void)
+{
+    system_boot_complete = true;
+    LOG_INF("System boot marked as complete - chunking enabled");
+}
+
+void update_files_cache(void)
+{
+    // This function runs in MAIN THREAD context - safe to use fs_opendir
+    if (!atomic_get(&cache_update_flag)) {
+        return;  // No update needed
+    }
+    
+    if (!sd_enabled) {
+        printf("[DEBUG] update_files_cache: SD card not enabled\n");
+        return;
+    }
+    
+    printf("[DEBUG] update_files_cache: Starting cache update (MAIN THREAD - SAFE)\n");
+    
+    struct fs_dir_t dir;
+    struct fs_dirent entry;
+    int res;
+    int local_file_count = 0;
+    
+    // Clear the cache first
+    memset(recent_files_cache, 0, sizeof(recent_files_cache));
+    
+    fs_dir_t_init(&dir);
+    res = fs_opendir(&dir, SDCARD_AUDIO_PATH);
+    if (res) {
+        LOG_ERR("Failed to open audio directory for cache update: %d", res);
+        printf("[DEBUG] update_files_cache: Failed to open audio directory: %d\n", res);
+        cached_file_count = 0;
+        // Clear file_num_array for storage system
+        extern uint8_t file_count;
+        file_count = 0;
+        file_num_array[0] = 0;
+        file_num_array[1] = 0;
+        atomic_set(&cache_update_flag, 0);  // Clear flag even on error
+        return;
+    }
+    
+    printf("[DEBUG] update_files_cache: Successfully opened audio directory\n");
+    
+    // Read directory entries and populate cache with REAL files
+    while ((res = fs_readdir(&dir, &entry)) == 0 && local_file_count < MAX_CACHED_FILES) {
+        if (entry.name[0] == 0) {
+            // End of directory
+            printf("[DEBUG] update_files_cache: End of directory reached\n");
+            break;
+        }
+        
+        // Skip hidden files and directories
+        if (entry.name[0] == '.') {
+            continue;
+        }
+        
+        // Only include .b files (chunk files) and .txt files (legacy)
+        if (strstr(entry.name, ".b") != NULL || strstr(entry.name, ".txt") != NULL) {
+            strncpy(recent_files_cache[local_file_count], entry.name, MAX_FILENAME_LENGTH - 1);
+            recent_files_cache[local_file_count][MAX_FILENAME_LENGTH - 1] = '\0';  // Ensure null termination
+            
+            printf("[DEBUG] update_files_cache: Cached file %d: %s (size: %d bytes)\n", 
+                   local_file_count + 1, recent_files_cache[local_file_count], (int)entry.size);
+            
+            // CRITICAL: Update file_num_array for storage download system compatibility
+            if (local_file_count < 2) {  // Only store first 2 files in file_num_array for now
+                file_num_array[local_file_count] = entry.size;
+                printf("[DEBUG] update_files_cache: Updated file_num_array[%d] = %d bytes\n", 
+                       local_file_count, (int)entry.size);
+            }
+            
+            local_file_count++;
+        }
+    }
+    
+    fs_closedir(&dir);
+    
+    cached_file_count = local_file_count;
+    
+    // Update global file_count for storage system (declared as extern in storage.c)
+    extern uint8_t file_count;
+    file_count = (local_file_count > 0) ? local_file_count : 0;
+    
+    // If we have fewer than 2 files, clear remaining file_num_array entries
+    for (int i = local_file_count; i < 2; i++) {
+        file_num_array[i] = 0;
+    }
+    
+    atomic_set(&cache_update_flag, 0);  // Clear update flag
+    
+    printf("[DEBUG] update_files_cache: Cache updated with %d REAL files\n", cached_file_count);
+    printf("[DEBUG] update_files_cache: Updated global file_count=%d, file_num_array[0]=%d, file_num_array[1]=%d\n", 
+           file_count, file_num_array[0], file_num_array[1]);
+    LOG_INF("File cache updated: %d files", cached_file_count);
+}
+
+void trigger_cache_update(void)
+{
+    atomic_set(&cache_update_flag, 1);
+    printf("[DEBUG] trigger_cache_update: Cache update requested\n");
+}
+
+int delete_chunk_file(const char* filename)
+{
+    if (!sd_enabled) {
+        LOG_ERR("SD card not enabled");
+        printf("[DEBUG] delete_chunk_file: SD card not enabled\n");
+        return -ENODEV;
+    }
+    
+    if (filename == NULL || strlen(filename) == 0) {
+        LOG_ERR("Invalid filename");
+        printf("[DEBUG] delete_chunk_file: Invalid filename\n");
+        return -EINVAL;
+    }
+    
+    char full_path[MAX_PATH_LENGTH];
+    snprintf(full_path, sizeof(full_path), "%saudio/%s", disk_mount_pt, filename);
+    
+    printf("[DEBUG] delete_chunk_file: Attempting to delete: %s\n", full_path);
+    
+    // Check if file exists first
+    struct fs_dirent entry;
+    int res = fs_stat(full_path, &entry);
+    if (res != 0) {
+        LOG_ERR("File not found: %s", filename);
+        printf("[DEBUG] delete_chunk_file: File not found: %s\n", filename);
+        return -ENOENT;
+    }
+    
+    // Delete the file
+    res = fs_unlink(full_path);
+    if (res != 0) {
+        LOG_ERR("Failed to delete file %s: %d", filename, res);
+        printf("[DEBUG] delete_chunk_file: Failed to delete %s: %d\n", filename, res);
+        return res;
+    }
+    
+    printf("[DEBUG] delete_chunk_file: ✅ Successfully deleted: %s\n", filename);
+    
+    // Update the cache to reflect the deletion
+    trigger_cache_update();
+    
+    return 0;
+}
+
+int get_audio_file_names(char* buffer, size_t buffer_size)
+{
+    printf("[DEBUG] get_audio_file_names: Called with buffer_size=%d (BLE THREAD CONTEXT)\n", (int)buffer_size);
+    
+    if (buffer == NULL || buffer_size == 0) {
+        LOG_ERR("Invalid buffer parameters");
+        printf("[DEBUG] get_audio_file_names: Invalid buffer parameters\n");
+        return -EINVAL;
+    }
+    
+    if (!sd_enabled) {
+        LOG_ERR("SD card not enabled");
+        printf("[DEBUG] get_audio_file_names: SD card not enabled\n");
+        return -ENODEV;
+    }
+    
+    printf("[DEBUG] get_audio_file_names: Using CACHED REAL FILES (thread-safe)\n");
+    printf("[DEBUG] get_audio_file_names: Cache contains %d real files\n", cached_file_count);
+    
+    int offset = 0;
+    int file_count = 0;
+    
+    // Copy real cached filenames to buffer (thread-safe read)
+    for (int i = 0; i < cached_file_count && file_count < MAX_CACHED_FILES; i++) {
+        if (recent_files_cache[i][0] != '\0') {  // File exists in cache
+            int name_len = strlen(recent_files_cache[i]);
+            
+            // Check if we have space (name length + newline + null terminator + safety margin)
+            if (offset + name_len + 2 < buffer_size) {
+                strcpy(buffer + offset, recent_files_cache[i]);
+                offset += name_len;
+                buffer[offset++] = '\n';
+                file_count++;
+                printf("[DEBUG] get_audio_file_names: Added REAL file %d: %s\n", file_count, recent_files_cache[i]);
+            } else {
+                printf("[DEBUG] get_audio_file_names: Buffer full, stopping at %d files\n", file_count);
+                break;
+            }
+        }
+    }
+    
+    // If no cached files, add informational message
+    if (file_count == 0) {
+        const char* no_files = "no_files_cached.info";
+        if (strlen(no_files) + 1 < buffer_size) {
+            strcpy(buffer, no_files);
+            offset = strlen(no_files);
+            file_count = 1;
+            printf("[DEBUG] get_audio_file_names: No cached files, returning info message\n");
+        }
+    }
+    
+    printf("[DEBUG] get_audio_file_names: File enumeration complete, found %d files\n", file_count);
+    
+    if (offset > 0) {
+        buffer[offset - 1] = '\0';  // Replace last newline with null terminator
+        offset--;  // Adjust offset to not count the null terminator
+        printf("[DEBUG] get_audio_file_names: Replaced last newline with null terminator\n");
+    } else {
+        buffer[0] = '\0';  // Empty list
+        printf("[DEBUG] get_audio_file_names: No files found, empty list\n");
+    }
+    
+    LOG_INF("Found %d files, %d bytes of file names", file_count, offset);
+    printf("[DEBUG] get_audio_file_names: Final result: %d files, %d bytes\n", file_count, offset);
+    
+    printf("[DEBUG] get_audio_file_names: Returning offset=%d\n", offset);
+    return offset;
+}
+
+
+
diff --git a/omi/firmware/devkit/src/sdcard.h b/omi/firmware/devkit/src/sdcard.h
index 05364539e5..8ae46f0723 100644
--- a/omi/firmware/devkit/src/sdcard.h
+++ b/omi/firmware/devkit/src/sdcard.h
@@ -1,6 +1,9 @@
 #ifndef SDCARD_H
 #define SDCARD_H
 
+#include <stdint.h>
+#include "sdcard_config.h"
+
 /**
  * @brief Mount the SD Card. Initializes the audio files 
  *
@@ -93,6 +96,50 @@ int clear_audio_file(uint8_t num);
  */
 int clear_audio_directory();
 
+/**
+ * @brief Get list of audio file names from the audio directory
+ *
+ * Returns a newline-separated list of audio file names from the /SD:/audio directory
+ * 
+ * @param buffer Buffer to store the file names (newline separated)
+ * @param buffer_size Size of the buffer
+ * @return Number of bytes written to buffer, or negative errno code if error
+ */
+int get_audio_file_names(char* buffer, size_t buffer_size);
+
+/**
+ * @brief Update the file cache with real files from SD card (MAIN THREAD ONLY)
+ * 
+ * This function safely uses fs_opendir in the main thread context to scan
+ * the audio directory and populate the cache with real filenames.
+ */
+void update_files_cache(void);
+
+/**
+ * @brief Trigger file cache update on next main loop iteration
+ * 
+ * Call this when files are created/deleted to refresh the cache.
+ */
+void trigger_cache_update(void);
+
+/**
+ * @brief Delete a chunk file from the SD card
+ * 
+ * Deletes the specified audio chunk file and updates the cache.
+ * 
+ * @param filename The name of the file to delete (e.g., "chunk_000001_00001.b")
+ * @return 0 if successful, negative errno code if error
+ */
+int delete_chunk_file(const char* filename);
+
+/**
+ * @brief External access to file cache for other modules
+ * 
+ * These variables are used by storage.c for file operations
+ */
+extern char recent_files_cache[10][64];  // MAX_CACHED_FILES, MAX_FILENAME_LENGTH
+extern int cached_file_count;
+
 int save_offset(uint32_t offset);
 int get_offset();
 
@@ -100,4 +147,94 @@ void sd_on();
 void sd_off();
 
 bool is_sd_on();
+
+/**
+ * @brief Global variable indicating if chunk recording is active
+ */
+extern bool chunk_active;
+
+/**
+ * @brief Global flag to enable/disable chunking system
+ * Controlled by CONFIG_OMI_ENABLE_AUDIO_CHUNKING in project configuration
+ * Set to false to use legacy file system, true for chunking
+ */
+extern bool chunking_enabled;
+
+/**
+ * @brief Generate a unique audio file name
+ *
+ * Creates a file name with persistent counter and timestamp for chunked recording
+ * Format: audio/chunk_NNNNN_HHMMSS.bin (where NNNNN is persistent counter)
+ * 
+ * @return dynamically allocated string with file path, must be freed with k_free()
+ */
+char* generate_timestamp_audio_filename(void);
+
+/**
+ * @brief Initialize a new chunk file for recording
+ *
+ * Creates a new audio file with chunk_HHMMSS.bin naming for 5-minute chunks
+ * 
+ * @return 0 if successful, negative errno code if error
+ */
+int initialize_chunk_file(void);
+
+/**
+ * @brief Check if current chunk should be rotated
+ *
+ * 
+ * @return true if chunk should be rotated, false otherwise
+ */
+bool should_rotate_chunk(void);
+
+/**
+ * @brief Check chunk rotation timing using cycle counter
+ *
+ * Should be called every 500ms from main loop.
+ * Uses simple counter instead of k_uptime_get() for maximum efficiency.
+ * Counts 500ms cycles and rotates after 600 cycles (5 minutes).
+ */
+void check_chunk_rotation_timing(void);
+
+/**
+ * @brief Start a new recording chunk
+ *
+ * Finalizes current chunk and starts a new one with timestamp-based naming
+ * 
+ * @return 0 if successful, negative errno code if error
+ */
+int start_new_chunk(void);
+
+/**
+ * @brief Mark system boot as complete to enable chunking
+ *
+ * Should be called after all system initialization is complete
+ */
+void set_system_boot_complete(void);
+
+/**
+ * @brief Save chunk counter to persistent storage
+ *
+ * Saves the current chunk counter value to SD card for persistence across reboots
+ * 
+ * @param counter The counter value to save
+ * @return 0 if successful, negative errno code if error
+ */
+int save_chunk_counter(uint32_t counter);
+
+/**
+ * @brief Load chunk counter from persistent storage
+ *
+ * Loads the chunk counter value from SD card, returns 0 if file doesn't exist
+ * 
+ * @return The loaded counter value, or 0 if file doesn't exist or on error
+ */
+/**
+ * @brief Get the persistent chunk counter value
+ * 
+ * @param counter Pointer to store the counter value
+ * @return 0 if successful, negative errno code if error
+ */
+int get_chunk_counter(uint32_t *counter);
+
 #endif
diff --git a/omi/firmware/devkit/src/sdcard_config.h b/omi/firmware/devkit/src/sdcard_config.h
new file mode 100644
index 0000000000..8a13e185fb
--- /dev/null
+++ b/omi/firmware/devkit/src/sdcard_config.h
@@ -0,0 +1,41 @@
+#ifndef SDCARD_CONFIG_H
+#define SDCARD_CONFIG_H
+
+/**
+ * @file sdcard_config.h
+ * @brief SD Card configuration constants
+ * 
+ * Centralizes all SD card related paths and configuration to avoid hardcoded values
+ * throughout the codebase and make the system more configurable.
+ * 
+ * Note: Audio chunking system is controlled by CONFIG_OMI_ENABLE_AUDIO_CHUNKING
+ * in the project configuration file (prj_*.conf).
+ */
+
+// SD Card mount point and base paths
+#define SDCARD_MOUNT_POINT "/SD:/"
+#define SDCARD_AUDIO_DIR "audio"
+#define SDCARD_AUDIO_PATH SDCARD_MOUNT_POINT SDCARD_AUDIO_DIR
+
+// Configuration files
+#define SDCARD_CHUNK_COUNTER_FILE SDCARD_MOUNT_POINT "chunk_counter.txt"
+#define SDCARD_INFO_FILE SDCARD_MOUNT_POINT "info.txt"
+
+// Chunking configuration
+#define CHUNK_DURATION_CYCLES  40  // 600  // 5 minutes = 600 cycles of 500ms each
+#define CHUNK_FILENAME_MAX_LENGTH 64
+#define CHUNK_FILENAME_FORMAT "audio/chunk_%02d%02d%02d_%05d.b"
+
+// File system configuration
+#define MAX_PATH_LENGTH 64
+#define MAX_WRITE_SIZE 512  // Adjust based on your system's requirements
+
+// Error codes (using negative values to match errno convention)
+#define SDCARD_ERR_CHUNKING_DISABLED   -200
+#define SDCARD_ERR_SD_NOT_ENABLED     -201
+#define SDCARD_ERR_SYSTEM_BOOTING     -202
+#define SDCARD_ERR_FILENAME_GENERATION -203
+#define SDCARD_ERR_CHUNK_COUNTER      -204
+#define SDCARD_ERR_FILE_CREATION      -205
+
+#endif // SDCARD_CONFIG_H
diff --git a/omi/firmware/devkit/src/storage.c b/omi/firmware/devkit/src/storage.c
index 5dde6a0be1..e5ff6f4526 100644
--- a/omi/firmware/devkit/src/storage.c
+++ b/omi/firmware/devkit/src/storage.c
@@ -36,7 +36,9 @@ static ssize_t storage_write_handler(struct bt_conn *conn, const struct bt_gatt_
 static struct bt_uuid_128 storage_service_uuid = BT_UUID_INIT_128(BT_UUID_128_ENCODE(0x30295780, 0x4301, 0xEABD, 0x2904, 0x2849ADFEAE43));
 static struct bt_uuid_128 storage_write_uuid = BT_UUID_INIT_128(BT_UUID_128_ENCODE(0x30295781, 0x4301, 0xEABD, 0x2904, 0x2849ADFEAE43));
 static struct bt_uuid_128 storage_read_uuid = BT_UUID_INIT_128(BT_UUID_128_ENCODE(0x30295782, 0x4301, 0xEABD, 0x2904, 0x2849ADFEAE43));
+static struct bt_uuid_128 storage_filenames_uuid = BT_UUID_INIT_128(BT_UUID_128_ENCODE(0x30295783, 0x4301, 0xEABD, 0x2904, 0x2849ADFEAE43));
 static ssize_t storage_read_characteristic(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, uint16_t len, uint16_t offset);
+static ssize_t storage_filenames_read_characteristic(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, uint16_t len, uint16_t offset);
 
 K_THREAD_STACK_DEFINE(storage_stack, 4096);
 static struct k_thread storage_thread;
@@ -51,6 +53,7 @@ static struct bt_gatt_attr storage_service_attr[] = {
     BT_GATT_CCC(storage_config_changed_handler, BT_GATT_PERM_READ | BT_GATT_PERM_WRITE),
     BT_GATT_CHARACTERISTIC(&storage_read_uuid.uuid, BT_GATT_CHRC_READ | BT_GATT_CHRC_NOTIFY, BT_GATT_PERM_READ, storage_read_characteristic, NULL, NULL),
     BT_GATT_CCC(storage_config_changed_handler, BT_GATT_PERM_READ | BT_GATT_PERM_WRITE),
+    BT_GATT_CHARACTERISTIC(&storage_filenames_uuid.uuid, BT_GATT_CHRC_READ, BT_GATT_PERM_READ, storage_filenames_read_characteristic, NULL, NULL),
 
 };
 
@@ -79,15 +82,60 @@ static void storage_config_changed_handler(const struct bt_gatt_attr *attr, uint
 
 static ssize_t storage_read_characteristic(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, uint16_t len, uint16_t offset) 
 {
+    printf("[DEBUG] storage_read_characteristic: Called! (existing storage read)\n");
+    
     k_msleep(10);
     uint32_t amount[2] = {0};
     for (int i = 0; i < 2; i++) {
            amount[i] = file_num_array[i];
         }
+    printf("[DEBUG] storage_read_characteristic: returning file_num_array[0]=%d, file_num_array[1]=%d\n", 
+           file_num_array[0], file_num_array[1]);
+           
     ssize_t result = bt_gatt_attr_read(conn, attr, buf, len, offset, amount, 2 * sizeof(uint32_t));
     return result;
 }
 
+// Global buffer to avoid stack overflow issues
+static char global_file_names_buffer[2048];
+
+static ssize_t storage_filenames_read_characteristic(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, uint16_t len, uint16_t offset)
+{
+    printf("[DEBUG] storage_filenames_read_characteristic: Called with len=%d, offset=%d\n", len, offset);
+    
+    printf("[DEBUG] storage_filenames_read_characteristic: SENDING ACTUAL FILE NAMES TO APP\n");
+    
+    // Clear the global buffer first (using global buffer to avoid stack issues)
+    memset(global_file_names_buffer, 0, sizeof(global_file_names_buffer));
+    
+    printf("[DEBUG] storage_filenames_read_characteristic: About to call get_audio_file_names with full buffer\n");
+    
+    // Call SD function with full buffer - send real data to app now that it's stable
+    int result = get_audio_file_names(global_file_names_buffer, sizeof(global_file_names_buffer));
+    
+    printf("[DEBUG] storage_filenames_read_characteristic: get_audio_file_names returned %d\n", result);
+    
+    if (result > 0) {
+        printf("[DEBUG] storage_filenames_read_characteristic: SENDING REAL FILES TO APP:\n%s\n", global_file_names_buffer);
+    } else {
+        printf("[DEBUG] storage_filenames_read_characteristic: No files or error: %d, sending empty response\n", result);
+        strcpy(global_file_names_buffer, "no_files_found.info");
+        result = strlen(global_file_names_buffer);
+    }
+    
+    int result_length = result;
+    
+    printf("[DEBUG] storage_filenames_read_characteristic: Sending test data to app, length=%d\n", result_length);
+    
+    LOG_INF("Returning test data: %.50s", global_file_names_buffer);
+    printf("[DEBUG] storage_filenames_read_characteristic: Returning test data to app: %.50s\n", global_file_names_buffer);
+    
+    ssize_t bt_result = bt_gatt_attr_read(conn, attr, buf, len, offset, global_file_names_buffer, result_length + 1); // +1 for null terminator
+    printf("[DEBUG] storage_filenames_read_characteristic: bt_gatt_attr_read returned %d\n", (int)bt_result);
+    
+    return bt_result;
+}
+
 uint8_t transport_started = 0;
 
 
@@ -121,17 +169,26 @@ static int setup_storage_tx()
     }
 
     LOG_INF("current read ptr %d",current_read_num);
+    
+    printf("[DEBUG] setup_storage_tx: file_num=%d, file_count=%d\n", current_read_num, file_count);
+    printf("[DEBUG] setup_storage_tx: file_num_array[0]=%d, file_num_array[1]=%d\n", 
+           file_num_array[0], file_num_array[1]);
    
     remaining_length = file_num_array[current_read_num-1];
+    printf("[DEBUG] setup_storage_tx: remaining_length from file_num_array = %d\n", remaining_length);
+    
     if(current_read_num == file_count) 
     {
         remaining_length = get_file_size(file_count);
+        printf("[DEBUG] setup_storage_tx: Updated remaining_length from get_file_size = %d\n", remaining_length);
     }
 
+    printf("[DEBUG] setup_storage_tx: offset=%d, remaining_length before subtraction=%d\n", offset, remaining_length);
     remaining_length = remaining_length - offset;
     
     // offset=offset_;
     LOG_INF("remaining length: %d",remaining_length);
+    printf("[DEBUG] setup_storage_tx: FINAL remaining_length = %d\n", remaining_length);
     LOG_INF("offset: %d",offset);
     LOG_INF("file: %d",current_read_num);
     
@@ -226,6 +283,7 @@ static uint8_t parse_storage_command(void *buf,uint16_t len)
 
 static ssize_t storage_write_handler(struct bt_conn *conn, const struct bt_gatt_attr *attr, const void *buf, uint16_t len, uint16_t offset, uint8_t flags) 
 {
+    printf("[DEBUG] storage_write_handler: Called! Storage service is working\n");
     LOG_INF("about to schedule the storage");
     LOG_INF("was sent %d  ", ((uint8_t*)buf)[0] );
 
@@ -268,17 +326,53 @@ static ssize_t storage_write_handler(struct bt_conn *conn, const struct bt_gatt_
 static void write_to_gatt(struct bt_conn *conn) { //unsafe. designed for max speeds. udp?
 
     uint32_t packet_size = MIN(remaining_length,SD_BLE_SIZE);
+    
+    printf("[DEBUG] write_to_gatt: Requesting packet_size=%d, remaining_length=%d, offset=%d\n", 
+           packet_size, remaining_length, offset);
 
     int r = read_audio_data(storage_write_buffer,packet_size,offset);
-    offset = offset + packet_size;
-    int err = bt_gatt_notify(conn, &storage_service.attrs[1], &storage_write_buffer,packet_size);
+    
+    if (r < 0) 
+    {
+        LOG_ERR("read error: %d", r);
+        printf("[DEBUG] write_to_gatt: ❌ Read error %d, stopping transmission\n", r);
+        remaining_length = 0; // Stop transmission on error
+        return; // Don't try to send data
+    }
+    else if (r == 0)  // EOF reached
+    {
+        LOG_INF("End of file reached");
+        printf("[DEBUG] write_to_gatt: ✅ EOF reached, stopping transmission\n");
+        remaining_length = 0; // Stop transmission on EOF
+        return; // Don't try to send data
+    }
+    else if (r < packet_size)  // Partial read (near EOF)
+    {
+        LOG_INF("Partial read: got %d bytes, expected %d", r, packet_size);
+        printf("[DEBUG] write_to_gatt: ✅ Partial read %d bytes (expected %d), this is the last packet\n", r, packet_size);
+        packet_size = r; // Send only what we actually read
+        remaining_length = 0; // This will be the last packet
+        offset += r;
+    }
+    else 
+    {
+        printf("[DEBUG] write_to_gatt: ✅ Full read %d bytes, continuing\n", r);
+        remaining_length = remaining_length - r; // Use actual bytes read
+        offset += r;
+    }
+    
+    printf("[DEBUG] write_to_gatt: Sending %d bytes to BLE, remaining_length=%d, offset=%d\n", 
+           packet_size, remaining_length, offset);
+    
+    int err = bt_gatt_notify(conn, &storage_service.attrs[1], &storage_write_buffer, packet_size);
     if (err) 
     {
         LOG_PRINTK("error writing to gatt: %d\n",err);
+        printf("[DEBUG] write_to_gatt: ❌ BLE notify failed: %d\n", err);
     }
     else 
     {
-    remaining_length = remaining_length - SD_BLE_SIZE;
+        printf("[DEBUG] write_to_gatt: ✅ BLE notify successful\n");
     }
     // LOG_PRINTK("wrote to gatt %d\n",err);
 }
@@ -298,13 +392,35 @@ void storage_write(void)
     if (delete_started) 
     { 
         LOG_INF("delete:%d\n",delete_started);
-        int err = clear_audio_file(1);
+        printf("[DEBUG] storage_write: Processing delete request for file_num=%d\n", delete_num);
+        
+        int err = 0;
+        
+        // For chunk files, use the cached filename approach
+        extern bool chunking_enabled;
+        
+        if (chunking_enabled && delete_num <= cached_file_count && delete_num > 0) {
+            const char* filename = recent_files_cache[delete_num - 1]; // Convert to 0-based index
+            if (filename[0] != '\0') {
+                printf("[DEBUG] storage_write: Deleting chunk file: %s\n", filename);
+                err = delete_chunk_file(filename);
+            } else {
+                printf("[DEBUG] storage_write: No cached filename for file_num=%d\n", delete_num);
+                err = -1;
+            }
+        } else {
+            // Legacy file deletion
+            printf("[DEBUG] storage_write: Deleting legacy file (clear_audio_file)\n");
+            err = clear_audio_file(1);
+        }
+        
         offset = 0;
         save_offset(offset);
         
         if (err) 
         {
-            LOG_PRINTK("error clearing\n");
+            LOG_PRINTK("error deleting file: %d\n", err);
+            printf("[DEBUG] storage_write: ❌ Delete failed: %d\n", err);
         }
         else 
         {
@@ -312,6 +428,7 @@ void storage_write(void)
             if (conn) 
             {
                 bt_gatt_notify(get_current_connection(), &storage_service.attrs[1], &result_buffer,1);
+                printf("[DEBUG] storage_write: ✅ Delete successful, sent confirmation\n");
             }
         }
         delete_started = 0;
diff --git a/omi/firmware/devkit/src/transport.c b/omi/firmware/devkit/src/transport.c
index 32926cbbf0..0feb75d656 100644
--- a/omi/firmware/devkit/src/transport.c
+++ b/omi/firmware/devkit/src/transport.c
@@ -28,6 +28,8 @@ extern bool is_connected;
 extern bool storage_is_on;
 extern uint8_t file_count;
 extern uint32_t file_num_array[2];
+extern bool chunk_active;
+extern bool chunking_enabled;
 struct bt_conn *current_connection = NULL;
 uint16_t current_mtu = 0;
 uint16_t current_package_index = 0;
@@ -568,7 +570,7 @@ static bool push_to_gatt(struct bt_conn *conn)
 #define OPUS_PADDED_LENGTH 80
 #define MAX_WRITE_SIZE 440
 static uint8_t storage_temp_data[MAX_WRITE_SIZE];
-static uint32_t offset = 0;
+static uint32_t offset __attribute__((unused)) = 0;
 static uint16_t buffer_offset = 0;
 // bool write_to_storage(void)
 // {
@@ -600,6 +602,23 @@ bool write_to_storage(void) {//max possible packing
         return false;
     }
 
+    // Check if we need to rotate to a new chunk (only if chunking enabled)
+    if (chunking_enabled && should_rotate_chunk()) {
+        // Flush any remaining data in the buffer before rotating
+        if (buffer_offset > 0) {
+            uint8_t *write_ptr = storage_temp_data;
+            write_to_file(write_ptr, buffer_offset);
+            buffer_offset = 0;
+        }
+        
+        // Start a new chunk
+        int ret = start_new_chunk();
+        if (ret != 0) {
+            LOG_ERR("Failed to start new chunk: %d", ret);
+            return false;
+        }
+    }
+
     uint8_t *buffer = tx_buffer+2;
     uint8_t packet_size = (uint8_t)(tx_buffer_size + OPUS_PREFIX_LENGTH);
 
@@ -704,6 +723,11 @@ void pusher(void)
                 k_mutex_lock(&write_sdcard_mutex, K_FOREVER);
                 if(is_sd_on())
                 {
+                    // Initialize first chunk if needed (only if chunking enabled)
+                    if (chunking_enabled && !chunk_active) {
+                        LOG_INF("Starting offline recording with chunking");
+                        start_new_chunk();
+                    }
                     result = write_to_storage();
                 }
                 k_mutex_unlock(&write_sdcard_mutex);
@@ -818,7 +842,9 @@ int transport_start()
 
     // Start advertising
     memset(storage_temp_data, 0, OPUS_PADDED_LENGTH * 4);
+    printf("[DEBUG] transport_start: About to register storage service\n");
     bt_gatt_service_register(&storage_service);
+    printf("[DEBUG] transport_start: Storage service registered successfully\n");
     bt_gatt_service_register(&audio_service);
     bt_gatt_service_register(&dfu_service);
     err = bt_le_adv_start(BT_LE_ADV_CONN, bt_ad, ARRAY_SIZE(bt_ad), bt_sd, ARRAY_SIZE(bt_sd));