@bdayadev/flutter-ultra-mcp 1.11.7 → 1.13.0

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

@@ -0,0 +1,160 @@
+---
+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
+
+## Contents
+
+- [Space Measurement Guidelines](#space-measurement-guidelines)
+- [Widget Sizing and Constraints](#widget-sizing-and-constraints)
+- [Device and Orientation Behaviors](#device-and-orientation-behaviors)
+- [Workflow: Constructing an Adaptive Layout](#workflow-constructing-an-adaptive-layout)
+- [Workflow: Optimizing for Large Screens](#workflow-optimizing-for-large-screens)
+- [Examples](#examples)
+
+## 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. 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
+
+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
+
+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 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 (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';
+
+const double largeScreenMinWidth = 600.0;
+
+class AdaptiveLayout extends StatelessWidget {
+  const AdaptiveLayout({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return LayoutBuilder(
+      builder: (context, constraints) {
+        if (constraints.maxWidth > largeScreenMinWidth) {
+          return _buildLargeScreenLayout();
+        } else {
+          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});
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      body: Center(
+        child: ConstrainedBox(
+          constraints: const BoxConstraints(
+            maxWidth: 800.0, // Maximum width for readability
+          ),
+          child: ListView.builder(
+            itemCount: 50,
+            itemBuilder: (context, index) {
+              return ListTile(
+                title: Text('Item $index'),
+              );
+            },
+          ),
+        ),
+      ),
+    );
+  }
+}
+```
+
+## Flutter Ultra Integration
+
+After building the layout, verify responsiveness across breakpoints:
+
+- `mcp__plugin_flutter_flutter-ultra-runtime__audit_responsive` — Automated responsive audit at multiple viewport sizes
+- `mcp__plugin_flutter_flutter-ultra-runtime__screenshot` — Capture screenshots at each breakpoint
+- `mcp__plugin_flutter_flutter-ultra-runtime__dump_render_tree` — Inspect render tree for constraint issues
+- `mcp__plugin_flutter_flutter-ultra-runtime__get_runtime_errors` — Check for overflow errors at different sizes
+
+---
+
+> **Attribution:** This skill is vendored from [flutter/skills](https://github.com/flutter/skills) (BSD-3-Clause).
+> Synced by `scripts/sync-upstream-skills.mjs`. Do not edit manually — changes will be overwritten on next sync.

package/skills/collect-coverage/SKILL.md

@@ -0,0 +1,168 @@
+---
+name: collect-coverage
+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
+
+## Contents
+
+- [Testing Fundamentals](#testing-fundamentals)
+- [Coverage Directives](#coverage-directives)
+- [Workflow: Configuring and Generating Coverage Reports](#workflow-configuring-and-generating-coverage-reports)
+- [Workflow: Advanced Manual Coverage Collection](#workflow-advanced-manual-coverage-collection)
+- [Examples](#examples)
+
+## Testing Fundamentals
+
+Structure your test suites using the standard Dart testing paradigms. Use `package:test` for Dart projects and `flutter_test` for Flutter projects.
+
+- **Unit Tests:** Verify individual functions, methods, or classes.
+- **Component/Widget Tests:** Verify component behavior, layout, and interaction using mock objects (`package:mockito`).
+- **Integration Tests:** Verify entire app flows on simulated or real devices.
+
+## Coverage Directives
+
+Exclude specific lines, blocks, or entire files from coverage metrics using inline comments. Pass the `--check-ignore` flag during formatting to enforce these directives.
+
+- Ignore a single line: `// coverage:ignore-line`
+- Ignore a block of code: `// coverage:ignore-start` and `// coverage:ignore-end`
+- Ignore an entire file: `// coverage:ignore-file`
+
+## Workflow: Configuring and Generating Coverage Reports
+
+Follow this sequential workflow to add the coverage package, execute tests, and generate an LCOV report.
+
+**Task Progress Checklist:**
+
+- [ ] 1. Add `coverage` as a `dev_dependency`.
+- [ ] 2. Execute the automated coverage script.
+- [ ] 3. Validate the LCOV output.
+
+### 1. Add Dependencies
+
+Add the `coverage` package as a `dev_dependency` to your project. Do not add it to standard dependencies.
+
+If working in a standard Dart project:
+
+```bash
+dart pub add dev:coverage
+```
+
+If working in a Flutter project:
+
+```bash
+flutter pub add dev:coverage
+```
+
+### 2. Collect Coverage and Generate LCOV
+
+Use the bundled `test_with_coverage` script. This script automatically runs all tests, collects the JSON coverage data from the Dart VM, and formats it into an LCOV report.
+
+```bash
+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.
+
+## Workflow: Advanced Manual Coverage Collection
+
+If you require granular control over the VM service, isolate pausing, or need branch/function-level coverage, use the manual collection workflow.
+
+**Task Progress Checklist:**
+
+- [ ] 1. Run tests with VM service enabled.
+- [ ] 2. Collect raw JSON coverage.
+- [ ] 3. Format JSON to LCOV.
+
+### 1. Run Tests with VM Service
+
+Execute tests while pausing isolates on exit and exposing the VM service on a specific port (e.g., 8181).
+
+```bash
+dart run --pause-isolates-on-exit --disable-service-auth-codes --enable-vm-service=8181 test &
+```
+
+### 2. Collect Raw Coverage
+
+Extract the coverage data from the running VM service and output it to a JSON file.
+
+```bash
+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.
+
+```bash
+dart run coverage:format_coverage --packages=.dart_tool/package_config.json --lcov -i coverage/coverage.json -o coverage/lcov.info --check-ignore
+```
+
+## Examples
+
+### Example: `pubspec.yaml` Configuration
+
+Ensure your `pubspec.yaml` reflects the `coverage` package strictly under `dev_dependencies`.
+
+```yaml
+name: my_dart_app
+environment:
+  sdk: ^3.0.0
+
+dependencies:
+  path: ^1.8.0
+
+dev_dependencies:
+  test: ^1.24.0
+  coverage: ^1.15.0
+```
+
+### 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';
+
+class SystemConfig {
+  final String env;
+
+  SystemConfig(this.env);
+
+  // coverage:ignore-start
+  void legacyInit() {
+    print('Deprecated initialization');
+  }
+  // coverage:ignore-end
+
+  bool isProduction() {
+    if (env == 'prod') return true;
+    return false; // coverage:ignore-line
+  }
+}
+```
+
+## Flutter Ultra Integration
+
+Collect coverage directly via the test runner:
+
+- `mcp__plugin_flutter_flutter-ultra-build__start_run_unit_tests` — Run tests with `coverage: true` to collect LCOV data
+- `mcp__plugin_flutter_flutter-ultra-build__get_run_unit_tests_result` — Get results including coverage report path
+
+---
+
+> **Attribution:** This skill is vendored from [dart-lang/skills](https://github.com/dart-lang/skills) (BSD-3-Clause).
+> Synced by `scripts/sync-upstream-skills.mjs`. Do not edit manually — changes will be overwritten on next sync.

package/skills/fix-layout-issues/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: fix-layout-issues
+description: Fixes Flutter layout errors (overflows, unbounded constraints) using Dart and Flutter MCP tools. Use when addressing "RenderFlex overflowed", "Vertical viewport was given unbounded height", or similar layout issues.
+  last_modified: Tue, 21 Apr 2026 19:45:59 GMT
+---
+
+# Resolving Flutter Layout Errors
+
+## Contents
+
+- [Constraint Violation Diagnostics](#constraint-violation-diagnostics)
+- [Layout Error Resolution Workflow](#layout-error-resolution-workflow)
+- [Examples](#examples)
+
+## Constraint Violation Diagnostics
+
+Flutter layout operates on a strict rule: **Constraints go down. Sizes go up. Parent sets position.** Layout errors occur when this negotiation fails, typically due to unbounded constraints or unconstrained children.
+
+Diagnose layout failures using the following error signatures:
+
+- **"Vertical viewport was given unbounded height"**: Triggered when a scrollable widget (`ListView`, `GridView`) is placed inside an unconstrained vertical parent (`Column`). The parent provides infinite height, and the child attempts to expand infinitely.
+- **"An InputDecorator...cannot have an unbounded width"**: Triggered when a `TextField` or `TextFormField` is placed inside an unconstrained horizontal parent (`Row`). The text field attempts to determine its width based on infinite available space.
+- **"RenderFlex overflowed"**: Triggered when a child of a `Row` or `Column` requests a size larger than the parent's allocated constraints. Visually indicated by yellow and black warning stripes.
+- **"Incorrect use of ParentData widget"**: Triggered when a `ParentDataWidget` is not a direct descendant of its required ancestor. (e.g., `Expanded` outside a `Flex`, `Positioned` outside a `Stack`).
+- **"RenderBox was not laid out"**: A cascading side-effect error. Ignore this and look further up the stack trace for the primary constraint violation (usually an unbounded height/width error).
+
+## Layout Error Resolution Workflow
+
+Copy and use this checklist to systematically resolve layout constraint violations.
+
+### Task Progress
+
+- [ ] Run the application in debug mode to capture the exact layout exception in the console.
+- [ ] Identify the primary error message (ignore cascading "RenderBox was not laid out" errors).
+- [ ] Apply the conditional fix based on the specific error type:
+  - **If "Vertical viewport was given unbounded height"**: Wrap the scrollable child (`ListView`, `GridView`) in an `Expanded` widget to consume remaining space, or wrap it in a `SizedBox` to provide an absolute height constraint.
+  - **If "An InputDecorator...cannot have an unbounded width"**: Wrap the `TextField` or `TextFormField` in an `Expanded` or `Flexible` widget.
+  - **If "RenderFlex overflowed"**: Constrain the overflowing child by wrapping it in an `Expanded` widget (to force it to fit) or a `Flexible` widget (to allow it to be smaller than the allocated space).
+  - **If "Incorrect use of ParentData widget"**: Move the `ParentDataWidget` to be a direct child of its required parent. Ensure `Expanded`/`Flexible` are direct children of `Row`/`Column`/`Flex`. Ensure `Positioned` is a direct child of `Stack`.
+- [ ] Execute Flutter hot reload.
+- [ ] Run validator -> review errors -> fix: Inspect the UI to verify the red/grey error screen or yellow/black overflow stripes are resolved. If new layout errors appear, repeat the workflow.
+
+## Examples
+
+### Fixing Unbounded Height (ListView in Column)
+
+**Input (Error State):**
+
+```dart
+// Throws "Vertical viewport was given unbounded height"
+Column(
+  children: <Widget>[
+    const Text('Header'),
+    ListView(
+      children: const <Widget>[
+        ListTile(title: Text('Item 1')),
+        ListTile(title: Text('Item 2')),
+      ],
+    ),
+  ],
+)
+```
+
+**Output (Resolved State):**
+
+```dart
+// Wrap ListView in Expanded to constrain its height to the remaining Column space
+Column(
+  children: <Widget>[
+    const Text('Header'),
+    Expanded(
+      child: ListView(
+        children: const <Widget>[
+          ListTile(title: Text('Item 1')),
+          ListTile(title: Text('Item 2')),
+        ],
+      ),
+    ),
+  ],
+)
+```
+
+### Fixing Unbounded Width (TextField in Row)
+
+**Input (Error State):**
+
+```dart
+// Throws "An InputDecorator...cannot have an unbounded width"
+Row(
+  children: [
+    const Icon(Icons.search),
+    TextField(),
+  ],
+)
+```
+
+**Output (Resolved State):**
+
+```dart
+// Wrap TextField in Expanded to constrain its width to the remaining Row space
+Row(
+  children: [
+    const Icon(Icons.search),
+    Expanded(
+      child: TextField(),
+    ),
+  ],
+)
+```
+
+### Fixing RenderFlex Overflow
+
+**Input (Error State):**
+
+```dart
+// Throws "A RenderFlex overflowed by X pixels on the right"
+Row(
+  children: [
+    const Icon(Icons.info),
+    const Text('This is a very long text string that will definitely overflow the available screen width and cause a RenderFlex error.'),
+  ],
+)
+```
+
+**Output (Resolved State):**
+
+```dart
+// Wrap the Text widget in Expanded to force it to wrap within the available constraints
+Row(
+  children: [
+    const Icon(Icons.info),
+    Expanded(
+      child: const Text('This is a very long text string that will definitely overflow the available screen width and cause a RenderFlex error.'),
+    ),
+  ],
+)
+```
+
+## Flutter Ultra Integration
+
+Diagnose and verify layout fixes with live app inspection:
+
+- `mcp__plugin_flutter_flutter-ultra-runtime__get_runtime_errors` — Fetch current runtime errors including RenderFlex overflows
+- `mcp__plugin_flutter_flutter-ultra-runtime__dump_render_tree` — Inspect render tree to see constraint propagation
+- `mcp__plugin_flutter_flutter-ultra-runtime__toggle_debug_paint` — Toggle debug paint to visualize layout boundaries
+- `mcp__plugin_flutter_flutter-ultra-runtime__hot_reload` — Hot reload after applying fix to verify immediately
+- `mcp__plugin_flutter_flutter-ultra-runtime__screenshot` — Capture before/after screenshots of the fix
+
+---
+
+> **Attribution:** This skill is vendored from [flutter/skills](https://github.com/flutter/skills) (BSD-3-Clause).
+> Synced by `scripts/sync-upstream-skills.mjs`. Do not edit manually — changes will be overwritten on next sync.

package/skills/fix-runtime-errors/SKILL.md

@@ -0,0 +1,197 @@
+---
+name: fix-runtime-errors
+description: Uses get_runtime_errors and lsp to fetch an active stack trace, locate the failing line, apply a fix, and verify resolution via hot_reload.
+  last_modified: Fri, 24 Apr 2026 15:13:22 GMT
+---
+
+# Resolving Dart Static Analysis Errors
+
+## Contents
+
+- [Core Concepts & Guidelines](#core-concepts--guidelines)
+  - [Type System & Soundness](#type-system--soundness)
+  - [Null Safety](#null-safety)
+  - [Error Handling](#error-handling)
+- [Workflows](#workflows)
+  - [Workflow: Static Analysis Resolution](#workflow-static-analysis-resolution)
+- [Examples](#examples)
+
+## Core Concepts & Guidelines
+
+### Type System & Soundness
+
+Enforce Dart's sound type system to prevent runtime invalid states.
+
+- **Method Overrides:** Maintain sound return types (covariant) and parameter types (contravariant). Never tighten a parameter type in a subclass unless explicitly marked with the `covariant` keyword.
+- **Generics & Collections:** Add explicit type annotations to generic classes (e.g., `List<T>`, `Map<K, V>`). Never assign a `List<dynamic>` to a typed list (e.g., `List<Cat>`).
+- **Downcasting:** Avoid implicit downcasts from `dynamic`. Use explicit casts (e.g., `as List<Cat>`) when necessary, but ensure the underlying runtime type matches to prevent `TypeError` exceptions.
+- **Strict Casts:** Enable `strict-casts: true` in `analysis_options.yaml` under `analyzer: language:` to force explicit casting and catch implicit downcast errors at compile time.
+
+### Null Safety
+
+Eliminate static errors related to null safety by correctly managing variable initialization and nullability.
+
+- **Modifiers:** Apply `?` for nullable types, `!` for null assertions, and `required` for named parameters that cannot be null.
+- **Late Initialization:** Use the `late` keyword for non-nullable variables guaranteed to be initialized before use. Apply this specifically to top-level or instance variables where Dart's control flow analysis cannot definitively prove initialization.
+- **Wildcards:** Use the `_` wildcard variable (Dart 3.7+) for non-binding local variables or parameters to avoid unused variable warnings.
+
+### Error Handling
+
+Distinguish between recoverable exceptions and unrecoverable errors.
+
+- **Catching:** Catch `Exception` subtypes for recoverable failures.
+- **Errors:** Never explicitly catch `Error` or its subtypes (e.g., `TypeError`, `ArgumentError`). Errors indicate programming bugs that must be fixed, not caught. Enforce this by enabling the `avoid_catching_errors` linter rule.
+- **Rethrowing:** Use `rethrow` inside a `catch` block to propagate an exception while preserving its original stack trace.
+
+## Workflows
+
+### Workflow: Static Analysis Resolution
+
+Use this sequential workflow to identify, fix, and verify static analysis errors in a Dart project. Copy the checklist to track your progress.
+
+**Task Progress:**
+
+- [ ] 1. Run static analyzer.
+- [ ] 2. Apply automated fixes.
+- [ ] 3. Resolve remaining errors manually.
+- [ ] 4. Verify fixes (Feedback Loop).
+
+**1. Run static analyzer**
+Execute the Dart analyzer to identify all static errors in the target directory or file.
+
+```bash
+dart analyze . --fatal-infos
+```
+
+**2. Apply automated fixes**
+Use the `dart fix` tool to automatically resolve standard linting and analysis issues.
+
+```bash
+# Preview changes
+dart fix --dry-run
+# Apply changes
+dart fix --apply
+```
+
+**3. Resolve remaining errors manually**
+Review the remaining analyzer output and apply conditional logic based on the error type:
+
+- **If the error is a Null Safety issue (e.g., "Property cannot be accessed on a nullable receiver"):**
+  - Verify if the variable can logically be null.
+  - If yes, use optional chaining (`?.`) or provide a fallback (`??`).
+  - If no, and initialization is guaranteed elsewhere, mark the declaration with `late`.
+- **If the error is a Type Mismatch (e.g., "The argument type 'List<dynamic>' can't be assigned..."):**
+  - Trace the variable's initialization.
+  - Add explicit generic type annotations to the instantiation (e.g., `<int>[]` instead of `[]`).
+- **If the error is an Invalid Override (e.g., "The parameter type doesn't match the overridden method"):**
+  - Widen the parameter type to match the superclass, OR
+  - Add the `covariant` keyword to the parameter if tightening the type is intentionally required by the domain logic.
+
+**4. Verify fixes (Feedback Loop)**
+Run the validator. Review errors. Fix.
+
+```bash
+dart analyze .
+dart test
+```
+
+- **If `dart analyze` reports errors:** Return to Step 3.
+- **If `dart test` fails with a `TypeError`:** You have introduced an invalid explicit cast (`as T`) or accessed an uninitialized `late` variable. Locate the runtime failure and correct the type hierarchy or initialization order.
+
+## Examples
+
+### Example: Fixing Dynamic List Assignments
+
+**Input (Fails Static Analysis):**
+
+```dart
+void printInts(List<int> a) => print(a);
+
+void main() {
+  final list = []; // Inferred as List<dynamic>
+  list.add(1);
+  list.add(2);
+  printInts(list); // Error: List<dynamic> can't be assigned to List<int>
+}
+```
+
+**Output (Passes Static Analysis):**
+
+```dart
+void printInts(List<int> a) => print(a);
+
+void main() {
+  final list = <int>[]; // Explicitly typed
+  list.add(1);
+  list.add(2);
+  printInts(list);
+}
+```
+
+### Example: Fixing Method Overrides (Contravariance)
+
+**Input (Fails Static Analysis):**
+
+```dart
+class Animal {
+  void chase(Animal a) {}
+}
+
+class Cat extends Animal {
+  @override
+  void chase(Mouse a) {} // Error: Tightening parameter type
+}
+```
+
+**Output (Passes Static Analysis):**
+
+```dart
+class Animal {
+  void chase(Animal a) {}
+}
+
+class Cat extends Animal {
+  @override
+  void chase(covariant Mouse a) {} // Explicitly marked covariant
+}
+```
+
+### Example: Fixing Null Safety with `late`
+
+**Input (Fails Static Analysis):**
+
+```dart
+class Thermometer {
+  String temperature; // Error: Non-nullable instance field must be initialized
+
+  void read() {
+    temperature = '20C';
+  }
+}
+```
+
+**Output (Passes Static Analysis):**
+
+```dart
+class Thermometer {
+  late String temperature; // Defers initialization check to runtime
+
+  void read() {
+    temperature = '20C';
+  }
+}
+```
+
+## Flutter Ultra Integration
+
+Diagnose and fix runtime errors in the live app:
+
+- `mcp__plugin_flutter_flutter-ultra-runtime__get_runtime_errors` — Fetch active stack traces from the running app
+- `mcp__plugin_flutter_flutter-ultra-runtime__evaluate` — Evaluate expressions in the running isolate
+- `mcp__plugin_flutter_flutter-ultra-runtime__hot_reload` — Hot reload after applying fix to verify immediately
+- `mcp__plugin_flutter_flutter-ultra-runtime__get_logs` — View recent log output for context
+
+---
+
+> **Attribution:** This skill is vendored from [dart-lang/skills](https://github.com/dart-lang/skills) (BSD-3-Clause).
+> Synced by `scripts/sync-upstream-skills.mjs`. Do not edit manually — changes will be overwritten on next sync.