@leejungkiin/awkit 1.0.7 → 1.0.9

package/skills/smali-to-swift/SKILL.md

@@ -4,10 +4,9 @@ description: >-
   iOS Reverse Engineering specialist. Reads decrypted IPA output (class-dump headers,
   Hopper/IDA disassembly, resources, Info.plist) and rebuilds the app from scratch using
   modern Swift + SwiftUI + Clean Architecture (MVVM).
-  UI-First approach: design and approve UI visuals before coding logic.
   Includes framework detection to reuse existing dependencies.
 author: Antigravity Team
-version: 2.0.0
+version: 1.0.0
 trigger: conditional
 activation_keywords:
   - "/reverse-ios"
@@ -25,11 +24,10 @@ platform: ios
 sibling_skill: smali-to-kotlin (Android counterpart)
 ---
 
-# 🍎 Smali-to-Swift Skill v2 — UI-First
+# 🍎 Smali-to-Swift Skill
 
 > **Purpose:** Transform decrypted iOS IPA (class-dump headers, disassembly, resources, plist) into a modern Swift app with SwiftUI, Clean Architecture, and MVVM.
-> **Philosophy:** "Map → Blueprint → UI First → Logic Behind"
-> **Key Change (v2):** UI is designed and approved BEFORE coding any business logic.
+> **Philosophy:** "Read ObjC headers to understand WHAT and WHY → Write Swift for HOW."
 
 ---
 
@@ -42,7 +40,7 @@ sibling_skill: smali-to-kotlin (Android counterpart)
 | Detect & reuse third-party frameworks | Crack/bypass DRM or jailbreak |
 | Extract only needed resources (on-demand) | Mass-copy assets blindly |
 | Set up Clean Architecture project structure | Handle Android reverse engineering |
-| Code UI first, then wire logic behind | Submit to App Store |
+| Scan IPA frameworks for dependency reuse | Submit to App Store |
 
 → For Android reverse engineering → sibling skill: `smali-to-kotlin`
 → After rebuild complete → use `/test` or `/deploy` workflows
@@ -57,7 +55,7 @@ When this skill is active, the agent becomes:
 > - Master at reading ObjC/Swift class-dump headers and ARM disassembly
 > - Fluent in Clean Architecture + MVVM + SwiftUI
 > - Knows when to reuse vs rewrite third-party frameworks
-> - Enforces UI-First and resource-on-demand principles
+> - Enforces resource-on-demand principle (zero bloat)
 
 ---
 
@@ -76,12 +74,17 @@ When this skill is active, the agent becomes:
 ### What we get from an IPA:
 ```
 Payload/App.app/
-├── App                          # Mach-O binary (need decrypt first)
-├── Info.plist                   # App metadata
-├── Frameworks/                  # Embedded frameworks
+├── App                          # Mach-O binary (encrypted → need decrypt first)
+├── Info.plist                   # App metadata (bundle ID, permissions, URL schemes)
+├── Frameworks/                  # Embedded frameworks (.framework / .dylib)
+│   ├── SomeSDK.framework/
+│   └── libswiftCore.dylib
 ├── Assets.car                   # Compiled asset catalog
 ├── Base.lproj/                  # Storyboards / XIBs (compiled)
-├── *.nib / *.momd               # Compiled UIKit / Core Data
+│   ├── Main.storyboardc/
+│   └── LaunchScreen.storyboardc/
+├── *.nib                        # Compiled XIB files
+├── *.momd                       # Core Data models (compiled)
 ├── embedded.mobileprovision     # Provisioning profile
 ├── _CodeSignature/              # Code signing
 └── [other resources: json, png, html, js, fonts...]
@@ -103,10 +106,10 @@ Payload/App.app/
 | Purpose | Technology | Replaces |
 |---------|-----------|----------|
 | **Network** | URLSession + async/await | AFNetworking / Alamofire (evaluate) |
-| **JSON** | Codable (Swift built-in) | NSJSONSerialization / Mantle |
+| **JSON** | Codable (Swift built-in) | NSJSONSerialization / Mantle / ObjectMapper |
 | **Local DB** | SwiftData (iOS 17+) or Core Data | Raw SQLite / FMDB / Realm |
 | **Preferences** | UserDefaults / @AppStorage | NSUserDefaults direct |
-| **Keychain** | KeychainAccess (or custom) | Raw Security.framework |
+| **Keychain** | KeychainAccess (or custom wrapper) | Raw Security.framework |
 | **Image Loading** | AsyncImage / Kingfisher / Nuke | SDWebImage (evaluate) |
 | **Async** | Swift Concurrency (async/await, actors) | GCD / NSOperation / PromiseKit |
 
@@ -127,22 +130,33 @@ always_replace:
   Mantle/ObjectMapper: "Codable"
   GCD_dispatch_async: "Task { } / async-await"
   NSOperation: "TaskGroup / async let"
+  NSTimer: "Timer.publish (Combine) or Task.sleep"
+  UIAlertView: "SwiftUI .alert modifier"
+  UIActionSheet: "SwiftUI .confirmationDialog"
   UITableView: "List / LazyVStack"
   UICollectionView: "LazyVGrid / LazyHGrid"
+  UIPageViewController: "TabView with .page style"
   Storyboard_segues: "NavigationStack + NavigationLink"
+  NSNotificationCenter_addObserver: "NotificationCenter.notifications (AsyncSequence)"
   KVO: "@Observable macro"
   Delegate_patterns: "AsyncStream or closures"
   Target_Action: "SwiftUI action closures"
 
 evaluate_before_replacing:
-  Alamofire: "Keep if deeply used, else → URLSession"
-  SDWebImage: "→ AsyncImage + Kingfisher"
-  Realm: "→ SwiftData (if iOS 17+)"
-  RxSwift: "→ async/await + AsyncSequence"
-  SnapKit: "→ SwiftUI layout"
+  Alamofire: "Keep if deeply used for interceptors/retry, otherwise → URLSession"
+  SDWebImage: "Replace with AsyncImage + Kingfisher"
+  Realm: "Migrate to SwiftData (if iOS 17+)"
+  RxSwift: "Migrate to async/await + AsyncSequence (gradual)"
+  SnapKit: "Replace with SwiftUI layout"
+  Masonry: "Replace with SwiftUI layout"
+  MBProgressHUD: "SwiftUI .overlay + ProgressView"
+  SVProgressHUD: "SwiftUI .overlay + ProgressView"
+  IQKeyboardManager: "SwiftUI handles keyboard automatically"
 
 keep_as_is:
   - "Firebase SDKs (use latest via SPM)"
+  - "Google Sign-In"
+  - "Facebook SDK (latest)"
   - "Apple frameworks (MapKit, CoreLocation, AVFoundation, etc.)"
   - "Native C/C++ libraries (.dylib)"
   - "CryptoKit (Apple native)"
@@ -150,50 +164,492 @@ keep_as_is:
 
 ---
 
-## 📋 EXECUTION PIPELINE (v2 — UI-First)
+## 📋 EXECUTION PIPELINE (6 Steps)
+
+> **Rule:** Always complete one step fully before moving to the next.
+> **Rule:** After each step, create a checkpoint summary for the user.
+
+### Step 0: Framework Scanner (PRE-STEP — Always First) 🔍
+
+**Purpose:** Scan the IPA structure to identify all third-party frameworks before any coding.
+
+**Process:**
+1. **Scan `Frameworks/` directory:**
+   ```
+   Frameworks/Alamofire.framework     → Alamofire (network)
+   Frameworks/SDWebImage.framework    → SDWebImage (image loading)
+   Frameworks/Realm.framework         → Realm (database)
+   Frameworks/FBSDKCoreKit.framework  → Facebook SDK
+   Frameworks/GoogleSignIn.framework  → Google Sign-In
+   ```
+
+2. **Scan class-dump headers for imports:**
+   ```
+   #import <AFNetworking/...>        → AFNetworking
+   #import <Masonry/...>             → Masonry (auto-layout)
+   #import <MBProgressHUD/...>       → MBProgressHUD
+   @import Firebase;                 → Firebase SDK
+   @import GoogleMobileAds;          → AdMob
+   ```
+
+3. **Check Mach-O linked frameworks:**
+   ```bash
+   otool -L Payload/App.app/App | grep -v /System | grep -v /usr/lib
+   ```
+
+4. **Check embedded dylibs:**
+   ```bash
+   find Payload/App.app -name "*.dylib" -o -name "*.framework" | sort
+   ```
+
+5. **Check for CocoaPods / SPM markers:**
+   ```
+   Pods/ directory presence → was using CocoaPods
+   .package.resolved → was using SPM
+   ```
+
+6. **Output: Framework Detection Report**
+   ```markdown
+   ## 📦 Framework Detection Report
+   
+   ### ✅ Can Reuse (add to Package.swift / Podfile)
+   | Framework | Detected | Latest Version | Action |
+   |-----------|----------|----------------|--------|
+   | Alamofire | Frameworks/Alamofire.framework | 5.9.0 | Evaluate |
+   | Kingfisher | (header import) | 7.12.0 | Add via SPM |
+   
+   ### 🔄 Must Replace (legacy)
+   | Old Framework | Detected | Modern Replacement |
+   |---------------|----------|-------------------|
+   | AFNetworking | Frameworks/AFNetworking.framework | URLSession async/await |
+   | Masonry | header imports | SwiftUI layout |
+   
+   ### 🍏 Apple Frameworks Used
+   | Framework | Purpose |
+   |-----------|---------|
+   | MapKit | Maps |
+   | CoreLocation | GPS |
+   | AVFoundation | Camera/Audio |
+   
+   ### 📱 Native (.dylib) — Investigate
+   | File | Notes |
+   |------|-------|
+   | libcrypto.dylib | Custom crypto? |
+   
+   ### ❓ Unknown (investigate)
+   | Framework/Import | Notes |
+   |------------------|-------|
+   | CustomSDK.framework | Proprietary? |
+   ```
 
-> **Philosophy:** "Nhìn thấy trước, code logic sau"
-> **Rule:** Always complete one phase fully before moving to the next.
-> **Rule:** UI must be approved before coding logic.
+---
 
+### Step 1: Info.plist & Entitlements Analysis + Project Bootstrap 📄
+
+**Input:** User provides `Info.plist` + entitlements from IPA.
+
+**Tasks:**
+1. Extract Bundle ID and display name
+2. List required permissions (Privacy keys):
+   ```
+   NSCameraUsageDescription          → Camera
+   NSPhotoLibraryUsageDescription    → Photo Library
+   NSLocationWhenInUseUsageDescription → Location
+   NSMicrophoneUsageDescription      → Microphone
+   ```
+3. Identify URL Schemes (deep links)
+4. Check app capabilities from entitlements:
+   ```
+   com.apple.developer.associated-domains → Universal Links
+   aps-environment → Push Notifications
+   com.apple.developer.in-app-payments → Apple Pay
+   ```
+5. Analyze class-dump headers for entry points:
+   - `AppDelegate` → lifecycle logic
+   - Root ViewController → initial screen
+   - Tab bar / Navigation structure
+6. **Output:** Propose Clean Architecture project structure
+
+**Project Structure Template:**
 ```
-Phase 0: Discovery         → App Map (satellite view)
-Phase 1: Architecture      → Layer design + UI-First build order (district view)
-  ┌─── Loop per Feature ──────────────────────────────────────┐
-  │ Phase 2: Blueprint + UI → Contracts + Visual UI Shell     │
-  │ 🚦 GATE: User approves UI + Contracts                    │
-  │ Phase 3: Logic Build    → Domain → Data → Wire UI↔Logic  │
-  │ 📊 CHECKPOINT: Feature complete                           │
-  └─── Repeat for next feature ───────────────────────────────┘
-Phase 4: Final Parity Check
+App/
+├── App.swift                          # @main entry point
+├── AppDelegate.swift                  # UIKit lifecycle (if needed for SDKs)
+├── Info.plist
+├── Assets.xcassets/
+├── DI/                                # Dependency Injection
+│   └── AppContainer.swift
+├── Data/                              # Data Layer
+│   ├── Network/
+│   │   ├── APIClient.swift            # URLSession wrapper
+│   │   ├── Endpoints/                 # API endpoint definitions
+│   │   └── DTOs/                      # Codable response models
+│   ├── Local/
+│   │   ├── SwiftDataModels/           # @Model classes
+│   │   ├── KeychainService.swift
+│   │   └── UserDefaultsKeys.swift
+│   └── Repositories/                  # Repository implementations
+├── Domain/                            # Domain Layer
+│   ├── Models/                        # Business models
+│   ├── Repositories/                  # Repository protocols
+│   └── UseCases/
+├── Presentation/                      # Presentation Layer
+│   ├── Navigation/
+│   │   ├── AppNavigation.swift        # NavigationStack + routes
+│   │   └── Route.swift                # Deep link routes
+│   ├── Theme/
+│   │   ├── AppTheme.swift             # Colors, fonts, spacing
+│   │   └── Components/               # Reusable SwiftUI components
+│   └── Screens/
+│       ├── Launch/
+│       │   └── LaunchScreen.swift
+│       ├── Auth/
+│       │   ├── LoginScreen.swift
+│       │   └── LoginViewModel.swift
+│       ├── Home/
+│       │   ├── HomeScreen.swift
+│       │   └── HomeViewModel.swift
+│       └── ...
+├── Utilities/
+│   ├── Extensions/
+│   ├── Crypto/                        # Encryption/hashing utils
+│   └── Helpers/
+└── Resources/
+    ├── Localizable.xcstrings
+    └── Fonts/
 ```
 
-### Reference Files
+---
+
+### Step 2: Data Layer Reconstruction 💾
+
+**Input:** User provides class-dump headers + Hopper pseudo-code for network/data classes.
+
+**Tasks:**
+1. **Models:** Convert ObjC interfaces → Swift structs
+   ```objc
+   // ObjC header (class-dump)
+   @interface UserModel : NSObject
+   @property (nonatomic, copy) NSString *userId;
+   @property (nonatomic, copy) NSString *fullName;
+   @property (nonatomic, assign) NSInteger age;
+   @end
+   ```
+   ```swift
+   // Swift
+   struct User: Codable, Identifiable {
+       let id: String
+       let fullName: String
+       let age: Int
+       
+       enum CodingKeys: String, CodingKey {
+           case id = "user_id"
+           case fullName = "full_name"
+           case age
+       }
+   }
+   ```
+
+2. **API Layer:**
+   - Extract base URL, endpoints, headers from disassembly
+   - Create async URLSession-based API client:
+   ```swift
+   actor APIClient {
+       private let session: URLSession
+       private let baseURL: URL
+       
+       func request<T: Decodable>(_ endpoint: Endpoint) async throws -> T {
+           let (data, response) = try await session.data(for: endpoint.urlRequest(baseURL: baseURL))
+           guard let httpResponse = response as? HTTPURLResponse,
+                 (200...299).contains(httpResponse.statusCode) else {
+               throw APIError.invalidResponse
+           }
+           return try JSONDecoder().decode(T.self, from: data)
+       }
+   }
+   ```
+
+3. **Local Storage:**
+   - CoreData models → SwiftData `@Model` classes
+   - NSUserDefaults keys → `@AppStorage` or typed UserDefaults wrapper
+   - Keychain items → KeychainAccess wrapper
+
+4. **Repository:**
+   ```swift
+   // Domain layer - protocol
+   protocol UserRepository: Sendable {
+       func getUser(id: String) async throws -> User
+       func login(email: String, password: String) async throws -> AuthToken
+   }
+   
+   // Data layer - implementation
+   final class UserRepositoryImpl: UserRepository {
+       private let apiClient: APIClient
+       private let modelContext: ModelContext
+       
+       func getUser(id: String) async throws -> User {
+           // offline-first: check local → fetch remote → cache
+       }
+   }
+   ```
+
+---
+
+### Step 3: Core Logic & Utils Reconstruction 🧮
+
+**Input:** Disassembly/pseudo-code for encryption, hashing, custom utils.
+
+**Tasks:**
+1. Translate ObjC/C crypto logic → Swift
+   - Use `CryptoKit` for modern crypto (SHA256, AES-GCM, HMAC)
+   - Use `CommonCrypto` for legacy-compatible (MD5, AES-CBC)
+   - Preserve exact input/output signatures
+
+2. Common ObjC → Swift crypto patterns:
+   ```objc
+   // ObjC (class-dump + disassembly)
+   + (NSString *)md5Hash:(NSString *)input;
+   + (NSData *)aesEncrypt:(NSData *)data withKey:(NSString *)key;
+   ```
+   ```swift
+   // Swift
+   import CryptoKit
+   import CommonCrypto
+   
+   enum CryptoUtils {
+       static func md5Hash(_ input: String) -> String {
+           let data = Data(input.utf8)
+           var digest = [UInt8](repeating: 0, count: Int(CC_MD5_DIGEST_LENGTH))
+           data.withUnsafeBytes { CC_MD5($0.baseAddress, CC_LONG(data.count), &digest) }
+           return digest.map { String(format: "%02x", $0) }.joined()
+       }
+       
+       static func aesEncrypt(data: Data, key: String) throws -> Data {
+           // Implement matching original algorithm exactly
+       }
+   }
+   ```
+
+3. **Verification:** XCTest unit tests with known input/output pairs
+
+**Critical Rule:**
+> ⚠️ Crypto/hash functions MUST produce identical output to the original app.
+> Test with known pairs captured from the running original app.
 
-Each phase has a detailed instruction file:
-- `phase-0-discovery.md` — Framework scan, plist analysis, app map
-- `phase-1-architecture.md` — Layer design, feature mapping, build order
-- `phase-2-blueprint-ui.md` — Contracts + UI visual shell + parity check
-- `phase-3-logic-build.md` — Domain, data, DI, ViewModel, wire UI↔logic
+---
 
-### Supporting Files
-- `objc-reading-guide.md` — How to read ObjC class-dump headers
-- `framework-patterns.md` — Common iOS framework detection patterns
+### Step 4: UI & ViewModel Reconstruction (Per Screen) 🎨
+
+**Input:** Storyboard analysis + class-dump headers for ViewControllers.
+
+**Tasks:**
+1. **Resource Extraction (On-Demand):**
+   - Extract only images, colors, strings for current screen
+   - Use Asset Catalog for organized resources
+   - Map ObjC string tables to `Localizable.xcstrings`
+
+2. **UIKit → SwiftUI Migration:**
+   ```
+   UIViewController          → SwiftUI View struct
+   UINavigationController    → NavigationStack
+   UITabBarController        → TabView
+   UITableView               → List / LazyVStack
+   UICollectionView          → LazyVGrid / LazyHGrid
+   UIScrollView              → ScrollView
+   UIImageView               → AsyncImage / Image
+   UILabel                   → Text
+   UITextField               → TextField
+   UIButton                  → Button
+   UIActivityIndicatorView   → ProgressView
+   UIAlertController         → .alert / .confirmationDialog modifier
+   UIPageViewController      → TabView(.page)
+   UIStackView               → VStack / HStack
+   MKMapView                 → Map (MapKit SwiftUI)
+   WKWebView                 → WebView (custom wrapper)
+   UIRefreshControl          → .refreshable modifier
+   UISearchController        → .searchable modifier
+   ```
+
+3. **ViewModel Creation:**
+   ```swift
+   @Observable
+   final class LoginViewModel {
+       var email = ""
+       var password = ""
+       var isLoading = false
+       var error: String?
+       
+       private let loginUseCase: LoginUseCase
+       
+       init(loginUseCase: LoginUseCase) {
+           self.loginUseCase = loginUseCase
+       }
+       
+       func login() async {
+           isLoading = true
+           defer { isLoading = false }
+           do {
+               try await loginUseCase.execute(email: email, password: password)
+           } catch {
+               self.error = error.localizedDescription
+           }
+       }
+   }
+   ```
+
+4. **Screen Composable:**
+   ```swift
+   struct LoginScreen: View {
+       @State private var viewModel: LoginViewModel
+       
+       init(loginUseCase: LoginUseCase) {
+           _viewModel = State(initialValue: LoginViewModel(loginUseCase: loginUseCase))
+       }
+       
+       var body: some View {
+           Form {
+               TextField("Email", text: $viewModel.email)
+                   .textContentType(.emailAddress)
+                   .keyboardType(.emailAddress)
+               
+               SecureField("Password", text: $viewModel.password)
+                   .textContentType(.password)
+               
+               Button("Login") {
+                   Task { await viewModel.login() }
+               }
+               .disabled(viewModel.isLoading)
+           }
+           .overlay { if viewModel.isLoading { ProgressView() } }
+           .alert("Error", isPresented: .constant(viewModel.error != nil)) {
+               Button("OK") { viewModel.error = nil }
+           } message: {
+               Text(viewModel.error ?? "")
+           }
+       }
+   }
+   ```
 
 ---
 
-## 🔑 KEY DIFFERENCES FROM v1
+### Step 5: Third-party SDK & Native Library Integration 📦
+
+**Input:** Framework Report from Step 0.
+
+**Tasks:**
+1. **Swift Package Manager setup:**
+   ```swift
+   // Package.swift dependencies (or Xcode SPM UI)
+   dependencies: [
+       .package(url: "https://github.com/firebase/firebase-ios-sdk", from: "11.0.0"),
+       .package(url: "https://github.com/onevcat/Kingfisher", from: "7.12.0"),
+       .package(url: "https://github.com/kishikawakatsumi/KeychainAccess", from: "4.2.2"),
+   ]
+   ```
+
+2. **Native C/C++ libraries:**
+   ```swift
+   // Bridging header for C libraries
+   // App-Bridging-Header.h
+   #include "native_crypto.h"
+   
+   // Swift usage
+   func callNativeFunction() -> String {
+       let result = native_function_name(param)
+       return String(cString: result)
+   }
+   ```
+
+3. **App lifecycle for SDK init:**
+   ```swift
+   @main
+   struct MyApp: App {
+       @UIApplicationDelegateAdaptor private var appDelegate: AppDelegate
+       
+       var body: some Scene {
+           WindowGroup {
+               ContentView()
+           }
+       }
+   }
+   
+   class AppDelegate: NSObject, UIApplicationDelegate {
+       func application(_ application: UIApplication,
+                        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+           FirebaseApp.configure()
+           // Other SDK initialization
+           return true
+       }
+   }
+   ```
+
+---
+
+### Step 6: Parity Check & Quality Gate ✅
+
+**Per-module checklist:**
+1. **Branch Coverage:** Review all conditional paths from disassembly
+2. **API Parity:** Same requests/responses as original
+3. **Data Parity:** Crypto output matches, local storage compatible
+4. **UI Parity:** Screen-by-screen comparison
+5. **Performance:**
+   - Instruments profiling
+   - No unnecessary @State re-renders
+   - Proper actor isolation (no data races)
+
+---
+
+## 🔍 ObjC HEADER READING GUIDE
+
+### Property Types → Swift
+```objc
+@property (nonatomic, copy) NSString *name;        // → let name: String
+@property (nonatomic, strong) NSArray *items;       // → let items: [Any] (refine type)
+@property (nonatomic, assign) BOOL isActive;        // → let isActive: Bool
+@property (nonatomic, assign) NSInteger count;      // → let count: Int
+@property (nonatomic, assign) CGFloat height;       // → let height: CGFloat
+@property (nonatomic, strong) NSDictionary *meta;   // → let meta: [String: Any]
+@property (nonatomic, strong) NSDate *createdAt;    // → let createdAt: Date
+@property (nonatomic, strong) NSURL *imageURL;      // → let imageURL: URL?
+@property (nonatomic, strong) NSData *data;         // → let data: Data
+@property (nullable, nonatomic, copy) NSString *bio; // → let bio: String?
+```
+
+### Method Signatures → Swift
+```objc
+- (void)fetchUserWithId:(NSString *)userId completion:(void (^)(UserModel *, NSError *))completion;
+// → func fetchUser(id: String) async throws -> User
+
++ (instancetype)sharedInstance;
+// → static let shared = ClassName()
+
+- (BOOL)validateEmail:(NSString *)email;
+// → func validateEmail(_ email: String) -> Bool
+```
 
-| Aspect | v1 (Old) | v2 (UI-First) |
-|--------|----------|---------------|
-| **Pipeline** | 6-step linear | 4-phase with feature loop |
-| **UI coded when** | Last (Step 4) | Early (Phase 2, before logic) |
-| **Resource extraction** | Last (Step 4.1) | Early (Phase 2.7, before UI code) |
-| **Visual parity check** | End only (Step 6) | Mid-pipeline (Phase 2.9) + Final |
-| **Gate between UI/Logic** | None | Mandatory — user approves UI first |
-| **Preview** | None | Full #Preview for all states |
-| **User feedback** | 1 time (end) | 2 times (UI gate + final check) |
-| **Rework risk** | High | Low (UI locked before logic) |
+### Delegate Patterns → Swift
+```objc
+@protocol UserServiceDelegate <NSObject>
+- (void)userServiceDidFetchUser:(UserModel *)user;
+- (void)userServiceDidFailWithError:(NSError *)error;
+@end
+```
+```swift
+// Replace with async/await:
+func fetchUser() async throws -> User
+// Or AsyncStream for multiple values:
+func userUpdates() -> AsyncStream<User>
+```
+
+### Blocks → Closures / async
+```objc
+typedef void (^CompletionHandler)(NSData * _Nullable data, NSError * _Nullable error);
+- (void)requestWithCompletion:(CompletionHandler)completion;
+```
+```swift
+// Modern Swift: drop the callback, use async
+func request() async throws -> Data
+```
 
 ---
 
@@ -202,12 +658,12 @@ Each phase has a detailed instruction file:
 ```yaml
 triggers_from:
   - "/reverse-ios" workflow command
-  - Keywords: "ipa", "class-dump", "objc to swift", "dịch ngược ios"
+  - Keywords: "ipa", "class-dump", "objc to swift", "dịch ngược ios", "reverse ios"
 
 delegates_to:
   - "/test" — after parity check
   - "/deploy" — when rebuild is complete
-  - beads-manager — auto-track progress per phase
+  - beads-manager — auto-track progress per step
 
 works_with:
   - memory-sync — saves decisions, patterns, solutions
@@ -219,58 +675,41 @@ independent_from:
   - smali-to-kotlin (sibling, same pattern, different platform)
 ```
 
-### Session State Tracking
-
-```yaml
-session_state:
-  current_phase: 0-4
-  current_feature: "Auth"
-  phase_2_status:
-    contracts: approved | pending
-    ui_shell: approved | pending
-    resources: extracted | pending
-  completed_features: ["Launch", "Login"]
-  pending_features: ["Home", "Settings"]
-```
-
 ---
 
 ## 🚫 ANTI-PATTERNS
 
 ```yaml
 never_do:
-  - Copy all resources blindly from IPA → only on-demand per screen
-  - Skip Phase 2 UI gate → jump to logic coding
-  - Code ViewModel before UI is approved → UI design might change
-  - Modify UI shell significantly in Phase 3 → only wire, don't redesign
+  - Copy all resources blindly from IPA → only on-demand
   - Use UIKit when SwiftUI equivalent exists → always prefer SwiftUI
-  - Use GCD for new code → use async/await
+  - Use GCD dispatch_async for new code → use async/await
+  - Use NSJSONSerialization → use Codable
   - Modify encryption output → must match original exactly
-  - Create massive ViewController God objects → split into Views + ViewModels
+  - Create massive ViewController God objects → split into SwiftUI Views + ViewModels
   - Skip framework scanner step → always detect reusable dependencies first
-  - Use ObjC in new code → Swift only (except bridging headers)
+  - Use ObjC in new code → Swift only (except bridging headers for C libs)
   - Force unwrap optionals → use guard let / if let / nil coalescing
 
 always_do:
-  - Run Framework Scanner (Phase 0) before any coding
-  - Extract resources BEFORE coding UI (2.7 → 2.8)
-  - Create #Preview for ALL states (normal, loading, error, empty)
-  - Get user approval on UI before coding logic
-  - Keep stateless View for Preview even after wiring
+  - Run Framework Scanner (Step 0) before any coding
+  - Present framework report to user for approval
   - Use Swift Concurrency (async/await) for all async operations
   - Use @Observable (iOS 17+) for ViewModels
-  - Use SPM for dependency management (not CocoaPods)
+  - Use NavigationStack for navigation
   - Unit test all encryption/hashing utils
+  - Follow Clean Architecture layer separation strictly
+  - Use SPM for dependency management (not CocoaPods)
 ```
 
 ---
 
 ## 📊 CHECKPOINT TEMPLATE
 
-After each phase/feature, output:
+After each step, output:
 
 ```markdown
-## ✅ [Phase/Feature] Complete: [Name]
+## ✅ Step [N] Complete: [Step Name]
 
 ### What was done:
 - [Summary]
@@ -284,7 +723,7 @@ After each phase/feature, output:
 ### Decisions made:
 - [Key decisions]
 
-### ⏭️ Next: [Phase/Feature] — [Name]
+### ⏭️ Next: Step [N+1] — [Step Name]
 - [What user needs to provide]
 ```
 
@@ -292,17 +731,19 @@ After each phase/feature, output:
 
 ## 🧩 PLATFORM RE TEMPLATE PATTERN
 
-This skill follows the same **4-phase pipeline** as `smali-to-kotlin`:
+This skill follows the same **6-step pipeline** as `smali-to-kotlin`:
 
-| Phase | Android (smali-to-kotlin) | iOS (smali-to-swift) |
-|-------|--------------------------|---------------------|
+| Step | Android (smali-to-kotlin) | iOS (smali-to-swift) |
+|------|--------------------------|---------------------|
 | 0 | Library Scanner (Smali packages) | Framework Scanner (Frameworks/ + headers) |
-| 1 | AndroidManifest → Architecture | Info.plist → Architecture |
-| 2 | Contracts + Compose UI Shell | Contracts + SwiftUI Shell |
-| 3 | Domain + Data + Wire Compose | Domain + Data + Wire SwiftUI |
-| 4 | Parity Check | Parity Check |
+| 1 | AndroidManifest.xml | Info.plist + Entitlements |
+| 2 | Retrofit + Room | URLSession + SwiftData |
+| 3 | Kotlin crypto utils | Swift CryptoKit/CommonCrypto |
+| 4 | Jetpack Compose + StateFlow | SwiftUI + @Observable |
+| 5 | Hilt + JNI | SPM + Bridging Header |
+| 6 | Parity Check | Parity Check |
 
 ---
 
-*smali-to-swift v2.0.0 — UI-First iOS Reverse Engineering Skill*
+*smali-to-swift v1.0.0 — iOS Reverse Engineering Skill for AWF*
 *Created by Antigravity Team*