@bonesofspring/ai-rules 0.2.5 → 0.2.7

package/presets/cursor/go/rules/code-review-mr.mdc

@@ -0,0 +1,52 @@
+---
+description: Code review checklist for Go hexagonal merge requests
+alwaysApply: false
+---
+
+<!-- shared-core: review/code-review-mr.md -->
+
+# Code review merge requests
+
+On-demand rule for review flows. **Procedure and output format:** skill `code-review`.
+
+## When to load
+
+- User asks for review/MR/diff
+- Pipeline step `code-reviewer`
+- Platform automated review (e.g. BUGBOT) when present
+
+## Checklist references (abstract)
+
+- Architecture layers and stack core rules
+- Public imports / module boundaries
+- UI conventions of the stack
+- Unit and e2e/UI test conventions
+- Post-change lint/build gate before final report
+- Design smells **in MR diff scope** — load `design-guidance`; не разворачивать полный каталог Fowler вне диффа
+- Pattern name (GoF) — только если репозиторий уже использует эту форму или match минимален
+- Principles (KISS / DRY+Ro3 / YAGNI / SOLID / CUPID) — через always-on `code-quality-and-refactoring`, не дублировать эссе в review
+
+Concrete rule stems — in **Stack notes**.
+
+## Constraints
+
+- Focus on MR diff, not the whole repo.
+- Use local `git diff` — do not invent hosting metadata.
+- Boy scout rule: suggest fixes feasible within the MR scope.
+- No «большие рефакторинги» without an explicit request (`code-quality-and-refactoring`).
+
+## Output contract
+
+Procedure details live in skill `code-review`. Required shape:
+
+- Each finding cites **`path:line`**, the problem, impact, and a concrete fix direction.
+- Rank by severity: **`blocker` | `important` | `nit`** (list blocker → nit).
+- Vague («looks risky») is not a finding — cite evidence or ask for surrounding file context.
+- End with a verdict on its own line: **`Safe to merge | needs changes | reject`**.
+
+## Stack notes
+
+- Hexagonal boundaries: `architecture-boundaries`, `domain-layer`, ports vs adapters.
+- HTTP/persistence mapping only at edges; composition root has no business logic.
+- Tests: `tests-unit`, `tests-integration`; post-change: `post-change-test` / `go-tooling`.
+- Never require Playwright, XCUITest, `lint:js`, or `xcodebuild` for Go MRs.

package/presets/cursor/go/rules/composition-root.mdc

@@ -0,0 +1,29 @@
+---
+description: Composition root and DI wiring for Go hexagonal services
+globs:
+  - cmd/**/*
+  - internal/app/**/*
+alwaysApply: false
+---
+
+
+# Composition root
+
+- Construct adapters, use cases, and servers in `cmd/<service>` and/or `internal/app`.
+- Wire interfaces to implementations explicitly (manual DI preferred unless repo already uses a container).
+- Load config once; fail fast on missing required settings.
+- Lifecycle: graceful shutdown via `context` cancel + server `Shutdown`.
+
+## Allowed here
+
+- Import all layers for wiring only.
+- Process-wide loggers/metrics providers.
+
+## Forbidden
+
+- Business rules, SQL queries, HTTP routing tables with domain logic.
+- Global mutable singletons for repos without clear init (prefer explicit deps).
+
+## Tests
+
+- Optional smoke that wiring builds (compile-time / construction test); heavy logic stays in unit/integration tests.

package/presets/cursor/go/rules/design-guidance.mdc

@@ -0,0 +1,111 @@
+---
+description: Design smells (Fowler) and curated GoF patterns for agents. Load when assessing structure, smells, or pattern fit.
+globs:
+  - "**/*.go"
+alwaysApply: false
+---
+
+<!-- shared-core: quality/design-guidance.md -->
+
+# Design guidance (smells & patterns)
+
+Словарь **code smells** (Fowler) и **design patterns** (GoF) для агентов при implement / review / debug.
+
+Применять только в scope задачи или MR. Лёгкий refactor — да; «большой» rewrite без явного запроса — нет.
+
+Называть паттерн **только если** репозиторий уже так делает или это минимальный match. Иначе — extract/split/move без ярлыка GoF.
+
+Не заменяет always-on Principles в `code-quality-and-refactoring` (KISS, DRY + Rule of Three, YAGNI, SOLID, CUPID, composition, Demeter).
+
+## When to load
+
+- **Feature delivery / implement** — оценка структуры модулей, границ и дублирования.
+- **Code review** — smells и pattern fit **в диффе MR**, не по всему репо.
+- **Debug** — root-cause похож на wrong abstraction, Feature Envy, Message Chains, Shotgun Surgery.
+- **Light refactor only** — улучшения в рамках boy-scout / MR scope; не расширять задачу ради каталога.
+
+Агенты и skills подгружают stem по one-liner wiring — не копировать этот каталог в промпт агента.
+
+## How to use (agent rules of thumb)
+
+1. Сначала сверить с Principles (always-on): проще ли решение, нет ли ранней абстракции, соблюдён ли public API.
+2. Затем отметить smells **в изменённых файлах** задачи/MR; предложить fix только если он укладывается в light refactor.
+3. Паттерн GoF — опциональный ярлык после того, как структура уже ясна; не начинать дизайн с выбора паттерна.
+4. Если smell и паттерн конфликтуют с границами слоёв стека — побеждают stack boundaries и existing repo patterns.
+5. Не требовать переименования «под GoF», если поведение уже корректно и читаемо.
+
+## Code smells (Fowler, curated ≤12)
+
+Таблица: smell → detect hint → fix hint (одна линия каждый). Без механических меню рефакторинга.
+
+| # | Smell | Detect | Fix hint |
+|---|-------|--------|----------|
+| 1 | Duplicate Code | одинаковая логика в ≥2 местах | dedupe после Rule of Three |
+| 2 | Long Method / Long Module | единица делает слишком много | extract в рамках scope; без big rewrite |
+| 3 | Feature Envy | метод чаще трогает чужие данные, чем свои | сдвинуть логику к данным / public API |
+| 4 | Data Clumps | одни и те же группы аргументов кочуют вместе | сгруппировать в type / value object |
+| 5 | Primitive Obsession | сырые string/int вместо доменных понятий | typed ids / value objects при нужде домена |
+| 6 | Speculative Generality | неиспользуемые хуки, флаги, абстракции «на будущее» | удалить (YAGNI) |
+| 7 | Message Chains | цепочки `a.b.c.d` | Demeter; facade / public API модуля |
+| 8 | Middle Man | класс почти только прокидывает вызовы | убрать pass-through **или** оставить как boundary |
+| 9 | Divergent Change | один модуль меняется по разным причинам | split по поводам изменения |
+| 10 | Shotgun Surgery | одно смысловое изменение разъезжается по многим файлам | consolidate ответственность |
+| 11 | Inappropriate Intimacy | доступ к чужим internals / private деталям | только public API / ports / facades |
+| 12 | Refused Bequest / Parallel Inheritance | подтип игнорирует базу; зеркальные иерархии классов | composition; не плодить параллельные деревья |
+
+**Skip Fowler (не в core):** Lazy Class, Incomplete Library Class, Comments-as-smell dogma, полный каталог 70+, пошаговые recipe-меню.
+
+Приоритет при конфликте smells: Inappropriate Intimacy и Message Chains (границы модулей) > Duplicate Code (после Rule of Three) > Long Method внутри уже правильного модуля.
+
+## Design patterns (GoF, curated ≤8)
+
+Suggest only when repo already uses the shape or the match is minimal. Prefer extract-function over naming Strategy ради ярлыка.
+
+Паттерны ниже — **разрешённый минимум** для агентов; остальной GoF по умолчанию в Skip.
+
+| Pattern | When to suggest | Anti-trigger |
+|---------|-----------------|--------------|
+| Strategy | взаимозаменяемые алгоритмы уже (или явно скоро) выбираются политикой | один алгоритм без ветвления политики |
+| Adapter | обернуть внешний / чужой API под локальный port | лишняя обёртка вокруг своего же API |
+| Facade | упростить multi-step subsystem за public API | facade превращается в god-object |
+| Factory Method | полиморфное создание уже принято в стиле репо | factory на каждый тривиальный `new` |
+| Decorator | аддитивное поведение без взрыва subclass-иерархий | decorator «для слоёв» без реальной нужды |
+| Observer | events / subscriptions уже есть в архитектуре | самодельный pub/sub без прецедента в репо |
+| Template Method | общий algorithm skeleton + вариативные hooks | наследование ради пары отличающихся строк |
+| Composite | дерево однородных узлов (UI/domain), как уже в репо | Composite на плоский список без иерархии |
+
+Если сомневаешься между двумя паттернами — выбери более простой extract/compose без имени; ярлык можно добавить на review, если репо уже так говорит.
+
+## Skip / avoid by default
+
+| Catalog | Skip |
+|---------|------|
+| GoF | Singleton, Abstract Factory, Flyweight, Memento, Interpreter, Visitor, Bridge, Prototype |
+| GoF (conditional) | Command, Chain of Responsibility, State — упоминать **только если** репо уже использует |
+| Fowler | всё сверх 12 smells выше |
+| DDD | Aggregates, bounded-context maps, event sourcing, CQRS — **не в core** |
+| DDD (pointer) | ubiquitous language anti-pattern — расширять в `feature-delivery-workflow`, не здесь |
+| GRASP | список Larman как отдельные правила — skip (перекрывается SOLID/CUPID) |
+| Clean Code dogma | жёсткие caps на строки функции / «ровно один assert» — skip |
+
+Не вводить второй stem (`refactoring-smells` / `design-patterns-for-agents`) — один каталог: `design-guidance`.
+
+## Out of scope for this stem
+
+- Полный GoF (23) и полный Fowler catalog.
+- Stack-specific рецепты (пути модулей, lint-команды) — только в **Stack notes** адаптера.
+- Security, a11y, perf — отдельные review-правила; здесь только структурные smells/patterns.
+- Четвёртое always-on правило — запрещено; этот stem только requestable / agent-load.
+
+## Cross-refs
+
+- Always-on Principles: `code-quality-and-refactoring`.
+- DIP / ports vs adapters: stack `architecture-boundaries` (детали стека — в Stack notes адаптеров).
+- Ubiquitous language: `feature-delivery-workflow` (lineage).
+- MR checklist (smells in scope; pattern name only if repo uses it): `code-review-mr`.
+- Token / twin policy for authors: `preset-token-budget`, `preset-twin-sync` (meta, not consumer always-on).
+
+## Stack notes
+
+- Strategy via func values / small interfaces at **ports**; adapters implement, domain stays free of frameworks.
+- Suggest Facade at package public API; avoid Singleton in favor of composition root wiring.

package/presets/cursor/go/rules/domain-layer.mdc

@@ -0,0 +1,33 @@
+---
+description: Domain layer invariants for Go hexagonal services
+globs:
+  - internal/domain/**/*
+  - "**/domain/**/*"
+alwaysApply: false
+---
+
+
+# Domain layer
+
+- Pure business types and rules; no I/O.
+- Prefer small value objects with validation constructors (`NewX` / `ParseX` that return typed errors).
+- Domain errors are typed (sentinel or structured); map to HTTP/gRPC statuses only in adapters.
+- Domain services orchestrate entities without calling outbound ports (ports live in application).
+- Keep invariants close to the type that owns them; avoid anemic bags of fields with all logic in use cases.
+
+## Forbidden imports
+
+- `net/http`, `database/sql`, ORM packages, Redis/Kafka clients, router frameworks (`gin`, `chi` as handler deps).
+- Transport DTOs and `json` tags that mirror API contracts (keep API shapes in adapters).
+- Framework `context` cancellation plumbing as a substitute for domain deadlines (prefer explicit types).
+
+## Allowed
+
+- `context` only if domain API genuinely needs deadlines (prefer application to pass primitives).
+- Stdlib: `time`, `errors`, `fmt`, `slices`, `maps`, etc.
+- Cross-aggregate references by ID, not by loading other aggregates via ports.
+
+## Tests
+
+- Table-driven unit tests; no DB, no `httptest`, no framework contexts.
+- Cover invalid constructor inputs and invariant violations explicitly.

package/presets/cursor/go/rules/feature-delivery-workflow.mdc

@@ -0,0 +1,46 @@
+---
+description: End-to-end delivery checklist for Go hexagonal features
+alwaysApply: false
+---
+
+<!-- shared-core: architecture/feature-delivery-workflow.md -->
+
+# Feature delivery (Go hexagonal)
+
+Order of work:
+
+1. **Domain** — entities/VOs/errors (`domain-layer`).
+2. **Application + ports** — use case + outbound interfaces (`application-usecases`, `ports-interfaces`).
+3. **Driven adapters** — persistence/cache/messaging implementing ports.
+4. **Driving adapters** — HTTP/gRPC/CLI mapping DTOs.
+5. **Composition root** — wire in `cmd/` / `internal/app`.
+6. **Tests** — unit (domain/app) → integration (adapters) → optional e2e smoke.
+7. **Gate** — `post-change-test` (+ `go-tooling`).
+
+```mermaid
+flowchart LR
+  D[Domain] --> A[Application+Ports]
+  A --> Drv[Driven adapters]
+  Drv --> A
+  HTTP[Driving HTTP] --> A
+  CR[Composition root] --> HTTP
+  CR --> A
+  CR --> Drv
+```
+
+## Matrix
+
+| Path | Rules |
+|------|-------|
+| `**/domain/**` | `domain-layer`, `architecture-boundaries` |
+| `**/application/**` | `application-usecases`, `ports-interfaces` |
+| `**/adapters/http/**` | `adapters-driving`, `api-http` |
+| `**/adapters/persistence/**` | `adapters-driven`, `persistence-adapters` |
+| `cmd/**`, `internal/app/**` | `composition-root` |
+| After `*.go` edits | `post-change-test` |
+
+## Anti-patterns
+
+- Framework types in domain; SQL in use cases; DI inside handlers; skipping port interfaces “for speed”.
+- **Ubiquitous language:** Domain names/boundaries reflect the feature domain — do not mix transport/framework terms into domain without need.
+- Load `design-guidance` (rule stem) when assessing structure, smells, or pattern fit.

package/presets/cursor/go/rules/go-app-core.mdc

@@ -0,0 +1,32 @@
+---
+description: Go backend stack, module layout, and agent entry points (hexagonal preset)
+alwaysApply: true
+---
+
+
+# Стек и окружение
+
+Версии Go, toolchain и зависимостей — **из `go.mod` / `go.work` целевого репозитория**. Рамка preset:
+
+- **Язык / платформа:** Go (module mode); min version — из `go` directive в `go.mod`.
+- **Архитектура:** hexagonal (ports & adapters); слой domain не знает HTTP/SQL/брокеры.
+- **Точки входа:** `cmd/<service>/main.go` → composition root.
+- **Concurrency:** `context.Context` в API границ; не хранить Context в структурах дольше запроса.
+- **Тесты:** `testing` + table-driven; integration за адаптерами; e2e HTTP smoke — по необходимости.
+- **HTTP:** framework-agnostic (`net/http`, chi/gin/echo — примеры, не мандат).
+- **Наблюдаемость:** только если уже в репо — централизованно (логи/metrics/tracing).
+
+# Структура (default: layer-first)
+
+```text
+cmd/<service>/main.go
+internal/domain/
+internal/application/          # use cases + ports
+internal/adapters/http|grpc|persistence|cache|messaging/
+internal/app/                  # optional DI wiring
+pkg/                           # optional public library API
+```
+
+**Feature-first variant** allowed: `internal/<feature>/{domain,application,adapters}` — same dependency direction.
+
+Границы — **`architecture-boundaries.mdc`**. Tooling — requestable **`go-tooling.mdc`**. После правок Go — **`post-change-test.mdc`**.

package/presets/cursor/go/rules/go-conventions.mdc

@@ -0,0 +1,52 @@
+---
+description: Idiomatic Go conventions for this hexagonal preset
+globs:
+  - "**/*.go"
+alwaysApply: false
+---
+
+# Go conventions
+
+- Follow [Effective Go](https://go.dev/doc/effective_go) and repo `golangci-lint` / `staticcheck` when present.
+- Accept `context.Context` as first param on I/O and use-case methods.
+- Prefer `camelCase` unexported, `PascalCase` exported; package names short and lowercase.
+- Do not expose `internal/` outside the module.
+- Prefer table-driven tests; use `t.Parallel` only when safe.
+
+## Errors
+
+- Always handle errors — never `_ = err`.
+- Wrap with `fmt.Errorf("…: %w", err)`; check with `errors.Is` / `errors.As`.
+- Prefer domain/custom error types for structured cases; avoid panics in library/service code.
+
+## Interfaces
+
+- Accept interfaces, return concrete types.
+- Define interfaces at the **call site** (ports / consumers), not on every implementation.
+- Prefer small, single-method interfaces when they match the use.
+
+## Packages
+
+- Avoid `util`/`common` dumping grounds — name by domain capability.
+- Keep `main` packages thin (see composition-root).
+- No `init()` for business logic; no package-level mutable state for request data.
+
+## Concurrency
+
+- Document cancelation; `defer cancel()` after creating a derived context.
+- Do not start unbounded goroutines from handlers without a termination condition / supervision (`WaitGroup`, errgroup, or context cancel).
+- Channels for communication, mutexes for shared state — match existing package patterns.
+
+## Anti-hallucination
+
+| ❌ Avoid | ✅ Prefer |
+|---------|----------|
+| `_ = err` / ignored errors | Handle or wrap with `%w` |
+| Interfaces on every struct «just in case» | Ports at consumer / call site |
+| Invented modules not in `go.mod` | Add dependency explicitly or copy existing import |
+| `interface{}` where generics or a concrete type fit | Generics / concrete types used by the repo |
+| Business logic in `init()` | Wire in composition root / `main` |
+
+## Agent requirement
+
+New Go code must stay idiomatic and verifiable against `go.mod` and neighboring packages. Less guessed code is better than more.

package/presets/cursor/go/rules/go-tooling.mdc

@@ -0,0 +1,33 @@
+---
+description: Go toolchain commands (test, vet, lint, race) — requestable
+alwaysApply: false
+---
+
+
+# Go tooling (requestable)
+
+Before running commands, read **`go.mod`** for module path and Go version.
+
+## Common commands
+
+```bash
+go test ./...
+go vet ./...
+go test ./... -race
+go test ./... -cover
+```
+
+- If the repo has `golangci-lint` or `staticcheck`, use the project’s documented invocation (Makefile/taskfile).
+- Do not invent a lint stack; prefer what CI already runs.
+- Module ops: `go get`, `go mod tidy` only when deps change.
+- Prefer `go test ./path/to/pkg` while iterating; widen to `./...` before handoff.
+
+## Race / cover
+
+- Use `-race` for concurrent maps, workers, or shared caches.
+- Coverage is optional unless the task or CI requires a threshold.
+
+## Related
+
+- Mandatory after Go edits: **`post-change-test.mdc`**.
+- Pipeline gate: `build-verifier` (same commands; no yarn lint / xcodebuild).

package/presets/cursor/go/rules/messaging-adapters.mdc

@@ -0,0 +1,22 @@
+---
+description: Messaging driven/driving adapters for Go hexagonal services
+globs:
+  - "**/adapters/messaging/**/*"
+alwaysApply: false
+---
+
+
+# Messaging adapters
+
+- **Publisher** (driven): implements outbound port; serializes domain events / integration events.
+- **Consumer** (driving): deserializes → calls use case / inbound port; ack/nack policy here.
+- Idempotency keys and retry/DLQ are adapter concerns; document at-least-once assumptions.
+- Do not put broker client types in domain or application signatures.
+
+## Event shapes
+
+- Prefer explicit event structs in application or a small `events` package used by ports — map to wire format in the adapter.
+
+## Tests
+
+- Unit-test mapping with fakes; integration against embedded/broker test duals when the repo has them.

package/presets/cursor/go/rules/module-public-api.mdc

@@ -0,0 +1,24 @@
+---
+description: Public module API (pkg/) and internal boundaries for Go services
+globs:
+  - pkg/**/*
+  - go.mod
+alwaysApply: false
+---
+
+
+# Module public API
+
+- Anything under `pkg/` is a compatibility surface — change carefully; prefer additive APIs.
+- Service-private code stays in `internal/`.
+- Do not import another module's `internal/` (compiler enforces for separate modules).
+- Document breaking Go API changes in CHANGELOG when the repo publishes libraries.
+
+## go.mod
+
+- Module path and Go version are SoT for toolchain.
+- Prefer minimal direct deps; pin via `go.mod` / `go.sum`.
+
+## Cross-feature
+
+- Inside one module, features communicate via application ports or small `pkg` facades — not by importing sibling feature adapter packages.

package/presets/cursor/go/rules/persistence-adapters.mdc

@@ -0,0 +1,29 @@
+---
+description: Persistence driven adapters (SQL/repos) for Go hexagonal services
+globs:
+  - "**/adapters/persistence/**/*"
+  - "**/*repository*.go"
+alwaysApply: false
+---
+
+
+# Persistence adapters
+
+- Implement outbound repository ports from application.
+- Use parameterized queries; map rows → domain entities inside the adapter.
+- Transactions: expose via port (`Transactional`, `UnitOfWork`) implemented here — use cases call the port, not `*sql.Tx` directly.
+- Migrations live with infra (separate package/dir) — not in domain.
+
+## Mapping
+
+- Persistence models (db tags) stay private to the adapter package when possible.
+- Nullability and DB defaults converted to domain values explicitly.
+
+## Forbidden
+
+- Importing persistence from domain or leaking `*sql.DB` through port APIs.
+- Building SQL strings in use cases.
+
+## Tests
+
+- Integration tests with testcontainers / test DB preferred for repos; unit-test mappers with fixtures.

package/presets/cursor/go/rules/ports-interfaces.mdc

@@ -0,0 +1,35 @@
+---
+description: Inbound and outbound port interfaces for Go hexagonal services
+globs:
+  - "**/ports/**/*"
+  - internal/application/**/*port*
+  - "**/application/**/*port*"
+alwaysApply: false
+---
+
+
+# Ports (interfaces)
+
+## Outbound (driven)
+
+- Repository, cache, publisher, clock, ID generator, external client — defined by **application**.
+- Signatures use **domain** types (or small application DTOs), never ORM models.
+- Keep interfaces small (ISP); prefer role interfaces over god-repos.
+- Accept `context.Context` as the first parameter when the call may block or cancel.
+
+## Inbound (driving)
+
+- Optional interface wrapping use cases for multiple drivers (HTTP + gRPC + CLI).
+- Drivers depend on inbound ports / use-case APIs — not on each other.
+- Prefer a concrete use-case struct when only one driver exists; extract an interface when a second driver appears.
+
+## Naming
+
+- `SaveOrder`, `FindOrderByID`, `PublishOrderPlaced` — verb-oriented.
+- Implementation types live in adapters (`PostgresOrderRepository`), not beside the interface in domain.
+
+## Anti-patterns
+
+- Ports returning `map[string]any` or `json.RawMessage` without need.
+- Putting port interfaces inside adapter packages (wrong owner).
+- Leakage of SQL/`driver.Valuer` types through port method signatures.

package/presets/cursor/go/rules/post-change-test.mdc

@@ -0,0 +1,27 @@
+---
+description: Mandatory verification after Go code edits (go test / vet / lint-if-present)
+alwaysApply: false
+---
+
+
+# Post-change test (requestable, mandatory after Go edits)
+
+After changing `*.go` / `go.mod` in a consumer repo:
+
+1. `go test ./...` (or scoped packages touched).
+2. `go vet ./...`.
+3. If present: `golangci-lint run` and/or `staticcheck ./...` per repo docs.
+4. Optional: `go test ./... -race` for concurrency-sensitive changes (`go-tooling.mdc`).
+
+## Scope hints
+
+- Prefer package-scoped tests while iterating; run `./...` before claiming the task done.
+- If only `*_test.go` helpers changed, still run the package under test.
+- Module/`go.mod` changes: run `go test ./...` after `go mod tidy`.
+
+## Agent requirement
+
+- Do not claim completion without running the applicable gate (or noting why CI-only).
+- Pipeline `build-verifier` enforces the same checklist.
+- Record failing command output in the task artifact when the gate fails.
+- Skip only when the change is docs/config with no `*.go` / `go.mod` impact — state that explicitly.

package/presets/cursor/go/rules/preset-layering.mdc

@@ -0,0 +1,36 @@
+---
+description: Preset authoring meta-rule (preset-layering)
+globs:
+  - packages/ai-rules/presets/**/*
+  - .cursor/rules/**/*
+  - .cursor/team/tasks/**/*
+alwaysApply: false
+---
+
+<!-- shared-core: meta/preset-layering.md -->
+
+# Preset layering
+
+Правила для **авторов пресетов** (`packages/ai-rules/presets/**`). Не always-on в consumer apps.
+
+## Слои
+
+| Слой | Где | Что класть |
+|------|-----|------------|
+| **Core** | `presets/_shared/core/**` | Stack-agnostic prose + checklists; без frontmatter; без путей `app/**`, `Features/**`, Playwright, xcodebuild |
+| **Stack** | `presets/{cursor\|claude}/<stack>/` | Domain/tooling, always-on trio стека, stack examples в **Stack notes** |
+| **Platform** | Cursor `.mdc` / Claude `.md` | Frontmatter (`alwaysApply`/`globs` vs `paths:`), platform-only (`BUGBOT.md`, `CLAUDE.md`) |
+
+## Куда класть новое правило
+
+1. Общие принципы для всех стеков → **core** + адаптеры с `<!-- shared-core: … -->`.
+2. Только один из installable стеков (`next` / `ios-swift` / `go`) → **stack-specific** (не в `_shared`).
+3. Только Cursor или только Claude packaging → platform artifact / frontmatter, не дублировать семантику.
+
+## SoT
+
+- Packages path — SoT; root `.cursor/` — dogfood sync.
+- Per stack: **Cursor** `presets/cursor/<stack>/` → Claude twin same PR.
+- `_shared` **не** `--preset` и не копируется CLI `init`.
+
+См. также: `preset-twin-sync`, `preset-token-budget`, `preset-pr-checklist`, `preset-no-cross-stack-leakage`.

package/presets/cursor/go/rules/preset-no-cross-stack-leakage.mdc

@@ -0,0 +1,58 @@
+---
+description: Preset authoring meta-rule (preset-no-cross-stack-leakage)
+globs:
+  - packages/ai-rules/presets/**/*
+  - .cursor/rules/**/*
+  - .cursor/team/tasks/**/*
+alwaysApply: false
+---
+
+<!-- shared-core: meta/preset-no-cross-stack-leakage.md -->
+
+# Preset no cross-stack leakage
+
+Запрет протекания stack-specific имён, путей и handoff stems между пресетами.
+
+## Principles
+
+- `next` must not require iOS-only agents/tooling (`xcuitest-*`, `xcodebuild` as required handoff, Keychain-only rules).
+- `ios-swift` must not ship Playwright handoffs or Next lint recipes as required commands.
+- `go` must not ship Playwright, XCUITest, Next lint recipes, or `xcodebuild`/`SwiftLint` as required handoffs.
+- Shared core must not embed stack paths (`app/src/**`, `Features/**`, `playwright`, `xcodebuild`).
+
+## Forbidden in ios-swift hooks/agents (FAIL)
+
+In ios-swift `chain-team-phases.sh` / agent handoffs (Cursor + Claude):
+
+- `playwright-test-`, `playwright-agents`, `playwright-e2e`, `user-playwright`
+- `app/__tests__/e2e` as a required path
+- Positive yarn recipes `lint:js` / `lint:css` as commands to run (negation prose alone is weak — prefer zero occurrences)
+
+Required instead: `xcuitest-test-*` stems; build-verifier mentions `xcodebuild` or `post-change-build` / `xcode-tooling`.
+
+## Forbidden in next hooks/agents (FAIL when present as required)
+
+- `xcuitest-test-` as handoff stems
+- Requiring `xcodebuild` / SwiftLint as the default post-change gate for Next app work
+
+## Forbidden in go hooks/agents (FAIL)
+
+- `playwright-test-`, `playwright-e2e`, `user-playwright`, `app/__tests__/e2e`
+- Positive yarn recipes `lint:js` / `lint:css`
+- `xcuitest-test-`, `xcodebuild`, `SwiftLint` as required handoffs
+- Agent file `accessibility-reviewer` (no UI surface)
+
+Required instead: `integration-test-*`; build-verifier / `post-change-test` / `go-tooling` (`go test`, `go vet`).
+
+## Soft / document
+
+- Mentioning the other stack in **docs** comparing presets is OK.
+- `build-verifier` may reference other stacks when validating **preset packaging** (`scope: preset-structure-validation`).
+
+## Chain fork
+
+`hooks/chain-team-phases.sh` must differ **byte-wise** pairwise among `next`, `ios-swift`, and `go` (per platform).
+
+## Stack notes
+
+Forbidden positive handoffs on this stack are listed in core § go. Prefer `integration-test-*` and `post-change-test`.