Add official Android agent skills for project-local use

Install the full Android CLI skill pack under project `.claude/skills`
and `skills/` (claude-code + openclaw), refreshing the existing adaptive,
navigation-3, and XML-to-Compose skills so agents share the same local set.

Author: rosuH

.claude/skills/adaptive/SKILL.md

@@ -10,7 +10,7 @@ description: Instructions to make or update an app's UI so that it adapts to dif
 license: Complete terms in LICENSE.txt
 metadata:
   author: Google LLC
-  last-updated: '2026-05-20'
+  last-updated: '2026-07-02'
   keywords:
   - android
   - ui
@@ -75,11 +75,11 @@ phone in portrait mode. On larger screen hand-held devices, like tablets and
 unfolded foldables, the navigation area must be accessible from the edge of the
 screen (navigation rail).
 
-If you need to provide more screen real state for the content, hide the
+If you need to provide more screen space for the content, hide the
 navigation area. Examples of this include:
 
 - Hiding the navigation bar when the user scrolls down and showing it again when the user scrolls up. The assumption is that when the user is scrolling down, they are consuming content but when scrolling up they are trying to navigate away from that content.
-- Hiding the navigation area when its content is distracting. For example, in camera previews or when the content is best displayed in full screen (such as a single photo screen).
+- Hiding the navigation area when its content is distracting. For example, in camera previews or when displaying a full-screen photo.
 
 When the detail screen is displayed full-screen on mobile, full-screen mode must
 be deactivated on larger screens.
@@ -101,7 +101,7 @@ parameter.
 
 Steps to migrate:
 
-- Identify the scenarios under which the navigation bar is hidden. This is usually done with a boolean variable for the visibility. It could be named something like `isNavBarVisible` or `shouldShowNavBar`.
+- Identify the scenarios under which the navigation bar is hidden. This is usually done with a boolean variable for the visibility. Use `isNavBarVisible` or `shouldShowNavBar` as the variable name.
 - Create an instance of `NavigationSuiteScaffoldState` using `rememberNavigationSuiteScaffoldState()` and pass it to `NavigationSuiteScaffold`.
 - When the navigation area visibility changes, use a `LaunchedEffect` to call `show` or `hide` on the `NavigationSuiteScaffoldState`.
 
@@ -207,8 +207,8 @@ Look for the following vertical list composables: `LazyColumn`,
 
 Steps to migrate:
 
-- Choose a suitable minimum width in dp for the column. It should be large enough so that item is clearly visible to the user.
-- For `LazyColumn`: change to a `LazyVerticalGrid` and follow the instruction below
+- Choose a suitable minimum width in dp for the column. The item must be clearly visible to the user at this width.
+- For `LazyColumn`: change to a `LazyVerticalGrid` and follow the instruction later
 - For `LazyVerticalGrid`: change the `columns` parameter to use `GridCells.Adaptive(<width>.dp)`
 - For `LazyVerticalStaggeredGrid`: change the `columns` parameter to use `StaggeredGridCells.Adaptive(<width>.dp)`
 

.claude/skills/adaptive/references/android/develop/ui/compose/layouts/adaptive/flexbox/container-behavior.md

@@ -95,7 +95,7 @@ There is space, so Child 1 is placed into the line.
 There is `80dp` available space in the line. The gap is `8dp`. Child 2 is
 `40dp`. The required space is `48dp`. There is space, so the gap and Child 2
 are placed into the line.
-![First item placed in the FlexBox container.](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/flexbox/algorithm-2.png) **Figure 2.** Second item placed in the `FlexBox` container after the first item.
+![Second item placed in the FlexBox container after the first item.](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/flexbox/algorithm-2.png) **Figure 2.** Second item placed in the `FlexBox` container after the first item.
 
 There is `32dp` available space in the line. The gap is `8dp`. Child 3 is
 `50dp`. The required space is `58dp`. There is not enough space in the current

.claude/skills/adaptive/references/android/develop/ui/compose/layouts/adaptive/flexbox/get-started.md

@@ -6,7 +6,7 @@ This page describes how to implement basic `FlexBox` layouts.
    `lib.versions.toml`.
 
        [versions]
-       compose = "1.12.0-alpha03"
+       compose = "1.12.0-beta02"
 
        [libraries]
        androidx-compose-foundation-layout = { group = "androidx.compose.foundation", name = "foundation-layout", version.ref = "compose" }

.claude/skills/adaptive/references/android/develop/ui/compose/layouts/adaptive/grid/container-properties.md

@@ -112,7 +112,7 @@ You can specify the size of a grid track using one of the following methods:
 - **Fixed** (`Dp`): Allocates a specific size (e.g., `column(180.dp)`).
 - **Percentage** (`Float`): Allocates a percentage of the total available space from `0.0f` to `1.0f` (e.g., `row(0.5f)` for 50%).
 - **Flexible** ([`Fr`](https://developer.android.com/reference/kotlin/androidx/compose/foundation/layout/Fr)): Distributes remaining space proportionally after fixed and percentage tracks are calculated. For example, if two rows are set to `1.fr` and `3.fr`, the latter receives 75% of the remaining height.
-- **Intrinsic** : Sizes the track based on the content inside it. For more information, see [Determine grid track size intrinsically](https://developer.android.com/develop/ui/compose/layouts/adaptive/grid/container-properties#intrisic-grid-track-size).
+- **Intrinsic** : Sizes the track based on the content inside it. For more information, see [Determine grid track size intrinsically](https://developer.android.com/develop/ui/compose/layouts/adaptive/grid/container-properties#intrinsic-grid-track-size).
 
 The following example uses the different track sizing options
 to define the row heights:
@@ -131,12 +131,94 @@ Grid(
     modifier = Modifier.height(480.dp)
 ) {
     PastelRedCard("Fixed(100.dp)")
+        PastelGreenCard("Percentage(0.2f)")
+    PastelBlueCard("Flex(1.fr)")
+        PastelYellowCard("Auto")
+
+}
 ```
 
 <br />
 
 ![Row heights defined using the four primary track sizing options.](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/grid/track-sizes.png) **Figure 3** . Row heights defined using the four primary track sizing options in `Grid`.
 
+### Set the minimum size for flexible grid tracks
+
+When a grid container has no remaining space,
+a standard flexible track can shrink to `0.dp`.
+To prevent this and ensure content isn't crushed,
+use [`GridTrackSize.MinMax`](https://developer.android.com/reference/kotlin/androidx/compose/foundation/layout/GridTrackSize#MinMax(androidx.compose.ui.unit.Dp,androidx.compose.foundation.layout.Fr))
+to enforce an explicit minimum size while keeping the track flexible.
+
+The following example allocates at least `100.dp` to the first row:
+
+
+```kotlin
+Grid(
+    config = {
+        column(1f)
+        // The first row has a minimum height of 100.dp and can expand to 
+        // the half of the remaining space.
+        row(GridTrackSize.MinMax(100.dp, 1.fr))
+        // The second row takes the half of the remaining space.
+        row(1.fr)
+        // The third row has a fixed height of 200.dp.
+        row(200.dp)
+    },
+    modifier = Modifier.size(360.dp) // Total grid height is 360.dp
+) {
+    PastelRedCard("MinMax(100.dp, 1.fr)")
+        PastelGreenCard("Flex(1.fr)")
+    PastelBlueCard("Fixed(200.dp)")
+}
+```
+
+<br />
+
+![Row heights defined using the four primary track sizing options.](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/grid/track-size-minmax.png) **Figure 4** . The first row has at least `100.dp` height.
+
+### Set the minimum grid track size to place lazy lists
+
+Standard flexible tracks automatically query the intrinsic sizes of
+their children to establish a base size.
+However, Jetpack Compose prohibits querying the intrinsic sizes of
+[`SubcomposeLayout`](https://developer.android.com/reference/kotlin/androidx/compose/ui/layout/SubcomposeLayout.composable#SubcomposeLayout(androidx.compose.ui.Modifier,kotlin.Function2)), which backs components,
+such as [`LazyColumn`](https://developer.android.com/reference/kotlin/androidx/compose/foundation/lazy/LazyColumn.composable) and [`LazyRow`](https://developer.android.com/reference/kotlin/androidx/compose/foundation/lazy/LazyRow.composable).
+
+Placing a lazy list inside a standard flexible track causes
+an [`IllegalStateException`](https://developer.android.com/reference/java/lang/IllegalStateException) crash.
+To safely place lazy lists inside a flexible grid track,
+use `MinMax` with an explicit minimum size (such as `0.dp`)
+to bypass the intrinsic measurement pass.
+
+
+```kotlin
+Grid(
+    config = {
+        column(1f)
+        // The first row's height is determined by the height of the Text composable.
+        row(GridTrackSize.Auto)
+        // The second row occupies the remaining space, allowing the LazyColumn to scroll.
+        row(GridTrackSize.MinMax(0.dp, 1.fr))
+
+        gap(8.dp)
+    },
+    modifier = Modifier.size(width = 170.dp, height = 240.dp)
+) {
+    Text("Lazy column in a Grid")
+    // The LazyColumn is placed in the second row, filling the remaining space.
+    LazyColumn(verticalArrangement = Arrangement.spacedBy(4.dp)) {
+        items(100) { number ->
+            PastelGreenCard("Card $number")
+        }
+    }
+}
+```
+
+<br />
+
+![Row heights defined using the four primary track sizing options.](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/grid/lazy-column-in-grid.png) **Figure 5** . `LazyColumn` in a grid cell.
+
 ### Determine grid track size intrinsically
 
 You can use [intrinsic sizing](https://developer.android.com/develop/ui/compose/layouts/intrinsic-measurements) for a `Grid`
@@ -163,14 +245,14 @@ Grid(
     },
     modifier = Modifier.width(480.dp)
 ) {
-    Text("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras imperdiet." )
-    Text("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras imperdiet." )
+    Text("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras imperdiet.")
+    Text("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras imperdiet.")
 }
 ```
 
 <br />
 
-![Intrinsic sizes specified in the columns.](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/grid/intrinsic-size.png) **Figure 4**. Intrinsic sizes specified in the columns.
+![Intrinsic sizes specified in the columns.](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/grid/intrinsic-size.png) **Figure 5**. Intrinsic sizes specified in the columns.
 
 ## Set gaps between rows and columns
 
@@ -206,7 +288,7 @@ Grid(
 
 <br />
 
-![Gaps between rows and columns.](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/grid/gaps.png) **Figure 5**. Gaps between rows and columns.
+![Gaps between rows and columns.](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/grid/gaps.png) **Figure 6**. Gaps between rows and columns.
 
 You can also use the convenience function [`gap`](https://developer.android.com/reference/kotlin/androidx/compose/foundation/layout/GridConfigurationScope#gap(androidx.compose.ui.unit.Dp))
 to define gaps of the same column and row size,

.claude/skills/adaptive/references/android/develop/ui/compose/layouts/adaptive/grid/get-started.md

@@ -6,7 +6,7 @@ This page describes how to implement basic [`Grid`](https://developer.android.co
    `lib.versions.toml`.
 
        [versions]
-       compose = "1.12.0-alpha03"
+       compose = "1.12.0-beta02"
 
        [libraries]
        androidx-compose-foundation-layout = { group = "androidx.compose.foundation", name = "foundation-layout", version.ref = "compose" }

.claude/skills/adaptive/references/android/develop/ui/compose/layouts/adaptive/grid/index.md

@@ -25,7 +25,7 @@ of which layouts are suitable for each API:
 
 | Component | Purpose |
 |---|---|
-| `LazyVerticalGrid`, `LazyStaggeredGrid`, `LazyHorizontalGrid` | Visualization of large, homogeneous data sets that requires lazy loading. |
+| `LazyVerticalGrid`, `LazyStaggeredGrid`, `LazyHorizontalGrid` | Visualization of large, homogeneous data sets that require lazy loading. |
 | `Row`, `Column`, `FlexBox` | One-dimensional layout |
 | `Grid` | Two-dimensional layout |
 

.claude/skills/adaptive/references/android/develop/ui/compose/layouts/adaptive/grid/item-properties.md

@@ -137,7 +137,7 @@ A UI element in `Grid`
 that has no position specification undergoes auto-placement.
 This example shows how you can mix auto-placed elements
 and the UI elements with specified grid cells.
-Card **#2** and card **#4** are specified grid cells,
+Card **#2** and Card **#4** are placed in specified grid cells,
 and the other items are auto-placed.
 
 
@@ -165,4 +165,4 @@ Grid(
 
 <br />
 
-![Card #3 is placed next to card <b>#1</b>, as it is an auto-placement.](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/grid/autoplacement-mixed-with-placement.png) **Figure 4** . Card **#3** is placed next to card **#1**, as it is an auto-placement.
+![Card #3 is placed next to Card <b>#1</b>, as it is an auto-placement.](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/grid/autoplacement-mixed-with-placement.png) **Figure 4** . Card **#3** is placed next to Card **#1**, as it is an auto-placement.

.claude/skills/adaptive/references/android/develop/ui/compose/tooling/debug.md

@@ -68,7 +68,7 @@ Inspector](https://developer.android.com/static/develop/ui/compose/images/li-sho
 
 ### Compose semantics
 
-In Compose, [Semantics](https://developer.android.com/develop/ui/compose/semantics) describe your UI in an
+In Compose, [Semantics](https://developer.android.com/develop/ui/compose/accessibility/semantics) describe your UI in an
 alternative manner that is understandable for
 [Accessibility](https://developer.android.com/develop/ui/compose/accessibility) services and for the
 [Testing](https://developer.android.com/develop/ui/compose/testing) framework. You can use the Layout Inspector

.claude/skills/agp-9-upgrade/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: agp-9-upgrade
+description: Upgrades, or migrates, an Android project to use Android Gradle Plugin
+  (AGP) version 9. Do not use this skill for migrating Kotlin Multiplatform (KMP)
+  projects.
+license: Complete terms in LICENSE.txt
+metadata:
+  author: Google LLC
+  last-updated: '2026-06-25'
+  keywords:
+  - Android Gradle Plugin 9
+  - AGP 9
+  - AGP Upgrade
+  - AGP Migration
+  - New AGP DSL
+  - Migrate to built-in Kotlin
+---
+
+## Migration guide
+
+See the [AGP 9 migration guide](references/android/build/releases/agp-9-0-0-release-notes.md) for the major changes, many
+breaking, in AGP 9 compared to AGP 8.
+
+## Requirements
+
+If the user requests to update or migrate to AGP 9, first check the AGP version
+used in the project. If it is lower than 9, stop and ask the user to run the AGP
+Upgrade Assistant in Android Studio to update to the latest stable version of
+AGP, and confirm when done. The user may also request that this requirement be
+skipped; if this is the case, you should update the version of AGP to the latest
+stable version as part of the AGP 9 migration. See the
+[AGP 9 migration guide](references/android/build/releases/agp-9-0-0-release-notes.md) for how to do this.
+
+Each version of AGP has its own set of compatibilities with other tools, such as
+Gradle, JDK, and Kotlin. The release notes for each of these versions will
+include a **Compatibility** table indicating the minimum versions for these
+tools.
+
+Do not use this skill for KMP projects, as they are unsupported.
+
+## Steps
+
+If AGP is already at 9 or higher, then do the following:
+
+### Step 1: Update dependencies
+
+If KSP (`com.google.devtools.ksp`) is used in the project, ensure it is on
+version 2.3.6 or higher.
+
+If Hilt is used in the project, ensure it is on version 2.59.2 or higher.
+
+### Step 2: Migrate to built-in Kotlin
+
+See [the guide](references/android/build/migrate-to-built-in-kotlin.md) for detailed information.
+
+### Step 3. Migrate to the new AGP DSL
+
+See [the guide](references/android/build/releases/agp-9-0-0-release-notes.md) for detailed information.
+
+See also [gradle-recipes](references/recipes.md) for examples on how to migrate old code to code
+that is compatible with AGP 9 and the new DSL.
+
+### Step 4. Migrate kapt to KSP or legacy-kapt
+
+If KSP (`com.google.devtools.ksp`) or kapt (`org.jetbrains.kotlin.kapt`) are
+used in the project, see [KSP, kapt, and legacy-kapt](references/ksp-kapt.md) for detailed migration
+steps.
+
+### Step 5. BuildConfig
+
+If any Android module contains custom BuildConfig fields, see [BuildConfig](references/buildconfig.md)
+for detailed information.
+
+### Step 6. Update gradle.properties
+
+After the migration, check gradle.properties. Remove the following flags:
+
+1. android.builtInKotlin
+2. android.newDsl
+3. android.uniquePackageNames
+4. android.enableAppCompileTimeRClass
+
+Additionally, delete all temporary files you've created.
+
+## Guidelines
+
+- Never write or run python scripts.
+- Only search the Gradle dependency cache when inspecting external dependencies, and only as a last resort.
+- Never add `android.disallowKotlinSourceSets=false` to `gradle.properties`.
+- When verifying changes, don't run the `clean` task. This is a waste of time.
+
+## Verification
+
+After migration, verify the following:
+
+1. Gradle IDE sync succeeds.
+2. `./gradlew help` succeeds.
+3. `./gradlew build --dry-run` succeeds.
+
+## Troubleshooting
+
+Paparazzi v2.0.0-alpha04 and lower versions have issues with AGP 9. See
+[references/paparazzi-gradle-9.md](references/paparazzi-gradle-9.md) for details.

.claude/skills/agp-9-upgrade/references/buildconfig.md

@@ -0,0 +1,54 @@
+When an Android module contains custom BuildConfig fields, the following steps
+are necessary to ensure a correct build.
+
+### Step 1: Enable the buildConfig build feature
+
+In a build script:
+
+    android {
+      buildFeatures {
+        buildConfig = true
+      }
+    }
+
+In custom build-logic for an app module:
+
+    extensions.configure<com.android.build.api.dsl.ApplicationExtension> {
+      buildFeatures {
+        buildConfig = true
+      }
+    }
+
+In custom build-logic for a library module:
+
+    extensions.configure<com.android.build.api.dsl.LibraryExtension> {
+      buildFeatures {
+        buildConfig = true
+      }
+    }
+
+In custom build-logic using `CommonExtension`:
+
+    extensions.configure<com.android.build.api.dsl.CommonExtension> {
+      buildFeatures {
+        buildConfig = true
+      }
+    }
+
+### Step 2: Migrate to the new API
+
+Use the **addCustomBuildConfigFields** recipe from the [gradle-recipes](https://developer.android.com/agents/skills/build/agp/agp-9-upgrade/references/recipes)
+repository.
+
+**IMPORTANT:** For `BuildConfigField`s with a type of `String`, the `value` field
+*must* include quotation marks as part of the String. For example:
+
+    BuildConfigField(
+      type = "String",
+      value = "\"Some value\"",
+      comment = "Optional comment",
+    )
+
+It is an **error** if the `value` field doesn't include quotation marks as
+part of the String. For example, `value = "Some value"` **is an error** . This is
+because the `value` is written out literally.