@bdayadev/flutter-ultra-mcp 1.12.0 → 1.14.0

package/skills/apply-architecture-best-practices/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: apply-architecture-best-practices
 description: Architects a Flutter application using the recommended layered approach (UI, Logic, Data). Use when structuring a new project or refactoring for scalability.
+  last_modified: Tue, 21 Apr 2026 20:11:20 GMT
 ---
 
 # Architecting Flutter Applications
@@ -14,28 +15,30 @@ description: Architects a Flutter application using the recommended layered appr
 
 ## Architectural Layers
 
-Enforce strict Separation of Concerns by dividing the application into distinct layers.
+Enforce strict Separation of Concerns by dividing the application into distinct layers. Never mix UI rendering with business logic or data fetching.
 
 ### UI Layer (Presentation)
 
-Implement the MVVM (Model-View-ViewModel) pattern.
+Implement the MVVM (Model-View-ViewModel) pattern to manage UI state and logic.
 
-- **Views:** Reusable, lean widgets. Restrict logic to UI-specific operations.
-- **ViewModels:** Manage UI state. Extend `ChangeNotifier`. Expose immutable state snapshots. Inject Repositories via constructor.
+- **Views:** Write reusable, lean widgets. Restrict logic in Views to UI-specific operations (e.g., animations, layout constraints, simple routing). Pass all required data from the ViewModel.
+- **ViewModels:** Manage UI state and handle user interactions. Extend `ChangeNotifier` (or use `Listenable`) to expose state. Expose immutable state snapshots to the View. Inject Repositories into ViewModels via the constructor.
 
 ### Data Layer
 
-Implement the Repository pattern for a single source of truth.
+Implement the Repository pattern to isolate data access logic and create a single source of truth.
 
-- **Services:** Stateless classes wrapping external APIs. Return raw API models or `Result` wrappers.
-- **Repositories:** Consume Services. Transform raw models into Domain Models. Handle caching and retry logic.
+- **Services:** Create stateless classes to wrap external APIs (HTTP clients, local databases, platform plugins). Return raw API models or `Result` wrappers.
+- **Repositories:** Consume one or more Services. Transform raw API models into clean Domain Models. Handle caching, offline synchronization, and retry logic. Expose Domain Models to ViewModels.
 
 ### Logic Layer (Domain - Optional)
 
-- **Use Cases:** Only if complex business logic clutters the ViewModel, or logic must be reused across ViewModels.
+- **Use Cases:** Implement this layer only if the application contains complex business logic that clutters the ViewModel, or if logic must be reused across multiple ViewModels. Extract this logic into dedicated Use Case (interactor) classes that sit between ViewModels and Repositories.
 
 ## Project Structure
 
+Organize the codebase using a hybrid approach: group UI components by feature, and group Data/Domain components by type.
+
 ```text
 lib/
 ├── data/
@@ -55,37 +58,46 @@ lib/
 
 ## Workflow: Implementing a New Feature
 
+Follow this sequential workflow when adding a new feature to the application. Copy the checklist to track progress.
+
 ### Task Progress
 
-- [ ] **Step 1:** Define Domain Models (immutable data classes).
-- [ ] **Step 2:** Implement Services (external API communication).
-- [ ] **Step 3:** Implement Repositories (consume Services, return Domain Models).
-- [ ] **Step 4:** Apply Conditional Logic:
-  - Complex data transformation or cross-repository logic: Create a Use Case.
-  - Simple CRUD: Skip to Step 5.
-- [ ] **Step 5:** Implement the ViewModel (extend `ChangeNotifier`, inject Repositories).
-- [ ] **Step 6:** Implement the View (use `ListenableBuilder` to listen to ViewModel).
-- [ ] **Step 7:** Inject Dependencies (register in DI container).
-- [ ] **Step 8:** Run tests. Feedback Loop: Run -> Review -> Fix -> Re-run.
+- [ ] **Step 1: Define Domain Models.** Create immutable data classes for the feature using `freezed` or `built_value`.
+- [ ] **Step 2: Implement Services.** Create or update Service classes to handle external API communication.
+- [ ] **Step 3: Implement Repositories.** Create the Repository to consume Services and return Domain Models.
+- [ ] **Step 4: Apply Conditional Logic (Domain Layer).**
+  - _If the feature requires complex data transformation or cross-repository logic:_ Create a Use Case class.
+  - _If the feature is a simple CRUD operation:_ Skip to Step 5.
+- [ ] **Step 5: Implement the ViewModel.** Create the ViewModel extending `ChangeNotifier`. Inject required Repositories/Use Cases. Expose immutable state and command methods.
+- [ ] **Step 6: Implement the View.** Create the UI widget. Use `ListenableBuilder` or `AnimatedBuilder` to listen to ViewModel changes.
+- [ ] **Step 7: Inject Dependencies.** Register the new Service, Repository, and ViewModel in the dependency injection container (e.g., `provider` or `get_it`).
+- [ ] **Step 8: Run Validator.** Execute unit tests for the ViewModel and Repository.
+  - _Feedback Loop:_ Run tests -> Review failures -> Fix logic -> Re-run until passing.
 
 ## Examples
 
 ### Data Layer: Service and Repository
 
 ```dart
+// 1. Service (Raw API interaction)
 class ApiClient {
-  Future<UserApiModel> fetchUser(String id) async { /* ... */ }
+  Future<UserApiModel> fetchUser(String id) async {
+    // HTTP GET implementation...
+  }
 }
 
+// 2. Repository (Single source of truth, returns Domain Model)
 class UserRepository {
   UserRepository({required ApiClient apiClient}) : _apiClient = apiClient;
+
   final ApiClient _apiClient;
   User? _cachedUser;
 
   Future<User> getUser(String id) async {
     if (_cachedUser != null) return _cachedUser!;
+
     final apiModel = await _apiClient.fetchUser(id);
-    _cachedUser = User(id: apiModel.id, name: apiModel.fullName);
+    _cachedUser = User(id: apiModel.id, name: apiModel.fullName); // Transform to Domain Model
     return _cachedUser!;
   }
 }
@@ -94,19 +106,23 @@ class UserRepository {
 ### UI Layer: ViewModel and View
 
 ```dart
+// 3. ViewModel (State management and presentation logic)
 class ProfileViewModel extends ChangeNotifier {
   ProfileViewModel({required UserRepository userRepository})
       : _userRepository = userRepository;
+
   final UserRepository _userRepository;
 
   User? _user;
   User? get user => _user;
+
   bool _isLoading = false;
   bool get isLoading => _isLoading;
 
   Future<void> loadProfile(String id) async {
     _isLoading = true;
     notifyListeners();
+
     try {
       _user = await _userRepository.getUser(id);
     } finally {
@@ -116,8 +132,10 @@ class ProfileViewModel extends ChangeNotifier {
   }
 }
 
+// 4. View (Dumb UI component)
 class ProfileView extends StatelessWidget {
   const ProfileView({super.key, required this.viewModel});
+
   final ProfileViewModel viewModel;
 
   @override
@@ -125,16 +143,24 @@ class ProfileView extends StatelessWidget {
     return ListenableBuilder(
       listenable: viewModel,
       builder: (context, _) {
-        if (viewModel.isLoading) return const Center(child: CircularProgressIndicator());
+        if (viewModel.isLoading) {
+          return const Center(child: CircularProgressIndicator());
+        }
+
         final user = viewModel.user;
-        if (user == null) return const Center(child: Text('User not found'));
-        return Column(children: [
-          Text(user.name),
-          ElevatedButton(
-            onPressed: () => viewModel.loadProfile(user.id),
-            child: const Text('Refresh'),
-          ),
-        ]);
+        if (user == null) {
+          return const Center(child: Text('User not found'));
+        }
+
+        return Column(
+          children: [
+            Text(user.name),
+            ElevatedButton(
+              onPressed: () => viewModel.loadProfile(user.id),
+              child: const Text('Refresh'),
+            ),
+          ],
+        );
       },
     );
   }

package/skills/build-cli-app/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: build-cli-app
 description: Entrypoint structure, exit codes, cross-platform scripts. Use when building command line utilities, scripts, or applications.
+  last_modified: Fri, 04 May 2026 17:41:00 GMT
 ---
 
 # Building Dart CLI Applications
@@ -32,7 +33,7 @@ Import the `args` package to manage command-line arguments, flags, and subcomman
 - If building a complex, multi-command CLI (like `git`): Implement `CommandRunner` and extend `Command` for each subcommand.
 - Define global arguments on the `CommandRunner.argParser` and command-specific arguments on the individual `Command.argParser`.
 - Catch `UsageException` to gracefully handle invalid arguments and display the automatically generated help text.
-- **Validate Help Text Accuracy**: Ensure the help text provides all necessary information to run the tool.
+- **Validate Help Text Accuracy**: Ensure the help text provides all necessary information to run the tool. If the help text references a compiled executable name, and the user needs to add it to their PATH to run it that way, provide clear instructions on how to do so in the help text or description.
 
 ## Execution & Error Handling
 
@@ -42,11 +43,14 @@ Leverage the `io` and `stack_trace` packages to build robust, production-ready C
 - Use `sharedStdIn` from the `io` package if multiple asynchronous listeners need sequential access to standard input.
 - Wrap the application execution in `Chain.capture()` from the `stack_trace` package to track asynchronous stack chains.
 - Format output stack traces using `Trace.terse` or `Chain.terse` to strip noisy core library frames and present readable errors to the user.
-- **Do not swallow exceptions** in lower-level logic unless recovery is possible. Let them bubble up.
-- **Fail fast and with non-zero exit codes**: Ensure operation failures result in descriptive error messages to `stderr` and appropriate non-zero exit codes.
+- **Do not swallow exceptions** in lower-level logic or storage classes unless recovery is possible. Let them bubble up or rethrow them so higher-level commands know operations failed.
+- **Fail fast and with non-zero exit codes**: Ensure operation failures result in descriptive error messages to `stderr` and appropriate non-zero exit codes (e.g., using `exit(1)` or triggering a 64 exit code after a caught `UsageException`).
 
 ## Testing CLI Applications
 
+> [!IMPORTANT]
+> **All new commands and significant features must be covered by automated tests.** Manual verification is not sufficient for testing logic. However, manual verification of help text and user experience (UX) is still required to ensure the interface is intuitive and correct.
+
 Use `test_process` and `test_descriptor` to write high-fidelity integration tests for your CLI.
 
 - Define expected filesystem states using `test_descriptor` (`d.dir`, `d.file`).
@@ -61,9 +65,25 @@ Use `test_process` and `test_descriptor` to write high-fidelity integration test
 Select the appropriate compilation target based on your distribution requirements.
 
 - **If testing locally during development:** Use `dart run bin/cli.dart`. This uses the JIT compiler for rapid iteration.
-- **If bundling code assets and dynamic libraries:** Use `dart build cli`.
-- **If distributing a standalone native executable:** Use `dart compile exe bin/cli.dart -o <output_path>`.
-- **If distributing multiple apps with strict disk space limits:** Use `dart compile aot-snapshot bin/cli.dart`.
+- **If bundling code assets and dynamic libraries:** Use `dart build cli`. This runs build hooks and outputs to `build/cli/_/bundle/`.
+- **If distributing a standalone native executable:** Use `dart compile exe bin/cli.dart -o <output_path>`. This bundles the Dart runtime and machine code into a single file.
+- **If distributing multiple apps with strict disk space limits:** Use `dart compile aot-snapshot bin/cli.dart`. Run the resulting `.aot` file using `dartaotruntime`.
+
+<details>
+<summary>Cross-Compilation Targets (Linux Only)</summary>
+
+Dart supports cross-compiling to Linux from macOS, Windows, or Linux hosts.
+Use the `--target-os` and `--target-arch` flags with `dart compile exe` or `dart compile aot-snapshot`.
+
+- `--target-os=linux` (Only Linux is currently supported as a cross-compilation target)
+- `--target-arch=arm64` (64-bit ARM)
+- `--target-arch=x64` (x86-64)
+- `--target-arch=arm` (32-bit ARM)
+- `--target-arch=riscv64` (64-bit RISC-V)
+
+Example: `dart compile exe --target-os=linux --target-arch=arm64 bin/cli.dart`
+
+</details>
 
 ## Workflows
 
@@ -74,9 +94,9 @@ Select the appropriate compilation target based on your distribution requirement
 - [ ] Register command-specific flags in the constructor using `argParser.addFlag()` or `argParser.addOption()`.
 - [ ] Implement the `run()` method with the core logic.
 - [ ] Register the new command in the `CommandRunner` instance in `bin/cli.dart` using `addCommand()`.
-- [ ] Create tests for the new command in the `test/` directory.
+- [ ] Create tests for the new command in the `test/` directory using `test_process` or standard tests.
 - [ ] Run validator -> Execute `dart run bin/cli.dart help <command_name>` to verify help text generation.
-- [ ] Verify final UX: Compile the application using `dart compile exe` and run the resulting executable.
+- [ ] Verify final UX: Compile the application using `dart compile exe` and run the resulting executable to verify the target user experience (e.g., `./bin/cli <command>`).
 
 ### Task Progress: Compile and Release Native Executable
 
@@ -84,6 +104,7 @@ Select the appropriate compilation target based on your distribution requirement
 - [ ] Run validator -> Execute `dart analyze` to ensure no static analysis errors.
 - [ ] Run validator -> Execute `dart test` to pass all integration tests.
 - [ ] Compile for host OS: `dart compile exe bin/cli.dart -o build/cli-host`
+- [ ] Compile for Linux (if host is macOS/Windows): `dart compile exe --target-os=linux --target-arch=x64 bin/cli.dart -o build/cli-linux-x64`
 
 ## Examples
 
@@ -121,7 +142,7 @@ void main(List<String> args) {
     if (error is UsageException) {
       stderr.writeln(error.message);
       stderr.writeln(error.usage);
-      exit(64);
+      exit(64); // ExitCode.usage.code
     } else {
       stderr.writeln('Fatal error: $error');
       stderr.writeln(chain.terse);
@@ -140,18 +161,24 @@ import 'package:test_descriptor/test_descriptor.dart' as d;
 
 void main() {
   test('CLI formats output correctly and modifies filesystem', () async {
+    // 1. Setup mock filesystem
     await d.dir('project', [
       d.file('config.json', '{"key": "value"}')
     ]).create();
 
+    // 2. Spawn the CLI process
     final process = await TestProcess.start(
       'dart',
       ['run', 'bin/cli.dart', 'process', '--path', '${d.sandbox}/project']
     );
 
+    // 3. Validate stdout stream
     await expectLater(process.stdout, emitsThrough('Processing complete.'));
+
+    // 4. Validate exit code
     await process.shouldExit(0);
 
+    // 5. Validate filesystem mutations
     await d.dir('project', [
       d.file('config.json', '{"key": "value"}'),
       d.file('output.log', 'Success')

package/skills/build-responsive-layout/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: build-responsive-layout
 description: Use `LayoutBuilder`, `MediaQuery`, or `Expanded/Flexible` to create a layout that adapts to different screen sizes. Use when you need the UI to look good on both mobile and tablet/desktop form factors.
+  last_modified: Tue, 21 Apr 2026 20:17:40 GMT
 ---
 
 # Implementing Adaptive Layouts
@@ -16,49 +17,64 @@ description: Use `LayoutBuilder`, `MediaQuery`, or `Expanded/Flexible` to create
 
 ## Space Measurement Guidelines
 
+Determine the available space accurately to ensure layouts adapt to the app window, not just the physical device.
+
 - **Use `MediaQuery.sizeOf(context)`** to get the size of the entire app window.
-- **Use `LayoutBuilder`** to make layout decisions based on the parent widget's allocated space.
-- **Do not use `MediaQuery.orientationOf` or `OrientationBuilder`** near the top of the widget tree. Device orientation does not accurately reflect available space.
-- **Do not check for hardware types** ("phone" vs. "tablet"). Base all decisions strictly on available window space.
+- **Use `LayoutBuilder`** to make layout decisions based on the parent widget's allocated space. Evaluate `constraints.maxWidth` to determine the appropriate widget tree to return.
+- **Do not use `MediaQuery.orientationOf` or `OrientationBuilder`** near the top of the widget tree to switch layouts. Device orientation does not accurately reflect the available app window space.
+- **Do not check for hardware types** (e.g., "phone" vs. "tablet"). Flutter apps run in resizable windows, multi-window modes, and picture-in-picture. Base all layout decisions strictly on available window space.
 
 ## Widget Sizing and Constraints
 
-- **`Expanded`**: Force a child to fill all remaining available space.
-- **`Flexible`**: Allow a child to size itself up to a limit while expanding/contracting. Use `flex` factor for sibling ratios.
-- **Constrain Width**: Wrap widgets in `ConstrainedBox` with `maxWidth` on large screens.
-- **Lazy Rendering**: Use `ListView.builder` or `GridView.builder` for long/unknown-length lists.
+Understand and apply Flutter's core layout rule: **Constraints go down. Sizes go up. Parent sets position.**
+
+- **Distribute Space:** Use `Expanded` and `Flexible` within `Row`, `Column`, or `Flex` widgets.
+  - Use `Expanded` to force a child to fill all remaining available space (equivalent to `Flexible` with `fit: FlexFit.tight` and a `flex` factor of 1.0).
+  - Use `Flexible` to allow a child to size itself up to a specific limit while still expanding/contracting. Use the `flex` factor to define the ratio of space consumption among siblings.
+- **Constrain Width:** Prevent widgets from consuming all horizontal space on large screens. Wrap widgets like `GridView` or `ListView` in a `ConstrainedBox` or `Container` and define a `maxWidth` in the `BoxConstraints`.
+- **Lazy Rendering:** Always use `ListView.builder` or `GridView.builder` when rendering lists with an unknown or large number of items.
 
 ## Device and Orientation Behaviors
 
-- **Do not lock screen orientation.** Causes severe layout issues on foldable devices.
-- **Support Multiple Inputs:** Implement support for mice, trackpads, and keyboard shortcuts.
+Ensure the app behaves correctly across all device form factors and input methods.
+
+- **Do not lock screen orientation.** Locking orientation causes severe layout issues on foldable devices, often resulting in letterboxing (the app centered with black borders). Android large format tiers require both portrait and landscape support.
+- **Fallback for Locked Orientation:** If business requirements strictly mandate a locked orientation, use the `Display API` to retrieve physical screen dimensions instead of `MediaQuery`. `MediaQuery` fails to receive the larger window size in compatibility modes.
+- **Support Multiple Inputs:** Implement support for basic mice, trackpads, and keyboard shortcuts. Ensure touch targets are appropriately sized and keyboard navigation is accessible.
 
 ## Workflow: Constructing an Adaptive Layout
 
+Follow this workflow to implement a layout that adapts to the available `BoxConstraints`.
+
 **Task Progress:**
 
-- [ ] Identify the target widget.
-- [ ] Wrap in a `LayoutBuilder`.
-- [ ] Extract `constraints.maxWidth`.
-- [ ] Define breakpoint (e.g., `600`).
-- [ ] If `maxWidth > breakpoint`: Return large-screen layout (e.g., `Row` with sidebar).
-- [ ] If `maxWidth <= breakpoint`: Return small-screen layout.
-- [ ] Resize the app window -> review transitions -> fix overflow errors.
+- [ ] Identify the target widget that requires adaptive behavior.
+- [ ] Wrap the widget tree in a `LayoutBuilder`.
+- [ ] Extract the `constraints.maxWidth` from the builder callback.
+- [ ] Define an adaptive breakpoint (e.g., `largeScreenMinWidth = 600`).
+- [ ] **If `maxWidth > largeScreenMinWidth`:** Return a large-screen layout (e.g., a `Row` placing a navigation sidebar and content area side-by-side).
+- [ ] **If `maxWidth <= largeScreenMinWidth`:** Return a small-screen layout (e.g., a `Column` or standard navigation-style approach).
+- [ ] Run validator -> resize the application window -> review layout transitions -> fix overflow errors.
 
 ## Workflow: Optimizing for Large Screens
 
+Follow this workflow to prevent UI elements from stretching unnaturally on large displays.
+
 **Task Progress:**
 
-- [ ] Identify full-width components.
-- [ ] **Lists**: Convert `ListView.builder` to `GridView.builder` with `SliverGridDelegateWithMaxCrossAxisExtent`.
-- [ ] **Forms/text**: Wrap in `ConstrainedBox` with `BoxConstraints(maxWidth: ...)`.
-- [ ] Wrap in `Center` to keep constrained content centered.
-- [ ] Test on desktop/tablet -> review horizontal stretching.
+- [ ] Identify full-width components (e.g., `ListView`, text blocks, forms).
+- [ ] **If optimizing a list:** Convert `ListView.builder` to `GridView.builder` using `SliverGridDelegateWithMaxCrossAxisExtent` to automatically adjust column counts based on window size.
+- [ ] **If optimizing a form or text block:** Wrap the component in a `ConstrainedBox`.
+- [ ] Apply `BoxConstraints(maxWidth: [optimal_width])` to the `ConstrainedBox`.
+- [ ] Wrap the `ConstrainedBox` in a `Center` widget to keep the constrained content centered on large screens.
+- [ ] Run validator -> test on desktop/tablet target -> review horizontal stretching -> adjust `maxWidth` or grid extents.
 
 ## Examples
 
 ### Adaptive Layout using LayoutBuilder
 
+Demonstrates switching between a mobile and desktop layout based on available width.
+
 ```dart
 import 'package:flutter/material.dart';
 
@@ -72,25 +88,37 @@ class AdaptiveLayout extends StatelessWidget {
     return LayoutBuilder(
       builder: (context, constraints) {
         if (constraints.maxWidth > largeScreenMinWidth) {
-          return Row(
-            children: [
-              const SizedBox(width: 250, child: Placeholder(color: Colors.blue)),
-              const VerticalDivider(width: 1),
-              Expanded(child: const Placeholder(color: Colors.green)),
-            ],
-          );
+          return _buildLargeScreenLayout();
         } else {
-          return const Placeholder(color: Colors.green);
+          return _buildSmallScreenLayout();
         }
       },
     );
   }
+
+  Widget _buildLargeScreenLayout() {
+    return Row(
+      children: [
+        const SizedBox(width: 250, child: Placeholder(color: Colors.blue)),
+        const VerticalDivider(width: 1),
+        Expanded(child: const Placeholder(color: Colors.green)),
+      ],
+    );
+  }
+
+  Widget _buildSmallScreenLayout() {
+    return const Placeholder(color: Colors.green);
+  }
 }
 ```
 
 ### Constraining Width on Large Screens
 
+Demonstrates preventing a widget from consuming all horizontal space.
+
 ```dart
+import 'package:flutter/material.dart';
+
 class ConstrainedContent extends StatelessWidget {
   const ConstrainedContent({super.key});
 
@@ -99,10 +127,16 @@ class ConstrainedContent extends StatelessWidget {
     return Scaffold(
       body: Center(
         child: ConstrainedBox(
-          constraints: const BoxConstraints(maxWidth: 800.0),
+          constraints: const BoxConstraints(
+            maxWidth: 800.0, // Maximum width for readability
+          ),
           child: ListView.builder(
             itemCount: 50,
-            itemBuilder: (context, index) => ListTile(title: Text('Item $index')),
+            itemBuilder: (context, index) {
+              return ListTile(
+                title: Text('Item $index'),
+              );
+            },
           ),
         ),
       ),

package/skills/collect-coverage/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: collect-coverage
-description: Collect coverage using the coverage package and create an LCOV report
+description: Collect coverage using the coverage packge and create an LCOV report
+  last_modified: Fri, 24 Apr 2026 15:14:32 GMT
 ---
 
 # Implementing Dart and Flutter Test Coverage
@@ -63,8 +64,12 @@ Use the bundled `test_with_coverage` script. This script automatically runs all
 dart run coverage:test_with_coverage
 ```
 
+_Note: If working within a Dart workspace (monorepo), specify the test directories explicitly (e.g., `dart run coverage:test_with_coverage -- pkgs/foo/test pkgs/bar/test`)._
+
 ### 3. Feedback Loop: Validate Output
 
+**Run validator -> review errors -> fix:**
+
 1. Verify that the `coverage/` directory was created in the project root.
 2. Ensure `coverage/coverage.json` (raw data) and `coverage/lcov.info` (formatted report) exist.
 3. If coverage is missing for specific files, ensure they are imported and executed by your test files, or add `// coverage:ignore-file` if they are intentionally excluded.
@@ -95,6 +100,8 @@ Extract the coverage data from the running VM service and output it to a JSON fi
 dart run coverage:collect_coverage --wait-paused --uri=http://127.0.0.1:8181/ -o coverage/coverage.json --resume-isolates
 ```
 
+_Optional: Append `--function-coverage` and `--branch-coverage` to gather deeper metrics (requires Dart VM 2.17.0+)._
+
 ### 3. Format to LCOV
 
 Convert the raw JSON data into the standard LCOV format.
@@ -107,6 +114,8 @@ dart run coverage:format_coverage --packages=.dart_tool/package_config.json --lc
 
 ### Example: `pubspec.yaml` Configuration
 
+Ensure your `pubspec.yaml` reflects the `coverage` package strictly under `dev_dependencies`.
+
 ```yaml
 name: my_dart_app
 environment:
@@ -122,6 +131,8 @@ dev_dependencies:
 
 ### Example: Applying Ignore Directives
 
+Use ignore directives to prevent generated code or untestable edge cases from lowering coverage scores.
+
 ```dart
 // coverage:ignore-file
 import 'package:meta/meta.dart';

package/skills/debug/SKILL.md

@@ -96,7 +96,24 @@ Collect live evidence before diagnosing. Propose code fixes only after inspectin
 - `mcp__plugin_flutter_flutter-ultra-runtime__count_widget_tree_nodes` to gauge tree complexity.
 - `mcp__plugin_flutter_flutter-ultra-runtime__start_tail_logs` + `mcp__plugin_flutter_flutter-ultra-runtime__poll_tail_logs` for live log streaming during reproduction.
 
-### 5. Evaluate in-app expressions
+### 5. Advanced VM service access
+
+For low-level inspection beyond the standard helpers, use `mcp__plugin_flutter_flutter-ultra-runtime__call_vm_service_method` to call raw VM Service protocol methods directly:
+
+- `getStack` — full isolate stack frames at any moment (useful when `get_runtime_errors` doesn't capture a synchronous deadlock).
+- `getObject` — inspect any live Dart object by its VM object ID retrieved from `evaluate`.
+- `evaluate` with full params — pass `disableBreakpoints: true` or `scope` overrides that the wrapper `evaluate` tool does not expose.
+
+```
+call_vm_service_method(
+  method: "getStack",
+  params: { "isolateId": "<id>", "limit": 20 }
+)
+```
+
+Use this when `evaluate` and `get_runtime_errors` are insufficient to explain observed behaviour.
+
+### 6. Evaluate in-app expressions
 
 `mcp__plugin_flutter_flutter-ultra-runtime__evaluate` freely to inspect live objects:
 
@@ -104,7 +121,7 @@ Collect live evidence before diagnosing. Propose code fixes only after inspectin
 - `context.read<MyBloc>().state.toString()`
 - `ProviderScope.containerOf(context).read(myProvider).toString()`
 
-### 6. Test the fix
+### 7. Test the fix
 
 1. Apply the code change.
 2. `mcp__plugin_flutter_flutter-ultra-runtime__hot_reload` (or `mcp__plugin_flutter_flutter-ultra-runtime__hot_restart` if `initState` changed).

package/skills/drive/SKILL.md

@@ -30,18 +30,22 @@ Break the user's request into discrete, verifiable steps. Announce the plan befo
 
 **Perform the action:**
 
-| Action                    | Tool                                                              |
-| ------------------------- | ----------------------------------------------------------------- |
-| Tap by key/text/coords    | `mcp__plugin_flutter_flutter-ultra-gesture__tap`                  |
-| Double tap                | `mcp__plugin_flutter_flutter-ultra-gesture__double_tap`           |
-| Long press                | `mcp__plugin_flutter_flutter-ultra-gesture__long_press`           |
-| Enter text                | `mcp__plugin_flutter_flutter-ultra-gesture__enter_text`           |
-| Clear text field          | `mcp__plugin_flutter_flutter-ultra-gesture__clear_text`           |
-| Scroll to element         | `mcp__plugin_flutter_flutter-ultra-gesture__scroll_to`            |
-| Scroll until visible      | `mcp__plugin_flutter_flutter-ultra-gesture__scroll_until_visible` |
-| Swipe gesture             | `mcp__plugin_flutter_flutter-ultra-gesture__swipe`                |
-| Pinch zoom                | `mcp__plugin_flutter_flutter-ultra-gesture__pinch_zoom`           |
-| Navigate programmatically | `mcp__plugin_flutter_flutter-ultra-runtime__evaluate`             |
+| Action                    | Tool                                                                   |
+| ------------------------- | ---------------------------------------------------------------------- |
+| Tap by key/text/coords    | `mcp__plugin_flutter_flutter-ultra-gesture__tap`                       |
+| Double tap                | `mcp__plugin_flutter_flutter-ultra-gesture__double_tap`                |
+| Long press                | `mcp__plugin_flutter_flutter-ultra-gesture__long_press`                |
+| Enter text                | `mcp__plugin_flutter_flutter-ultra-gesture__enter_text`                |
+| Clear text field          | `mcp__plugin_flutter_flutter-ultra-gesture__clear_text`                |
+| Scroll to element         | `mcp__plugin_flutter_flutter-ultra-gesture__scroll_to`                 |
+| Scroll until visible      | `mcp__plugin_flutter_flutter-ultra-gesture__scroll_until_visible`      |
+| Swipe gesture             | `mcp__plugin_flutter_flutter-ultra-gesture__swipe`                     |
+| Pinch zoom                | `mcp__plugin_flutter_flutter-ultra-gesture__pinch_zoom`                |
+| Drag and drop             | `mcp__plugin_flutter_flutter-ultra-browser__drag`                      |
+| Multi-touch gesture       | `mcp__plugin_flutter_flutter-ultra-gesture__perform_actions`           |
+| Open deep link            | `mcp__plugin_flutter_flutter-ultra-native-mobile__dispatch_deep_link`  |
+| Set location              | `mcp__plugin_flutter_flutter-ultra-native-mobile__set_device_location` |
+| Navigate programmatically | `mcp__plugin_flutter_flutter-ultra-runtime__evaluate`                  |
 
 **Wait for the UI to settle:**
 
@@ -77,8 +81,19 @@ When a flow involves an external OAuth consent screen:
 3. `mcp__plugin_flutter_flutter-ultra-browser__fill` for username/password fields.
 4. `mcp__plugin_flutter_flutter-ultra-browser__click` on the submit button.
 5. `mcp__plugin_flutter_flutter-ultra-browser__wait_for_url` matching the app's redirect URI.
+6. Use `mcp__plugin_flutter_flutter-ultra-browser__mock_network_route` to stub API responses during the flow when deterministic data is needed.
+7. Use `mcp__plugin_flutter_flutter-ultra-browser__network_state_set` to simulate offline/slow-network conditions and verify the app handles connectivity loss gracefully.
 
-### 6. Native mobile system dialogs (mobile targets)
+### 6. Native OS interactions (mobile targets)
+
+For flows that leave the Flutter layer and interact with the host OS:
+
+- **Share sheet**: `mcp__plugin_flutter_flutter-ultra-native-mobile__handle_share_sheet` to detect the OS share sheet after triggering a share action, then select an app or dismiss.
+- **Notification flows**: `mcp__plugin_flutter_flutter-ultra-native-mobile__open_notification_tray` to expand the shade, `mcp__plugin_flutter_flutter-ultra-native-mobile__list_notifications` to find the target notification, `mcp__plugin_flutter_flutter-ultra-native-mobile__tap_notification` to open it and return to the app.
+- **Chrome Custom Tab / SFSafariViewController flows**: `mcp__plugin_flutter_flutter-ultra-native-mobile__detect_in_app_browser` to confirm the CCT/SVC is open, `mcp__plugin_flutter_flutter-ultra-native-mobile__interact_in_app_browser` to type/tap within it (e.g., OAuth consent), then wait for the app to resume.
+- **File picker**: `mcp__plugin_flutter_flutter-ultra-native-mobile__pick_file_native` to select a file from the OS file picker dialog that Flutter cannot drive with gesture tools.
+
+### 7. Native mobile system dialogs (mobile targets)
 
 - `mcp__plugin_flutter_flutter-ultra-native-mobile__wait_for_native_element` to detect OS dialogs.
 - `mcp__plugin_flutter_flutter-ultra-native-mobile__native_permission_grant` or `mcp__plugin_flutter_flutter-ultra-native-mobile__native_permission_deny`.
@@ -87,7 +102,7 @@ When a flow involves an external OAuth consent screen:
 - `mcp__plugin_flutter_flutter-ultra-native-mobile__native_home` to press Home.
 - `mcp__plugin_flutter_flutter-ultra-native-mobile__solve_oauth_cct` for Chrome Custom Tab OAuth flows.
 
-### 7. Native desktop dialogs (desktop targets)
+### 8. Native desktop dialogs (desktop targets)
 
 - `mcp__plugin_flutter_flutter-ultra-native-desktop__wait_for_window` to detect native dialogs.
 - `mcp__plugin_flutter_flutter-ultra-native-desktop__desktop_click` to interact with dialog buttons.
@@ -95,7 +110,7 @@ When a flow involves an external OAuth consent screen:
 - `mcp__plugin_flutter_flutter-ultra-native-desktop__select_file_in_dialog` for file picker dialogs.
 - `mcp__plugin_flutter_flutter-ultra-native-desktop__confirm_dialog` to accept/dismiss confirmation dialogs.
 
-### 8. Report the flow result
+### 9. Report the flow result
 
 Produce a numbered summary: steps taken, pass/fail status per step, screenshot paths, and any errors from `mcp__plugin_flutter_flutter-ultra-runtime__get_runtime_errors`.