Preserve Checkpoint across update installs.

Skip deleting sd:/switch/checkpoint so user saves under saves/ are not wiped.

DEBUG_INI.md

@@ -0,0 +1,90 @@
+# Debug configuration (`debug.ini`)
+
+Optional file to **skip parts of the install** for testing (e.g. run only deletion and inspect the SD card). If the file is **missing**, the installer ignores debug entirely and runs the full flow.
+
+## Location
+
+```
+sd:/config/omninx/debug.ini
+```
+
+Create the folder `sd:/config/omninx/` on the SD card if it does not exist. Same parent directory as `manifest.ini` and `config.ini`.
+
+## Format
+
+- Section name must be exactly **`[Debug]`** (case-sensitive in the parser).
+- One key per line: `name=value`.
+- **Enabling a skip:** set the value so it **starts** with one of: `1`, `t`, `T`, `y`, `Y`  
+  Examples: `1`, `true`, `yes`, `True` — all enable that skip.
+- **Disabling:** `0`, `false`, `no`, or omit the key.
+
+## Parameters
+
+### Clean install mode (`INSTALL_MODE_CLEAN`)
+
+| Key | What is skipped |
+|-----|-----------------|
+| `skip_clean_backup` | Step 1 — backup of `sd:/switch/DBI/dbi.config`, `sd:/switch/prod.keys` to `sd:/temp_backup` |
+| `skip_clean_wipe` | Step 2 — all cleanup from `deletion_lists_clean.h` (deletion / wipe) |
+| `skip_clean_restore` | Step 3 — restore from `sd:/temp_backup` and post-restore paths (e.g. delete `sd:/switch/tinfoil/db`) |
+| `skip_clean_install` | Step 4 — copy files from the OmniNX staging folder to the SD root |
+| `skip_clean_staging_cleanup` | After install: do not remove the staging directory or other variant staging folders |
+
+### Update mode (`INSTALL_MODE_UPDATE`)
+
+| Key | What is skipped |
+|-----|-----------------|
+| `skip_update_cleanup` | Step 1 — selective deletion from `deletion_lists_update.h` |
+| `skip_update_install` | Step 2 — copy from staging to SD |
+| `skip_update_staging_cleanup` | End: do not remove staging / other variant folders |
+| `skip_update_horizon_oc` | **OC variant only:** HorizonOC config backup before update, restore and cleanup after (entire HorizonOC update side path) |
+
+### Both modes
+
+| Key | What is skipped |
+|-----|-----------------|
+| `skip_hekate_8gb_post_copy` | After a successful copy: the optional `hekate_8GB` / RAM menu and related file moves (see `install_hekate_8gb_post_copy` in `install.c`) |
+
+## Behaviour
+
+- On startup, if `debug.ini` exists and parses successfully, the payload prints a **DEBUG-MODUS** banner listing which skips are active.
+- If the file is absent, unreadable, or has no `[Debug]` section, **no** skips apply — behaviour matches a release install.
+- Skipping steps can leave the SD in an inconsistent state; this is **for developers/testers only**.
+
+## Examples
+
+### Wipe only (test deletion, no backup/restore/copy)
+
+Inspect leftovers after the clean-install wipe, without backing up, restoring, installing, or cleaning staging:
+
+```ini
+[Debug]
+skip_clean_backup=1
+skip_clean_restore=1
+skip_clean_install=1
+skip_clean_staging_cleanup=1
+skip_hekate_8gb_post_copy=1
+```
+
+Do **not** set `skip_clean_wipe` (leave unset or `0`).
+
+### Update: deletion only
+
+```ini
+[Debug]
+skip_update_install=1
+skip_update_staging_cleanup=1
+skip_hekate_8gb_post_copy=1
+```
+
+### OC update without touching HorizonOC backup/restore
+
+```ini
+[Debug]
+skip_update_horizon_oc=1
+```
+
+## Implementation
+
+- Parsed in `install.c`: `install_debug_load()`, `perform_installation()`.
+- Uses the same INI parser as `config.ini` (`ini_parse` from BDK).

INSTALLATION_PROCESS.md

@@ -2,6 +2,8 @@
 
 This document provides a detailed, step-by-step breakdown of everything that is checked and done during the OmniNX installation/update process.
 
+For **optional debug step skips** (`sd:/config/omninx/debug.ini`), see **[DEBUG_INI.md](DEBUG_INI.md)**.
+
 ## Overview
 
 The OmniNX Installer Payload operates in two modes:
@@ -88,7 +90,9 @@ The OmniNX Installer Payload operates in two modes:
 **Trigger**: `INSTALL_MODE_UPDATE` (OmniNX already installed)
 
 ### Step 1: Cleanup (Selective Deletion)
-**Location**: `install.c:321-380`
+**Location**: `install_update.c` (`update_mode_cleanup`), `install.c` (`delete_path_lists_grouped`)
+
+Before deletion, the payload reads optional **`sd:/config/omninx/preserve.ini`** (section `[Preserve]`). Paths enabled there are skipped, as are delete targets that would remove them (parent/child overlap). See **[PRESERVE_INI.md](PRESERVE_INI.md)**. Clean install does not use this file.
 
 #### 10. Clean Atmosphere Subdirectories
 **Location**: `install.c:325-327`, `deletion_lists.h:9-34`
@@ -305,17 +309,12 @@ channel_pack={variant}        # Same as current_pack
 #### 32. Create Backup Directory
 - Creates `sd:/temp_backup/` directory
 
-#### 33. Backup DBI
-- **Source**: `sd:/switch/DBI/`
-- **Destination**: `sd:/temp_backup/DBI/`
-- Only if source exists
+#### 33. Backup DBI settings
+- **Source**: `sd:/switch/DBI/dbi.config` (file only, not the whole `DBI` tree)
+- **Destination**: `sd:/temp_backup/dbi.config`
+- Only if the source file exists
 
-#### 34. Backup Tinfoil
-- **Source**: `sd:/switch/tinfoil/`
-- **Destination**: `sd:/temp_backup/tinfoil/`
-- Only if source exists
-
-#### 35. Backup prod.keys
+#### 34. Backup prod.keys
 - **Source**: `sd:/switch/prod.keys`
 - **Destination**: `sd:/temp_backup/prod.keys`
 - Only if source exists
@@ -325,22 +324,22 @@ channel_pack={variant}        # Same as current_pack
 ### Step 2: Wipe Directories
 **Location**: `install.c:543-602`
 
-#### 36. Delete Entire Directories
+#### 35. Delete Entire Directories
 Recursively deletes (if they exist):
 - `sd:/atmosphere/` (entire directory tree)
 - `sd:/bootloader/` (entire directory tree)
 - `sd:/config/` (entire directory tree)
 - `sd:/switch/` (entire directory tree)
 
-#### 37. Delete Root Files
+#### 36. Delete Root Files
 - Uses same deletion list as update mode (Step 19)
 - Deletes `boot.dat`, `boot.ini`, `exosphere.ini`, etc.
 
-#### 38. Delete Miscellaneous Items
+#### 37. Delete Miscellaneous Items
 - Uses same deletion lists as update mode (Steps 20-21)
 - Deletes `argon/`, `games/`, `SaltySD/`, etc.
 
-#### 39. Recreate Switch Directory
+#### 38. Recreate Switch Directory
 - Creates empty `sd:/switch/` directory for restoration
 
 ---
@@ -348,27 +347,17 @@ Recursively deletes (if they exist):
 ### Step 3: Restore User Data
 **Location**: `backup.c:55-95`
 
-#### 40. Restore DBI
-- **Source**: `sd:/temp_backup/DBI/`
-- **Destination**: `sd:/switch/DBI/`
-- **Cleanup**: After restoration, deletes old DBI NRO files:
-  - `sd:/switch/DBI/DBI_810_EN.nro`
-  - `sd:/switch/DBI/DBI_810_DE.nro`
-  - `sd:/switch/DBI/DBI_845_EN.nro`
-  - `sd:/switch/DBI/DBI_845_DE.nro`
-  - `sd:/switch/DBI/DBI.nro`
+#### 39. Restore DBI settings
+- **Source**: `sd:/temp_backup/dbi.config`
+- **Destination**: `sd:/switch/DBI/dbi.config` (creates `sd:/switch/DBI/` if needed)
+- No longer copies the full `DBI` folder; old `.nro` cleanup is unnecessary
 
-#### 41. Restore Tinfoil
-- **Source**: `sd:/temp_backup/tinfoil/`
-- **Destination**: `sd:/switch/tinfoil/`
-- **Cleanup**: After restoration, deletes `sd:/switch/tinfoil/tinfoil.nro`
-
-#### 42. Restore prod.keys
+#### 40. Restore prod.keys
 - **Source**: `sd:/temp_backup/prod.keys`
 - **Destination**: `sd:/switch/prod.keys`
 
-#### 43. Cleanup Backup Directory
-**Location**: `backup.c:98-103`
+#### 41. Cleanup Backup Directory
+**Location**: `backup.c` (`cleanup_backup`)
 - Deletes `sd:/temp_backup/` directory after restoration
 
 ---

PRESERVE_INI.md

@@ -0,0 +1,59 @@
+# User preserve list (`preserve.ini`)
+
+**Update mode only.** During OmniNX update cleanup (selective deletion), any path listed here with a truthy value is **not** deleted. Paths that would remove a preserved path (parent directory) are skipped as well.
+
+- **File:** `sd:/config/omninx/preserve.ini`
+- If missing or invalid, behavior is unchanged (full update deletion list applies).
+
+## Format
+
+Section **`[Preserve]`** (case-sensitive). Each line is **path as key**, **enable flag as value**:
+
+```ini
+[Preserve]
+'sd:/ROMs'=1
+sd:/switch/MyHomebrewFolder=0
+sd:/backup/tools=1
+```
+
+### Path (key)
+
+- Must start with **`sd:/`** (after optional quoting).
+- **Optional** matching **single** or **double** quotes around the key are stripped (helps Ultrahand `set-ini-val` and readability).
+- Trailing slashes are normalized away (except the volume root).
+- **`sd:/` alone** is rejected (too broad).
+- Minimum useful length after `sd:/` is enforced (at least one more character).
+
+### Value (enable)
+
+**On** if the value starts with `1`, `t`, `T`, `y`, or `Y` (e.g. `1`, `true`, `yes`). Anything else is **off** (path ignored).
+
+### Limits
+
+- Up to **96** preserved paths; longer keys truncated internally (~224 bytes per path).
+- Duplicate paths after normalization are skipped.
+- The list is allocated on the **heap** only while update cleanup runs (not a large static buffer in IPL IRAM), to avoid crowding hardware-adjacent memory used by Joy-Con UART and similar peripherals.
+
+## Overlap rules
+
+For each delete candidate from `deletion_lists_update.h`, deletion is skipped if it **overlaps** any enabled preserve path:
+
+- Same path, or
+- Delete target is **inside** a preserved tree (preserved path is a prefix), or
+- Delete target is an **ancestor** of a preserved path (deleting it would remove the preserved data).
+
+So preserving `sd:/ROMs` also blocks deleting `sd:/ROMs/title` if that were on the delete list, and blocks deleting `sd:/` if `sd:/ROMs` is preserved.
+
+## Ultrahand
+
+You can toggle entries with:
+
+```text
+set-ini-val sd:/config/omninx/preserve.ini Preserve 'sd:/ROMs' 1
+```
+
+and `0` to disable. Use the same quoted path in the key argument as in your INI.
+
+## Clean install
+
+**Not used** in clean install mode. `preserve.ini` is only read for **update** cleanup (`update_mode_cleanup`).

README.md

@@ -12,7 +12,7 @@ Based on [HATS-Installer-Payload](https://github.com/sthetix/HATS-Installer-Payl
 - **Automatic Variant Detection**: Detects which OmniNX pack variant is present (Standard/Light/OC)
 - **Smart Installation Modes**: 
   - **Update Mode**: Selective deletion when OmniNX is already installed
-  - **Clean Install**: Full wipe with backup/restore of user data (DBI, Tinfoil, prod.keys)
+  - **Clean Install**: Full wipe with backup/restore of user data (DBI `dbi.config`, prod.keys)
 - **Version Detection**: Detects installed OmniNX version via marker files (`1.0.0s`, `1.0.0l`, `1.0.0oc`)
 - **Progress Display**: Visual status messages during installation
 - **Error Handling**: Detailed error reporting on screen
@@ -22,12 +22,15 @@ Based on [HATS-Installer-Payload](https://github.com/sthetix/HATS-Installer-Payl
 
 For detailed information about the installation process, see:
 - **[INSTALLATION_PROCESS.md](INSTALLATION_PROCESS.md)** - Complete step-by-step breakdown of everything checked and done during installation/update
+- **[DEBUG_INI.md](DEBUG_INI.md)** - Optional `sd:/config/omninx/debug.ini` parameters to skip install steps (for testing)
+- **[PRESERVE_INI.md](PRESERVE_INI.md)** - Optional `sd:/config/omninx/preserve.ini` to skip deleting chosen paths in **update** mode
 
 ## Installation Modes
 
 ### Update Mode (OmniNX Detected)
 - Detected when version marker files (`1.0.0s`, `1.0.0l`, or `1.0.0oc`) are found
 - Performs selective deletion of specific directories/files
+- Optional **`sd:/config/omninx/preserve.ini`**: user-listed `sd:/…` paths (with `=1`) are excluded from that cleanup (see [PRESERVE_INI.md](PRESERVE_INI.md))
 - Preserves user data, savegames, and installed games
 - Updates only necessary CFW components
 
@@ -35,8 +38,7 @@ For detailed information about the installation process, see:
 - Detected when no version marker files are found
 - Performs full wipe of `/atmosphere`, `/bootloader`, `/config`, and `/switch`
 - **Backs up and restores**:
-  - `sd:/switch/DBI` → preserved
-  - `sd:/switch/tinfoil` → preserved
+  - `sd:/switch/DBI/dbi.config` → preserved (not the whole `DBI` folder)
   - `sd:/switch/prod.keys` → preserved
 - Fresh installation of all CFW components
 

VERSION

@@ -1 +1 @@
-1.0.0
+1.0.1

bdk/input/joycon.c

@@ -721,6 +721,12 @@ void jc_deinit()
 	clock_disable_uart(UART_C);
 }
 
+/* Drop current button state without power-cycling the Joy-Cons. */
+void jc_clear_input(void)
+{
+	jc_gamepad.buttons = 0;
+}
+
 static void jc_init_conn(joycon_ctxt_t *jc)
 {
 	if (((u32)get_tmr_ms() - jc->last_received_time) > 1000)

bdk/input/joycon.h

@@ -92,6 +92,7 @@ typedef struct _jc_gamepad_rpt_t
 void jc_power_supply(u8 uart, bool enable);
 void jc_init_hw();
 void jc_deinit();
+void jc_clear_input(void);
 jc_gamepad_rpt_t *joycon_poll();
 jc_gamepad_rpt_t *jc_get_bt_pairing_info(bool *is_l_hos, bool *is_r_hos);
 

source/backup.c

@@ -24,17 +24,9 @@ int backup_user_data(void) {
         return res;
     }
     
-    // Backup DBI if it exists
-    if (path_exists("sd:/switch/DBI")) {
-        res = folder_copy("sd:/switch/DBI", TEMP_BACKUP_PATH);
-        if (res != FR_OK) {
-            return res;
-        }
-    }
-    
-    // Backup Tinfoil if it exists
-    if (path_exists("sd:/switch/tinfoil")) {
-        res = folder_copy("sd:/switch/tinfoil", TEMP_BACKUP_PATH);
+    // Backup DBI settings file only (not .nro installers)
+    if (path_exists(DBI_CONFIG_PATH)) {
+        res = file_copy(DBI_CONFIG_PATH, TEMP_BACKUP_DBI_CONFIG);
         if (res != FR_OK) {
             return res;
         }
@@ -48,6 +40,35 @@ int backup_user_data(void) {
         }
     }
 
+    // Backup CyberFoil (nro, config, remotes) if installed
+    if (path_exists(CYBERFOIL_DIR)) {
+        res = f_mkdir(TEMP_BACKUP_CYBERFOIL);
+        if (res != FR_OK && res != FR_EXIST) {
+            return res;
+        }
+
+        if (path_exists(CYBERFOIL_NRO)) {
+            res = file_copy(CYBERFOIL_NRO, TEMP_BACKUP_CYBERFOIL_NRO);
+            if (res != FR_OK) {
+                return res;
+            }
+        }
+
+        if (path_exists(CYBERFOIL_CONFIG)) {
+            res = file_copy(CYBERFOIL_CONFIG, TEMP_BACKUP_CYBERFOIL_CONFIG);
+            if (res != FR_OK) {
+                return res;
+            }
+        }
+
+        if (path_exists(CYBERFOIL_REMOTES)) {
+            res = folder_copy(CYBERFOIL_REMOTES, TEMP_BACKUP_CYBERFOIL);
+            if (res != FR_OK) {
+                return res;
+            }
+        }
+    }
+    
     return FR_OK;
 }
 
@@ -61,25 +82,15 @@ int restore_user_data(void) {
         return res;
     }
     
-    // Restore DBI if backup exists
-    if (path_exists("sd:/temp_backup/DBI")) {
-        res = folder_copy("sd:/temp_backup/DBI", "sd:/switch");
-        if (res == FR_OK) {
-            // Delete old DBI .nro files
-            f_unlink("sd:/switch/DBI/DBI_810_EN.nro");
-            f_unlink("sd:/switch/DBI/DBI_810_DE.nro");
-            f_unlink("sd:/switch/DBI/DBI_845_EN.nro");
-            f_unlink("sd:/switch/DBI/DBI_845_DE.nro");
-            f_unlink("sd:/switch/DBI/DBI.nro");
+    // Restore DBI settings if backed up
+    if (path_exists(TEMP_BACKUP_DBI_CONFIG)) {
+        res = f_mkdir("sd:/switch/DBI");
+        if (res != FR_OK && res != FR_EXIST) {
+            return res;
         }
-    }
-    
-    // Restore Tinfoil if backup exists
-    if (path_exists("sd:/temp_backup/tinfoil")) {
-        res = folder_copy("sd:/temp_backup/tinfoil", "sd:/switch");
-        if (res == FR_OK) {
-            // Delete old tinfoil.nro
-            f_unlink("sd:/switch/tinfoil/tinfoil.nro");
+        res = file_copy(TEMP_BACKUP_DBI_CONFIG, DBI_CONFIG_PATH);
+        if (res != FR_OK) {
+            return res;
         }
     }
     
@@ -91,6 +102,35 @@ int restore_user_data(void) {
         }
     }
 
+    // Restore CyberFoil if backed up
+    if (path_exists(TEMP_BACKUP_CYBERFOIL)) {
+        res = f_mkdir(CYBERFOIL_DIR);
+        if (res != FR_OK && res != FR_EXIST) {
+            return res;
+        }
+
+        if (path_exists(TEMP_BACKUP_CYBERFOIL_NRO)) {
+            res = file_copy(TEMP_BACKUP_CYBERFOIL_NRO, CYBERFOIL_NRO);
+            if (res != FR_OK) {
+                return res;
+            }
+        }
+
+        if (path_exists(TEMP_BACKUP_CYBERFOIL_CONFIG)) {
+            res = file_copy(TEMP_BACKUP_CYBERFOIL_CONFIG, CYBERFOIL_CONFIG);
+            if (res != FR_OK) {
+                return res;
+            }
+        }
+
+        if (path_exists(TEMP_BACKUP_CYBERFOIL_REMOTES)) {
+            res = folder_copy(TEMP_BACKUP_CYBERFOIL_REMOTES, CYBERFOIL_DIR);
+            if (res != FR_OK) {
+                return res;
+            }
+        }
+    }
+    
     return FR_OK;
 }
 

source/backup.h

@@ -7,6 +7,19 @@
 #include <utils/types.h>
 
 #define TEMP_BACKUP_PATH "sd:/temp_backup"
+/** DBI settings; preserved across clean install (not whole DBI folder). */
+#define DBI_CONFIG_PATH "sd:/switch/DBI/dbi.config"
+#define TEMP_BACKUP_DBI_CONFIG TEMP_BACKUP_PATH "/dbi.config"
+
+/** CyberFoil homebrew; preserved across clean install (nro, config, remotes only). */
+#define CYBERFOIL_DIR "sd:/switch/CyberFoil"
+#define CYBERFOIL_NRO CYBERFOIL_DIR "/cyberfoil.nro"
+#define CYBERFOIL_CONFIG CYBERFOIL_DIR "/config.json"
+#define CYBERFOIL_REMOTES CYBERFOIL_DIR "/remotes"
+#define TEMP_BACKUP_CYBERFOIL TEMP_BACKUP_PATH "/CyberFoil"
+#define TEMP_BACKUP_CYBERFOIL_NRO TEMP_BACKUP_CYBERFOIL "/cyberfoil.nro"
+#define TEMP_BACKUP_CYBERFOIL_CONFIG TEMP_BACKUP_CYBERFOIL "/config.json"
+#define TEMP_BACKUP_CYBERFOIL_REMOTES TEMP_BACKUP_CYBERFOIL "/remotes"
 
 /** Live HorizonOC settings (Overclock tool). */
 #define HORIZON_OC_CONFIG_PATH "sd:/config/horizon-oc/config.ini"
@@ -14,7 +27,7 @@
 #define HORIZON_OC_UPDATE_BACKUP_DIR "sd:/.omninx_oc_update"
 #define HORIZON_OC_UPDATE_BACKUP_INI HORIZON_OC_UPDATE_BACKUP_DIR "/config.ini"
 
-// Backup user data (DBI, Tinfoil, prod.keys) before clean install
+// Backup user data (CyberFoil, DBI dbi.config, prod.keys) before clean install
 int backup_user_data(void);
 
 // Restore user data after clean install

source/deletion_lists_clean.h

@@ -1,86 +1,23 @@
 /*
  * OmniNX Installer - Deletion Lists for Clean Install Mode
- * Selective deletion when no OmniNX install was found.
- * Only listed paths are removed; does not wipe whole card or user configs.
+ * Deletion policy aligned with NiklasCFW pack clean install (TegraExplorer script):
+ * full sd:/atmosphere, bootloader/config subsets, sd:/switch, root + misc, then
+ * post-restore paths (e.g. tinfoil db). CyberFoil/DBI/prod.keys backup is in backup.c.
  */
 
 #pragma once
 
-// Atmosphere subdirectories to delete
+// Entire atmosphere/ tree (NiklasCFW: deldir("sd:/atmosphere"))
 static const char* clean_atmosphere_dirs_to_delete[] = {
-    "sd:/atmosphere/config",
-    "sd:/atmosphere/crash_reports",
-    "sd:/atmosphere/erpt_reports",
-    "sd:/atmosphere/exefs_patches/CrunchPatch",
-    "sd:/atmosphere/exefs_patches/Crunchyroll Patch 1.10.0",
-    "sd:/atmosphere/exefs_patches/bluetooth_patches",
-    "sd:/atmosphere/exefs_patches/bootlogo",
-    "sd:/atmosphere/exefs_patches/btm_patches",
-    "sd:/atmosphere/exefs_patches/es_patches",
-    "sd:/atmosphere/exefs_patches/hid_patches",
-    "sd:/atmosphere/exefs_patches/logo1",
-    "sd:/atmosphere/exefs_patches/nfim_ctest",
-    "sd:/atmosphere/exefs_patches/nim_ctest",
-    "sd:/atmosphere/exefs_patches/nvnflinger_cmu",
-    "sd:/atmosphere/extrazz",
-    "sd:/atmosphere/fatal_errors",
-    "sd:/atmosphere/fatal_reports",
-    "sd:/atmosphere/flags",
-    "sd:/atmosphere/hbl_html",
-    "sd:/atmosphere/hosts",
-    "sd:/atmosphere/kips",
-    "sd:/atmosphere/kip1",
-    "sd:/atmosphere/kip_patches",
-    "sd:/atmosphere/logs",
+    "sd:/atmosphere",
     NULL
 };
 
-// Atmosphere contents directories (title IDs; only under atmosphere/contents/)
 static const char* clean_atmosphere_contents_dirs_to_delete[] = {
-    "sd:/atmosphere/contents/0000000000534C56",
-    "sd:/atmosphere/contents/00FF0000B378D640",
-    "sd:/atmosphere/contents/00FF0000636C6BFF",
-    "sd:/atmosphere/contents/00FF0000A53BB665",
-    "sd:/atmosphere/contents/0100000000000008",
-    "sd:/atmosphere/contents/010000000000000D",
-    "sd:/atmosphere/contents/010000000000002B",
-    "sd:/atmosphere/contents/0100000000000032",
-    "sd:/atmosphere/contents/0100000000000034",
-    "sd:/atmosphere/contents/0100000000000036",
-    "sd:/atmosphere/contents/0100000000000037",
-    "sd:/atmosphere/contents/010000000000003C",
-    "sd:/atmosphere/contents/0100000000000042",
-    "sd:/atmosphere/contents/0100000000000895",
-    "sd:/atmosphere/contents/0100000000000F12",
-    "sd:/atmosphere/contents/0100000000001000",
-    "sd:/atmosphere/contents/0100000000001007",
-    "sd:/atmosphere/contents/0100000000001013",
-    "sd:/atmosphere/contents/010000000000DA7A",
-    "sd:/atmosphere/contents/010000000000bd00",
-    "sd:/atmosphere/contents/01006a800016e000",
-    "sd:/atmosphere/contents/01009D901BC56000",
-    "sd:/atmosphere/contents/0100A3900C3E2000",
-    "sd:/atmosphere/contents/0100F43008C44000",
-    "sd:/atmosphere/contents/050000BADDAD0000",
-    "sd:/atmosphere/contents/4200000000000000",
-    "sd:/atmosphere/contents/420000000000000B",
-    "sd:/atmosphere/contents/420000000000000E",
-    "sd:/atmosphere/contents/4200000000000010",
-    "sd:/atmosphere/contents/4200000000000FFF",
-    "sd:/atmosphere/contents/420000000007E51A",
-    "sd:/atmosphere/contents/420000000007E51B",
-    "sd:/atmosphere/contents/690000000000000D",
     NULL
 };
 
-// Atmosphere files to delete
 static const char* clean_atmosphere_files_to_delete[] = {
-    "sd:/atmosphere/config/exosphere.ini",
-    "sd:/atmosphere/config/stratosphere.ini",
-    "sd:/atmosphere/hbl.nsp",
-    "sd:/atmosphere/package3",
-    "sd:/atmosphere/reboot_payload.bin",
-    "sd:/atmosphere/stratosphere.romfs",
     NULL
 };
 
@@ -101,7 +38,6 @@ static const char* clean_bootloader_files_to_delete[] = {
     "sd:/bootloader/ArgonNX.bin",
     "sd:/bootloader/bootlogo.bmp",
     "sd:/bootloader/hekate_ipl.ini",
-    "sd:/bootloader/nyx.ini",
     "sd:/bootloader/patches.ini",
     "sd:/bootloader/update.bin",
     "sd:/bootloader/ini/EmuMMC ohne Mods.ini",
@@ -114,7 +50,6 @@ static const char* clean_config_dirs_to_delete[] = {
     "sd:/config/blue_pack_updater",
     "sd:/config/kefir-updater",
     "sd:/config/nx-hbmenu",
-    "sd:/config/quickntp",
     "sd:/config/sys-con",
     "sd:/config/sys-patch",
     "sd:/config/uberhand",
@@ -122,120 +57,13 @@ static const char* clean_config_dirs_to_delete[] = {
     NULL
 };
 
-// Switch directories to delete
+// Entire switch/ tree (clean install recreates sd:/switch after wipe)
 static const char* clean_switch_dirs_to_delete[] = {
-    "sd:/switch/.overlays",
-    "sd:/switch/.packages",
-    "sd:/switch/90DNS_tester",
-    "sd:/switch/aio-switch-updater",
-    "sd:/switch/amsPLUS-downloader",
-    "sd:/switch/appstore",
-    "sd:/switch/AtmoXL-Titel-Installer",
-    "sd:/switch/breeze",
-    "sd:/switch/checkpoint",
-    "sd:/switch/cheats-updater",
-    "sd:/switch/chiaki",
-    "sd:/switch/ChoiDujourNX",
-    "sd:/switch/crash_ams",
-    "sd:/switch/Daybreak",
-    "sd:/switch/DNS_mitm Tester",
-    "sd:/switch/EdiZon",
-    "sd:/switch/Fizeau",
-    "sd:/switch/FTPD",
-    "sd:/switch/fw-downloader",
-    "sd:/switch/gamecard_installer",
-    "sd:/switch/Goldleaf",
-    "sd:/switch/haze",
-    "sd:/switch/JKSV",
-    "sd:/switch/kefir-updater",
-    "sd:/switch/ldnmitm_config",
-    "sd:/switch/Linkalho",
-    "sd:/switch/Moonlight-Switch",
-    "sd:/switch/Neumann",
-    "sd:/switch/NX-Activity-Log",
-    "sd:/switch/NX-Save-Sync",
-    "sd:/switch/NX-Shell",
-    "sd:/switch/NX-Update-Checker ",
-    "sd:/switch/NXGallery",
-    "sd:/switch/NXRemoteLauncher",
-    "sd:/switch/NXThemesInstaller",
-    "sd:/switch/nxdumptool",
-    "sd:/switch/nxmtp",
-    "sd:/switch/Payload_launcher",
-    "sd:/switch/Reboot",
-    "sd:/switch/reboot_to_argonNX",
-    "sd:/switch/reboot_to_hekate",
-    "sd:/switch/Shutdown_System",
-    "sd:/switch/SimpleModDownloader",
-    "sd:/switch/SimpleModManager",
-    "sd:/switch/sphaira",
-    "sd:/switch/studious-pancake",
-    "sd:/switch/Switch-Time",
-    "sd:/switch/SwitchIdent",
-    "sd:/switch/Switch_themes_Installer",
-    "sd:/switch/Switchfin",
-    "sd:/switch/Sys-Clk Manager",
-    "sd:/switch/Sys-Con",
-    "sd:/switch/sys-clk-manager",
-    "sd:/switch/themezer-nx",
-    "sd:/switch/themezernx",
-    "sd:/switch/tinwoo",
+    "sd:/switch",
     NULL
 };
 
-// Switch files (NRO) to delete
 static const char* clean_switch_files_to_delete[] = {
-    "sd:/switch/90DNS_tester/90DNS_tester.nro",
-    "sd:/switch/breeze.nro",
-    "sd:/switch/cheats-updater.nro",
-    "sd:/switch/chiaki.nro",
-    "sd:/switch/ChoiDujourNX.nro",
-    "sd:/switch/daybreak.nro",
-    "sd:/switch/DBI.nro",
-    "sd:/switch/DBI/DBI.nro",
-    "sd:/switch/DBI/DBI_810_DE.nro",
-    "sd:/switch/DBI/DBI_810_EN.nro",
-    "sd:/switch/DBI/DBI_845_DE.nro",
-    "sd:/switch/DBI/DBI_845_EN.nro",
-    "sd:/switch/DBI/DBI_849_DE.nro",
-    "sd:/switch/DBI/DBI_849_EN.nro",
-    "sd:/switch/DBI/DBI_874_DE.nro",
-    "sd:/switch/DBI/DBI_874_EN.nro",
-    "sd:/switch/DBI_810_DE/DBI_810.nro",
-    "sd:/switch/DBI_810_DE/DBI_810_DE.nro",
-    "sd:/switch/DBI_810_EN/DBI_810_EN.nro",
-    "sd:/switch/DBI_RU/DBI_RU.nro",
-    "sd:/switch/DBI/DBI_EN.nro",
-    "sd:/switch/DBI_DE/DBI_DE.nro",
-    "sd:/switch/DNS_mitm Tester.nro",
-    "sd:/switch/EdiZon.nro",
-    "sd:/switch/Fizeau.nro",
-    "sd:/switch/Goldleaf.nro",
-    "sd:/switch/haze.nro",
-    "sd:/switch/JKSV.nro",
-    "sd:/switch/ldnmitm_config.nro",
-    "sd:/switch/linkalho.nro",
-    "sd:/switch/Moonlight-Switch.nro",
-    "sd:/switch/Neumann.nro",
-    "sd:/switch/NX-Shell.nro",
-    "sd:/switch/NXGallery.nro",
-    "sd:/switch/NXThemesInstaller.nro",
-    "sd:/switch/nxdumptool.nro",
-    "sd:/switch/nxtc.bin",
-    "sd:/switch/reboot_to_payload.nro",
-    "sd:/switch/SimpleModDownloader.nro",
-    "sd:/switch/SimpleModManager.nro",
-    "sd:/switch/sphaira.nro",
-    "sd:/switch/SwitchIdent.nro",
-    "sd:/switch/Switch_themes_Installer/NXThemesInstaller.nro",
-    "sd:/switch/Switchfin.nro",
-    "sd:/switch/Sys-Clk Manager/sys-clk-manager.nro",
-    "sd:/switch/Sys-Con.nro",
-    "sd:/switch/sys-clk-manager.nro",
-    "sd:/switch/tinfoil.nro",
-    "sd:/switch/tinfoil/tinfoil.nro",
-    "sd:/switch/tinwoo.nro",
-    "sd:/switch/tinwoo/tinwoo.nro",
     NULL
 };
 
@@ -263,9 +91,9 @@ static const char* clean_misc_dirs_to_delete[] = {
     "sd:/NSPs (Tools)",
     "sd:/Patched Apps",
     "sd:/SaltySD/flags",
+    "sd:/SaltySD/patches",
     "sd:/scripts",
     "sd:/TegraExplorer",
-    "sd:/switch/tinfoil/db",
     "sd:/themes/systemData",
     "sd:/tools",
     "sd:/warmboot_mariko",
@@ -285,6 +113,12 @@ static const char* clean_misc_files_to_delete[] = {
     NULL
 };
 
+// After DBI/prod.keys restore (NiklasCFW: deldir("sd:/switch/tinfoil/db"))
+static const char* clean_post_restore_dirs_to_delete[] = {
+    "sd:/switch/tinfoil/db",
+    NULL
+};
+
 // Old version marker files to delete (clean install only)
 static const char* old_version_files_to_delete[] = {
     "sd:/1.4.0-pre",
@@ -294,5 +128,6 @@ static const char* old_version_files_to_delete[] = {
     "sd:/1.5.0",
     "sd:/1.6.0",
     "sd:/1.6.1",
+    "sd:/1.6.2",
     NULL
 };

source/deletion_lists_update.h

@@ -10,14 +10,16 @@ static const char* atmosphere_dirs_to_delete[] = {
     "sd:/atmosphere/config",
     "sd:/atmosphere/crash_reports",
     "sd:/atmosphere/erpt_reports",
+    "sd:/atmosphere/exefs_patches/audio_mastervolume",
     "sd:/atmosphere/exefs_patches/CrunchPatch",
+    "sd:/atmosphere/exefs_patches/SaltyNX_Fixes",
     "sd:/atmosphere/exefs_patches/Crunchyroll Patch 1.10.0",
     "sd:/atmosphere/exefs_patches/bluetooth_patches",
     "sd:/atmosphere/exefs_patches/bootlogo",
     "sd:/atmosphere/exefs_patches/btm_patches",
     "sd:/atmosphere/exefs_patches/es_patches",
     "sd:/atmosphere/exefs_patches/hid_patches",
-    "sd:/atmosphere/exefs_patches/logo1",
+    "sd:/atmosphere/exefs_patches/logo",
     "sd:/atmosphere/exefs_patches/nfim_ctest",
     "sd:/atmosphere/exefs_patches/nim_ctest",
     "sd:/atmosphere/exefs_patches/nvnflinger_cmu",
@@ -132,17 +134,19 @@ static const char* switch_dirs_to_delete[] = {
     "sd:/switch/amsPLUS-downloader",
     "sd:/switch/appstore",
     "sd:/switch/AtmoXL-Titel-Installer",
+    "sd:/switch/Benchmark-Toolbox",
     "sd:/switch/breeze",
-    "sd:/switch/checkpoint",
     "sd:/switch/cheats-updater",
     "sd:/switch/chiaki",
     "sd:/switch/ChoiDujourNX",
     "sd:/switch/crash_ams",
     "sd:/switch/Daybreak",
+    "sd:/switch/DNS-Block_Tester",
     "sd:/switch/DNS_mitm Tester",
     "sd:/switch/EdiZon",
     "sd:/switch/Fizeau",
     "sd:/switch/FTPD",
+    "sd:/switch/Furmark-NX",
     "sd:/switch/fw-downloader",
     "sd:/switch/gamecard_installer",
     "sd:/switch/Goldleaf",
@@ -167,6 +171,7 @@ static const char* switch_dirs_to_delete[] = {
     "sd:/switch/reboot_to_argonNX",
     "sd:/switch/reboot_to_hekate",
     "sd:/switch/Shutdown_System",
+    "sd:/switch/SimpleModAlchemist",
     "sd:/switch/SimpleModDownloader",
     "sd:/switch/SimpleModManager",
     "sd:/switch/sphaira",
@@ -174,18 +179,22 @@ static const char* switch_dirs_to_delete[] = {
     "sd:/switch/Switch-Time",
     "sd:/switch/SwitchIdent",
     "sd:/switch/Switch_themes_Installer",
+    "sd:/switch/swr-ini-tool",
     "sd:/switch/Sys-Clk Manager",
     "sd:/switch/Sys-Con",
     "sd:/switch/sys-clk-manager",
     "sd:/switch/themezer-nx",
+    "sd:/switch/ThemezerNX",
     "sd:/switch/themezernx",
     "sd:/switch/tinwoo",
+    "sd:/switch/Ultrahand-Reload",
     NULL
 };
 
 // Switch files (NRO) to delete
 static const char* switch_files_to_delete[] = {
     "sd:/switch/90DNS_tester/90DNS_tester.nro",
+    "sd:/switch/Benchmark-Toolbox/Benchmark-Toolbox.nro",
     "sd:/switch/breeze.nro",
     "sd:/switch/cheats-updater.nro",
     "sd:/switch/chiaki.nro",
@@ -205,9 +214,11 @@ static const char* switch_files_to_delete[] = {
     "sd:/switch/DBI_RU/DBI_RU.nro",
     "sd:/switch/DBI/DBI_EN.nro",
     "sd:/switch/DBI_DE/DBI_DE.nro",
+    "sd:/switch/DNS-Block_Tester/dns_tester.nro",
     "sd:/switch/DNS_mitm Tester.nro",
     "sd:/switch/EdiZon.nro",
     "sd:/switch/Fizeau.nro",
+    "sd:/switch/Furmark-NX/Furmark-NX.nro",
     "sd:/switch/Goldleaf.nro",
     "sd:/switch/haze.nro",
     "sd:/switch/JKSV.nro",
@@ -221,6 +232,7 @@ static const char* switch_files_to_delete[] = {
     "sd:/switch/nxdumptool.nro",
     "sd:/switch/nxtc.bin",
     "sd:/switch/reboot_to_payload.nro",
+    "sd:/switch/SimpleModAlchemist/Simple_Mod_Alchemist.nro",
     "sd:/switch/SimpleModDownloader.nro",
     "sd:/switch/SimpleModManager.nro",
     "sd:/switch/sphaira.nro",
@@ -230,10 +242,12 @@ static const char* switch_files_to_delete[] = {
     "sd:/switch/Sys-Clk Manager/sys-clk-manager.nro",
     "sd:/switch/Sys-Con.nro",
     "sd:/switch/sys-clk-manager.nro",
+    "sd:/switch/ThemezerNX/themezer-nx.nro",
     "sd:/switch/tinfoil.nro",
     "sd:/switch/tinfoil/tinfoil.nro",
     "sd:/switch/tinwoo.nro",
     "sd:/switch/tinwoo/tinwoo.nro",
+    "sd:/switch/Ultrahand-Reload/Ultrahand-Reload.nro",
     NULL
 };
 

source/install.c

@@ -21,10 +21,7 @@
 
 #define GROUPED_DELETE_MAX_ENTRIES 512
 
-#ifndef VERSION
-#define VERSION "1.0.0"
-#endif
-
+static bool install_path_blocked_by_user_preserve(const char *path);
 
 // Color definitions (some already defined in types.h, but we override for consistency)
 #undef COLOR_CYAN
@@ -463,7 +460,7 @@ int delete_path_lists_grouped(const char *folder_display_name, ...) {
     const char **list;
     while (n_entries < GROUPED_DELETE_MAX_ENTRIES && (list = va_arg(ap, const char **)) != NULL) {
         for (int i = 0; list[i] != NULL && n_entries < GROUPED_DELETE_MAX_ENTRIES; i++) {
-            if (install_path_exists(list[i]))
+            if (install_path_exists(list[i]) && !install_path_blocked_by_user_preserve(list[i]))
                 entries[n_entries++] = list[i];
         }
     }
@@ -538,9 +535,9 @@ int delete_path_list(const char* paths[], const char* description) {
     u32 start_x, start_y;
     int last_percent = -1;
     
-    // Count total paths first
+    // Count total paths first (only those we will delete)
     for (int i = 0; paths[i] != NULL; i++) {
-        if (install_path_exists(paths[i])) {
+        if (install_path_exists(paths[i]) && !install_path_blocked_by_user_preserve(paths[i])) {
             total_paths++;
         }
     }
@@ -558,7 +555,7 @@ int delete_path_list(const char* paths[], const char* description) {
     install_set_color(COLOR_WHITE);
     
     for (int i = 0; paths[i] != NULL; i++) {
-        if (install_path_exists(paths[i])) {
+        if (install_path_exists(paths[i]) && !install_path_blocked_by_user_preserve(paths[i])) {
             FILINFO fno;
             f_stat(paths[i], &fno);
             
@@ -635,12 +632,19 @@ int delete_path_list(const char* paths[], const char* description) {
     return (failed == 0) ? FR_OK : FR_DISK_ERR;
 }
 
-#define HEKATE_8GB_SRC   "sd:/bootloader/hekate_8gb.bin"
+#define EXTRAS_DIR              "sd:/extras"
+#define HEKATE_8GB_SRC          EXTRAS_DIR "/hekate_8gb.bin"
+#define HEKATE_PRO_8GB_SRC      EXTRAS_DIR "/hekate-pro_8gb.bin"
+#define HEKATE_AMS_PRO_SRC      EXTRAS_DIR "/hekate-ams-pro"
 #define PAYLOAD_BIN_DST         "sd:/payload.bin"
 #define UPDATE_BIN_DST          "sd:/bootloader/update.bin"
-#define RAM_CONFIG_PATH  "sd:/config/omninx/ram_config.ini"
+#define INSTALL_CONFIG_INI         "sd:/config/omninx/config.ini"
+#define INSTALL_CONFIG_INI_LEGACY  "sd:/config/omninx/ram_config.ini"
 
-enum { RAM_READ_OK = 0, RAM_READ_NEED_MENU = 1 };
+enum {
+    INSTALL_CONFIG_OK = 0,
+    INSTALL_CONFIG_NEED_MENU = 1,
+};
 
 static void unlink_ignore_err(const char *path)
 {
@@ -652,30 +656,13 @@ static void unlink_ignore_err(const char *path)
     f_unlink(path);
 }
 
-static void ram_config_ensure_parent_dirs(void)
+static void install_config_ensure_parent_dirs(void)
 {
     f_mkdir("sd:/config");
     f_mkdir("sd:/config/omninx");
 }
 
-static int ram_config_write(bool use_8gb)
-{
-    ram_config_ensure_parent_dirs();
-    FIL f;
-    if (f_open(&f, RAM_CONFIG_PATH, FA_WRITE | FA_CREATE_ALWAYS) != FR_OK)
-        return FR_DISK_ERR;
-
-    static const char sec[] = "[Ram]\n";
-    static const char line0[] = "8gb=0\n";
-    static const char line1[] = "8gb=1\n";
-    UINT bw;
-    f_write(&f, sec, sizeof(sec) - 1, &bw);
-    f_write(&f, use_8gb ? line1 : line0, sizeof(line0) - 1, &bw);
-    f_close(&f);
-    return FR_OK;
-}
-
-static void ram_config_free_sections(link_t *sections)
+static void install_ini_free_sections(link_t *sections)
 {
     LIST_FOREACH_ENTRY(ini_sec_t, sec, sections, link) {
         LIST_FOREACH_ENTRY(ini_kv_t, kv, &sec->kvs, link) {
@@ -686,46 +673,278 @@ static void ram_config_free_sections(link_t *sections)
     }
 }
 
-/* Valid [Ram] 8gb=0|1 → silent; missing file or invalid → menu. */
-static int read_ram_config_silent(const char *path, bool *use_8gb)
+static bool install_config_read_key_bool(const char *path, const char *section, const char *key, bool *out)
 {
-    if (!install_path_exists(path))
-        return RAM_READ_NEED_MENU;
+    FIL f;
+    if (f_open(&f, path, FA_READ) != FR_OK)
+        return false;
+
+    char line[96];
+    bool in_section = false;
+    bool found = false;
+
+    while (f_gets(line, sizeof(line), &f)) {
+        size_t n = strlen(line);
+        while (n > 0 && (line[n - 1] == '\n' || line[n - 1] == '\r'))
+            line[--n] = '\0';
+        if (n == 0)
+            continue;
+
+        if (line[0] == '[') {
+            in_section = false;
+            char *end = strchr(line, ']');
+            if (!end)
+                continue;
+            *end = '\0';
+            if (!strcmp(line + 1, section))
+                in_section = true;
+            continue;
+        }
+
+        if (!in_section)
+            continue;
+
+        char *eq = strchr(line, '=');
+        if (!eq)
+            continue;
+        *eq = '\0';
+        if (strcmp(line, key) != 0)
+            continue;
+
+        const char *val = eq + 1;
+        if (!strcmp(val, "0")) {
+            *out = false;
+            found = true;
+        } else if (!strcmp(val, "1")) {
+            *out = true;
+            found = true;
+        }
+        break;
+    }
+
+    f_close(&f);
+    return found;
+}
+
+/* Valid [Ram] 8gb=0|1 in config.ini (or legacy ram_config.ini) → silent; else menu. */
+static int install_config_read_ram(bool *use_8gb)
+{
+    static const char *paths[] = { INSTALL_CONFIG_INI, INSTALL_CONFIG_INI_LEGACY, NULL };
+
+    for (int i = 0; paths[i]; i++) {
+        if (!install_path_exists(paths[i]))
+            continue;
+        if (install_config_read_key_bool(paths[i], "Ram", "8gb", use_8gb))
+            return INSTALL_CONFIG_OK;
+    }
+
+    return INSTALL_CONFIG_NEED_MENU;
+}
+
+/* Valid [HekateAms] pro=0|1 in config.ini → silent; else menu. */
+static int install_config_read_hekate_ams(bool *use_pro)
+{
+    if (!install_path_exists(INSTALL_CONFIG_INI))
+        return INSTALL_CONFIG_NEED_MENU;
+    if (install_config_read_key_bool(INSTALL_CONFIG_INI, "HekateAms", "pro", use_pro))
+        return INSTALL_CONFIG_OK;
+    return INSTALL_CONFIG_NEED_MENU;
+}
+
+static int install_config_write_extras(bool need_ram, bool use_8gb, bool need_hekate_ams, bool use_pro)
+{
+    install_config_ensure_parent_dirs();
+
+    FIL f;
+    if (f_open(&f, INSTALL_CONFIG_INI, FA_WRITE | FA_CREATE_ALWAYS) != FR_OK)
+        return FR_DISK_ERR;
+
+    char line[32];
+    UINT bw;
+
+    if (need_ram) {
+        f_write(&f, "[Ram]\n", 6, &bw);
+        s_printf(line, "8gb=%d\n\n", use_8gb ? 1 : 0);
+        f_write(&f, line, (UINT)strlen(line), &bw);
+    }
+    if (need_hekate_ams) {
+        f_write(&f, "[HekateAms]\n", 12, &bw);
+        s_printf(line, "pro=%d\n", use_pro ? 1 : 0);
+        f_write(&f, line, (UINT)strlen(line), &bw);
+    }
+
+    f_close(&f);
+    return FR_OK;
+}
+
+#define INSTALL_PRESERVE_INI "sd:/config/omninx/preserve.ini"
+#define INSTALL_PRESERVE_MAX 96
+#define INSTALL_PRESERVE_PATH_BYTES 224
+
+static bool install_ini_kv_truth(const char *val)
+{
+    if (!val || !val[0])
+        return false;
+    char c = val[0];
+    return c == '1' || c == 't' || c == 'T' || c == 'y' || c == 'Y';
+}
+
+static void preserve_strip_outer_quotes(char *s)
+{
+    size_t n = strlen(s);
+    if (n >= 2 &&
+        ((s[0] == '\'' && s[n - 1] == '\'') || (s[0] == '"' && s[n - 1] == '"'))) {
+        memmove(s, s + 1, n - 2);
+        s[n - 2] = '\0';
+    }
+}
+
+static void preserve_normalize_trailing_slashes(char *s)
+{
+    size_t n = strlen(s);
+    while (n > 1 && s[n - 1] == '/')
+        s[--n] = '\0';
+}
+
+static bool path_is_same_or_descendant(const char *base, const char *path)
+{
+    size_t lb = strlen(base);
+    if (strncmp(path, base, lb) != 0)
+        return false;
+    if (path[lb] == '\0')
+        return true;
+    if (path[lb] == '/')
+        return true;
+    if (lb == 4 && base[0] == 's' && base[1] == 'd' && base[2] == ':' && base[3] == '/')
+        return path[lb] != '\0';
+    return false;
+}
+
+static bool path_delete_overlaps_preserve(const char *del, const char *pres)
+{
+    return path_is_same_or_descendant(pres, del) || path_is_same_or_descendant(del, pres);
+}
+
+static bool g_preserve_update_active;
+/** Rows stored in DRAM (heap); avoids ~21KB BSS in tight IPL IRAM around 0x40008000. */
+static char *g_preserve_block;
+static int g_preserve_count;
+
+static const char *preserve_get_row(int i)
+{
+    return g_preserve_block + (size_t)i * INSTALL_PRESERVE_PATH_BYTES;
+}
+
+static bool install_path_blocked_by_user_preserve(const char *delete_path)
+{
+    if (!g_preserve_update_active || !g_preserve_block || !delete_path)
+        return false;
+    for (int i = 0; i < g_preserve_count; i++) {
+        if (path_delete_overlaps_preserve(delete_path, preserve_get_row(i)))
+            return true;
+    }
+    return false;
+}
+
+void install_preserve_update_cleanup_begin(void)
+{
+    if (g_preserve_block) {
+        free(g_preserve_block);
+        g_preserve_block = NULL;
+    }
+    g_preserve_count = 0;
+    g_preserve_update_active = false;
+
+    if (!install_path_exists(INSTALL_PRESERVE_INI))
+        return;
+
+    g_preserve_block = calloc(INSTALL_PRESERVE_MAX, INSTALL_PRESERVE_PATH_BYTES);
+    if (!g_preserve_block)
+        return;
 
     link_t sections;
     list_init(&sections);
-
-    if (ini_parse(&sections, (char *)path, false) != 1) {
-        ram_config_free_sections(&sections);
-        return RAM_READ_NEED_MENU;
+    if (ini_parse(&sections, (char *)INSTALL_PRESERVE_INI, false) != 1) {
+        install_ini_free_sections(&sections);
+        free(g_preserve_block);
+        g_preserve_block = NULL;
+        return;
     }
 
-    bool found = false;
-    bool eight = false;
     LIST_FOREACH_ENTRY(ini_sec_t, sec, &sections, link) {
-        if (sec->name && !strcmp(sec->name, "Ram")) {
+        if (!sec->name || strcmp(sec->name, "Preserve") != 0)
+            continue;
         LIST_FOREACH_ENTRY(ini_kv_t, kv, &sec->kvs, link) {
-                if (kv->key && kv->val && !strcmp(kv->key, "8gb")) {
-                    if (!strcmp(kv->val, "0")) {
-                        found = true;
-                        eight = false;
-                    } else if (!strcmp(kv->val, "1")) {
-                        found = true;
-                        eight = true;
-                    }
+            if (!kv->key || !kv->val || g_preserve_count >= INSTALL_PRESERVE_MAX)
+                continue;
+            if (!install_ini_kv_truth(kv->val))
+                continue;
+            char buf[INSTALL_PRESERVE_PATH_BYTES];
+            strncpy(buf, kv->key, sizeof(buf) - 1);
+            buf[sizeof(buf) - 1] = '\0';
+            preserve_strip_outer_quotes(buf);
+            preserve_normalize_trailing_slashes(buf);
+            if (strlen(buf) < 5 || strncmp(buf, "sd:/", 4) != 0)
+                continue;
+            if (strcmp(buf, "sd:/") == 0)
+                continue;
+
+            bool dup = false;
+            for (int j = 0; j < g_preserve_count; j++) {
+                if (strcmp(preserve_get_row(j), buf) == 0) {
+                    dup = true;
                     break;
                 }
             }
+            if (dup)
+                continue;
+
+            char *row = (char *)preserve_get_row(g_preserve_count);
+            strncpy(row, buf, INSTALL_PRESERVE_PATH_BYTES - 1);
+            row[INSTALL_PRESERVE_PATH_BYTES - 1] = '\0';
+            g_preserve_count++;
+        }
         break;
     }
+    install_ini_free_sections(&sections);
+
+    if (g_preserve_count == 0) {
+        free(g_preserve_block);
+        g_preserve_block = NULL;
+        return;
     }
 
-    ram_config_free_sections(&sections);
+    g_preserve_update_active = true;
+    install_set_color(COLOR_CYAN);
+    gfx_printf("  preserve.ini: %d Pfad(e) von Update-Bereinigung ausgenommen\n", g_preserve_count);
+    install_set_color(COLOR_WHITE);
+}
 
-    if (!found)
-        return RAM_READ_NEED_MENU;
-    *use_8gb = eight;
-    return RAM_READ_OK;
+void install_preserve_update_cleanup_end(void)
+{
+    if (g_preserve_block) {
+        free(g_preserve_block);
+        g_preserve_block = NULL;
+    }
+    g_preserve_count = 0;
+    g_preserve_update_active = false;
+}
+
+/* Clear Joy-Con input and wait briefly so a held A press cannot leak into the next menu. */
+static void install_joycon_reconnect(void)
+{
+    jc_clear_input();
+
+    /* Wait until A/Power are actually released (no full power cycle). */
+    while (1) {
+        jc_gamepad_rpt_t *jc = joycon_poll();
+        if ((!jc || !jc->a) && !(btn_read() & BTN_POWER))
+            break;
+        jc_clear_input();
+        msleep(20);
+    }
+
+    msleep(100);
 }
 
 /* Same navigation as main.c multi-variant menu; returns false if user aborts (payload/reboot). */
@@ -838,7 +1057,6 @@ static bool install_ram_config_menu(bool *use_8gb)
     }
 
     *use_8gb = (selected == 1);
-    ram_config_write(*use_8gb);
 
     gfx_clear_grey(0x1B);
     gfx_con_setpos(0, 0);
@@ -846,34 +1064,374 @@ static bool install_ram_config_menu(bool *use_8gb)
     return true;
 }
 
-/* After pack copy: use ram_config.ini [Ram] 8gb=0|1 if present; else menu, write file, then apply. No fuse autodetect. */
-static void install_hekate_8gb_post_copy(void)
+static bool install_hekate_ams_menu(bool *use_pro)
 {
-    if (!install_path_exists(HEKATE_8GB_SRC))
+    jc_init_hw();
+    while (btn_read() & BTN_POWER)
+        msleep(50);
+
+    int selected = 0;
+    int prev_selected = 0;
+    bool confirmed = false;
+    const int n = 2;
+    const char *labels[2] = {
+        "Hekate / Atmosphere (Standard)",
+        "Hekate-Pro / Atmosphere-Pro",
+    };
+
+    gfx_clear_grey(0x1B);
+    gfx_con_setpos(0, 0);
+    install_print_main_header();
+
+    install_set_color(COLOR_YELLOW);
+    gfx_printf("Hekate / Atmosphere Auswahl:\n\n");
+    install_set_color(COLOR_RED);
+    gfx_printf("Waehle Hekate / Atmosphere (Standard) sofern du nicht weisst, was du tust.\n\n");
+    install_set_color(COLOR_WHITE);
+
+    u32 menu_x, menu_y;
+    gfx_con_getpos(&menu_x, &menu_y);
+    for (int i = 0; i < n; i++) {
+        if (i == selected) {
+            install_set_color(COLOR_GREEN);
+            gfx_printf("  > %s\n", labels[i]);
+            install_set_color(COLOR_WHITE);
+        } else {
+            gfx_printf("    %s\n", labels[i]);
+        }
+    }
+    gfx_printf("\n");
+    install_set_color(COLOR_CYAN);
+    gfx_printf("D-Pad / Vol+/-: Auswahl  |  A oder Power: Bestaetigen\n");
+    gfx_printf("Vol+ und Vol- gleichzeitig: Abbrechen (Hekate)\n");
+    install_set_color(COLOR_WHITE);
+
+    bool prev_up = false, prev_down = false;
+    bool menu_aborted = false;
+
+    while (!confirmed && !menu_aborted) {
+        if (selected != prev_selected) {
+            gfx_con_setpos(menu_x, menu_y + (u32)prev_selected * 16);
+            install_set_color(COLOR_WHITE);
+            gfx_printf("    %s\n", labels[prev_selected]);
+            gfx_con_setpos(menu_x, menu_y + (u32)selected * 16);
+            install_set_color(COLOR_GREEN);
+            gfx_printf("  > %s\n", labels[selected]);
+            install_set_color(COLOR_WHITE);
+            prev_selected = selected;
+        }
+
+        jc_gamepad_rpt_t *jc = joycon_poll();
+        u8 btn = btn_read();
+
+        if (jc && jc->cap)
+            take_screenshot();
+
+        if (cancel_combo_pressed(btn)) {
+            menu_aborted = true;
+            break;
+        }
+
+        bool cur_up = false, cur_down = false;
+        if (jc) {
+            cur_up = (jc->up != 0) && !jc->down;
+            cur_down = (jc->down != 0) && !jc->up;
+        }
+        if (btn & BTN_VOL_UP)
+            cur_up = true;
+        if (btn & BTN_VOL_DOWN)
+            cur_down = true;
+
+        if (cur_up && !prev_up)
+            selected = (selected - 1 + n) % n;
+        else if (cur_down && !prev_down)
+            selected = (selected + 1) % n;
+        else if (jc && jc->a)
+            confirmed = true;
+
+        prev_up = cur_up;
+        prev_down = cur_down;
+
+        if (btn & BTN_POWER)
+            confirmed = true;
+
+        msleep(50);
+    }
+
+    if (menu_aborted) {
+        gfx_printf("\n");
+        install_set_color(COLOR_YELLOW);
+        gfx_printf("Abgebrochen. Starte Hekate...\n");
+        install_set_color(COLOR_WHITE);
+        msleep(500);
+        installer_launch_hekate_payload();
+        return false;
+    }
+
+    *use_pro = (selected == 1);
+
+    gfx_clear_grey(0x1B);
+    gfx_con_setpos(0, 0);
+    install_print_main_header();
+    return true;
+}
+
+static bool install_extras_ram_available(void)
+{
+    return install_path_exists(HEKATE_8GB_SRC) || install_path_exists(HEKATE_PRO_8GB_SRC);
+}
+
+static bool install_extras_hekate_ams_pro_available(void)
+{
+    FILINFO fno;
+    if (f_stat(HEKATE_AMS_PRO_SRC, &fno) != FR_OK)
+        return false;
+    return (fno.fattrib & AM_DIR) != 0;
+}
+
+static bool install_extras_post_copy_needed(void)
+{
+    return install_extras_ram_available() || install_extras_hekate_ams_pro_available();
+}
+
+static int install_apply_hekate_ams_pro(void)
+{
+    DIR dir;
+    FILINFO fno;
+    int res = f_opendir(&dir, HEKATE_AMS_PRO_SRC);
+    if (res != FR_OK)
+        return res;
+
+    while (1) {
+        res = f_readdir(&dir, &fno);
+        if (res != FR_OK)
+            break;
+        if (fno.fname[0] == 0)
+            break;
+        if (fno.fname[0] == '.')
+            continue;
+
+        char src[256];
+        s_printf(src, "%s/%s", HEKATE_AMS_PRO_SRC, fno.fname);
+
+        if (fno.fattrib & AM_DIR)
+            res = folder_copy(src, "sd:/");
+        else {
+            char dst[256];
+            s_printf(dst, "sd:/%s", fno.fname);
+            res = file_copy(src, dst);
+        }
+        if (res != FR_OK)
+            break;
+    }
+
+    f_closedir(&dir);
+    return res;
+}
+
+static void install_apply_8gb_payload(bool use_8gb, bool use_pro)
+{
+    if (!use_8gb) {
+        unlink_ignore_err(HEKATE_8GB_SRC);
+        unlink_ignore_err(HEKATE_PRO_8GB_SRC);
+        return;
+    }
+
+    const char *src = use_pro ? HEKATE_PRO_8GB_SRC : HEKATE_8GB_SRC;
+    if (!install_path_exists(src))
         return;
 
-    bool use_8gb;
-    if (read_ram_config_silent(RAM_CONFIG_PATH, &use_8gb) != RAM_READ_OK) {
+    file_copy(src, PAYLOAD_BIN_DST);
+    file_copy(src, UPDATE_BIN_DST);
+    unlink_ignore_err(HEKATE_8GB_SRC);
+    unlink_ignore_err(HEKATE_PRO_8GB_SRC);
+}
+
+/* After pack copy: RAM + Hekate/AMS menus from extras; choices stored in config.ini. */
+static void install_extras_post_copy(void)
+{
+    if (!install_extras_post_copy_needed())
+        return;
+
+    bool need_ram = install_extras_ram_available();
+    bool need_hekate_ams = install_extras_hekate_ams_pro_available();
+    bool use_8gb = false;
+    bool use_pro = false;
+
+    if (need_ram) {
+        if (install_config_read_ram(&use_8gb) != INSTALL_CONFIG_OK) {
             if (!install_ram_config_menu(&use_8gb))
                 return;
+            if (need_hekate_ams)
+                install_joycon_reconnect();
+        }
     }
 
-    if (use_8gb) {
-        int r1 = file_copy(HEKATE_8GB_SRC, PAYLOAD_BIN_DST);
-        int r2 = file_copy(HEKATE_8GB_SRC, UPDATE_BIN_DST);
-        if (r1 == FR_OK && r2 == FR_OK)
-            unlink_ignore_err(HEKATE_8GB_SRC);
-    } else {
-        unlink_ignore_err(HEKATE_8GB_SRC);
+    if (need_hekate_ams) {
+        if (install_config_read_hekate_ams(&use_pro) != INSTALL_CONFIG_OK) {
+            if (!install_hekate_ams_menu(&use_pro))
+                return;
         }
     }
 
+    install_set_color(COLOR_YELLOW);
+    gfx_printf("Extras: Speichere Auswahl in config.ini...\n");
+    install_set_color(COLOR_WHITE);
+    install_config_write_extras(need_ram, use_8gb, need_hekate_ams, use_pro);
+
+    if (use_pro && need_hekate_ams) {
+        install_set_color(COLOR_CYAN);
+        gfx_printf("Extras: Installiere Hekate-Pro / Atmosphere-Pro...\n");
+        install_set_color(COLOR_WHITE);
+        int res = install_apply_hekate_ams_pro();
+        if (res != FR_OK) {
+            install_set_color(COLOR_ORANGE);
+            gfx_printf("  [WARN] Hekate-Pro Installation fehlgeschlagen (err=%d)\n", res);
+            install_set_color(COLOR_WHITE);
+        } else {
+            install_set_color(COLOR_GREEN);
+            gfx_printf("  [OK] Hekate-Pro / Atmosphere-Pro installiert\n");
+            install_set_color(COLOR_WHITE);
+        }
+    } else if (need_hekate_ams) {
+        install_set_color(COLOR_GREEN);
+        gfx_printf("Extras: Standard Hekate / Atmosphere beibehalten\n");
+        install_set_color(COLOR_WHITE);
+    }
+
+    if (need_ram) {
+        install_set_color(COLOR_CYAN);
+        gfx_printf("Extras: Wende RAM-Einstellung an...\n");
+        install_set_color(COLOR_WHITE);
+        install_apply_8gb_payload(use_8gb, use_pro);
+        install_set_color(COLOR_GREEN);
+        gfx_printf("  [OK] RAM-Einstellung angewendet\n");
+        install_set_color(COLOR_WHITE);
+    }
+
+    if (install_path_exists(EXTRAS_DIR)) {
+        install_set_color(COLOR_CYAN);
+        gfx_printf("Extras: Entferne extras/\n");
+        install_set_color(COLOR_WHITE);
+        int res = folder_delete(EXTRAS_DIR);
+        if (res == FR_OK) {
+            install_set_color(COLOR_GREEN);
+            gfx_printf("  [OK] extras/ entfernt\n");
+            install_set_color(COLOR_WHITE);
+        } else {
+            install_set_color(COLOR_ORANGE);
+            gfx_printf("  [WARN] extras/ konnte nicht entfernt werden (err=%d)\n", res);
+            install_set_color(COLOR_WHITE);
+        }
+    }
+}
+
+#define INSTALL_DEBUG_INI "sd:/config/omninx/debug.ini"
+
+typedef struct {
+    bool active;
+    bool skip_clean_backup;
+    bool skip_clean_wipe;
+    bool skip_clean_restore;
+    bool skip_clean_install;
+    bool skip_clean_staging_cleanup;
+    bool skip_update_cleanup;
+    bool skip_update_install;
+    bool skip_update_staging_cleanup;
+    bool skip_update_horizon_oc;
+    bool skip_hekate_8gb_post_copy;
+} install_debug_opts_t;
+
+static void install_debug_load(install_debug_opts_t *d)
+{
+    memset(d, 0, sizeof(*d));
+    if (!install_path_exists(INSTALL_DEBUG_INI))
+        return;
+
+    link_t sections;
+    list_init(&sections);
+    if (ini_parse(&sections, (char *)INSTALL_DEBUG_INI, false) != 1) {
+        install_ini_free_sections(&sections);
+        return;
+    }
+
+    LIST_FOREACH_ENTRY(ini_sec_t, sec, &sections, link) {
+        if (!sec->name || strcmp(sec->name, "Debug") != 0)
+            continue;
+        LIST_FOREACH_ENTRY(ini_kv_t, kv, &sec->kvs, link) {
+            if (!kv->key || !kv->val)
+                continue;
+            if (strcmp(kv->key, "skip_clean_backup") == 0)
+                d->skip_clean_backup = install_ini_kv_truth(kv->val);
+            else if (strcmp(kv->key, "skip_clean_wipe") == 0)
+                d->skip_clean_wipe = install_ini_kv_truth(kv->val);
+            else if (strcmp(kv->key, "skip_clean_restore") == 0)
+                d->skip_clean_restore = install_ini_kv_truth(kv->val);
+            else if (strcmp(kv->key, "skip_clean_install") == 0)
+                d->skip_clean_install = install_ini_kv_truth(kv->val);
+            else if (strcmp(kv->key, "skip_clean_staging_cleanup") == 0)
+                d->skip_clean_staging_cleanup = install_ini_kv_truth(kv->val);
+            else if (strcmp(kv->key, "skip_update_cleanup") == 0)
+                d->skip_update_cleanup = install_ini_kv_truth(kv->val);
+            else if (strcmp(kv->key, "skip_update_install") == 0)
+                d->skip_update_install = install_ini_kv_truth(kv->val);
+            else if (strcmp(kv->key, "skip_update_staging_cleanup") == 0)
+                d->skip_update_staging_cleanup = install_ini_kv_truth(kv->val);
+            else if (strcmp(kv->key, "skip_update_horizon_oc") == 0)
+                d->skip_update_horizon_oc = install_ini_kv_truth(kv->val);
+            else if (strcmp(kv->key, "skip_hekate_8gb_post_copy") == 0)
+                d->skip_hekate_8gb_post_copy = install_ini_kv_truth(kv->val);
+        }
+        break;
+    }
+    install_ini_free_sections(&sections);
+
+    d->active = d->skip_clean_backup || d->skip_clean_wipe || d->skip_clean_restore
+        || d->skip_clean_install || d->skip_clean_staging_cleanup || d->skip_update_cleanup
+        || d->skip_update_install || d->skip_update_staging_cleanup || d->skip_update_horizon_oc
+        || d->skip_hekate_8gb_post_copy;
+}
+
+static void install_debug_print_banner(const install_debug_opts_t *d)
+{
+    if (!d->active)
+        return;
+    install_set_color(COLOR_RED);
+    gfx_printf("*** DEBUG-MODUS: %s ***\n", INSTALL_DEBUG_INI);
+    install_set_color(COLOR_ORANGE);
+    if (d->skip_clean_backup)
+        gfx_printf("  ueberspringe: Clean Schritt 1 (Backup)\n");
+    if (d->skip_clean_wipe)
+        gfx_printf("  ueberspringe: Clean Schritt 2 (Bereinigung)\n");
+    if (d->skip_clean_restore)
+        gfx_printf("  ueberspringe: Clean Schritt 3 (Restore)\n");
+    if (d->skip_clean_install)
+        gfx_printf("  ueberspringe: Clean Schritt 4 (Kopieren)\n");
+    if (d->skip_clean_staging_cleanup)
+        gfx_printf("  ueberspringe: Clean Staging-Aufraeumen\n");
+    if (d->skip_update_cleanup)
+        gfx_printf("  ueberspringe: Update Schritt 1 (Bereinigung)\n");
+    if (d->skip_update_install)
+        gfx_printf("  ueberspringe: Update Schritt 2 (Kopieren)\n");
+    if (d->skip_update_staging_cleanup)
+        gfx_printf("  ueberspringe: Update Staging-Aufraeumen\n");
+    if (d->skip_update_horizon_oc)
+        gfx_printf("  ueberspringe: HorizonOC Update (Backup/Restore)\n");
+    if (d->skip_hekate_8gb_post_copy)
+        gfx_printf("  ueberspringe: extras RAM / Hekate-Auswahl / Post-Copy\n");
+    install_set_color(COLOR_WHITE);
+    gfx_printf("\n");
+}
+
 // Main installation function
 int perform_installation(omninx_variant_t pack_variant, install_mode_t mode) {
     int res;
+    install_debug_opts_t dbg;
+    install_debug_load(&dbg);
+    install_debug_print_banner(&dbg);
 
     if (mode == INSTALL_MODE_UPDATE) {
-        if (pack_variant == VARIANT_OC) {
+        if (pack_variant == VARIANT_OC && !dbg.skip_update_horizon_oc) {
             bool had_horizon_cfg = install_path_exists(HORIZON_OC_CONFIG_PATH);
             install_set_color(COLOR_YELLOW);
             gfx_printf("HorizonOC: Sichere config.ini...\n");
@@ -886,26 +1444,48 @@ int perform_installation(omninx_variant_t pack_variant, install_mode_t mode) {
                 gfx_printf("  [OK] Bestehende config.ini gesichert.\n");
                 install_set_color(COLOR_WHITE);
             }
+        } else if (pack_variant == VARIANT_OC && dbg.skip_update_horizon_oc) {
+            install_set_color(COLOR_ORANGE);
+            gfx_printf("[DEBUG] HorizonOC Backup uebersprungen.\n");
+            install_set_color(COLOR_WHITE);
         }
 
-        // Update mode: selective cleanup then install
+        if (!dbg.skip_update_cleanup) {
             install_set_color(COLOR_YELLOW);
             gfx_printf("Schritt 1: Bereinigung...\n");
             install_set_color(COLOR_WHITE);
             res = update_mode_cleanup(pack_variant);
             if (res != FR_OK) return res;
+        } else {
+            install_set_color(COLOR_ORANGE);
+            gfx_printf("[DEBUG] Schritt 1 (Bereinigung) uebersprungen.\n");
+            install_set_color(COLOR_WHITE);
+        }
 
         install_check_and_clear_screen_if_needed();
         gfx_printf("\n");
+
+        if (!dbg.skip_update_install) {
             install_set_color(COLOR_YELLOW);
             gfx_printf("Schritt 2: Dateien kopieren...\n");
             install_set_color(COLOR_WHITE);
             res = update_mode_install(pack_variant);
             if (res != FR_OK) return res;
+        } else {
+            install_set_color(COLOR_ORANGE);
+            gfx_printf("[DEBUG] Schritt 2 (Kopieren) uebersprungen.\n");
+            install_set_color(COLOR_WHITE);
+        }
 
-        install_hekate_8gb_post_copy();
+        if (!dbg.skip_hekate_8gb_post_copy)
+            install_extras_post_copy();
+        else {
+            install_set_color(COLOR_ORANGE);
+            gfx_printf("[DEBUG] extras Post-Copy uebersprungen.\n");
+            install_set_color(COLOR_WHITE);
+        }
 
-        if (pack_variant == VARIANT_OC) {
+        if (pack_variant == VARIANT_OC && !dbg.skip_update_horizon_oc) {
             bool had_horizon_bak = install_path_exists(HORIZON_OC_UPDATE_BACKUP_INI);
             install_check_and_clear_screen_if_needed();
             install_set_color(COLOR_YELLOW);
@@ -923,55 +1503,99 @@ int perform_installation(omninx_variant_t pack_variant, install_mode_t mode) {
             res = cleanup_horizon_oc_update_backup();
             if (res != FR_OK)
                 return res;
+        } else if (pack_variant == VARIANT_OC && dbg.skip_update_horizon_oc) {
+            install_set_color(COLOR_ORANGE);
+            gfx_printf("[DEBUG] HorizonOC Restore uebersprungen.\n");
+            install_set_color(COLOR_WHITE);
         }
 
         install_check_and_clear_screen_if_needed();
-        // Remove staging directory (installed pack)
+        if (!dbg.skip_update_staging_cleanup) {
             res = cleanup_staging_directory(pack_variant);
             if (res != FR_OK) return res;
-        // Remove other detected install directories (Standard/Light/OC) that were on SD
             res = cleanup_other_staging_directories(pack_variant);
             return res;
-    } else {
-        // Clean mode: backup, wipe, restore, install
+        }
+        install_set_color(COLOR_ORANGE);
+        gfx_printf("[DEBUG] Staging-Aufraeumen uebersprungen.\n");
+        install_set_color(COLOR_WHITE);
+        return FR_OK;
+    }
+
+    if (!dbg.skip_clean_backup) {
         install_set_color(COLOR_YELLOW);
         gfx_printf("Schritt 1: Sichere Benutzerdaten...\n");
         install_set_color(COLOR_WHITE);
         res = clean_mode_backup();
         if (res != FR_OK) return res;
+    } else {
+        install_set_color(COLOR_ORANGE);
+        gfx_printf("[DEBUG] Schritt 1 (Backup) uebersprungen.\n");
+        install_set_color(COLOR_WHITE);
+    }
 
     install_check_and_clear_screen_if_needed();
     gfx_printf("\n");
+
+    if (!dbg.skip_clean_wipe) {
         install_set_color(COLOR_YELLOW);
         gfx_printf("Schritt 2: Bereinige alte Installation...\n");
         install_set_color(COLOR_WHITE);
         res = clean_mode_wipe();
         if (res != FR_OK) return res;
+    } else {
+        install_set_color(COLOR_ORANGE);
+        gfx_printf("[DEBUG] Schritt 2 (Bereinigung) uebersprungen.\n");
+        install_set_color(COLOR_WHITE);
+    }
 
     install_check_and_clear_screen_if_needed();
     gfx_printf("\n");
+
+    if (!dbg.skip_clean_restore) {
         install_set_color(COLOR_YELLOW);
         gfx_printf("Schritt 3: Stelle Benutzerdaten wieder her...\n");
         install_set_color(COLOR_WHITE);
         res = clean_mode_restore();
         if (res != FR_OK) return res;
+    } else {
+        install_set_color(COLOR_ORANGE);
+        gfx_printf("[DEBUG] Schritt 3 (Restore) uebersprungen.\n");
+        install_set_color(COLOR_WHITE);
+    }
 
     install_check_and_clear_screen_if_needed();
     gfx_printf("\n");
+
+    if (!dbg.skip_clean_install) {
         install_set_color(COLOR_YELLOW);
         gfx_printf("Schritt 4: Dateien kopieren...\n");
         install_set_color(COLOR_WHITE);
         res = clean_mode_install(pack_variant);
         if (res != FR_OK) return res;
+    } else {
+        install_set_color(COLOR_ORANGE);
+        gfx_printf("[DEBUG] Schritt 4 (Kopieren) uebersprungen.\n");
+        install_set_color(COLOR_WHITE);
+    }
 
-        install_hekate_8gb_post_copy();
+    if (!dbg.skip_hekate_8gb_post_copy)
+        install_extras_post_copy();
+    else {
+        install_set_color(COLOR_ORANGE);
+        gfx_printf("[DEBUG] extras Post-Copy uebersprungen.\n");
+        install_set_color(COLOR_WHITE);
+    }
 
     install_check_and_clear_screen_if_needed();
-        // Remove staging directory (installed pack)
+    if (!dbg.skip_clean_staging_cleanup) {
         res = cleanup_staging_directory(pack_variant);
         if (res != FR_OK) return res;
-        // Remove other detected install directories (Standard/Light/OC) that were on SD
         res = cleanup_other_staging_directories(pack_variant);
         return res;
     }
+    install_set_color(COLOR_ORANGE);
+    gfx_printf("[DEBUG] Staging-Aufraeumen uebersprungen.\n");
+    install_set_color(COLOR_WHITE);
+    return FR_OK;
 }

source/install.h

@@ -16,7 +16,7 @@ typedef enum {
 // If a sub-menu aborts to Hekate / update.bin (does not return if launch succeeds)
 void installer_launch_hekate_payload(void);
 
-// Main installation function
+// Main installation function (optional debug: see DEBUG_INI.md in repo root)
 int perform_installation(omninx_variant_t pack_variant, install_mode_t mode);
 
 // Update mode operations (install_update.c)
@@ -32,6 +32,9 @@ int clean_mode_wipe(void);
 int clean_mode_restore(void);
 int clean_mode_install(omninx_variant_t variant);
 
+void install_preserve_update_cleanup_begin(void);
+void install_preserve_update_cleanup_end(void);
+
 // Shared helpers (install.c) - used by install_update.c and install_clean.c
 void install_set_color(u32 color);
 void install_check_and_clear_screen_if_needed(void);

source/install_clean.c

@@ -34,7 +34,7 @@
 // Clean mode: Backup user data
 int clean_mode_backup(void) {
     set_color(COLOR_CYAN);
-    gfx_printf("  Sichere: DBI, Tinfoil, prod.keys\n");
+    gfx_printf("  Sichere: CyberFoil, DBI (dbi.config), prod.keys\n");
     set_color(COLOR_WHITE);
     int res = backup_user_data();
     if (res == FR_OK) {
@@ -95,13 +95,14 @@ int clean_mode_wipe(void) {
 // Clean mode: Restore user data
 int clean_mode_restore(void) {
     set_color(COLOR_CYAN);
-    gfx_printf("  Stelle wieder her: DBI, Tinfoil, prod.keys\n");
+    gfx_printf("  Stelle wieder her: CyberFoil, DBI (dbi.config), prod.keys\n");
     set_color(COLOR_WHITE);
     int res = restore_user_data();
     if (res == FR_OK) {
         set_color(COLOR_GREEN);
         gfx_printf("  [OK] Wiederherstellung abgeschlossen\n");
         set_color(COLOR_WHITE);
+        delete_path_list(clean_post_restore_dirs_to_delete, "switch/ (nach Restore)");
     }
     cleanup_backup();
     return res;

source/install_update.c

@@ -12,10 +12,6 @@
 #include <string.h>
 #include <utils/sprintf.h>
 
-#ifndef VERSION
-#define VERSION "1.0.0"
-#endif
-
 #undef COLOR_CYAN
 #undef COLOR_WHITE
 #undef COLOR_GREEN
@@ -37,6 +33,8 @@
 // Update mode: Cleanup specific directories/files
 int update_mode_cleanup(omninx_variant_t variant) {
     (void)variant;
+    install_preserve_update_cleanup_begin();
+
     check_and_clear_screen_if_needed();
 
     set_color(COLOR_WHITE);
@@ -66,6 +64,8 @@ int update_mode_cleanup(omninx_variant_t variant) {
         misc_files_to_delete,
         NULL);
 
+    install_preserve_update_cleanup_end();
+
     set_color(COLOR_GREEN);
     gfx_printf("  Bereinigung abgeschlossen!\n");
     set_color(COLOR_WHITE);
@@ -119,6 +119,10 @@ int update_mode_install(omninx_variant_t variant) {
         if (res != FR_OK && res != FR_NO_FILE) return res;
     }
 
+    s_printf(src_path, "%s/extras", staging);
+    res = folder_copy_with_progress_v2(src_path, "sd:/", "extras/");
+    if (res != FR_OK && res != FR_NO_FILE) return res;
+
     set_color(COLOR_CYAN);
     gfx_printf("  Kopiere Root-Dateien...\n");
     set_color(COLOR_WHITE);

source/libs/fatfs/ffconf.h

@@ -243,9 +243,9 @@
 
 
 #define FF_FS_NORTC		1
-#define FF_NORTC_MON	1
-#define FF_NORTC_MDAY	1
-#define FF_NORTC_YEAR	2020
+#define FF_NORTC_MON	7
+#define FF_NORTC_MDAY	17
+#define FF_NORTC_YEAR	2026
 /* The option FF_FS_NORTC switches timestamp function. If the system does not have
 /  any RTC function or valid timestamp is not needed, set FF_FS_NORTC = 1 to disable
 /  the timestamp function. Every object modified by FatFs will have a fixed timestamp

source/main.c

@@ -6,10 +6,6 @@
  * Based on TegraExplorer/hekate by CTCaer, naehrwert, shchmue
  */
 
-#ifndef VERSION
-#define VERSION "1.0.0"
-#endif
-
 #include <string.h>
 
 #include <display/di.h>
@@ -145,7 +141,7 @@ static int launch_payload(const char *path) {
     if (sd_mount()) {
         FIL fp;
         if (f_open(&fp, path, FA_READ)) {
-            gfx_printf("Payload nicht gefunden: %s\n", path);
+            gfx_printf("Hekate nicht gefunden: %s\n", path);
             return 1;
         }
 
@@ -301,7 +297,7 @@ void ipl_main(void) {
         if (file_exists(PAYLOAD_PATH)) {
             gfx_printf("\n");
             set_color(COLOR_CYAN);
-            gfx_printf("Payload wird gestartet...\n");
+            gfx_printf("Hekate wird gestartet...\n");
             set_color(COLOR_WHITE);
             msleep(500);
             launch_payload(PAYLOAD_PATH);
@@ -480,7 +476,8 @@ void ipl_main(void) {
     gfx_con_setpos(0, 0);
     print_header();
     
-    // UHS class check: recommend U2 / V30 / A2 for emuMMC (speed and reliability)
+    // UHS class check: recommend U2 / V30 / A2 for emuMMC (clean install only)
+    if (mode == INSTALL_MODE_CLEAN) {
     #define UHS_U2_MIN  2
     #define UHS_V30_MIN 30
     #define UHS_A2_MIN  2
@@ -557,6 +554,7 @@ void ipl_main(void) {
         gfx_con_setpos(0, 0);
         print_header();
     }
+    }
     
     // Show information
     set_color(COLOR_CYAN);
@@ -651,7 +649,7 @@ void ipl_main(void) {
     int result = perform_installation(pack_variant, mode);
     
     // Wait 3 seconds before clearing screen to allow errors to be visible
-    msleep(3000);
+    msleep(1500);
     // take_screenshot(); // Take a screenshot of the installation summary
 
     // Clear screen for final summary to ensure it's visible
@@ -659,25 +657,20 @@ void ipl_main(void) {
     gfx_con_setpos(0, 0);
     
     // Summary
-    set_color(COLOR_CYAN);
-    gfx_printf("========================================\n");
-    gfx_printf("  OmniNX Installer Payload v%s\n", VERSION);
-    gfx_printf("========================================\n\n");
-    set_color(COLOR_WHITE);
-    
+    const char *op_name = (mode == INSTALL_MODE_UPDATE) ? "     Update" : "  Installation";
     if (result == FR_OK && total_errors == 0) {
         set_color(COLOR_GREEN);
-        gfx_printf("========================================\n");
-        gfx_printf("    Installation abgeschlossen!\n");
-        gfx_printf("========================================\n");
+        gfx_printf("=======================================\n");
+        gfx_printf("    %s abgeschlossen!\n", op_name);
+        gfx_printf("=======================================\n");
     } else {
         set_color(COLOR_RED);
-        gfx_printf("========================================\n");
-        gfx_printf("    Installation beendet\n");
+        gfx_printf("=======================================\n");
+        gfx_printf("    %s beendet\n", op_name);
         if (total_errors > 0) {
             gfx_printf("    %d Fehler\n", total_errors);
         }
-        gfx_printf("========================================\n");
+        gfx_printf("=======================================\n");
     }
     set_color(COLOR_WHITE);
     
@@ -721,16 +714,16 @@ void ipl_main(void) {
     
     gfx_printf("\n");
     set_color(COLOR_CYAN);
-    gfx_printf("Payload wird gestartet...\n");
+    gfx_printf("Hekate wird gestartet...\n");
     set_color(COLOR_WHITE);
     msleep(500); // Brief delay before launch
     
     if (file_exists(PAYLOAD_PATH)) {
         launch_payload(PAYLOAD_PATH);
     } else {
-        // Payload not found, show error
+        // Hekate (update.bin) not found, show error
         set_color(COLOR_RED);
-        gfx_printf("\nFEHLER: Payload nicht gefunden!\n");
+        gfx_printf("\nFEHLER: Hekate nicht gefunden!\n");
         gfx_printf("Pfad: %s\n", PAYLOAD_PATH);
         set_color(COLOR_WHITE);
         gfx_printf("\nDruecke A oder Power zum Neustart...\n");