@bonesofspring/ai-rules 0.2.4 → 0.2.6

package/presets/cursor/go/hooks.json

@@ -0,0 +1,17 @@
+{
+  "version": 1,
+  "hooks": {
+    "beforeShellExecution": [
+      {
+        "command": ".cursor/hooks/guard-shell-command.sh",
+        "failClosed": true
+      }
+    ],
+    "subagentStop": [
+      {
+        "command": ".cursor/hooks/chain-team-phases.sh",
+        "loop_limit": 15
+      }
+    ]
+  }
+}

package/presets/cursor/go/mcp.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "context7": {
+      "command": "npx",
+      "args": ["-y", "@upstash/context7-mcp"]
+    },
+    "figma": {
+      "url": "https://mcp.figma.com/mcp"
+    }
+  }
+}

package/presets/cursor/go/rules/README.md

@@ -0,0 +1,89 @@
+# Rules (preset go)
+
+## alwaysApply (3)
+
+| Rule | Role |
+|------|------|
+| `go-app-core` | Stack + layout |
+| `architecture-boundaries` | Hexagonal invariants |
+| `code-quality-and-refactoring` | Shared quality + Go notes |
+
+**Session-start body budget:** sum of the 3 always-on bodies ≤ **120** lines (stretch ≤100).
+
+## Twin depth (Cursor↔Claude)
+
+- **Domain** rules: target ≥15 non-empty body lines (FAIL soft when undocumented stubs).
+- **Thin aliases** (may be shorter): `agent-team-intake`, `technical-retro`.
+- **Documented stubs** (checklist-style, expand in consumer Stack notes / target repo): see Catalog **Depth** column (`stub`). High-traffic stems (`domain-layer`, `ports-interfaces`, `adapters-*`, `post-change-test`, `go-tooling`) are expanded to **full** depth.
+
+## Loading strategy
+
+- **`alwaysApply: true`** (Cursor) / **без `paths:`** (Claude) — только базовые инварианты (**3**): `go-app-core`, `architecture-boundaries`, `code-quality-and-refactoring`
+- **On-demand / requestable** — `post-change-test`, `go-tooling`, `agent-team-intake`, `agent-team-orchestrator`, hexagonal domain/adapters, tests, feature-delivery-workflow, reference-features, `technical-retro`
+- **Preset author meta** (globs `packages/ai-rules/presets/**`, never alwaysApply): `preset-layering`, `preset-twin-sync`, `preset-token-budget`, `preset-pr-checklist`, `preset-no-cross-stack-leakage`
+- **Skills** — длинные процедуры (`feature-delivery`, `code-review`, `integration-testing`, …)
+
+### Hexagonal edit bundles
+
+| When editing | Load |
+|--------------|------|
+| `**/domain/**` | `domain-layer` + `architecture-boundaries` |
+| `**/application/**` | `application-usecases` + `ports-interfaces` |
+| `**/adapters/http/**` (or gRPC/CLI driving) | `adapters-driving` + `api-http` / `api-grpc` + `architecture-boundaries` |
+| `**/adapters/persistence/**` (or messaging/cache) | `adapters-driven` + `persistence-adapters` / `messaging-adapters` |
+| `cmd/**`, `internal/app/**` | `composition-root` |
+| After `*.go` edits | `post-change-test` (+ `go-tooling`) |
+
+## Shared core → stack mapping
+
+SoT prose: `packages/ai-rules/presets/_shared/core/**` (see `_shared/README.md`). Adapters carry `<!-- shared-core: … -->`.
+
+| Shared core | This stack adapter | Mode | Delta |
+|-------------|--------------------|------|-------|
+| `quality/code-quality-and-refactoring.md` | `code-quality-and-refactoring.mdc` | embed | Stack notes: Go errors/`%w`, ports, `post-change-test` |
+| `quality/design-guidance.md` | `design-guidance.mdc` | embed | requestable smells/GoF |
+| `agent-team/agent-team-orchestrator.md` | `agent-team-orchestrator.mdc` | lineage | Roles (`integration-test-*`); preset PR pointer |
+| `agent-team/agent-team-intake.md` | `agent-team-intake.mdc` | embed | thin alias |
+| `architecture/feature-delivery-workflow.md` | `feature-delivery-workflow.mdc` | lineage | Go hexagonal checklist (stack-native body; core = abstract SoT) |
+| `architecture/reference-features.template.md` | `reference-features.mdc` | lineage | `internal/**` / `cmd/**` table + dogfood |
+| `review/code-review-mr.md` | `code-review-mr.mdc` | embed | Go checklist |
+| `review/technical-retro.md` | `technical-retro.mdc` | embed | thin alias |
+| `meta/preset-*.md` | `preset-*.mdc` | embed | author-only globs (incl. `preset-no-cross-stack-leakage`) |
+
+Claude twins + Cursor→Claude map: `presets/claude/go/rules/README.md`. Cross-stack leakage policy: `preset-no-cross-stack-leakage`.
+
+## Catalog
+
+| Stem | Depth | Notes |
+|------|-------|-------|
+| `go-app-core` | full | always-on |
+| `architecture-boundaries` | full | always-on |
+| `code-quality-and-refactoring` | full | always-on + shared embed |
+| `design-guidance` | full | requestable embed |
+| `feature-delivery-workflow` | full | lineage |
+| `reference-features` | full | lineage |
+| `agent-team-orchestrator` | full | lineage |
+| `code-review-mr` | full | embed |
+| `preset-*` (×5) | full | author meta |
+| `agent-team-intake` | thin-alias | |
+| `technical-retro` | thin-alias | |
+| `api-grpc` | stub | optional transport; expand when repo uses gRPC |
+| `domain-layer` | full | high-traffic hexagonal |
+| `application-usecases` | stub | |
+| `ports-interfaces` | full | high-traffic hexagonal |
+| `adapters-driven` | full | high-traffic hexagonal |
+| `adapters-driving` | full | high-traffic hexagonal |
+| `composition-root` | stub | |
+| `api-http` | stub | |
+| `persistence-adapters` | stub | |
+| `messaging-adapters` | stub | |
+| `module-public-api` | stub | |
+| `go-conventions` | stub | |
+| `go-tooling` | full | requestable toolchain |
+| `post-change-test` | full | requestable gate |
+| `security-go` | stub | |
+| `tests-unit` | stub | |
+| `tests-integration` | stub | |
+| `tests-e2e` | stub | optional smoke; prefer integration-test-* |
+
+**Всего topic `.mdc`:** 27 domain + 5 preset-meta (без README) = 32.

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

@@ -0,0 +1,35 @@
+---
+description: Driven adapters (persistence, cache, messaging) for Go hexagonal services
+globs:
+  - internal/adapters/persistence/**/*
+  - "**/adapters/persistence/**/*"
+  - "**/adapters/cache/**/*"
+  - "**/adapters/messaging/**/*"
+alwaysApply: false
+---
+
+
+# Driven adapters
+
+- Implement application **outbound ports**.
+- Map storage/broker models → domain at the boundary; never return ORM structs to application.
+- Handle retries/timeouts/idempotency here when infrastructure-specific.
+- Wrap driver errors with context; translate to domain/application errors when meaningful.
+- Honor `context.Context` cancellation and deadlines from the application call.
+
+## Persistence
+
+- See `persistence-adapters.mdc` for SQL/transactions.
+- Keep SQL/query builders inside the adapter package; application sees only port methods.
+
+## Cache / messaging
+
+- Cache keys and serialization are adapter concerns.
+- Publishers implement port `PublishX`; consumers are driving adapters if they trigger use cases.
+- Prefer idempotent publish/consume handlers when brokers may redeliver.
+
+## Forbidden
+
+- Calling other driven adapters bypassing application (hidden coupling).
+- Leaking `*sql.Rows` / Redis types through port signatures.
+- Embedding business invariants that belong in domain (e.g. discount rules in SQL only).

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

@@ -0,0 +1,36 @@
+---
+description: Driving adapters (HTTP, gRPC, CLI) for Go hexagonal services
+globs:
+  - internal/adapters/http/**/*
+  - "**/adapters/http/**/*"
+  - "**/adapters/grpc/**/*"
+  - cmd/**/*
+alwaysApply: false
+---
+
+
+# Driving adapters
+
+- Translate transport → application calls → transport response.
+- Map request/response DTOs at the edge; do not pass framework types into use cases.
+- AuthN/AuthZ and validation of wire format belong here (or dedicated middleware); domain validation stays in domain.
+- Errors: map domain/application errors to status codes once (central mapper preferred).
+- Keep handlers thin: decode → call use case → encode; no multi-step workflows in the adapter.
+
+## HTTP
+
+- See `api-http.mdc`. Prefer thin handlers; routing table in one place.
+- Framework examples (chi/gin/echo) are optional — match the repo.
+- Bind path/query/body into request DTOs before calling application.
+
+## gRPC / CLI
+
+- Same mapping rules; see thin `api-grpc.mdc` for protobuf notes.
+- CLI `cmd` tools may call composition root or inbound ports — no SQL in `main`.
+- Propagate cancellation from the transport `context` into use-case calls.
+
+## Forbidden
+
+- SQL or business invariants inside handlers.
+- Importing persistence packages from HTTP handlers (wire via application).
+- Swallowing errors without mapping to a transport status / log field.

package/presets/cursor/go/rules/agent-team-intake.mdc

@@ -0,0 +1,20 @@
+---
+description: Suggest /task for Go backend work requests
+alwaysApply: false
+---
+
+<!-- shared-core: agent-team/agent-team-intake.md -->
+
+# Agent team intake
+
+When the user message looks like a **work request** (implement, add, fix, refactor, review MR, write tests, spike) — not a question about how code works:
+
+1. Prefer **`/task <their request>`** or invoke **task-router** first.
+2. Do not jump straight to coding without router + pipeline when scope is non-trivial.
+3. Pure questions («как работает X», «объясни») — answer normally, no `/task`.
+
+Exceptions: user explicitly says «без pipeline», «просто сделай», or continues an active slug.
+
+## Stack notes
+
+- Scope: Go services (`cmd/`, `internal/**`) — hexagonal ports/adapters — not Playwright/XCUITest UI flows.

package/presets/cursor/go/rules/agent-team-orchestrator.mdc

@@ -0,0 +1,156 @@
+---
+description: Orchestrates the agent team via task-router and pipeline.json for Go presets
+alwaysApply: false
+---
+
+<!-- shared-core: agent-team/agent-team-orchestrator.md -->
+
+# Agent team orchestrator
+
+Parent agent = **manager**. Router plans; specialists execute. Artifacts: `.cursor/team/tasks/<slug>/` (Claude: `.claude/team/tasks/<slug>/`).
+
+Work request без `/task` — см. **agent-team-intake** (когда предлагать router вместо прямого кодинга).
+
+## Entry points
+
+| Command | When |
+|---------|------|
+| **`/task <desc>`** | **Preferred** — router → dynamic pipeline → first agent |
+| `/task-continue <slug>` | After human gate or pause |
+| `/feature-start <desc>` | Legacy: analyst-only start (no router) |
+| `/feature-continue <slug>` | Alias of task-continue |
+| `/technical-retro [slug]` | Retro with agent team block |
+
+## Roles (shared catalog)
+
+Roster of specialists is **stack-specific** (agent names and write scopes differ). See **Stack notes** in the stack adapter for the live Roles table. Common patterns:
+
+| Kind | Examples (names vary by stack) |
+|------|--------------------------------|
+| Planning | `task-router`, `task-analyst`, `solution-architect`, `migration-specialist` |
+| Implementation | `feature-developer`, `debugger`, `ci-investigator` |
+| Gates / review | `build-verifier`, `code-reviewer`, `security-reviewer`, `performance-auditor` (no `accessibility-reviewer`) |
+| Tests | unit planner/generator/healer; e2e/UI planner/generator/healer (stack-native) |
+| Docs | `tech-writer` |
+
+**Cursor frontmatter:** all team pipeline agents use `readonly: false` so they can write team artifacts. Production/app restrictions live in the agent prompt body — do **not** set `readonly: true`.
+
+Full prompts: stack `agents/*.md`. Artifact conventions: stack `team/README.md`.
+
+## Dynamic pipeline
+
+```mermaid
+flowchart TD
+  task["/task prompt"]
+  router["task-router"]
+  pipeline["pipeline.json"]
+  step0["steps 0..N"]
+  gate{"humanGates?"}
+  hook["subagentStop hook"]
+  retro["/technical-retro"]
+
+  task --> router
+  router --> pipeline
+  pipeline --> step0
+  step0 --> gate
+  gate -->|"/task-continue"| step0
+  step0 --> hook
+  hook --> step0
+  step0 --> retro
+```
+
+**Source of truth for order:** `pipeline.json` → `steps[]`. Never hardcode analyst → dev → review → QA when `pipeline.json` exists.
+
+## status.json (pipeline mode)
+
+```json
+{
+  "slug": "...",
+  "intent": "feature",
+  "pipelineIndex": 0,
+  "currentAgent": "task-analyst",
+  "phase": "executing",
+  "state": "in_progress",
+  "awaitingHumanGate": false
+}
+```
+
+| state | Meaning |
+|-------|---------|
+| `in_progress` | Current step running |
+| `completed` | Current step done; hook advances |
+| `awaiting_approval` | Human gate; wait for `/task-continue` |
+| `changes_requested` | Reviewer blocked; re-run developer (`retryAfterFix`) |
+| `validation_failed` | build-verifier failed; re-run developer then build-verifier |
+
+## Pipeline step options
+
+| Field | Use |
+|-------|-----|
+| `skipIf` | `debugger.fixed` / `ci-investigator.resolved` — hook skips step when artifact says fix applied |
+| `parallel: true` | `agent` is array — invoke **all** agents in one parent turn; each appends to `parallelCompleted` |
+| `scope` | e.g. `unit-in-dev`, `e2e-only`, `preset-artifacts-only` — passed to developer/qa |
+| `model` | `cheap` \| `standard` \| `strong` — optional tier override |
+
+## Rules (strict)
+
+1. **`/task` always starts with task-router** (except user says "skip router" with documented pipeline).
+2. Read `pipeline.json` before every subagent invocation.
+3. One role per Task call — **except** parallel steps: multiple Task calls in one message.
+4. **Never** skip `humanGates` without `/task-continue` or explicit user approval.
+5. Persist handoffs to disk (`brief.md`, `decomposition.md`, `debug-report.md`, `validation-report.md`, `architecture.md`, `migration-plan.md`, `ci-report.md`, `a11y-review.md`, `perf-report.md`, `security-review.md`, `api-contract-review.md`, `unit-test-plan.md`, `documentation.md`, `review.md`).
+6. On `changes_requested` from reviewers: hook sets `retryAfterFix` → developer → same reviewer.
+7. On `validation_failed` from `build-verifier`: hook sets `retryAfterFix: build-verifier` → developer → build-verifier.
+8. When all steps complete, suggest `/technical-retro <slug>`.
+9. If `autoChain: false` in pipeline, do not rely on hook — manual step only.
+
+## Team artifact I/O (Cursor Shell sandbox)
+
+- Create/update team task dirs with the **Write** tool (parents are created automatically). Do **not** bootstrap slug dirs with Shell `mkdir -p` — default sandbox returns `Operation not permitted` (worse on macOS Desktop/Documents with TCC).
+- If Shell must touch team paths and fails with EPERM, retry with `required_permissions: ["all"]`. Prefer Write for artifacts.
+- Prefer repo under `~/Projects` / `WebstormProjects` over `~/Desktop` when using agent team heavily.
+
+## Invoking agents
+
+Use Task tool or `/agent-name`. Pass: slug, artifact paths, step `scope` if set.
+
+### Model when invoking (Task)
+
+1. Read `steps[i].model` if present; else use the agent’s frontmatter `model` (see `agents/README.md` matrix).
+2. Map abstract tiers:
+   - **`cheap`** → pass Task `model: "fast"` when the tool accepts it (or rely on agent `fast`).
+   - **`standard`** → omit Task `model` (frontmatter `inherit` / mid default).
+   - **`strong`** → **never** pass `fast`; rely on agent pin or parent Max model.
+3. Parallel steps: apply the step-level `model` to **each** agent in the array (or omit → each agent’s own frontmatter).
+
+After each agent completes, ensure `status.json` has `state: completed` (or `awaiting_approval` if gate applies).
+
+## Legacy mode
+
+If `pipeline.json` is missing (old `/feature-start` tasks), fall back to fixed phases: analysis → development → review → testing. Hook supports both.
+
+## Skip pipeline when
+
+Do **not** run `/task` + router for:
+
+- Pure questions («как работает X», «объясни»).
+- Typo / one-file fix / trivial config with no architecture risk.
+- User explicitly says «без pipeline», «просто сделай», or continues an active slug.
+- Single-line `docs-only` with no code impact.
+
+Borderline work requests — см. **agent-team-intake**.
+
+## Auto-detection (optional)
+
+When user describes a **non-trivial task** (not a question), suggest `/task <message>` or run router if they agree.
+
+## Preset authoring
+
+When the work edits `packages/ai-rules/presets/**` (or dogfood `.cursor/` sync of presets), follow meta-rules: **preset-pr-checklist**, **preset-twin-sync**, **preset-layering**, **preset-token-budget**, **preset-no-cross-stack-leakage**.
+
+## Stack notes
+
+- Scope: Go hexagonal modules (`internal/`, `cmd/`) — not Next `app/src` or iOS `Features/`.
+- **No `accessibility-reviewer`** agent (no UI surface) — do not schedule it; `task-router` bans it. Gates: `build-verifier`, `code-reviewer`, `security-reviewer`, `performance-auditor`.
+- E2E/integration intents use **`integration-test-*`** agents — never Playwright or XCUITest.
+- After Go code changes, pipeline includes **build-verifier** with `go test` / `post-change-test`.

package/presets/cursor/go/rules/api-grpc.mdc

@@ -0,0 +1,28 @@
+---
+description: Thin gRPC/protobuf extension notes for Go hexagonal services (HTTP-first v1)
+globs:
+  - "**/*.proto"
+  - "**/adapters/grpc/**/*"
+alwaysApply: false
+---
+
+
+# gRPC adapters (extension stub)
+
+HTTP is the **v1 SoT** for this preset. gRPC is supported as an optional driving adapter with the same hexagonal rules.
+
+## Requirements when adding gRPC
+
+1. Keep protobuf messages in the adapter (or `api/proto`); map to domain/application at the edge.
+2. Implement the same inbound ports / use cases as HTTP — do not fork business logic.
+3. Map gRPC status codes from domain/application errors (parity with HTTP mapper).
+4. Generate code via repo-standard `buf` / `protoc` scripts — do not hand-edit `*.pb.go` unless the repo requires it.
+
+## Non-goals (v1)
+
+- Full protobuf style guide and streaming patterns — extend this rule when the consumer repo adopts gRPC widely.
+- Mandating gRPC over HTTP.
+
+## Ports
+
+- Prefer shared application use cases; gRPC service struct is a driving adapter only.

package/presets/cursor/go/rules/api-http.mdc

@@ -0,0 +1,27 @@
+---
+description: HTTP API adapter conventions for Go hexagonal services
+globs:
+  - "**/adapters/http/**/*"
+  - "**/*handler*.go"
+  - "**/*router*.go"
+alwaysApply: false
+---
+
+
+# HTTP API adapters
+
+- Handlers call inbound ports / use cases; return mapped status + body.
+- Use consistent error envelope; map domain errors centrally.
+- Version routes if the repo already versions (`/v1/...`).
+- Prefer `net/http` interfaces so tests can use `httptest` without a full framework.
+- Timeouts: set server read/write timeouts; propagate request context.
+
+## Testing
+
+- Prefer `httptest` against handler/router with mocked use cases (unit of adapter).
+- Integration: real router + test doubles or testcontainers behind driven ports.
+
+## Forbidden
+
+- Business rules or SQL in handlers.
+- Ignoring `ctx` cancelation from `r.Context()`.

package/presets/cursor/go/rules/application-usecases.mdc

@@ -0,0 +1,30 @@
+---
+description: Application use cases and orchestration in Go hexagonal services
+globs:
+  - internal/application/**/*
+  - "**/application/**/*"
+alwaysApply: false
+---
+
+
+# Application / use cases
+
+- One use case ≈ one application service method (command/query).
+- Depend on **outbound ports** (interfaces), not concrete repos/clients.
+- Orchestrate domain; transaction boundaries via ports (`UnitOfWork`) when needed — still no SQL here.
+- Accept `context.Context` on public methods; propagate to ports.
+
+## Forbidden
+
+- Importing `adapters/*`, SQL drivers, HTTP frameworks.
+- Embedding `*sql.DB`, Redis clients, or handler types in use-case structs.
+- Business rules that belong in domain entities (keep use cases thin).
+
+## Structure
+
+- Prefer `application/<usecase>.go` + `ports.go` (or `ports/`) colocated.
+- Inbound port = interface the driving adapter calls (optional if use-case struct is the API).
+
+## Tests
+
+- Mock outbound ports; assert domain outcomes and port interactions — no real DB.

package/presets/cursor/go/rules/architecture-boundaries.mdc

@@ -0,0 +1,30 @@
+---
+description: Hexagonal layer boundaries for Go backends (domain, application, ports, adapters)
+alwaysApply: true
+---
+
+
+# Границы слоёв (hexagonal)
+
+- **Domain** (`internal/domain`, `**/domain`):
+  - Может: entities, value objects, domain services, domain errors; stdlib / same BC domain.
+  - Не должен: HTTP/gRPC/CLI frameworks, SQL/ORM/drivers, Redis/Kafka clients, transport DTO/`encoding/json` API shapes.
+- **Application** (`internal/application`, `**/application`):
+  - Может: use cases; **define ports** (inbound/outbound interfaces) with domain types in signatures.
+  - Не должен: concrete adapters, SQL strings, framework handler types (`gin.Context`, `http.Request` as domain input).
+- **Ports**: interfaces only — no adapter implementations in port packages.
+- **Driving adapters** (`adapters/http|grpc`, CLI): map DTO ↔ application/domain at the edge; no business rules/SQL in handlers.
+- **Driven adapters** (`persistence|cache|messaging|external`): implement outbound ports; map rows/messages → domain; do not leak persistence models upward.
+- **Composition root** (`cmd/`, `internal/app`): wires the graph; no business logic.
+
+# Зависимости
+
+- Направление: **adapters → application → domain**.
+- Driven adapters implement outbound ports defined by application.
+- Domain never imports adapters or frameworks.
+- Cross-feature access — only via public ports / `pkg` API, not deep imports of another feature's internals.
+
+# Требование к агенту
+
+- Класть файлы в правильный слой; не «коротить» слои ради скорости.
+- DI только в composition root.

package/presets/cursor/go/rules/code-quality-and-refactoring.mdc

@@ -0,0 +1,73 @@
+---
+description: Code quality and light refactoring for Go hexagonal services
+alwaysApply: true
+---
+
+<!-- shared-core: quality/code-quality-and-refactoring.md -->
+
+# Поддержка существующего стиля
+
+- Новые изменения должны:
+  - следовать существующим паттернам (имена, структура, типизация / DI / error handling стека);
+  - минимизировать «стилистический шум» (лишние правки форматирования, rename без нужды).
+- Перед добавлением нового решения:
+  - искать аналогичное в коде и **повторять подход**, а не изобретать новый;
+  - проверять, нет ли уже подходящего компонента или паттерна в дизайн‑системе / UI‑пакетах проекта, прежде чем добавлять новый кастомный контрол;
+  - использовать при обращении к чужим модулям только их **public API** (barrel / протоколы / facades), а deep‑импорты внутренних файлов рассматривать как повод для рефакторинга.
+
+# Принципы
+
+- **KISS:** выбирать самое простое изменение, которое совпадает с паттернами репозитория; не изобретать новый стиль «с нуля».
+- **DRY + Rule of Three:** устранять дублирование логики; выносить общее **только после 3-го** повторения — ошибочная абстракция дороже дублирования.
+- **YAGNI:** не добавлять API, флаги, слои и обобщения «на будущее» без текущего требования.
+- **SOLID** (agent-actionable, не эссе):
+  - **S** — один модуль / один повод менять; дробить god-файлы в рамках лёгкого refactor.
+  - **O** — расширять через композицию/новые реализации, не раздувая существующие ветки «на всякий случай».
+  - **L** — подтип не ломает контракт базового типа/протокола.
+  - **I** — узкие порты/интерфейсы; не заставлять клиента зависеть от неиспользуемого.
+  - **D** — зависеть от абстракций (порты); детали — в адаптерах стека (не дублировать stack boundaries).
+- **CUPID** (компактный блок, Milanov):
+  - **Composable** — маленькие части стыкуются без скрытого глобального состояния.
+  - **Unix philosophy** — одна чёткая ответственность на единицу; пайплайн простых шагов.
+  - **Predictable** — одинаковый вход → одинаковый выход; минимум сюрпризов для вызывающего.
+  - **Idiomatic** — следовать идиомам языка и **существующим** конвенциям репо.
+  - **Domain-based** — имена и границы отражают предметную область фичи (не транспорт/фреймворк).
+- **Composition over inheritance:** предпочитать композицию / делегирование наследованию иерархий.
+- **Law of Demeter (hint):** не строить цепочки `a.b.c.d`; ходить через public API / facade модуля.
+
+# Рефакторинг при изменениях
+
+- Разрешён лёгкий refactor, если он:
+  - уменьшает дублирование;
+  - повышает читаемость;
+  - не ломает публичные контракты модулей.
+- Примеры допустимых улучшений (абстрактно):
+  - вынести дублирующуюся логику в общую утилиту / хук / mapper / use case;
+  - сузить небезопасные типы и unsafe-операции стека;
+  - разделить слишком крупный модуль на несколько более простых;
+  - заменить локальные «магические» значения на токены/примитивы дизайн‑системы;
+  - заменить deep‑импорты внутренних файлов других модулей на обращения к их public API.
+
+# Ограничения
+
+- Не выполнять «большой» рефакторинг, если задача точечная и не про архитектуру:
+  - не менять структуру директорий / модулей / таргетов без нужды;
+  - не менять названия публичных типов/функций/API без явного запроса.
+- При необходимости крупного изменения:
+  - сначала локально улучшить архитектуру минимальными шагами;
+  - оставить код в консистентном (собираемом) состоянии.
+
+# Требование к агенту
+
+- **Boy scout rule:** оставлять модуль немного лучше, чем до изменения (простые, безопасные улучшения).
+- Не жертвовать архитектурой и слоями ради краткости реализации.
+
+> Stack-specific lint gates, примеры и toolchain — в секции **Stack notes** адаптера пресета.
+
+## Stack notes
+
+- **No UI layer in this preset** — ignore shared-core bullets about дизайн‑система / UI‑пакеты / CSS‑токены; apply public-API and boy-scout rules to Go packages/ports instead.
+- Public API between packages: exported types/funcs in `pkg/` or explicit ports — avoid deep imports of another feature's `internal`.
+- Prefer wrapping errors with `%w`; check with `errors.Is` / `errors.As`.
+- Interfaces belong at **ports** (consumer side), not on every struct.
+- Post-change gate: **`post-change-test.mdc`** + **`go-tooling.mdc`** (not yarn lint / xcodebuild).

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

@@ -0,0 +1,43 @@
+---
+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`).
+
+## 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.