@buivietphi/skill-mobile-mt 1.0.0

package/android/android-native.md

@@ -0,0 +1,208 @@
+# Android Native — Production Patterns
+
+> Battle-tested patterns for Android Kotlin development.
+> Multi-module Gradle, Hilt DI, Compose UI, offline-first.
+> Also reference for RN/Flutter Android-side issues.
+
+---
+
+## Clean Architecture (Multi-Module)
+
+```
+project/
+├── app/                          # Main application module
+│   ├── src/main/
+│   │   ├── java/com/company/app/
+│   │   │   ├── di/              # Hilt modules
+│   │   │   ├── presentation/
+│   │   │   │   ├── features/
+│   │   │   │   │   ├── auth/
+│   │   │   │   │   │   ├── ui/     # Composables
+│   │   │   │   │   │   └── viewmodel/
+│   │   │   │   │   └── home/
+│   │   │   │   ├── navigation/
+│   │   │   │   └── theme/
+│   │   │   └── domain/
+│   │   │       ├── model/        # Domain entities
+│   │   │       ├── usecase/      # Business rules
+│   │   │       └── repository/   # Repository interfaces
+│   │   ├── res/
+│   │   └── AndroidManifest.xml
+│   └── build.gradle.kts
+├── data/                         # Data layer module
+│   ├── src/main/java/
+│   │   ├── repository/           # Repository implementations
+│   │   ├── remote/               # API service, DTOs
+│   │   ├── local/                # Room DAOs, entities
+│   │   └── mapper/               # DTO ↔ Entity ↔ Domain mappers
+│   └── build.gradle.kts
+├── common/                       # Shared utilities module
+│   └── src/main/java/
+├── build.gradle.kts              # Root build file
+├── settings.gradle.kts           # Module declarations
+└── gradle/
+    └── libs.versions.toml        # Version catalog
+```
+
+### Dependency Rule
+```
+app (presentation) → domain/ ← data/
+
+Presentation depends on Domain. Data depends on Domain.
+Domain depends on NOTHING.
+app module has access to all modules.
+data module implements domain interfaces.
+```
+
+## Compose UI Pattern
+
+```kotlin
+@Composable
+fun ProductListScreen(
+    viewModel: ProductListViewModel = hiltViewModel(),
+    onProductClick: (String) -> Unit,
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    Scaffold(
+        topBar = { TopAppBar(title = { Text("Products") }) },
+    ) { padding ->
+        when (val state = uiState) {
+            is UiState.Loading -> Box(Modifier.fillMaxSize(), Alignment.Center) {
+                CircularProgressIndicator()
+            }
+            is UiState.Empty -> EmptyContent()
+            is UiState.Error -> ErrorContent(state.message, onRetry = viewModel::load)
+            is UiState.Success -> LazyColumn(
+                modifier = Modifier.padding(padding),
+                contentPadding = PaddingValues(16.dp),
+                verticalArrangement = Arrangement.spacedBy(8.dp),
+            ) {
+                items(state.data, key = { it.id }) { product ->
+                    ProductCard(product, onClick = { onProductClick(product.id) })
+                }
+            }
+        }
+    }
+}
+
+sealed interface UiState<out T> {
+    data object Loading : UiState<Nothing>
+    data object Empty : UiState<Nothing>
+    data class Success<T>(val data: T) : UiState<T>
+    data class Error(val message: String) : UiState<Nothing>
+}
+```
+
+## ViewModel (Hilt)
+
+```kotlin
+@HiltViewModel
+class ProductListViewModel @Inject constructor(
+    private val getProducts: GetProductsUseCase,
+) : ViewModel() {
+    private val _uiState = MutableStateFlow<UiState<List<Product>>>(UiState.Loading)
+    val uiState = _uiState.asStateFlow()
+
+    init { load() }
+
+    fun load() {
+        viewModelScope.launch {
+            _uiState.value = UiState.Loading
+            getProducts()
+                .catch { _uiState.value = UiState.Error(it.message ?: "Error") }
+                .collect { items ->
+                    _uiState.value = if (items.isEmpty()) UiState.Empty else UiState.Success(items)
+                }
+        }
+    }
+}
+```
+
+## DI (Hilt)
+
+```kotlin
+@Module @InstallIn(SingletonComponent::class)
+object NetworkModule {
+    @Provides @Singleton
+    fun provideRetrofit(): Retrofit = Retrofit.Builder()
+        .baseUrl(BuildConfig.API_BASE_URL)
+        .addConverterFactory(Json.asConverterFactory("application/json".toMediaType()))
+        .build()
+}
+
+@Module @InstallIn(SingletonComponent::class)
+abstract class RepositoryModule {
+    @Binds @Singleton
+    abstract fun bindProductRepo(impl: ProductRepositoryImpl): ProductRepository
+}
+```
+
+## Data Layer (Retrofit + Room — Offline-First)
+
+```kotlin
+// data/remote/ProductApi.kt
+interface ProductApi {
+    @GET("products") suspend fun getProducts(): ApiResponse<List<ProductDto>>
+}
+
+// data/local/ProductDao.kt
+@Dao interface ProductDao {
+    @Query("SELECT * FROM products") fun getAll(): Flow<List<ProductEntity>>
+    @Upsert suspend fun upsertAll(items: List<ProductEntity>)
+}
+
+// data/repository/ProductRepositoryImpl.kt
+class ProductRepositoryImpl @Inject constructor(
+    private val api: ProductApi, private val dao: ProductDao,
+) : ProductRepository {
+    override fun getProducts(): Flow<List<Product>> = flow {
+        val cached = dao.getAll().first()
+        if (cached.isNotEmpty()) emit(cached.map { it.toDomain() })
+        try {
+            val fresh = api.getProducts()
+            dao.upsertAll(fresh.data.map { it.toEntity() })
+        } catch (e: Exception) { if (cached.isEmpty()) throw e }
+        emitAll(dao.getAll().map { it.map { e -> e.toDomain() } })
+    }
+}
+```
+
+## Secure Storage
+
+```kotlin
+val prefs = EncryptedSharedPreferences.create(
+    context, "secure_prefs",
+    MasterKey.Builder(context).setKeyScheme(MasterKey.KeyScheme.AES256_GCM).build(),
+    EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+    EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM,
+)
+```
+
+## Multi-Module Gradle Setup
+
+```kotlin
+// settings.gradle.kts
+include(":app", ":data", ":common")
+
+// app/build.gradle.kts
+dependencies {
+    implementation(project(":data"))
+    implementation(project(":common"))
+}
+```
+
+## Common Pitfalls
+
+| Pitfall | Fix |
+|---------|-----|
+| `!!` assertion | `?.` / `?:` / `requireNotNull` |
+| `collectAsState` | `collectAsStateWithLifecycle()` |
+| Context leak | `@ApplicationContext`, never Activity |
+| Missing ProGuard | Test release builds |
+| Main thread blocking | `Dispatchers.IO` |
+
+---
+
+> Multi-module Gradle + Hilt + Compose + offline-first.
+> Clean Architecture with domain module having zero dependencies.

package/bin/install.mjs

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+
+/**
+ * @buivietphi/skill-mobile installer
+ *
+ * Installs skill-mobile-mt/ folder with subfolders for each platform.
+ *
+ * Usage:
+ *   npx @buivietphi/skill-mobile              # Interactive
+ *   npx @buivietphi/skill-mobile --all        # All detected agents
+ *   npx @buivietphi/skill-mobile --claude     # Claude Code only
+ *   npx @buivietphi/skill-mobile --gemini     # Gemini CLI
+ *   npx @buivietphi/skill-mobile --kimi       # Kimi
+ *   npx @buivietphi/skill-mobile --antigravity # Antigravity
+ *   npx @buivietphi/skill-mobile --auto       # Auto-detect (postinstall)
+ *   npx @buivietphi/skill-mobile --path DIR   # Custom path
+ */
+
+import { existsSync, mkdirSync, cpSync, readFileSync } from 'node:fs';
+import { join, resolve, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { createInterface } from 'node:readline';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = resolve(__dirname, '..');
+const SKILL_NAME = 'skill-mobile-mt';
+const HOME = homedir();
+
+// Structure: root files + subfolders
+const ROOT_FILES = ['SKILL.md', 'AGENTS.md'];
+
+const SUBFOLDERS = {
+  'react-native': ['react-native.md'],
+  'flutter':      ['flutter.md'],
+  'ios':          ['ios-native.md'],
+  'android':      ['android-native.md'],
+  'shared':       ['code-review.md', 'bug-detection.md', 'prompt-engineering.md', 'release-checklist.md', 'common-pitfalls.md', 'error-recovery.md', 'document-analysis.md', 'anti-patterns.md', 'performance-prediction.md', 'platform-excellence.md', 'version-management.md', 'observability.md', 'claude-md-template.md', 'agent-rules-template.md'],
+};
+
+const AGENTS = {
+  claude:       { name: 'Claude Code',     dir: join(HOME, '.claude', 'skills'),   detect: () => existsSync(join(HOME, '.claude')) },
+  codex:        { name: 'Codex',           dir: join(HOME, '.codex', 'skills'),    detect: () => existsSync(join(HOME, '.codex')) },
+  gemini:       { name: 'Gemini CLI',      dir: join(HOME, '.gemini', 'skills'),   detect: () => existsSync(join(HOME, '.gemini')) },
+  kimi:         { name: 'Kimi',            dir: join(HOME, '.kimi', 'skills'),     detect: () => existsSync(join(HOME, '.kimi')) },
+  antigravity:  { name: 'Antigravity',     dir: join(HOME, '.agents', 'skills'),   detect: () => existsSync(join(HOME, '.agents')) },
+  cursor:       { name: 'Cursor',          dir: join(HOME, '.cursor', 'skills'),   detect: () => existsSync(join(HOME, '.cursor')) },
+  windsurf:     { name: 'Windsurf',        dir: join(HOME, '.windsurf', 'skills'), detect: () => existsSync(join(HOME, '.windsurf')) },
+  copilot:      { name: 'Copilot',         dir: join(HOME, '.copilot', 'skills'),  detect: () => existsSync(join(HOME, '.copilot')) },
+};
+
+const c = { reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m', green: '\x1b[32m', yellow: '\x1b[33m', blue: '\x1b[34m', magenta: '\x1b[35m', cyan: '\x1b[36m', red: '\x1b[31m' };
+const log = m => console.log(m);
+const ok = m => log(`  ${c.green}✓${c.reset} ${m}`);
+const info = m => log(`  ${c.blue}ℹ${c.reset} ${m}`);
+const fail = m => log(`  ${c.red}✗${c.reset} ${m}`);
+
+function banner() {
+  log(`\n${c.bold}${c.cyan}  ┌──────────────────────────────────────────────┐`);
+  log(`  │  📱 @buivietphi/skill-mobile-mt v1.0.0       │`);
+  log(`  │  Master Senior Mobile Engineer                │`);
+  log(`  │                                              │`);
+  log(`  │  Claude · Codex · Gemini · Kimi              │`);
+  log(`  │  Antigravity · Cursor · Windsurf · Copilot  │`);
+  log(`  │  React Native · Flutter · iOS · Android      │`);
+  log(`  └──────────────────────────────────────────────┘${c.reset}\n`);
+}
+
+function tokenCount(filePath) {
+  if (!existsSync(filePath)) return 0;
+  return Math.ceil(readFileSync(filePath, 'utf-8').length / 3.5);
+}
+
+function showContext() {
+  log(`${c.bold}  📊 Context:${c.reset}`);
+  let total = 0;
+
+  // Root files
+  for (const f of ROOT_FILES) {
+    const t = tokenCount(join(PKG_ROOT, f));
+    total += t;
+    log(`  ${c.dim}  ${f.padEnd(30)} ~${t.toLocaleString()} tokens${c.reset}`);
+  }
+
+  // Subfolders
+  for (const [folder, files] of Object.entries(SUBFOLDERS)) {
+    let folderTotal = 0;
+    for (const f of files) {
+      folderTotal += tokenCount(join(PKG_ROOT, folder, f));
+    }
+    total += folderTotal;
+    log(`  ${c.dim}  ${(folder + '/').padEnd(30)} ~${folderTotal.toLocaleString()} tokens${c.reset}`);
+  }
+
+  log(`${c.dim}  ─────────────────────────────────────────${c.reset}`);
+  log(`  ${c.bold}  All loaded:${c.reset}                    ~${total.toLocaleString()} tokens`);
+  log(`  ${c.green}  Smart load (1 platform):${c.reset}       ~${Math.ceil(total * 0.55).toLocaleString()} tokens\n`);
+}
+
+function install(baseDir, agentName) {
+  const dst = join(baseDir, SKILL_NAME);
+  mkdirSync(dst, { recursive: true });
+  let n = 0;
+
+  // Copy root files
+  for (const f of ROOT_FILES) {
+    const src = join(PKG_ROOT, f);
+    if (!existsSync(src)) continue;
+    cpSync(src, join(dst, f), { force: true });
+    n++;
+  }
+
+  // Copy subfolders
+  for (const [folder, files] of Object.entries(SUBFOLDERS)) {
+    const dstFolder = join(dst, folder);
+    mkdirSync(dstFolder, { recursive: true });
+    for (const f of files) {
+      const src = join(PKG_ROOT, folder, f);
+      if (!existsSync(src)) continue;
+      cpSync(src, join(dstFolder, f), { force: true });
+      n++;
+    }
+  }
+
+  ok(`${c.bold}${SKILL_NAME}/${c.reset} → ${agentName} ${c.dim}(${dst})${c.reset}`);
+  return n;
+}
+
+async function ask(q) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(r => { rl.question(q, a => { rl.close(); r(a.trim()); }); });
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const flags = new Set(args.map(a => a.replace(/^--?/, '')));
+
+  banner();
+  showContext();
+
+  let targets = [];
+
+  if (flags.has('all')) targets = Object.keys(AGENTS);
+  else if (flags.has('auto')) {
+    targets = Object.keys(AGENTS).filter(k => AGENTS[k].detect());
+    if (!targets.length) { info('No agents found. Using Claude.'); targets = ['claude']; }
+  } else if (flags.has('path')) {
+    const p = args[args.indexOf('--path') + 1];
+    if (!p) { fail('--path needs dir'); process.exit(1); }
+    install(resolve(p), 'Custom');
+    log(`\n${c.green}${c.bold}  ✅ Done!${c.reset}\n`); return;
+  } else {
+    for (const k of Object.keys(AGENTS)) if (flags.has(k)) targets.push(k);
+  }
+
+  if (!targets.length) {
+    const det = Object.keys(AGENTS).filter(k => AGENTS[k].detect());
+    log(`${c.bold}  Detected agents:${c.reset}`);
+    det.forEach(k => log(`    ${c.green}●${c.reset} ${AGENTS[k].name}`));
+    Object.keys(AGENTS).filter(k => !det.includes(k)).forEach(k => log(`    ${c.dim}○ ${AGENTS[k].name}${c.reset}`));
+    log('');
+    const a = await ask('  Install to detected agents? [Y/n] ');
+    if (a.toLowerCase() === 'n') { info('Cancelled.'); return; }
+    targets = det.length ? det : ['claude'];
+  }
+
+  log(`\n${c.bold}  Installing...${c.reset}\n`);
+  for (const k of targets) install(AGENTS[k].dir, AGENTS[k].name);
+
+  log(`\n${c.green}${c.bold}  ✅ Done!${c.reset} → ${targets.length} agent(s)\n`);
+  log(`  ${c.bold}Usage:${c.reset}`);
+  log(`    ${c.cyan}@skill-mobile-mt${c.reset}         Pre-built patterns (18 production apps)`);
+  log(`    ${c.cyan}@skill-mobile-mt project${c.reset} Read current project, adapt to it\n`);
+  log(`  ${c.bold}Installed structure:${c.reset}`);
+  log(`    ${SKILL_NAME}/`);
+  log(`    ├── SKILL.md                    Entry point + auto-detect`);
+  log(`    ├── AGENTS.md                   Multi-agent config`);
+  log(`    ├── react-native/`);
+  log(`    │   └── react-native.md         React Native patterns`);
+  log(`    ├── flutter/`);
+  log(`    │   └── flutter.md              Flutter patterns`);
+  log(`    ├── ios/`);
+  log(`    │   └── ios-native.md           iOS Swift patterns`);
+  log(`    ├── android/`);
+  log(`    │   └── android-native.md       Android Kotlin patterns`);
+  log(`    └── shared/`);
+  log(`        ├── code-review.md          Review checklist`);
+  log(`        ├── bug-detection.md        Bug scanner`);
+  log(`        ├── prompt-engineering.md   Auto-think`);
+  log(`        ├── anti-patterns.md        PII/cardinality detection`);
+  log(`        ├── performance-prediction.md  Frame budget calculator`);
+  log(`        ├── platform-excellence.md  iOS 18+ vs Android 15+`);
+  log(`        ├── version-management.md   SDK compatibility matrix`);
+  log(`        ├── observability.md        Sessions as 4th pillar`);
+  log(`        ├── claude-md-template.md   CLAUDE.md template for Claude Code`);
+  log(`        └── agent-rules-template.md Rules template for ALL agents\n`);
+}
+
+main().catch(e => { fail(e.message); process.exit(1); });

package/flutter/flutter.md

@@ -0,0 +1,246 @@
+# Flutter — Production Patterns
+
+> Battle-tested patterns from production Flutter apps.
+> State: Riverpod (standard)
+> DI: get_it + injectable
+> Networking: Dio + Retrofit, or http
+> Navigation: GoRouter
+
+---
+
+## Clean Architecture
+
+```
+lib/
+├── main.dart                     # Entry: Firebase init, Hive init, ProviderScope
+├── app/
+│   ├── app.dart                  # MaterialApp.router
+│   ├── router.dart               # GoRouter config
+│   └── theme/
+├── features/
+│   ├── auth/
+│   │   ├── domain/               # Entities + use cases + repository interfaces
+│   │   ├── data/                 # Repository impl, API client, DTOs, mappers
+│   │   ├── presentation/         # Screens + widgets
+│   │   └── providers/            # Riverpod providers
+│   └── [feature]/
+│       └── ... (same structure)
+├── shared/
+│   ├── widgets/                  # Reusable UI
+│   ├── extensions/
+│   └── utils/
+└── core/
+    ├── network/                  # Dio client setup, interceptors
+    ├── storage/                  # Hive + SharedPrefs + flutter_secure_storage
+    ├── di/                       # get_it + injectable setup
+    └── constants/
+```
+
+### Dependency Rule
+```
+presentation/ → domain/ ← data/
+
+Presentation depends on Domain. Data depends on Domain.
+Domain depends on NOTHING.
+Never import data/ from presentation/ directly.
+Use cases call repository interfaces (defined in domain/).
+Data layer provides implementations.
+```
+
+## State Management (Riverpod)
+
+```dart
+// domain/usecases/get_products.dart
+class GetProducts {
+  final ProductRepository repository;
+  GetProducts(this.repository);
+  Future<List<Product>> call() => repository.getProducts();
+}
+
+// features/product/providers/product_providers.dart
+@riverpod
+class ProductList extends _$ProductList {
+  @override
+  FutureOr<List<Product>> build() async {
+    final repo = ref.read(productRepositoryProvider);
+    return repo.getProducts();
+  }
+
+  Future<void> refresh() async {
+    state = const AsyncLoading();
+    state = await AsyncValue.guard(() async {
+      final repo = ref.read(productRepositoryProvider);
+      return repo.getProducts();
+    });
+  }
+}
+
+// features/product/presentation/product_screen.dart
+class ProductScreen extends ConsumerWidget {
+  const ProductScreen({super.key});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final products = ref.watch(productListProvider);
+    return products.when(
+      data: (list) => list.isEmpty
+          ? const EmptyState()
+          : ListView.builder(
+              itemCount: list.length,
+              itemBuilder: (_, i) => ProductCard(product: list[i]),
+            ),
+      loading: () => const Center(child: CircularProgressIndicator()),
+      error: (e, _) => ErrorState(onRetry: () => ref.invalidate(productListProvider)),
+    );
+  }
+}
+```
+
+## Dependency Injection (get_it + injectable)
+
+```dart
+// core/di/injection.dart
+import 'package:get_it/get_it.dart';
+import 'package:injectable/injectable.dart';
+
+final getIt = GetIt.instance;
+
+@InjectableInit()
+void configureDependencies() => getIt.init();
+
+// Usage: annotate classes
+@injectable
+class AuthRepository {
+  final ApiClient _client;
+  AuthRepository(this._client);
+}
+```
+
+## Navigation (GoRouter)
+
+```dart
+final router = GoRouter(
+  redirect: (context, state) {
+    final isAuth = authNotifier.isAuthenticated;
+    final isAuthRoute = state.matchedLocation.startsWith('/auth');
+    if (!isAuth && !isAuthRoute) return '/auth/login';
+    if (isAuth && isAuthRoute) return '/';
+    return null;
+  },
+  routes: [
+    ShellRoute(
+      builder: (_, __, child) => MainScaffold(child: child),
+      routes: [
+        GoRoute(path: '/', builder: (_, __) => const HomeScreen()),
+        GoRoute(path: '/profile', builder: (_, __) => const ProfileScreen()),
+      ],
+    ),
+    GoRoute(path: '/auth/login', builder: (_, __) => const LoginScreen()),
+  ],
+);
+```
+
+## Networking
+
+### Dio + Retrofit
+
+```dart
+@RestApi(baseUrl: ApiConstants.baseUrl)
+abstract class ApiClient {
+  factory ApiClient(Dio dio) = _ApiClient;
+
+  @GET('/products')
+  Future<ApiResponse<List<ProductDto>>> getProducts();
+
+  @POST('/auth/login')
+  Future<ApiResponse<AuthDto>> login(@Body() LoginInput input);
+}
+
+// Dio setup with interceptors
+final dio = Dio(BaseOptions(
+  baseUrl: ApiConstants.baseUrl,
+  connectTimeout: const Duration(seconds: 15),
+))
+  ..interceptors.addAll([
+    AuthInterceptor(secureStorage),
+    PrettyDioLogger(requestBody: true, responseBody: true),
+    RetryInterceptor(dio: dio, retries: 2),
+  ]);
+```
+
+### HTTP (simpler pattern)
+
+```dart
+final response = await http.get(
+  Uri.parse('$baseUrl/endpoint'),
+  headers: {'Authorization': 'Bearer $token'},
+);
+```
+
+## Local Storage
+
+```dart
+// Hive (structured data)
+await Hive.initFlutter();
+Hive.registerAdapter(UserAdapter());
+final box = await Hive.openBox<User>('users');
+
+// Floor (Room-like SQL)
+@dao
+abstract class ProductDao {
+  @Query('SELECT * FROM products')
+  Future<List<ProductEntity>> getAll();
+
+  @Insert(onConflict: OnConflictStrategy.replace)
+  Future<void> insertAll(List<ProductEntity> products);
+}
+
+// SharedPreferences (simple key-value)
+final prefs = await SharedPreferences.getInstance();
+
+// flutter_secure_storage (tokens)
+final storage = const FlutterSecureStorage();
+await storage.write(key: 'token', value: token);
+```
+
+## Firebase
+
+```dart
+// Firebase init in main.dart
+await Firebase.initializeApp();
+await FirebaseMessaging.instance.requestPermission();
+
+// Firestore
+final doc = await FirebaseFirestore.instance.collection('users').doc(uid).get();
+
+// FCM push
+FirebaseMessaging.onMessage.listen((message) {
+  // Handle foreground notification
+});
+```
+
+## Key Libraries
+
+| Purpose | Library |
+|---------|---------|
+| State | flutter_riverpod |
+| DI | get_it + injectable |
+| HTTP | dio + retrofit |
+| HTTP | http |
+| DB | floor |
+| DB | hive |
+| Router | go_router |
+| UI | flutter_screenutil |
+| Anim | flutter_animate |
+| Auth | local_auth (biometric) |
+| Crypto | encrypt, crypto |
+| Forms | formz |
+| Func | dartz (Either, Option) |
+| Models | freezed_annotation |
+| Firebase | firebase_core, messaging, firestore |
+| Image | cached_network_image |
+
+---
+
+> Standard: Riverpod + get_it/injectable + Clean Architecture.
+> Dio/Retrofit for complex APIs. Floor for offline-first. Firebase for push/analytics.