svharness 0.8.0

package/templates/android-compose/skeleton/agent-env/skills/harness-xml-to-compose/references/android/develop/ui/compose/designsystems/migrate-xml-theme-to-compose.md

@@ -0,0 +1,168 @@
+When you introduce Compose in an existing app, you need to migrate your Material
+XML themes to use `MaterialTheme` for Compose components. This means your app's
+theming will have two sources of truth: the View-based theme and the Compose
+theme. Any changes to your styling need to be made in multiple places. Once
+your app is fully migrated to Compose, remove your XML theming.
+
+You can use the [Material Theme Builder](https://m3.material.io/theme-builder)
+tool for migrating colors.
+
+When you start the migration from XML to Compose, migrate the theming to
+Material 3 Compose theming.
+
+## Glossary
+
+| Term | Definition |
+|---|---|
+| `MaterialTheme` | The composable function that provides theming (colors, typography, shapes) to Compose UI components. |
+| `Shape` | A Compose object used to define custom component shapes for a `MaterialTheme`. |
+| `Typography` | A Compose object used to define custom text styles (font families, sizes, weights) for a `MaterialTheme`. |
+| `Color` | A Compose object used to define custom color schemes for `MaterialTheme`. |
+| XML Theme | The Android theming system defined in XML files, used by the View system. |
+
+## Limitations
+
+Before migrating, be aware of the following limitations:
+
+- This guide focuses on migrating to Material 3 only. For migrating from alternative design systems, see [Material 2](https://developer.android.com/develop/ui/compose/designsystems/material) or [Custom design systems in Compose](https://developer.android.com/develop/ui/compose/designsystems/custom).
+- The ultimate goal is a complete migration to Compose, which allows for the removal of XML theming. This guide explains how to migrate, but it doesn't explain how to finally remove XML theming.
+
+## Step 1: Evaluate the design system
+
+Identify which design system is used in the XML View project.
+Analyze the migration path and necessary steps to migrate the existing design
+system to Material 3 in Compose.
+
+## Step 2: Identify theme source files
+
+In XML you write `?attr/colorPrimary`. In Compose, you access theme values
+with `MaterialTheme.*`:
+
+Identify and locate all XML resources and files necessary for theming:
+light and dark color schemes and qualifiers, themes, shapes, dimensions,
+typography, styles and other relevant files.
+
+Resources such as strings can be reused as is and don't need to be migrated.
+
+## Step 3: Migrate colors
+
+**Key principle:** XML uses named hex colors.
+Material 3 uses *semantic roles* (e.g., `primary`, `onPrimary`, `surface`).
+Stop naming colors by their hex; name them by their role.
+
+Examples:
+
+| XML color name | Material 3 role |
+|---|---|
+| `colorPrimary` | `primary` |
+| `colorPrimaryDark` / `colorPrimaryVariant` | `primaryContainer` or `secondary` |
+| `colorAccent` | `secondary` or `tertiary` |
+| `colorOnPrimary` | `onPrimary` |
+| `android:colorBackground` | `background` |
+| `colorSurface` | `surface` |
+| `colorOnSurface` | `onSurface` |
+| `colorError` | `error` |
+| `colorOnError` | `onError` |
+| `colorOutline` | `outline` |
+| `colorSurfaceVariant` | `surfaceVariant` |
+| `colorOnSurfaceVariant` | `onSurfaceVariant` |
+
+*** ** * ** ***
+
+Migrate the dark and light color schemes from XML to their equivalents in
+Material 3 Compose.
+
+> [!NOTE]
+> **Note:** Material 3 naming differs from Material 2 color naming.
+
+## Step 4: Migrate custom shapes and typography
+
+- If your app uses custom shapes:
+
+  1. In your Compose code, define a `Shape` object to replicate your XML shape definitions.
+  2. Provide this `Shape` object to your `MaterialTheme`.
+
+     For more details, see [shapes](https://developer.android.com/develop/ui/compose/designsystems/material3#shapes).
+- If your app uses custom typography:
+
+  1. In your Compose code, define a `Typography` object in your Compose code to replicate your XML text styles and font definitions.
+  2. Provide this `Typography` object to your `MaterialTheme`.
+
+     For more details, see [typography](https://developer.android.com/develop/ui/compose/designsystems/material3#typography).
+
+| Compose role | XML name |
+|---|---|
+| `displayLarge` | `TextAppearance.Material3.DisplayLarge` |
+| `displayMedium` | `TextAppearance.Material3.DisplayMedium` |
+| `displaySmall` | `TextAppearance.Material3.DisplaySmall` |
+| `headlineLarge` | `TextAppearance.Material3.HeadlineLarge` |
+| `headlineMedium` | `TextAppearance.Material3.HeadlineMedium` |
+| `headlineSmall` | `TextAppearance.Material3.HeadlineSmall` |
+| `titleLarge` | `TextAppearance.Material3.TitleLarge` |
+| `titleMedium` | `TextAppearance.Material3.TitleMedium` |
+| `titleSmall` | `TextAppearance.Material3.TitleSmall` |
+| `bodyLarge` | `TextAppearance.Material3.BodyLarge` |
+| `bodyMedium` | `TextAppearance.Material3.BodyMedium` |
+| `bodySmall` | `TextAppearance.Material3.BodySmall` |
+| `labelLarge` | `TextAppearance.Material3.LabelLarge` |
+| `labelMedium` | `TextAppearance.Material3.LabelMedium` |
+| `labelSmall` | `TextAppearance.Material3.LabelSmall` |
+
+## Step 5: Migrate styles (styles.xml)
+
+XML styles (styles.xml) system defines styles and appearance of:
+1. Widgets, components, themes for windows and dialogs
+2. Typography
+3. Themes and overlays
+4. Shapes
+
+XML Views and components combine multiple attributes to create a style.
+They set their styles from styles.xml in two different ways:
+1. Setting "style="@style/..." directly and explicitly in the XML View
+2. Setting the style indirectly and implicitly for a component as part of a larger Theme (theme.xml)
+
+Styles have no direct equivalent in Compose - instead styles are passed as:
+parameters to composables, defined in the AppTheme, or by creating layered,
+reusable composable variations with the defined style.
+
+Provide separate @Composable functions named according to the style and the
+base component, to signify the difference in styling and use cases for those
+components.
+
+- **Pattern:** If an XML element uses a custom style (e.g., `style="@style/MyPrimaryButton"`), don't try to replicate the style inline. Instead, suggest creating a specific composable.
+- **Example:**
+  - *XML:* `<Button style="@style/MyPrimaryButton" ... />`
+  - *Compose:* `MyPrimaryButton(onClick = { ... })`
+- **Common Attribute Groups:** If a style sets common modifiers (like padding + height), extract them into a readable extension property or a shared Modifier variable.
+
+### Common examples
+
+| XML | Compose |
+|---|---|
+| `Theme.MaterialComponents.*` | `MaterialTheme(colorScheme, typography, shapes) { }` |
+| `TextAppearance.Material3.BodyMedium` | `TextStyle(...)` defined in `Typography(bodyMedium = ...)` |
+| `ShapeAppearance.*.SmallComponent` | `Shapes(small = RoundedCornerShape(X.dp))` |
+| `Widget.MaterialComponents.Button` | `Button(colors = ButtonDefaults.buttonColors(...))` |
+| `Widget.MaterialComponents.CardView` | `Card(shape=..., elevation=..., colors=...)` |
+| `Widget.*.TextInputLayout.OutlinedBox` | `OutlinedTextField(colors = OutlinedTextFieldDefaults.colors(...))` |
+| `Widget.*.Chip.Filter` | `FilterChip(colors = FilterChipDefaults.filterChipColors(...))` |
+| `Widget.*.Toolbar.Primary` | `TopAppBar(colors = TopAppBarDefaults.topAppBarColors(...))` |
+| `Widget.*.FloatingActionButton` | `FloatingActionButton(containerColor = ...)` |
+| `backgroundTint` | `containerColor` in `ComponentDefaults.ComponentColors()` |
+| `android:textColor` | `contentColor` in `ComponentDefaults.ComponentColors()` |
+| `cornerRadius` | `shape = RoundedCornerShape(X.dp)` |
+| `android:elevation` | `elevation = ComponentDefaults.elevation(defaultElevation = X.dp)` |
+| `android:padding` | `contentPadding = PaddingValues(...)` or `Modifier.padding()` |
+| `android:minHeight` | `Modifier.heightIn(min = X.dp)` |
+| `strokeColor` + `strokeWidth` | `border = BorderStroke(width, color)` |
+| `android:textSize` | `fontSize = X.sp` in `TextStyle` |
+
+## Step 6: Validate the theme migration
+
+Always use the existing theme values from the original XML theme as the source
+of truth for the new Material Theme in Compose
+Never invent new theme values during migration, to maintain brand consistency
+and avoid visual regressions.
+
+Verify all new Compose theme values match the existing XML values.
+Don't hardcode any migrated values.

package/templates/android-compose/skeleton/agent-env/skills/harness-xml-to-compose/references/android/develop/ui/compose/setup-compose-dependencies-and-compiler.md

@@ -0,0 +1,183 @@
+## Set up the Compose Compiler Gradle plugin
+
+For Gradle, use the Compose Compiler Gradle plugin to set
+up and configure Compose.
+
+> [!NOTE]
+> **Note:** The Compose Compiler Gradle Plugin is only available from Kotlin 2.0+. For migration instructions, see ["Jetpack Compose compiler moving to the Kotlin
+> repository"](https://android-developers.googleblog.com/2024/04/jetpack-compose-compiler-moving-to-kotlin-repository.html).
+
+### Set up with Gradle version catalogs
+
+Set up the Compose Compiler Gradle plugin:
+
+1. In the `libs.versions.toml` file, remove any reference to the Compose Compiler.
+2. In the `versions` and `plugins` sections, add the new dependency:
+
+    [versions]
+    kotlin = "2.3.10"
+
+    [plugins]
+    org-jetbrains-kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+
+    // Add this line
+    compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+
+1. In the project's root `build.gradle.kts` file, add the following to the `plugins` section.
+
+    plugins {
+       // Existing plugins
+       alias(libs.plugins.compose.compiler) apply false
+    }
+
+1. In each module that uses Compose, apply the plugin:
+
+    plugins {
+       // Existing plugins
+       alias(libs.plugins.compose.compiler)
+    }
+
+The project should now build and compile if it was using the default set up. If
+it had configured custom options on the Compose compiler, follow the next
+section.
+
+### Set up the Compose Compiler without Gradle version catalogs
+
+Add the plugin to `build.gradle.kts` files associated with modules where Compose
+is used:
+
+    plugins {
+        id("org.jetbrains.kotlin.plugin.compose") version "2.3.10" // this version matches your Kotlin version
+    }
+
+Add the classpath to your top-level project `build.gradle.kts` file:
+
+    buildscript {
+        dependencies {
+            classpath("org.jetbrains.kotlin.plugin.compose:org.jetbrains.kotlin.plugin.compose.gradle.plugin:2.3.10")
+        }
+    }
+
+### Configuration options with the Compose Compiler Gradle Plugin
+
+To configure the Compose compiler using the Gradle plugin, add the
+`composeCompiler` block to the module's `build.gradle.kts` file at the top
+level:
+
+    android { ... }
+
+    composeCompiler {
+        reportsDestination = layout.buildDirectory.dir("compose_compiler")
+        stabilityConfigurationFile = rootProject.layout.projectDirectory.file("stability_config.conf")
+    }
+
+For the full list of available options, see the [documentation](https://www.jetbrains.com/help/kotlin-multiplatform-dev/compose-compiler.html#compose-compiler-options-dsl).
+
+## Set up Compose dependencies
+
+Always use the latest Compose BOM version: `2026.03.00`.
+
+Set the `compose` flag to `true` inside the Android [`BuildFeatures`](https://developer.android.com/reference/tools/gradle-api/7.0/com/android/build/api/dsl/BuildFeatures)
+to enable [Compose functionality](https://developer.android.com/develop/ui/compose/tooling) in Android Studio.
+
+Add the following definition to your app's `build.gradle` file:
+
+### Groovy
+
+    android {
+        buildFeatures {
+            compose true
+        }
+    }
+
+### Kotlin
+
+    android {
+        buildFeatures {
+            compose = true
+        }
+    }
+
+Add the Compose BOM and the subset of Compose library dependencies:
+
+### Groovy
+
+    dependencies {
+
+        def composeBom = platform('androidx.compose:compose-bom:2026.03.00')
+        implementation composeBom
+        androidTestImplementation composeBom
+
+        // Choose one of the following:
+        // Material Design 3
+        implementation 'androidx.compose.material3:material3'
+        // or skip Material Design and build directly on top of foundational components
+        implementation 'androidx.compose.foundation:foundation'
+        // or only import the main APIs for the underlying toolkit systems,
+        // such as input and measurement/layout
+        implementation 'androidx.compose.ui:ui'
+
+        // Android Studio Preview support
+        implementation 'androidx.compose.ui:ui-tooling-preview'
+        debugImplementation 'androidx.compose.ui:ui-tooling'
+
+        // UI Tests
+        androidTestImplementation 'androidx.compose.ui:ui-test-junit4'
+        debugImplementation 'androidx.compose.ui:ui-test-manifest'
+
+        // Optional - Add window size utils
+        implementation 'androidx.compose.material3.adaptive:adaptive'
+
+        // Optional - Integration with activities
+        implementation 'androidx.activity:activity-compose:1.13.0'
+        // Optional - Integration with ViewModels
+        implementation 'androidx.lifecycle:lifecycle-viewmodel-compose:2.10.0'
+        // Optional - Integration with LiveData
+        implementation 'androidx.compose.runtime:runtime-livedata'
+        // Optional - Integration with RxJava
+        implementation 'androidx.compose.runtime:runtime-rxjava2'
+
+    }
+
+### Kotlin
+
+    dependencies {
+
+        val composeBom = platform("androidx.compose:compose-bom:2026.03.00")
+        implementation(composeBom)
+        androidTestImplementation(composeBom)
+
+        // Choose one of the following:
+        // Material Design 3
+        implementation("androidx.compose.material3:material3")
+        // or skip Material Design and build directly on top of foundational components
+        implementation("androidx.compose.foundation:foundation")
+        // or only import the main APIs for the underlying toolkit systems,
+        // such as input and measurement/layout
+        implementation("androidx.compose.ui:ui")
+
+        // Android Studio Preview support
+        implementation("androidx.compose.ui:ui-tooling-preview")
+        debugImplementation("androidx.compose.ui:ui-tooling")
+
+        // UI Tests
+        androidTestImplementation("androidx.compose.ui:ui-test-junit4")
+        debugImplementation("androidx.compose.ui:ui-test-manifest")
+
+        // Optional - Add window size utils
+        implementation("androidx.compose.material3.adaptive:adaptive")
+
+        // Optional - Integration with activities
+        implementation("androidx.activity:activity-compose:1.13.0")
+        // Optional - Integration with ViewModels
+        implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.10.0")
+        // Optional - Integration with LiveData
+        implementation("androidx.compose.runtime:runtime-livedata")
+        // Optional - Integration with RxJava
+        implementation("androidx.compose.runtime:runtime-rxjava2")
+
+    }
+
+> [!NOTE]
+> **Note:** Jetpack Compose is shipped using a Bill of Materials (BOM), to keep the versions of all library groups in sync. Read more about it in the [Bill of
+> Materials page](https://developer.android.com/develop/ui/compose/bom/bom).

package/templates/android-compose/skeleton/agent-env/skills/harness-xml-to-compose/references/identify-optimal-xml-candidate.md

@@ -0,0 +1,31 @@
+### 1. Analysis scope
+
+**Action:** Use find files and examine all XML layout files within the project (typically located in `res`directories). For each file, parse the view hierarchy and metadata.
+
+### 2. Selection criteria
+
+Prioritize layouts that meet the following criteria:
+
+- **Hierarchy depth:** Target **leaf nodes** or components at the bottom of the UI tree.
+- **Complexity:** Select layouts with the **smallest number of nested children** and minimal logic.
+- **State management:** Prioritize **stateless** components or those with the fewest UI state variables.
+- **Dependency footprint:** Identify layouts with **zero to minimal external UI dependencies**.
+- **Isolation:** Focus on **self-contained** components that do not rely heavily on parent context or complex data binding.
+
+### 3. Risk assessment
+
+Evaluate the migration risk based on:
+\* **Reusability:** Find layouts with **minimum reuse** across the project to limit regression impact.
+\* **Accessibility:** Ensure the layout has an **easily accessible entry point** (e.g., used in a simple Activity, Fragment, or as a standalone include).
+
+*** ** * ** ***
+
+## Output requirements
+
+Provide a ranked list of the top 3-5 candidates. For each candidate, include:
+1. **File path:** (e.g., `res/layout/item_user_profile.xml`)
+2. **Rationale:** Why this is a good candidate based on the provided criteria.
+3. **Complexity score:** A rating from 1-5 (1 being simplest).
+4. **Dependency count:** List of custom/external views found within.
+
+**Action:** If you support user interaction, ask the user to choose which XML to proceed with. Else proceed with the best option, based on the previous criteria.

package/templates/android-compose/skeleton/agent-env/skills/harness-xml-to-compose/references/xml-layout-migration.md

@@ -0,0 +1,86 @@
+## 1. Structural analysis \& mapping
+
+**Identify the precise mapping** between XML elements and Compose equivalents.
+You must determine:
+
+- The exact `@Composable` functions (e.g., `ConstraintLayout`, `Column`, `LazyColumn`) that replace the XML tag hierarchy.
+- The specific parameters and `Modifier` extensions required to replicate XML attributes (e.g., `layout_width`, `padding`, `elevation`).
+- The appropriate state management strategy for interactive elements.
+
+## 2. Migration execution
+
+**Convert the XML layout code to Jetpack Compose**, ensuring the visual
+hierarchy and layout logic are preserved while leveraging Compose's declarative
+nature.
+
+## 3. Theming \& design system integrity
+
+**Do not use hard-coded values.** Follow these rules for styling:
+
+- **Token Alignment:** Cross-reference XML dimensions, colors, and style attributes with the existing Compose `Theme` (e.g., `MaterialTheme.colorScheme` or custom design system tokens).
+- **Reuse over Creation:** If matching values exist in the current Compose theme, reuse them. If a value is missing but required for the design, define it within the theme structure rather than hard-coding it in the Composable.
+- **Project Consistency:** You **MUST** strictly adhere to existing code conventions, naming standards, and implementation patterns found in the project. **Prioritize** project-specific reusable components over generic Material defaults.
+
+## 4. Component layering \& reusability
+
+Evaluate if the XML layout serves as a foundation-level design system component
+(reused across the app with a distinct role). If it is:
+
+- **Create a reusable composable:** Do not just inline the code. Define a new standalone `@Composable`.
+- **Parameterization:** Expose specific parameters for variable data (text, colors, styles) and use `Modifier` for layout-specific customizations.
+- **Feature parity \& restriction:** Ensure the new composable enforces the same UI constraints as the original XML component, preventing unauthorized style overrides while maintaining the intended flexibility.
+
+Example before migration:
+
+    <style
+        name="Widget.Rounded.Button"
+        parent="Widget.Button.Borderless">
+        <item name="android:fontFamily">sans-serif-medium</item>
+        <item name="android:minWidth">@dimen/min_width</item>
+        <item name="android:paddingStart">@dimen/padding_2</item>
+        <item name="android:paddingEnd">@dimen/padding_2</item>
+        <item name="cornerRadius">8dp</item>
+    </style>
+
+Example after migration:
+
+
+```kotlin
+@Composable
+fun RoundedBorderlessButton(
+    text: String,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+    enabled: Boolean = true
+) {
+    TextButton(
+        onClick, modifier
+            .defaultMinSize(minWidth = dimensionResource(R.dimen.min_width))
+            .padding(
+                start = dimensionResource(R.dimen.padding_2),
+                end = dimensionResource(R.dimen.padding_2)
+            ), enabled, shape = RoundedCornerShape(8.dp),
+        colors = ButtonDefaults.textButtonColors(
+            contentColor = MaterialTheme.colorScheme.primary
+        )
+    ) {
+        Text(
+            text = text,
+            style = MaterialTheme.typography.bodyMedium.copy(
+                fontFamily = FontFamily.SansSerif,
+                fontWeight = FontWeight.Medium
+            )
+        )
+    }
+}
+```
+
+<br />
+
+*** ** * ** ***
+
+## 5. Output requirements
+
+- Provide the full Kotlin file content.
+- Include necessary imports.
+- Add documentation comments (`/** ... */`) explaining the mapping logic for complex transformations.

package/templates/android-xml/skeleton/agent-env/rules/seed-aidl-thread.md

@@ -0,0 +1,29 @@
+# AIDL 回调切主线程（种子规则）
+
+> 种子规则：可保留、修改或删除。
+
+## 是什么
+
+所有通过 AIDL / Messenger / IPC 跨进程回传的结果，UI 消费前必须切主线程；
+禁止在 Binder 线程直接更新 UI 或修改 LiveData/StateFlow 的主观察者。
+
+## 正例
+
+```java
+private final IWirelessCallback aidlCb = new IWirelessCallback.Stub() {
+    @Override public void onState(WirelessState s) {
+        mainHandler.post(() -> liveData.setValue(s));
+    }
+};
+```
+
+## 反例
+
+```java
+// ❌ Binder 线程直接 setValue，LiveData 会抛异常
+public void onState(WirelessState s) { liveData.setValue(s); }
+```
+
+## 如何检测
+
+- AIDL `.Stub` 实现内 grep `liveData\.setValue` / `view\.` 命中即违规。

package/templates/android-xml/skeleton/agent-env/rules/seed-lifecycle-awareness.md

@@ -0,0 +1,32 @@
+# 生命周期感知（种子规则）
+
+> 种子规则：可保留、修改或删除。
+
+## 是什么
+
+订阅 / 注册 / 监听，必须在 `onStart` 建立、在 `onStop` 释放（或更严格），
+避免在 `onCreate`/`onDestroy` 对称以外的地方偷偷改动。
+
+## 正例
+
+```java
+@Override protected void onStart() {
+    super.onStart();
+    controller.setDataChangeListener(callback);
+}
+@Override protected void onStop() {
+    controller.removeDataChangeListener(callback);
+    super.onStop();
+}
+```
+
+## 反例
+
+```java
+// ❌ onCreate 注册、onDestroy 释放：Activity 不可见时仍回调
+@Override protected void onCreate(Bundle s) { controller.setDataChangeListener(cb); }
+```
+
+## 如何检测
+
+- PR 评审：任何 `setXxxListener` 必须在同一类中能找到对称 `removeXxxListener`。

package/templates/android-xml/skeleton/agent-env/rules/seed-mvc-layering.md

@@ -0,0 +1,32 @@
+# MVC 分层铁律（种子规则）
+
+> 种子规则：可保留、修改或删除。
+
+## 是什么
+
+Activity / Fragment 只能依赖 ViewModel 或 Presenter；不得直接访问 Repository、
+Manager、AIDL 代理、`CarPropertyManager`，也不得在 Activity 里解析数据。
+
+## 正例
+
+```java
+public class WirelessFragment extends BaseFragment {
+    private WirelessViewModel viewModel;
+
+    @Override public void onViewCreated(@NonNull View v, Bundle s) {
+        viewModel.getState().observe(getViewLifecycleOwner(), this::render);
+    }
+    private void render(WirelessState s) { binding.sw.setChecked(s.isEnabled()); }
+}
+```
+
+## 反例
+
+```java
+// ❌ Activity 直接调 Manager
+MyCarPropertyManager.INSTANCE().sendSignal(ID, new int[]{1}, "");
+```
+
+## 如何检测
+
+- UI 目录下 grep `MyCarPropertyManager` / `CarPropertyManager` 命中即违规。

package/templates/android-xml/skeleton/agent-env/rules/seed-view-binding.md

@@ -0,0 +1,33 @@
+# 禁止 findViewById（种子规则）
+
+> 种子规则：可保留、修改或删除。
+
+## 是什么
+
+Activity / Fragment 必须使用 DataBinding 或 ViewBinding 访问视图，
+严禁 `findViewById` + 手动 cast。
+
+## 正例
+
+```java
+public class WirelessActivity extends BaseActivity {
+    private ActivityWirelessBinding binding;
+    @Override protected void onCreate(Bundle s) {
+        super.onCreate(s);
+        binding = ActivityWirelessBinding.inflate(getLayoutInflater());
+        setContentView(binding.getRoot());
+        binding.sw.setOnCheckedChangeListener((v, c) -> vm.setEnabled(c));
+    }
+}
+```
+
+## 反例
+
+```java
+// ❌ 手写 findViewById
+Switch sw = (Switch) findViewById(R.id.sw);
+```
+
+## 如何检测
+
+- grep `findViewById\s*\(` 命中即违规（过渡期可加白名单）。

package/templates/android-xml/skeleton/agent-env/rules/seed-xml-styling.md

@@ -0,0 +1,27 @@
+# XML 样式不得硬编码（种子规则）
+
+> 种子规则：可保留、修改或删除。
+
+## 是什么
+
+`color` / `dimen` / `textSize` 等视觉属性必须走 `@color/...` / `@dimen/...` / `style`，
+禁止在 layout XML 里硬编码 `#RRGGBB` 或 `16dp`。
+
+## 正例
+
+```xml
+<TextView
+    android:textSize="@dimen/text_body"
+    android:textColor="@color/fg_primary" />
+```
+
+## 反例
+
+```xml
+<!-- ❌ 直接写字面量 -->
+<TextView android:textSize="16sp" android:textColor="#FFFFFF" />
+```
+
+## 如何检测
+
+- 对 `res/layout/**/*.xml` grep `#[0-9A-Fa-f]{6}` / `\d+(sp|dp)\s*"` 命中即违规。

package/templates/cpp/skeleton/agent-env/rules/seed-cmake-explicit-sources.md

@@ -0,0 +1,31 @@
+# CMake target 显式列源文件（种子规则）
+
+> 种子规则：可保留、修改或删除。
+
+## 是什么
+
+每个库 / 可执行 target 必须显式列出源文件，**禁止** `file(GLOB ...)` 搜集源文件；
+理由：GLOB 不会触发 CMake 重新生成，新增/删除文件编译结果错乱难以察觉。
+
+## 正例
+
+```cmake
+add_library(wireless STATIC
+    wireless_controller.cpp
+    wireless_parser.cpp
+    wireless_sender.cpp)
+target_include_directories(wireless PUBLIC include)
+target_link_libraries(wireless PUBLIC common core)
+```
+
+## 反例
+
+```cmake
+# ❌ 新增文件不会触发重新配置
+file(GLOB SRCS "*.cpp")
+add_library(wireless STATIC ${SRCS})
+```
+
+## 如何检测
+
+- grep 所有 `CMakeLists.txt`：`file\s*\(\s*GLOB` 命中即违规。