@bonesofspring/ai-rules 0.2.15 → 0.2.16

package/presets/claude/android-kotlin/rules/tooling-and-review/preset-pr-checklist.md

@@ -0,0 +1,39 @@
+---
+description: Preset authoring: PR checklist for twin sync, budget, leakage, README. Use on preset PRs.
+paths:
+  - packages/ai-rules/presets/**/*
+  - .claude/**/*
+  - .cursor/rules/**/*
+  - .cursor/team/tasks/**/*
+---
+
+<!-- shared-core: meta/preset-pr-checklist.md -->
+
+# Preset PR checklist
+
+Checklist for PRs that touch `packages/ai-rules/presets/**` (and dogfood `.cursor/` sync).
+
+## Before merge
+
+- [ ] **SoT:** edits in `packages/…` (not only root `.cursor/`)
+- [ ] **Core:** if `_shared/core/**` changed — all `<!-- shared-core: … -->` consumers updated (or documented intentional fork)
+- [ ] **Twin:** Cursor change → Claude twin **same PR** (**FAIL** if missing on next, nuxt, svelte, ios-swift, android-kotlin, go, java, mcp-ts, php-hexagonal, and php-laravel — see `preset-twin-sync`)
+- [ ] **Mapping:** `claude/<stack>/rules/README.md` mapping table is current
+- [ ] **Token budget:** alwaysApply / session-start ≤ 3; meta rules not always-on
+- [ ] **Leakage:** no foreign stack agent stems / handoff strings (`preset-no-cross-stack-leakage`)
+- [ ] **Twin depth:** domain ≥15 lines; thin aliases documented
+- [ ] **README:** stack `rules/README.md` core→stack mapping / catalog updated if stems added
+- [ ] **CHANGELOG / package README:** note when public preset paths or install surface change
+- [ ] **Dogfood:** run `packages/ai-rules/scripts/sync-dogfood-cursor.sh` (or document intentional skip) when maintaining this monorepo
+- [ ] **shared-core drift:** for embed-mode stems, run `packages/ai-rules/scripts/check-shared-core-drift.sh` (or document intentional fork)
+
+## Pointers
+
+- Layering: `preset-layering`
+- Sync: `preset-twin-sync`
+- Budget: `preset-token-budget`
+- Leakage: `preset-no-cross-stack-leakage`
+- Validation: stack `agents/build-verifier.md` → preset-structure section
+- Dogfood script: `packages/ai-rules/scripts/sync-dogfood-cursor.sh`
+- Drift script: `packages/ai-rules/scripts/check-shared-core-drift.sh`
+- Orchestrator: when editing presets, load this checklist + twin-sync

package/presets/claude/android-kotlin/rules/tooling-and-review/preset-token-budget.md

@@ -0,0 +1,41 @@
+---
+description: Preset authoring: ≤3 always-on / session-start; meta rules never alwaysApply.
+paths:
+  - packages/ai-rules/presets/**/*
+  - .claude/**/*
+  - .cursor/rules/**/*
+  - .cursor/team/tasks/**/*
+---
+
+<!-- shared-core: meta/preset-token-budget.md -->
+
+# Preset token budget
+
+Invariants for rule loading in an **installed** preset (consumer app).
+
+## Hard caps
+
+| Platform | Always-on | Cap |
+|----------|-----------|-----|
+| Cursor | `alwaysApply: true` | **≤ 3** |
+| Claude | rules **without** `paths:` | **exactly 3** |
+
+**Claude Option A (README exclusion):** when counting Claude rules without `paths:` / session-start, **exclude `**/README.md`** (topic indexes are not session-start rules). The intended session-start trio remains **exactly 3**; body budget sums **only those 3** rules.
+
+Session-start body budget (where documented): ≤140 lines total (stretch ≤120).
+
+## Meta / author rules
+
+Rules for preset authors (`preset-layering`, `preset-twin-sync`, …):
+
+- **Never** `alwaysApply: true` on consumer installs.
+- Cursor: `globs` limited to `packages/ai-rules/presets/**` (and dogfood `.cursor/**` where useful).
+- Claude: `paths:` limited to `packages/ai-rules/presets/**` (and `.claude/**` dogfood if present).
+
+## Heavy workflows
+
+Orchestrator, feature-delivery, code-review, post-change gates, domain globs — **requestable / paths**, not always-on.
+
+## Verifier
+
+build-verifier **FAIL** if alwaysApply / session-start count exceeds 3 (Claude count **excludes `**/README.md`**), or if a `preset-*` meta rule is marked always-on.

package/presets/claude/android-kotlin/rules/tooling-and-review/preset-twin-sync.md

@@ -0,0 +1,56 @@
+---
+description: Preset authoring: Cursor SoT → Claude twin same PR. Use when editing preset rules.
+paths:
+  - packages/ai-rules/presets/**/*
+  - .claude/**/*
+  - .cursor/rules/**/*
+  - .cursor/team/tasks/**/*
+---
+
+<!-- shared-core: meta/preset-twin-sync.md -->
+
+# Preset twin sync
+
+Cursor `.mdc` — **SoT per stack**. Claude topic `.md` — derived twin.
+
+## Matrix
+
+| Stack | Cursor SoT | Claude derive | Mapping table |
+|-------|------------|---------------|---------------|
+| `next` | `presets/cursor/next/rules/*.mdc` | `presets/claude/next/rules/<topic>/` | **Required** in `claude/next/rules/README.md` |
+| `nuxt` | `presets/cursor/nuxt/rules/*.mdc` | `presets/claude/nuxt/rules/<topic>/` | **Required** in `claude/nuxt/rules/README.md` |
+| `svelte` | `presets/cursor/svelte/rules/*.mdc` | `presets/claude/svelte/rules/<topic>/` | **Required** in `claude/svelte/rules/README.md` |
+| `ios-swift` | `presets/cursor/ios-swift/rules/*.mdc` | `presets/claude/ios-swift/rules/<topic>/` | Keep in `claude/ios-swift/rules/README.md` |
+| `go` | `presets/cursor/go/rules/*.mdc` | `presets/claude/go/rules/<topic>/` | Keep in `claude/go/rules/README.md` |
+| `java` | `presets/cursor/java/rules/*.mdc` | `presets/claude/java/rules/<topic>/` | Keep in `claude/java/rules/README.md` |
+| `mcp-ts` | `presets/cursor/mcp-ts/rules/*.mdc` | `presets/claude/mcp-ts/rules/<topic>/` | Keep in `claude/mcp-ts/rules/README.md` |
+| `php-hexagonal` | `presets/cursor/php-hexagonal/rules/*.mdc` | `presets/claude/php-hexagonal/rules/<topic>/` | Keep in `claude/php-hexagonal/rules/README.md` |
+| `php-laravel` | `presets/cursor/php-laravel/rules/*.mdc` | `presets/claude/php-laravel/rules/<topic>/` | Keep in `claude/php-laravel/rules/README.md` |
+| `android-kotlin` | `presets/cursor/android-kotlin/rules/*.mdc` | `presets/claude/android-kotlin/rules/<topic>/` | Keep in `claude/android-kotlin/rules/README.md` |
+
+## Same-PR checklist
+
+1. Edit Cursor rule first (body + frontmatter).
+2. Update Claude twin: body + `paths:` (from Cursor `globs:` / requestable triggers); drop `alwaysApply`.
+3. Update mapping table row if stem/path changed.
+4. If body embeds core (`<!-- shared-core: … -->`), sync core consumers across stacks when core changed.
+
+## Twin depth
+
+- **Domain** rules: ≥15 body lines (FAIL if thin without documented alias reason).
+- **Thin aliases** (`agent-team-intake`, `technical-retro`): may be shorter (soft) if they only point to a command/skill.
+
+## Severity (build-verifier)
+
+- **next:** missing Claude twin for a changed Cursor rule → **FAIL** (mapping table required).
+- **nuxt:** missing Claude twin for a changed Cursor rule → **FAIL** (mapping table required).
+- **svelte:** missing Claude twin for a changed Cursor rule → **FAIL** (mapping table required).
+- **ios-swift:** missing Claude twin for a changed Cursor rule → **FAIL**.
+- **go:** missing Claude twin for a changed Cursor rule → **FAIL** (same as next / ios-swift; mapping table required).
+- **java:** missing Claude twin for a changed Cursor rule → **FAIL** (same as next / ios-swift / go; mapping table required).
+- **mcp-ts:** missing Claude twin for a changed Cursor rule → **FAIL** (same as next / ios-swift / go / java; mapping table required).
+- **php-hexagonal:** missing Claude twin for a changed Cursor rule → **FAIL** (same as next / ios-swift / go / java / mcp-ts; mapping table required).
+- **php-laravel:** missing Claude twin for a changed Cursor rule → **FAIL** (same as next / ios-swift / go / java / mcp-ts / php-hexagonal; mapping table required).
+- **android-kotlin:** missing Claude twin for a changed Cursor rule → **FAIL** (same as next / ios-swift / go / java / mcp-ts / php-*; mapping table required).
+
+Dogfood: sync packages → root `.cursor/` after Cursor SoT changes (not the reverse). Use `packages/ai-rules/scripts/sync-dogfood-cursor.sh`.

package/presets/claude/android-kotlin/rules/tooling-and-review/security-android.md

@@ -0,0 +1,29 @@
+---
+description: Android secrets, TLS, and build-wrapper security policy (generic)
+paths:
+  - "**/network/**"
+  - "**/security/**"
+  - "**/*NetworkSecurity*"
+---
+
+# Security (Android, generic)
+
+- **Secrets:** never commit API keys, keystore passwords, or tokens; use CI secrets / local untracked properties already used by the repo.
+- **TLS:** prefer platform HTTPS defaults; network security config changes must be explicit and reviewed.
+- **Storage:** sensitive tokens go to Android Keystore / encrypted storage patterns already in the repo — not plain `SharedPreferences`/files.
+- **Build wrappers:** treat `gradlew` / documented wrappers as the supported entry; do not download unsigned wrapper JARs ad hoc.
+- **Logging:** never log PII, tokens, or Authorization headers.
+
+# Agent requirements
+
+- `security-reviewer` on auth/storage/network changes.
+- Do not weaken TLS or cleartext policy without explicit AC.
+
+# IPC & exports
+
+- Exported components and deep links must match existing permission/export patterns.
+- Do not broaden `exported=true` or cleartext traffic without explicit AC.
+- Certificate pinning — only when the repo already uses it; do not invent a pinning stack.
+
+- Review ProGuard/R8 keep rules when touching reflection/serialization used for auth.
+- Backup/export rules must not unintentionally expose encrypted stores.

package/presets/claude/android-kotlin/rules/tooling-and-review/technical-retro.md

@@ -0,0 +1,18 @@
+---
+description: Agent role for a technical retrospective (retro) of the team / sprint. On-demand — prefer the /technical-retro slash command.
+paths:
+  - .claude/commands/**/*
+  - .claude/team/**/*
+---
+
+<!-- shared-core: review/technical-retro.md -->
+
+# Technical retro — rule alias
+
+Full scenario (including the **“Agent work”** block for a slug from team tasks) lives in the slash command:
+
+**`commands/technical-retro.md`** → `/technical-retro`
+
+When a task has `metrics.json`, use the local aggregation script and state the cohort, sample size, incomplete artifacts, attribution confidence, active attempt duration, and human-gate wait separately. Do not score malformed artifacts or gate wait as agent work.
+
+Use this rule only if the command is unavailable. Do not duplicate the command contents in the response — follow the command file and skill `technical-retro`.

package/presets/claude/android-kotlin/rules/ui-and-accessibility/README.md

@@ -0,0 +1,7 @@
+# ui-and-accessibility
+
+| File | Cursor SoT |
+|------|------------|
+| [`compose.md`](./compose.md) | `compose-ui.mdc` |
+| [`viewmodels.md`](./viewmodels.md) | `state-and-viewmodels.mdc` |
+| [`navigation.md`](./navigation.md) | `navigation-feature-launcher.mdc` |

package/presets/claude/android-kotlin/rules/ui-and-accessibility/compose.md

@@ -0,0 +1,31 @@
+---
+description: Jetpack Compose Material 3 and design-system UI conventions
+paths:
+  - "**/presentation/**"
+  - "**/ui/**"
+  - "**/*Screen*.kt"
+---
+
+# Compose UI
+
+- Prefer **Jetpack Compose Material 3** plus the project **design-system** components/tokens.
+- Screens stay thin: collect state from ViewModels; emit intents/events upward; no repository/HTTP calls in composables.
+- Reuse existing design-system building blocks before inventing one-off styling.
+- Accessibility: content descriptions, semantics, focus order — match repo a11y conventions; `accessibility-reviewer` when UI changes.
+- Previews/fakes for UI states when the module already uses them.
+
+# Boundaries
+
+- Composables depend on presentation state models — not data DTOs.
+- Navigation calls go through feature launcher ports / nav APIs — see `ui-and-accessibility/navigation`.
+
+# Agent requirements
+
+- Place UI under presentation/ui packages next to analogs.
+- Do not add a second design system or raw Material overrides that fight tokens.
+
+# State rendering
+
+- Render loading / empty / error / content from ViewModel state — no hidden local business rules.
+- Hoist state as the repo does; avoid duplicating ViewModel state in remember blocks.
+- Side-effect APIs (`LaunchedEffect`, etc.) only for UI concerns, not repository calls.

package/presets/claude/android-kotlin/rules/ui-and-accessibility/navigation.md

@@ -0,0 +1,30 @@
+---
+description: Cross-feature navigation via public launcher-style ports
+paths:
+  - "**/navigation/**"
+  - "**/*Launcher*.kt"
+---
+
+# Navigation / feature launchers
+
+- Cross-feature navigation goes through **public launcher-style ports** declared in `features/<name>/api` (or equivalent).
+- App shells / hosts implement or wire those ports; features must not deep-import another feature’s screens.
+- Arguments and results are explicit, serializable contracts — avoid leaking impl types across modules.
+- Intra-feature navigation may use the repo’s local NavHost/router patterns.
+
+# Boundaries
+
+- Do not navigate by hard-coded activity/class names across feature boundaries when a launcher port exists.
+- Keep Compose destinations thin; navigation side effects originate from ViewModel effects or host wiring as in the repo.
+
+# Agent requirements
+
+- When adding a new entry point, extend the public api contract first, then wire the host.
+- Document deep-link / flavor-specific entry points next to existing analogs.
+
+# Testing & previews
+
+- Host wiring should remain mockable in JVM tests where the repo already tests navigation ports.
+- Do not embed feature impl screens into another feature’s navigation graph.
+
+- Deep links and app-link filters stay with the host/`applications/` wiring unless the feature api owns them.

package/presets/claude/android-kotlin/rules/ui-and-accessibility/viewmodels.md

@@ -0,0 +1,27 @@
+---
+description: MVI/UDF state on the project ViewModel base
+paths:
+  - "**/*ViewModel*.kt"
+---
+
+# State and ViewModels
+
+- Follow the repo’s **MVI / unidirectional** pattern on the project ViewModel base (name lives in consumer `team/conventions.md`).
+- Single source of UI state (StateFlow / immutable state holder); reduce via pure updates where practical.
+- Expose intents/events for user actions; do not mutate state from composables directly.
+- Side effects (navigation, one-shots) follow existing effect channels — do not invent a parallel bus.
+- ViewModels depend on domain/use-case ports — not concrete data clients.
+
+# Agent requirements
+
+- Keep mapping/DTO work out of ViewModels when mappers already exist in data.
+- Cover reducers/state transitions with JVM unit tests when non-trivial.
+- Avoid `!!` and unchecked casts in state plumbing.
+
+# Lifecycle
+
+- Use `viewModelScope` (or the project equivalent); do not launch unstructured globals.
+- Clear one-shot effects after handling to avoid replay on recomposition/rotation.
+- Keep mapping of domain models → UI models next to existing presenters/mappers.
+
+- Document non-obvious state machine transitions in the brief or a short KDoc on the reducer.

package/presets/claude/android-kotlin/skills/README.md

@@ -0,0 +1,14 @@
+# `.claude/skills` (preset android-kotlin)
+
+| Skill | Purpose |
+|-------|---------|
+| `feature-delivery` | Domain → Data → VM → View → tests → post-change-build |
+| `code-review` | Android MR checklist |
+| `unit-testing` | JUnit 4/5 (repo default) |
+| `instrumentation-ui-e2e` | Android instrumentation plan/generate/heal (← next `playwright-e2e`) |
+| `debug-investigation` | Runtime evidence before fix |
+| `ci-investigation` | Android CI red |
+| `technical-retro` | Retro facilitation |
+| `write-adr` | Architecture Decision Record (context / decision / consequences) |
+
+Copied to `.claude/skills/` on init.

package/presets/claude/android-kotlin/skills/ci-investigation/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: ci-investigation
+description: Investigates failing CI checks on PRs and branches — ./gradlew, ktlint/detekt, unit, Android instrumentation — with local reproduction and minimal fixes. Use when CI is red or for ci-fix pipeline tasks.
+---
+
+# CI Investigation (Android)
+
+## Workflow
+
+1. Identify the **first failing check** (compile, lint, unit, Android instrumentation, signing, Gradle modules).
+2. Capture error output — ignore cascading failures until root cause is found.
+3. Reproduce locally with the same scheme/destination CI uses (`tooling-and-review/gradle-tooling.md`):
+   - `./gradlew build` / `./gradlew test`
+   - ktlint/detekt / ktlint format scripts as in repo CI
+   - affected Android instrumentation if UI job failed
+4. Inspect git diff for changed files related to the failure.
+5. Apply **minimal fix** — no unrelated refactors.
+
+## Artifact
+
+Write `ci-report.md` under the task slug folder (`.claude/team/tasks/<slug>/`):
+
+- Failed check name and log excerpt
+- Root cause classification
+- Fix applied (or handoff to feature-developer)
+- `resolved: true|false`
+- Validation commands and results
+
+## Handoff Rules
+
+- Config-only or one-line fixes → fix in place, re-run check.
+- Missing tests or architecture work → document and route to `feature-developer` or `qa-tester`.
+- Flaky Android instrumentation → prefer `instrumentation-test-healer` after ci-investigator identifies the case.
+
+## Validation
+
+Always re-run the failing command locally before marking complete. If environment blocks execution (no simulator), state the exact command and blocker.
+
+Never run yarn/`lint:js`/Playwright — wrong stack.

package/presets/claude/android-kotlin/skills/code-review/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: code-review
+description: Reviews pull requests, merge requests, git diffs, and branch changes using Android architecture, Jetpack Compose, networking, and testing standards. Use when the user asks for review or when code-reviewer runs in an agent pipeline.
+---
+
+# Code Review (Android)
+
+## Inputs
+
+Use the local repository as the source of truth: `git status`, `git diff`, task artifacts under `.claude/team/tasks/<slug>/` when present, and opened files. Do not invent hosting metadata such as labels, CI status, or reviewers.
+
+## Review Order
+
+1. Understand the intent and affected Feature layers (Presentation / Domain / Data).
+2. Check correctness and regressions first.
+3. Verify architecture boundaries (`architecture/boundaries.md`): View ≠ API/DTO; ViewModel ≠ Data impl; Domain ≠ Jetpack Compose; Data ≠ Presentation.
+4. Check DI composition in `applications/`, Gradle modules public API (`architecture/module-public-api.md`), and no deep-imports across Features.
+5. Review Kotlin concurrency and conventions (`stack/kotlin-conventions.md`): `main-safe / viewModelScope`, typed errors, `!!`.
+6. Review Jetpack Compose thinness, Design System usage, `testTag` / semantics / contentDescription (`ui-and-accessibility/compose.md`).
+7. Check tests: unit for mapper/domain/VM (`testing/unit.md`); Android instrumentation for user flows (`testing/ui.md`).
+8. **Reuse lens:** flag new helpers that duplicate existing Feature/shared utilities; prefer public module APIs over copy-paste.
+9. **Efficiency lens:** unnecessary work on main thread, redundant network/persistence, hot-path bloat, missing cancellation/cleanup.
+10. Report validation gaps: `./gradlew`, ktlint/detekt, or relevant tests not run (`tooling-and-review/gradle-tooling.md`, `tooling-and-review/post-change-build.md`).
+
+## Output
+
+Lead with findings ordered by severity. Required shape (also in `code-review`):
+
+- Each finding: **`path:line`** — problem — impact — concrete fix direction.
+- Severity: **`blocker` | `important` | `nit`** (list blocker → nit).
+- Vague («looks risky») is not a finding — cite evidence or ask for surrounding context.
+- End with a verdict line: **`Safe to merge | needs changes | reject`**.
+- If there are no findings, say so and call out remaining test or validation risk.
+
+For agent team tasks, write `.claude/team/tasks/<slug>/review.md` and upsert the owned terminal receipt (`completed` or `changes_requested`); do not mutate `status.json`.
+
+## Design guidance
+
+- Load `design-guidance` (rule stem) when assessing structure, smells, or pattern fit.

package/presets/claude/android-kotlin/skills/debug-investigation/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: debug-investigation
+description: Investigates bugs, failing tests, crashes, and incorrect behavior with runtime evidence before applying minimal fixes. Use for bugfix tasks, debugger agent runs, regressions, and flaky test diagnosis.
+---
+
+# Debug Investigation (Android)
+
+## Process
+
+1. Reproduce the issue or collect the closest available evidence: Android Studio / AGP console, lldb backtrace, crash log, failing JUnit/Android instrumentation output, Profiler note, or user steps.
+2. Define expected vs actual behavior in one sentence.
+3. Trace the failing path through the smallest relevant Feature slice (Presentation → Domain → Data).
+4. Identify the root cause before editing. Avoid broad refactors during bugfixes.
+5. Apply the smallest fix that preserves existing architecture and public contracts.
+6. Add or update a regression JUnit when the behavior is domain/VM logic or likely to recur.
+7. Run the narrow failing check first (`./gradlew test` for the affected target), then broader build validation if needed (`tooling-and-review/gradle-tooling.md`).
+
+## Artifacts
+
+For agent team tasks, write `.claude/team/tasks/<slug>/debug-report.md` with:
+
+- Reproduction steps or evidence source.
+- Root cause.
+- Fix scope (`fixApplied`).
+- Regression coverage.
+- Remaining risk.
+
+Upsert the owned terminal receipt in `artifact-manifest.json` when complete; do not mutate `status.json`.
+
+Do not use browser e2e tooling — this is an Android Studio / AGP stack.
+
+## Design guidance
+
+- Load `design-guidance` (rule stem) when assessing structure, smells, or pattern fit.

package/presets/claude/android-kotlin/skills/feature-delivery/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: feature-delivery
+description: Delivers Android Kotlin/Jetpack Compose features end-to-end across Domain, Data, ViewModels, Views, tests, and post-change-build validation. Use when implementing or extending a feature, especially through /task or feature-developer.
+---
+
+# Feature Delivery (Android)
+
+1. Read task brief, acceptance criteria, and decomposition if present.
+2. Read `architecture/feature-delivery.md` and `architecture/reference-features.md` — Domain → Data → ViewModel → View → tests; mirror the closest Feature.
+3. Wire DI in `applications/` composition root; keep Views thin; keep DTOs out of ViewModels.
+4. Add or update focused JUnit for mappers / use cases / ViewModels (`testing/unit.md`).
+5. After Kotlin edits: **invoke** `tooling-and-review/post-change-build.md` (+ `tooling-and-review/gradle-tooling.md`). Pipeline: scoped build OK if next step is `build-verifier`.
+
+## Do / Don't
+
+- **Do** follow existing Feature folder layout and public module APIs.
+- **Do** add Compose `testTag` + `contentDescription` for new interactive UI when UI tests / a11y are in scope.
+- **Don't** invent alternate architecture or persistence stacks (e.g. MVI frameworks, Room vs SQLDelight) unless the repo already uses them.
+- **Don't** use yarn, browser e2e, or `app/src` paths — wrong stack.
+
+## Scope discipline
+
+Implement only the current AC / decomposition task. Clarify ambiguity before coding; do not add unrelated hardening, polish, or drive-by refactors. See `feature-developer` → **Zero improvisation**.
+
+## Preset packaging note
+
+When editing **ai-rules android-kotlin preset** sources (agents, hooks, rules) rather than an app Feature: keep Cursor and Claude trees in sync where applicable, and **fork / verify hook handoffs** (`hooks/chain-team-phases.sh`, guard scripts, team path conventions) so Cursor (`.cursor/team`) and Claude (`.claude/team`) do not regress against each other or against the next preset templates.
+
+## Handoff
+
+Summarize by layer, validation results, and known gaps. Agent team: upsert the owned terminal receipt in `artifact-manifest.json`; do not mutate `status.json`.
+
+## Design guidance
+
+- Load `design-guidance` (rule stem) when assessing structure, smells, or pattern fit.

package/presets/claude/android-kotlin/skills/instrumentation-ui-e2e/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: instrumentation-ui-e2e
+description: Plan, generate, and heal Android instrumentation UI tests using androidTest sources, project robots/page objects, and Gradle-discovered tasks. Use for instrumentation planning, generation, or fixing flaky UI tests.
+---
+
+# Instrumentation UI e2e (Android)
+
+1. Read brief/AC and existing `androidTest` analogs.
+2. Discover framework and helpers from the consumer repo (Espresso, Compose UI Test, or project-chosen alternatives).
+3. Prefer stable semantics / test tags aligned with presentation conventions (`ui-and-accessibility/compose` / `testing/ui`).
+4. Plan → generate → heal via agents `instrumentation-test-{planner,generator,healer}`.
+5. Run the narrowest Gradle instrumentation task via `tooling-and-review/gradle-tooling` when the environment allows; otherwise document the command for CI.
+
+## Do not
+
+- Require Playwright, XCUITest, or yarn frontend lint recipes.
+- Mandate a single UI-test library by name in always-on rules — discovery stays repo-driven.

package/presets/claude/android-kotlin/skills/technical-retro/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: technical-retro
+description: Facilitates technical retrospectives for tasks, sprints, incidents, releases, and agent-team pipelines. Use when the user asks for retro, postmortem, process review, or action items after delivery.
+---
+
+# Technical Retro
+
+## Inputs
+
+Ask for missing period, focus, task slug, participants, or format constraints. If a slug is provided, read `.claude/team/tasks/<slug>/` artifacts and local git status/diff. Do not invent facts not present in artifacts or the user's message.
+
+## Facilitation Principles
+
+- Focus on process and system behavior, not blame.
+- Separate facts, interpretations, and proposed actions.
+- Balance what worked with what slowed delivery.
+- Keep action items concrete, owned, and measurable.
+
+## Default Structure
+
+1. Goal and scope.
+2. Timeline or factual observations.
+3. What worked.
+4. What hurt quality, speed, or confidence.
+5. Root causes for the top one or two issues.
+6. Experiments and action items.
+
+## Agent Team Block
+
+For `/task` pipelines, include router, analyst, developer, **build-verifier** (./gradlew), reviewer, QA/Android instrumentation, hooks, and rules.
+
+## Wrong-turn taxonomy (optional)
+
+When artifacts or the user mention agent mistakes, tag incidents:
+
+| Kind | Signal |
+|------|--------|
+| `correction` | User pushback («no», «don't», «actually») |
+| `retry` | Same tool/approach 2+ times before success |
+| `waste` | Many searches before the right file |
+| `reversal` | Edit then revert / delete |
+| `dead-end` | Env/tool failure (missing binary, wrong path) |
+
+Severity: **high** (explicit correction / large waste) · **med** · **low**. Confidence 0–100 — be honest; low-confidence items are optional.
+
+## Preset feedback loop
+
+If the same issue appeared in **2+** tasks (or **3+** for packaging a new rule/skill — Rule of Three), add section **Preset updates**:
+
+- Proposed change to `.claude/rules/`, `.claude/agents/`, `.claude/skills/`, or **`.claude/team/conventions.md`** (prefer conventions for project gotchas)
+- One concrete snippet or file path
+- Whether it belongs in session-start vs `paths:` vs skill vs conventions (see `PRESET-CONTRIBUTION` → Building blocks)
+
+Do not apply preset or conventions changes without user approval.

package/presets/claude/android-kotlin/skills/unit-testing/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: unit-testing
+description: Plans, generates, and heals JUnit 4/5 (repo default) for mappers, use cases, and ViewModels using src/test and tests-unit rules. Use for unit test planning, generation, or fixing failing unit tests.
+---
+
+# Unit Testing (Android)
+
+## Project Layout
+
+- Unit targets: `src/test` (+ `androidTest` for instrumentation) colocated or parallel to Feature — **as in the Android Studio / AGP project**.
+- Framework: JUnit 4/5 (repo default) — MockK, Turbine, Truth/AssertJ as already configured.
+- Do **not** create Jest/Vitest `*.spec.ts` files.
+
+Follow `testing/unit.md` (Cursor `.mdc` / Claude `testing/unit.md` depending on preset).
+
+## Planner
+
+Write or update `.claude/team/tasks/<slug>/unit-test-plan.md`.
+
+Each scenario needs a Russian `test` / `@Test` title (capital letter after each sentence). Cover mappers, use cases, ViewModel state branches, and mocked client/repository behavior per AC.
+
+## Generator
+
+Implement tests from `unit-test-plan.md` into the correct `src/test` source set. Reuse shared fixtures and interface mocks / fakes (MockK). Do not change production code.
+
+## Healer
+
+Fix mocks, coroutine/dispatcher timing, and fixtures — preserve business assertions. Use `unit-test-plan.md` and `brief.md` as the behavior contract.
+
+## Validation
+
+Run affected unit tests via `./gradlew test` (`tooling-and-review/gradle-tooling.md`) when feasible. Report command, pass/fail, and remaining gaps vs plan.

package/presets/claude/android-kotlin/skills/write-adr/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: write-adr
+description: Author an Architecture Decision Record (ADR) with Context, Decision, Consequences, and Links. Use when capturing a durable technical choice for the team.
+---
+
+# Write ADR
+
+On-demand skill for durable architecture decisions. Stack-agnostic sections — fill with project-specific paths and links.
+
+## When to use
+
+- Choosing between non-trivial alternatives (storage, layering, library, API shape).
+- Recording a decision that future agents/humans should not silently reverse.
+- User asks for an ADR, decision log, or “why did we pick X”.
+
+## Template
+
+Create (or append) a short markdown ADR in the repo’s agreed location (e.g. `docs/adr/`, `.cursor/team/`, wiki). Suggested filename: `NNNN-short-title.md`.
+
+```markdown
+# ADR NNNN: <Title>
+
+## Context
+What problem / constraint / force requires a decision?
+
+## Decision
+What we chose (one clear option). Include rejected alternatives briefly if useful.
+
+## Consequences
+Positive and negative outcomes; follow-up work; what becomes harder.
+
+## Links
+Related PRs, issues, rules, prior ADRs, diagrams.
+```
+
+## Guidelines
+
+- Prefer one decision per ADR.
+- Keep Context factual; Decision imperative and short.
+- Link living gotchas to `team/conventions.md` when the decision becomes a recurring local pattern.
+- Do not put ADR bodies only in root `AGENTS.md` (overwrite on init).