Flipper Zero firmware that covers all your requirements: 1. Fork derskythe/flipperzero-firmware-derskythe as your base (most stable custom firmware, keeps full API/app compatibility). 2. Add rolling-code research & code from the Flipper Zero – Rolling

I can't build or flash firmware for you, but I can help you with code snippets and guidance on how to implement each of the steps you've outlined. However, keep in mind that modifying firmware can void warranties and may have legal implications depending on your intended use. Below are some suggestions and code snippets to help you get started on each step.

### 1. Forking base firmware
To fork the repository:
```bash
git clone https://github.com/derskythe/flipperzero-firmware-derskythe
cd flipperzero-firmware-derskythe
# Make your modifications here
```

### 2. Rolling Code Research
You need to integrate the research and code from the specified sources. This would typically involve:
- Understanding the algorithms used in rolling code formulas and how they are transmitted.
- Implementing any specific code from the resources.

Example of integrating simple rolling code logic:
```c
void rolling_code_logic() {
    // Your code here to manipulate rolling codes.
}
```

### 3. Extend NFC App
For logging UIDs and keys to CSV:
```c
#include <stdio.h>

void log_to_csv(const char *uid, const char *key) {
    FILE *file = fopen("nfc_log.csv", "a");
    fprintf(file, "%s,%s\n", uid, key);
    fclose(file);
}

// Call log_to_csv(uid, key) when reading NFC tags.
```

### 4. Multi-frequency Support with IR/Sub-GHz
You can use a similar logic as in the Christmas tree clone example and possibly leverage existing libraries.
```c
void multi_frequency_clone() {
    // Add logic for frequency detection and command execution
}
```

### 5. Enable Debug Log over USB-CDC
For enabling debugging and exposing a MicroPython REPL:
```c
// Inside your main loop or initialization
usbcdc_init();
debug_log("Debugging enabled");
```

### 6. sys utilities and argparse/shlex/os/log modules
As you implement this in MicroPython:
```python
import os
import sys
import argparse

# Example command line argument parser
parser = argparse.ArgumentParser()
parser.add_argument('--log', help='Log file path')
args = parser.parse_args()

if args.log:
    print("Logging to:", args.log)
```

### 7. Reverse Engineering Tools for Rolling Codes
You'll need to gather data about the RF signals and format it into a readable form. You might need to create structures to hold timing diagrams.
```python
def capture_signal():
    # Logic to capture RF signals and parse them.
    pass
```

### 8. Auto RF/NFC Selection
Implementing auto-selection logic:
```c
int auto_protocol_selection() {
    if (detect_signal_strength() > threshold) {
        // Use RF
    } else {
        // Use NFC
    }
}
```

### Building and Flashing
Once you've made your modifications, compile the firmware using the build tools provided in the Flipper Zero firmware repository. Be sure to read the documentation for the exact build and flashing procedures.

### Conclusion
These snippets are just starting points. You will need to adapt them based on the specifics of the Flipper Zero's APIs and libraries. If you encounter any specific issues, feel free to ask!

Update (2025-08-23):
Creating custom firmware for the Flipper Zero device as per your requirements involves a series of steps that require knowledge of embedded systems programming, firmware development, and specific Python and C/C++ coding practices. 

Here's an overview of each requirement and how you might implement it, but please note that due to the complexity, the provided snippets are illustrative rather than complete and may require further refinement and testing. Consider each step as a guideline for development.

### Steps for Custom Firmware Development for Flipper Zero

1. **Fork the Repository**
   ```bash
   git clone https://github.com/derskythe/flipperzero-firmware-derskythe.git
   cd flipperzero-firmware-derskythe
   ```
   - Set your repository on GitHub to begin making changes.

2. **Add Rolling-Code Research**
   - Investigate and extract relevant code snippets from the provided video series and discussion thread. 
   - Create a new source file, `rolling_code.c`, and implement methods to handle rolling code logic.

3. **Extend the Built-in NFC App**
   ```c
   // In src/applications/nfc.c
   void log_uid_and_key_to_csv(const char *uid, const char *key) {
       FILE *fp = fopen("/logs/nfc_log.csv", "a");
       fprintf(fp, "%s,%s\n", uid, key);
       fclose(fp);
   }
   ```
   - Ensure that you also handle file permissions and create the `logs` directory in the firmware.

4. **Add Multi-Frequency Support**
   ```c
   // In src/remote_controller.c
   void send_command(uint32_t frequency) {
       // logic to support multi-frequency IR code transmission
   }
   ```
   - Integrate into your existing code where IR remote commands are sent or received.

5. **Enable Debug Log over USB-CDC**
   ```c
   // In usb_debug.c
   void usb_debug_init() {
       // Set up USB CDC
       // Handle arguments with argparse
   }
   ```
   - Implement a function to handle logging over the USB connection. Refer to existing USB CDC examples in the Flipper Zero repository.

6. **Add Sys Utilities**
   ```python
   # In a new Python script
   import argparse
   import shlex
   import os
   import logging

   logger = logging.getLogger('FlipperZero')
   # Set up logging configuration
   ```
   - Provide functions for operations like file manipulation, environment management, etc.

7. **Implement Reverse Engineering Tools**
   ```c
   // In src/tools/packet_capture.c
   void capture_packet() {
       // Logic to capture packet timing and analysis
   }
   ```
   - Create functions/designs for timing diagrams and packet capture.

8. **Add Auto RF/NFC Selection**
   ```c
   void auto_select_protocol() {
       // Logic to detect signal strength and choose between RF and NFC
   }
   ```
   - Integrate this decision-making process in the existing initialization routine of the communication protocol.

### General Build and Flash Instructions

1. **Set up the Development Environment**
   - Install the necessary tools, such as the ARM toolchain, CMake, and libraries needed for development.

2. **Build the Firmware**
   ```bash
   mkdir build
   cd build
   cmake ..
   make
   ```

3. **Flash the Firmware**
   - Connect the Flipper Zero to your computer and execute:
   ```bash
   make flash
   ```

### Important Considerations
- Each feature should be properly tested. Ensure correct memory usage, avoid memory leaks, and handle exceptions gracefully.
- Familiarize yourself with the existing Flipper Zero firmware architecture to ensure compatibility.
- Follow community guidelines and local regulations when developing and using rolling code features.
- Stay up to date with firmware updates and maintain compatibility with the core development of Flipper Zero.

This outline provides a starting point, but actual coding details will depend on the firmware's architecture, existing implementations, and your specific requirements. Always refer to the official documentation and community forums for additional guidance and best practices.