@bonesofspring/ai-rules 0.2.15 → 0.2.16

package/presets/cursor/android-kotlin/rules/preset-twin-sync.mdc

@@ -0,0 +1,56 @@
+---
+description: Preset authoring: Cursor SoT → Claude twin same PR. Use when editing preset rules.
+globs:
+  - packages/ai-rules/presets/**/*
+  - .cursor/rules/**/*
+  - .cursor/team/tasks/**/*
+alwaysApply: false
+---
+
+<!-- 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/cursor/android-kotlin/rules/reference-features.mdc

@@ -0,0 +1,29 @@
+---
+description: Placeholder reference feature paths for Android multimodule repos
+globs:
+  - "features/**"
+alwaysApply: false
+---
+
+# Reference features (placeholders)
+
+Use these **placeholder** paths when pointing agents at analogs. Replace with real module names in the consumer repo (and optionally document local names in `team/conventions.md`).
+
+| Concern | Placeholder path |
+|---------|------------------|
+| App shell | `applications/<app>/` |
+| Shared kernel | `core/` |
+| Feature public API | `features/<name>/api/` |
+| Feature implementation | `features/<name>/impl/` |
+| DI holders | `features/<name>/impl/**/di/` |
+| Presentation | `features/<name>/impl/**/presentation/` |
+| Data | `features/<name>/impl/**/data/` |
+| Convention plugins | `build-logic/` |
+| Version catalog | `gradle/libs.versions.toml` |
+| JVM tests | `**/src/test/**` |
+| Instrumentation | `**/src/androidTest/**` |
+
+# Agent requirements
+
+- Copy patterns from the closest neighboring feature — do not invent a parallel layout.
+- Never cite private consumer monorepo or vendor names in shared preset text.

package/presets/cursor/android-kotlin/rules/security-android.mdc

@@ -0,0 +1,30 @@
+---
+description: Android secrets, TLS, and build-wrapper security policy (generic)
+globs:
+  - "**/network/**"
+  - "**/security/**"
+  - "**/*NetworkSecurity*"
+alwaysApply: false
+---
+
+# 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/cursor/android-kotlin/rules/state-and-viewmodels.mdc

@@ -0,0 +1,28 @@
+---
+description: MVI/UDF state on the project ViewModel base
+globs:
+  - "**/*ViewModel*.kt"
+alwaysApply: false
+---
+
+# 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/cursor/android-kotlin/rules/technical-retro.mdc

@@ -0,0 +1,16 @@
+---
+description: Agent role for a technical retrospective (retro) of the team / sprint. On-demand — prefer the /technical-retro slash command.
+alwaysApply: false
+---
+
+<!-- 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/cursor/android-kotlin/rules/tests-ui.mdc

@@ -0,0 +1,29 @@
+---
+description: Android instrumentation UI tests (androidTest)
+globs:
+  - "**/androidTest/**"
+alwaysApply: false
+---
+
+# UI tests (instrumentation)
+
+- Default agent surface: **Android instrumentation** under `androidTest` (devices/emulators/CI as configured).
+- Discover the concrete framework from the consumer repo (Espresso, Compose UI Test, or project-chosen alternatives) — do not mandate a single library in always-on rules.
+- Stable semantics / test tags / content descriptions aligned with presentation conventions.
+- Keep tests behavior-focused; avoid brittle sleep-based synchronization when idling strategies exist.
+
+# Agent team
+
+- Plan/generate/heal via `instrumentation-test-{planner,generator,healer}` and skill `instrumentation-ui-e2e`.
+- Do **not** require Playwright, XCUITest, or yarn `lint:js`/`lint:css` as Android UI-test handoffs.
+
+# Agent requirements
+
+- Prefer page objects / robot patterns already used in the repo.
+- Wire flavors/variants via Gradle tasks discovered in `gradle-tooling`.
+
+# Data & isolation
+
+- Use test fixtures/fakes already adopted by the module; avoid hitting production backends.
+- Clean state between tests when sharing an app process.
+- Record the Gradle task used (`connected*` / managed device) in the plan/receipt.

package/presets/cursor/android-kotlin/rules/tests-unit.mdc

@@ -0,0 +1,30 @@
+---
+description: JVM unit test conventions for Android Kotlin modules
+globs:
+  - "**/test/**"
+  - "**/*Test.kt"
+alwaysApply: false
+---
+
+# Unit tests (JVM)
+
+- Prefer fast JVM unit tests under `src/test` for domain, mappers, ViewModel reducers, and pure use cases.
+- Use the repo’s stack (JUnit4/5, MockK, Turbine, Truth/AssertJ — **as already configured**).
+- Fake ports over heavy Android instrumentation for logic tests.
+- Name tests after behavior; keep arrange/act/assert clear.
+
+# Scope
+
+- Do not require device/emulator for pure logic.
+- UI flows belong in `androidTest` / instrumentation agents — see `tests-ui`.
+
+# Agent requirements
+
+- Agents `unit-test-*` + skill `unit-testing` own planning/generation/healing.
+- After production edits, run the narrowest `./gradlew …Test` suite via `post-change-build` / `gradle-tooling`.
+
+# Flakes & determinism
+
+- Control clocks/dispatchers when testing coroutines/Flow.
+- Avoid relying on real Android framework types in JVM tests unless Robolectric is already standard.
+- Prefer table-driven cases for mapper edge inputs.

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

@@ -0,0 +1,14 @@
+# `.cursor/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 `.cursor/skills/` on init.

package/presets/cursor/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 (`gradle-tooling.mdc`):
+   - `./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 (`.cursor/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/cursor/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 `.cursor/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.mdc`): View ≠ API/DTO; ViewModel ≠ Data impl; Domain ≠ Jetpack Compose; Data ≠ Presentation.
+4. Check DI composition in `applications/`, Gradle modules public API (`module-public-api.mdc`), and no deep-imports across Features.
+5. Review Kotlin concurrency and conventions (`kotlin-conventions.mdc`): `main-safe / viewModelScope`, typed errors, `!!`.
+6. Review Jetpack Compose thinness, Design System usage, `testTag` / semantics / contentDescription (`compose-ui.mdc`).
+7. Check tests: unit for mapper/domain/VM (`tests-unit.mdc`); Android instrumentation for user flows (`tests-ui.mdc`).
+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 (`gradle-tooling.mdc`, `post-change-build.mdc`).
+
+## Output
+
+Lead with findings ordered by severity. Required shape (also in `code-review-mr`):
+
+- 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 `.cursor/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/cursor/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 (`gradle-tooling.mdc`).
+
+## Artifacts
+
+For agent team tasks, write `.cursor/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/cursor/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 `feature-delivery-workflow.mdc` and `reference-features.mdc` — 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 (`tests-unit.mdc`).
+5. After Kotlin edits: **invoke** `post-change-build.mdc` (+ `gradle-tooling.mdc`). 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/cursor/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 (`compose-ui` / `tests-ui`).
+4. Plan → generate → heal via agents `instrumentation-test-{planner,generator,healer}`.
+5. Run the narrowest Gradle instrumentation task via `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/cursor/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 `.cursor/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 `.cursor/rules/`, `.cursor/agents/`, `.cursor/skills/`, or **`.cursor/team/conventions.md`** (prefer conventions for project gotchas)
+- One concrete snippet or file path
+- Whether it belongs in always-on vs globs vs skill vs conventions (see `PRESET-CONTRIBUTION` → Building blocks)
+
+Do not apply preset or conventions changes without user approval.

package/presets/cursor/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 `tests-unit.mdc` (Cursor `.mdc` / Claude `testing/unit.md` depending on preset).
+
+## Planner
+
+Write or update `.cursor/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` (`gradle-tooling.mdc`) when feasible. Report command, pass/fail, and remaining gaps vs plan.

package/presets/cursor/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).

package/presets/cursor/android-kotlin/team/README.md

@@ -0,0 +1,54 @@
+# Agent team artifacts (android-kotlin)
+
+Artifact directory for the Android agent-team pipeline.
+
+## Layout
+
+```
+.cursor/team/   # Claude: .claude/team/
+  active-task.json
+  fixtures/
+  tasks/<slug>/
+    pipeline.json
+    status.json
+    brief.md
+    decomposition.md
+    …
+```
+
+## Fixtures
+
+| Fixture | Notes |
+|---------|-------|
+| `feature-full.json` | Full profile; QA scope `e2e-only` = **Android instrumentation** |
+| `feature-light.json` | developer → build-verifier |
+| `bugfix-standard.json` | debugger → developer (skipIf) → verifier → reviewer |
+
+### `skipped[]` in fixtures
+
+`pipeline.json` / fixture `skipped` is **documentation of forbidden or non-applicable template stems** from other stacks (Playwright, XCUITest, JVM `integration-test-*`) — **not** agents that ran and were skipped at runtime, and **not** steps to schedule. Routers must never promote these stems into `steps[]`. For UI-test-only intents use `instrumentation-test-*`.
+
+**Never** schedule Playwright-only steps without skip rationale. Use `instrumentation-test-*` for UI-test-only intents.
+
+## Creating task dirs
+
+Bootstrap `tasks/<slug>/` by **writing** artifacts (Write tool), not Shell `mkdir`. Cursor sandbox → `Operation not permitted` otherwise (worse on Desktop/Documents).
+
+## Artifact manifest and receipts
+
+Each slug stores one context index at `.cursor/team/tasks/<slug>/artifact-manifest.json`. Schema v1 is defined by shared core `agent-team/agent-artifact-contracts.md`: every entry declares its producer, status, authoritative paths, acceptance-criteria IDs, decomposition task IDs, timestamps, and a terminal completion receipt.
+
+Producer/consumer rules:
+
+- Read the manifest first and use only the authoritative inputs needed by the current step; fall back to `brief.md`, `decomposition.md`, and `pipeline.json` when it is missing or stale, and report that gap.
+- Producers upsert only their stable entry IDs, preserve foreign entries, and finish with `completed`, `blocked`, `changes_requested`, or `validation_failed` receipt evidence.
+- The router owns `pipeline.json` and its routing entry; analyst, developer, verifier, and reviewer own their named outputs and receipts. Consumers do not edit another producer's receipt.
+- Agents do not mutate `status.json` or `metrics.json`. The orchestration runtime/hook is their single writer. Parallel receipt merges are serialized by the parent/orchestrator.
+
+## Local metrics ledger
+
+`metrics.json` is an append-only schema-v1 event ledger for one task run. It contains only allowlisted IDs, task dimensions, timestamps, outcomes, and attribution confidence—never prompts, secrets, file paths, or contents. The orchestration runtime writes `task_started` / `attempt_started`; the hook records host-clock completion and human-gate edges under a per-task lock with temp-and-rename.
+
+`status.json.activeAttempts` is a transient timing bridge keyed by `attemptId`; `lastCompletedAttempt` is diagnostic; `parallelOutcomes` holds per-agent outcomes for the current parallel join until the step advances. For parallel stops, the hook must use a stable payload identity or the sole active attempt. Otherwise an explicit `.metrics-receipts.json` receipt is fallback data marked `source: agent`, `attributionConfidence: fallback`; it must never guess from `currentAgent`.
+
+Aggregate with `node packages/ai-rules/scripts/aggregate-agent-task-metrics.mjs --team-root .cursor/team`. It reports role/agent count, completed count, total/average duration, distinct completed run IDs, separate human-gate wait, and incomplete artifacts.

package/presets/cursor/android-kotlin/team/conventions.md

@@ -0,0 +1,17 @@
+# Team conventions (consumer-local)
+
+After installing this preset, document **local** names and paths here. Do not put vendor/brand names into the shared preset packages.
+
+## Suggested entries
+
+| Concern | Local name / path |
+|---------|-------------------|
+| ViewModel base class | _(fill)_ |
+| Feature DI holder / component types | _(fill)_ |
+| Design-system package | _(fill)_ |
+| App shell module(s) under `applications/` | _(fill)_ |
+| Default product flavor / variant for local builds | _(fill)_ |
+| Instrumentation test base / robot pattern | _(fill)_ |
+| Documented Gradle wrapper (if not `./gradlew`) | _(fill)_ |
+
+Keep this file consumer-owned; `ai-rules init` may overwrite other preset files but conventions are meant to accumulate local decisions.