@bonesofspring/ai-rules 0.2.14 → 0.2.15

package/presets/claude/nuxt/rules/architecture/architecture-boundaries.md

@@ -1,71 +1,72 @@
 ---
-description: Архитектурные границы и правила импортов
+description: Architectural boundaries and import rules
 paths:
   - api/**/*
   - stores/**/*
   - types/**/*
   - lib/**/*
 ---
-# Границы между слоями
+
+# Layer boundaries
 
 - **UI (`pages/**`, `components/**`, `layouts/**`)**:
-  - Может импортировать: `components/**`, `composables/**`, `stores/**` (public), типы из `~/types` / `@/types` и enum из `~/types/enums` / `@/types/enums` (**только как в `public-imports.mdc`**), контракт к API — **только** `import … from '~/api'` / `from '@/api'` (**`public-imports.mdc`**).
-  - Не должен:
-    - обращаться к HTTP‑клиенту напрямую (`$fetch` / ofetch вне `lib/clients`);
-    - знать детали DTO backend — только доменные типы.
+  - May import: `components/**`, `composables/**`, `stores/**` (public), types from `~/types` / `@/types` and enums from `~/types/enums` / `@/types/enums` (**only as in `public-imports.mdc`**), API contract — **only** `import … from '~/api'` / `from '@/api'` (**`public-imports.mdc`**).
+  - Must not:
+    - call the HTTP client directly (`$fetch` / ofetch outside `lib/clients`);
+    - know backend DTO details — only domain types.
 - **Store (`stores/**`)** — Pinia `defineStore` only (`store-pinia.mdc`):
-  - Может импортировать: другие `stores/**` (public), сервисы и публичные сущности API — **только** из `~/api` / `@/api` (**`public-imports.mdc`**), типы из `~/types` / `@/types` и enum из `~/types/enums` / `@/types/enums` (**`public-imports.mdc`**).
-  - Не должен:
-    - зависеть от конкретных UI‑компонентов / страниц;
-    - напрямую работать с global/window API.
-  - Вызовы к backend — только через сервисы, импортируемые из `~/api` / `@/api`; **транспортные** типы ответа и ошибки (из `@/types`, в том же виде, что у прикладного HTTP‑клиента) в **Pinia actions** допустимы, если так выстроен API‑слой (`http-client.mdc`, `store-pinia.mdc`).
-- **API (`api/**`)** — реализация в `services/**`, `clients/**`, реэкспорт в `api/index.ts`:
-  - Внутри слоя: типы из `@/types` и enum из `@/types/enums` (**`public-imports.mdc`**); импорты `@/api/services/**`, `@/api/clients/**`, относительные пути между файлами слоя (`http-client.mdc`, `api-services.mdc`).
-  - Не должен:
-    - тянуть в себя UI или store;
-    - смешивать HTTP‑слой и доменный слой — использовать мапперы.
-
-## UI и обращение к API (`~/api` / `@/api`)
-
-- По умолчанию сценарии с **изменением серверного состояния** и координация нескольких шагов — через **Pinia actions** (`defineStore`, паттерн фичи в репозитории).
-- Прямой вызов методов сервисов, импортированных из **`~/api` / `@/api`**, из UI допустим только в **узких случаях**: преимущественно **чтение** или действие **без необходимости держать результат в Pinia**; те же **доменные типы**, что использовала бы store action; **не** дублировать уже существующий сценарий из store и **не** протаскивать DTO в компоненты.
-- Предпочтительно оформлять такие вызовы так же, как в **соседних фичах** репозитория (composable‑фасад, `use*` и т.д.).
-
-## Порты и адаптеры (краткая карта)
-
-- **Входящий адаптер**: UI — ввод пользователя, отображение; зависит от store и доменных типов, не от транспорта.
-- **Оркестрация сценариев**: store (Pinia actions) — вызывает сервисы, кладёт в state **доменные** модели после маппинга.
-- **Исходящий порт (контракт к backend)**: публичный API **`~/api` / `@/api`** (barrel `api/index.ts`; реализация — в `api/services/**` и т.д., см. `public-imports.mdc`).
-- **Исходящий адаптер**: общая реализация HTTP в **`lib/clients/**`** и экземпляры в **`api/clients/**`** (обёртка `$fetch` / ofetch).
-
-## Фича как срез
-
-- Для сложной фичи выравниваются имена и термины (**единый язык** предметной области) в типах, getters/actions, сервисах и UI; структура папок — как в соседних фичах репозитория.
-
-# Правила импортов
-
-- Всегда использовать алиас `~/` или `@/` для импортов между слоями (как принято в репо); уважать `#imports`.
-- Внутри одного модуля/фичи можно использовать относительные импорты, но **без подъёма выше корня фичи** (избегать `../../../`).
-- При обращении из компонентов, composables, утилит и других модулей к чужому слою или фиче использовать только **public API** (barrel/index‑файлы и явно экспортируемые сущности), не делать deep‑импорты внутренних файлов других фич; для регламентированных слоёв — **`layer-barrel-exports.mdc`** и `public-imports.mdc`; для API‑слоя снаружи `api/**` — **`public-imports.mdc`** (только `~/api` / `@/api`).
-- При добавлении нового кода проверять:
-  - если модуль переиспользуемый — он должен зависеть только от более "низких" слоёв (types, utils, api), но не от страниц.
-
-# Организация фич
-
-- Для сложных фич (например, `OrderCheckout`):
-  - Страница / route: `pages/**` и/или `components/pages/OrderCheckoutPage/**`.
-  - Локальные компоненты: поддиректории `components/**` внутри страницы.
-  - Связанный store: `stores/orderCheckout.ts` (или схема соседних Pinia‑модулей в репо).
-  - API: `api/services/OrdersApi/OrderCheckout/**` (имя корневого сервиса взять из принятой в проекте схемы).
-  - Типы: `types/**` с экспортом через barrel **`types/index.ts`** (`public-imports.mdc`).
-
-# Требование к агенту
-
-При добавлении новой функциональности:
-- Разместить файлы в **соответствующих слоях**.
-- Проверить существующие фичи с аналогичной структурой и **повторить их организацию**.
-- Не "коротить" слои (например, не вызывать API прямо из компонента только ради упрощения).
-- **Запрещено:** RTK / Redux (`createSlice`, `createAsyncThunk`, `useDispatch`, `stores/slices/**` как канон).
+  - May import: other `stores/**` (public), services and public API entities — **only** from `~/api` / `@/api` (**`public-imports.mdc`**), types from `~/types` / `@/types` and enums from `~/types/enums` / `@/types/enums` (**`public-imports.mdc`**).
+  - Must not:
+    - depend on specific UI components / pages;
+    - work with global/window API directly.
+  - Backend calls — only through services imported from `~/api` / `@/api`; **transport** response and error types (from `@/types`, same shape as the application HTTP client) in **Pinia actions** are acceptable if the API layer is structured that way (`http-client.mdc`, `store-pinia.mdc`).
+- **API (`api/**`)** — implementation in `services/**`, `clients/**`, re-export in `api/index.ts`:
+  - Inside the layer: types from `@/types` and enums from `@/types/enums` (**`public-imports.mdc`**); imports `@/api/services/**`, `@/api/clients/**`, relative paths between layer files (`http-client.mdc`, `api-services.mdc`).
+  - Must not:
+    - pull in UI or store;
+    - mix HTTP and domain layers — use mappers.
+
+## UI and API access (`~/api` / `@/api`)
+
+- By default, scenarios that **change server state** and coordinate multiple steps go through **Pinia actions** (`defineStore`, feature pattern in the repository).
+- Direct calls to service methods imported from **`~/api` / `@/api`** from UI are allowed only in **narrow cases**: mainly **reads** or actions **without needing the result in Pinia**; same **domain types** a store action would use; **do not** duplicate an existing store scenario and **do not** pass DTOs into components.
+- Prefer structuring such calls like **neighboring features** in the repository (composable facade, `use*`, etc.).
+
+## Ports and adapters (short map)
+
+- **Inbound adapter**: UI — user input, display; depends on store and domain types, not transport.
+- **Scenario orchestration**: store (Pinia actions) — calls services, puts **domain** models in state after mapping.
+- **Outbound port (backend contract)**: public API **`~/api` / `@/api`** (barrel `api/index.ts`; implementation — in `api/services/**`, etc., see `public-imports.mdc`).
+- **Outbound adapter**: shared HTTP implementation in **`lib/clients/**`** and instances in **`api/clients/**`** (wrap `$fetch` / ofetch).
+
+## Feature as a slice
+
+- For a complex feature, align names and terms (**ubiquitous language** of the domain) in types, getters/actions, services, and UI; folder structure — as in neighboring features in the repository.
+
+# Import rules
+
+- Always use the `~/` or `@/` alias for cross-layer imports (as established in the repo); respect `#imports`.
+- Within one module/feature, relative imports are OK, but **without climbing above the feature root** (avoid `../../../`).
+- When components, composables, utilities, and other modules reach into another layer or feature, use only **public API** (barrel/index files and explicitly exported entities); no deep imports into other features' internal files; for regulated layers — **`layer-barrel-exports.mdc`** and `public-imports.mdc`; for the API layer from outside `api/**` — **`public-imports.mdc`** (only `~/api` / `@/api`).
+- When adding new code, check:
+  - if the module is reusable — it should depend only on "lower" layers (types, utils, api), not on pages.
+
+# Feature organization
+
+- For complex features (for example, `OrderCheckout`):
+  - Page / route: `pages/**` and/or `components/pages/OrderCheckoutPage/**`.
+  - Local components: `components/**` subdirectories inside the page.
+  - Related store: `stores/orderCheckout.ts` (or the neighboring Pinia module scheme in the repo).
+  - API: `api/services/OrdersApi/OrderCheckout/**` (root service name from the project scheme).
+  - Types: `types/**` with export through barrel **`types/index.ts`** (`public-imports.mdc`).
+
+# Agent requirement
+
+When adding new functionality:
+- Place files in the **appropriate layers**.
+- Check existing features with similar structure and **repeat their organization**.
+- Do not "short-circuit" layers (for example, do not call API directly from a component just to simplify).
+- **Forbidden:** RTK / Redux (`createSlice`, `createAsyncThunk`, `useDispatch`, `stores/slices/**` as the canon).
 
 ## Incorrect
 

package/presets/claude/nuxt/rules/architecture/feature-delivery-workflow.md

@@ -1,5 +1,5 @@
 ---
-description: Сквозной чеклист новой фичи и матрица «слой → правило Cursor». Use when implementing features via feature-developer or feature-delivery skill.
+description: End-to-end checklist for a new feature and the “layer → Cursor rule” matrix. Use when implementing features via feature-developer or feature-delivery skill.
 paths:
   - pages/**/*
   - components/**/*
@@ -8,76 +8,77 @@ paths:
   - composables/**/*
   - types/**/*
 ---
+
 <!-- shared-core: architecture/feature-delivery-workflow.md -->
 
-# Доставка фичи (сквозной порядок)
+# Feature delivery (end-to-end order)
 
 ## Stack notes
 
-Типичная фича с данными с backend и общим состоянием. Детали слоёв — `architecture-boundaries.mdc`, `nuxt-app-core.mdc`.
+Typical feature with backend data and shared state. Layer details — `architecture-boundaries.mdc`, `nuxt-app-core.mdc`.
 
-## Чеклист (порядок работ)
+## Checklist (work order)
 
-1. **Доменные типы** — `types/**`, экспорт через barrel (`public-imports.mdc`, **`layer-barrel-exports.mdc`**); JSDoc — `types-jsdoc.mdc`.
-2. **Контракт API** — DTO там, где принято; доменные типы в `@/types`.
-3. **Мапперы** — DTO → домен в `*responseMappers.ts` (`api-services.mdc`).
-4. **Сервисы** — клиенты `api/clients/**`, barrel `@/api` (`api-services.mdc`, `http-client.mdc`, **`layer-barrel-exports.mdc`**). Без `fetch` из UI/store.
-5. **Состояние** — `defineStore` / Pinia actions (`store-pinia.mdc`); actions → сервисы из `~/api` / `@/api`.
-6. **UI** — типы из `@/types`, без DTO (`vue-ui.mdc`, `architecture-boundaries-ui.mdc`, `no-v-bind-spread.mdc`).
-7. **Моки** — по схеме репо; регистрация в `mocks/handlers.ts` (см. ниже).
-8. **Тесты** — unit для мапперов (`tests-unit.mdc`); e2e по `*.cases.md` (`tests-e2e-structure.mdc`, `playwright-agents.mdc`).
-9. **Завершение** — **`post-change-lint.mdc`**: `lint:js` + `lint:css` + `typecheck`; менеджер — `package-manager.mdc`.
+1. **Domain types** — `types/**`, export via barrel (`public-imports.mdc`, **`layer-barrel-exports.mdc`**); JSDoc — `types-jsdoc.mdc`.
+2. **API contract** — DTOs where the repo uses them; domain types in `@/types`.
+3. **Mappers** — DTO → domain in `*responseMappers.ts` (`api-services.mdc`).
+4. **Services** — clients `api/clients/**`, barrel `@/api` (`api-services.mdc`, `http-client.mdc`, **`layer-barrel-exports.mdc`**). No `fetch` from UI/store.
+5. **State** — `defineStore` / Pinia actions (`store-pinia.mdc`); actions → services from `~/api` / `@/api`.
+6. **UI** — types from `@/types`, no DTOs (`vue-ui.mdc`, `architecture-boundaries-ui.mdc`, `no-v-bind-spread.mdc`).
+7. **Mocks** — per repo layout; register in `mocks/handlers.ts` (see below).
+8. **Tests** — unit for mappers (`tests-unit.mdc`); e2e from `*.cases.md` (`tests-e2e-structure.mdc`, `playwright-agents.mdc`).
+9. **Completion** — **`post-change-lint.mdc`**: `lint:js` + `lint:css` + `typecheck`; package manager — `package-manager.mdc`.
 
-## Поток данных (ориентир)
+## Data flow (orientation)
 
 ```mermaid
 flowchart LR
-  subgraph transport [Транспорт]
+  subgraph transport [Transport]
     HttpClient[HttpClient]
   end
-  DTO[DTO] --> Mappers[Мапперы]
-  Mappers --> Domain[Доменные типы]
-  Domain --> Service[API сервис]
+  DTO[DTO] --> Mappers[Mappers]
+  Mappers --> Domain[Domain types]
+  Domain --> Service[API service]
   Service --> HttpClient
   Service --> Action[Pinia action]
   Action --> Store[Store]
   Store --> UI[UI]
 ```
 
-## Регистрация по слоям
+## Registration by layer
 
-1. **Типы** — `types/**`; доменная модель — источник правды для UI и store.
-2. **API** — `api/services/<ServiceRoot>/<Segment>/`; публичные экспорты (в т.ч. **константы путей** для моков) → **`api/index.ts`**.
-3. **Моки (MSW)** — `mocks/data/<feature>/`; хендлеры в **`mocks/handlers.ts`**. Пути из `@/api`, не дублировать URL-строки. Проверить браузерный worker и Node `setupServer`, если оба используются.
-4. **Store** — `stores/<featureName>.ts` (`defineStore`); опционально composable‑фасад в `composables/**`. Регистрация через `@pinia/nuxt` / принятый в репо паттерн — **не** RTK `reducers.ts` / `middleware/**`.
-5. **UI** — `pages/**`, `components/pages/<FeatureName>Page/**` и/или `components/**`; данные через store / composables.
-6. **Unit** — `*.spec.ts`; мапперы и нетривиальная логика — обязательно.
+1. **Types** — `types/**`; domain model is the source of truth for UI and store.
+2. **API** — `api/services/<ServiceRoot>/<Segment>/`; public exports (incl. **path constants** for mocks) → **`api/index.ts`**.
+3. **Mocks (MSW)** — `mocks/data/<feature>/`; handlers in **`mocks/handlers.ts`**. Paths from `@/api`; do not duplicate URL strings. Check browser worker and Node `setupServer` if both are used.
+4. **Store** — `stores/<featureName>.ts` (`defineStore`); optional composable facade in `composables/**`. Registration via `@pinia/nuxt` / the repo’s accepted pattern — **not** RTK `reducers.ts` / `middleware/**`.
+5. **UI** — `pages/**`, `components/pages/<FeatureName>Page/**` and/or `components/**`; data via store / composables.
+6. **Unit** — `*.spec.ts`; mappers and non-trivial logic are required.
 7. **E2E** — `tests/e2e/<Area>/<plan>.cases.md` + `*.spec.ts`.
 
-## Частичные сценарии
+## Partial scenarios
 
-| Задача | Минимум действий |
-|--------|------------------|
-| Только API + типы | Типы, сервис, мапперы, `@/api` barrel; unit на маппер. |
-| Только моки | Путь в `@/api`; handlers + `mocks/handlers.ts`. |
-| Только store | Pinia actions на `@/api`; `stores/<feature>.ts`. |
-| Только UI | Store state; без HTTP/DTO. |
-| Только e2e | `*.cases.md` + spec; page object. |
+| Task | Minimum actions |
+|------|-----------------|
+| API + types only | Types, service, mappers, `@/api` barrel; unit for mapper. |
+| Mocks only | Path in `@/api`; handlers + `mocks/handlers.ts`. |
+| Store only | Pinia actions via `@/api`; `stores/<feature>.ts`. |
+| UI only | Store state; no HTTP/DTO. |
+| E2E only | `*.cases.md` + spec; page object. |
 
-## Антипаттерны
+## Anti-patterns
 
-- DTO в UI или нетипизированном store.
-- HTTP-клиент из компонента/Pinia action в обход сервиса.
-- Deep-import `@/api/services/**` из UI/store.
-- `{...props}` / `v-bind="$attrs"` spread без явного списка — `no-v-bind-spread.mdc`.
-- RTK / Redux (`createSlice`, `createAsyncThunk`, `stores/slices/**` как канон).
-- **Ubiquitous language:** имена Domain/типов отражают предметную область фичи — не смешивать транспорт/фреймворк-термины в домен без нужды.
+- DTO in UI or untyped store.
+- HTTP client from a component/Pinia action bypassing the service.
+- Deep-import `@/api/services/**` from UI/store.
+- `{...props}` / `v-bind="$attrs"` spread without an explicit list — `no-v-bind-spread.mdc`.
+- RTK / Redux (`createSlice`, `createAsyncThunk`, `stores/slices/**` as the canon).
+- **Ubiquitous language:** Domain/type names reflect the feature’s subject domain — do not mix transport/framework terms into the domain without need.
 - Load `design-guidance` (rule stem) when assessing structure, smells, or pattern fit.
 
-## Матрица: зона → правила
+## Matrix: zone → rules
 
-| Зона | Правила |
-|------|---------|
+| Zone | Rules |
+|------|-------|
 | `api/clients/**`, `lib/clients/**` | `http-client.mdc`, `tests-unit.mdc` (behavior) |
 | `api/services/**` | `api-services.mdc`, `layer-barrel-exports.mdc`, `http-client.mdc` |
 | `stores/**` | `store-pinia.mdc`, `architecture-boundaries.mdc`, `public-imports.mdc` |
@@ -85,4 +86,4 @@ flowchart LR
 | `types/**` | `public-imports.mdc`, `types-jsdoc.mdc`, `layer-barrel-exports.mdc` |
 | `tests/e2e/**` | `tests-e2e-structure.mdc`, `playwright-agents.mdc` |
 
-При добавлении или расширении фичи **пройти чеклист** и правила из таблицы для затронутых зон.
+When adding or extending a feature, **walk the checklist** and the rules from the table for affected zones.

package/presets/claude/nuxt/rules/architecture/layer-barrel-exports.md

@@ -1,60 +1,61 @@
 ---
-description: Двухуровневые barrel-экспорты для слоёв с регламентированным public API
+description: Two-level barrel exports for layers with a regulated public API
 paths: **/index.ts
 ---
-# Barrel-экспорты слоёв с public API
 
-## Когда применять
+# Barrel exports for layers with a public API
 
-Для **любого слоя** (каталога, пакета, bounded context), у которого:
+## When to apply
 
-- есть **корневой barrel** — единая точка импорта для внешних потребителей;
-- deep-импорты внутрь слоя **запрещены** снаружи (ESLint `no-restricted-imports`, правила `public-imports.mdc`).
+For **any layer** (directory, package, bounded context) that has:
 
-Примеры alias/entry point в разных проектах: `@/api`, `@/types`, `@/core`, `@/store`, `packages/foo`.
+- a **root barrel** — single import point for external consumers;
+- deep imports into the layer **forbidden** from outside (ESLint `no-restricted-imports`, `public-imports.mdc` rules).
 
-## Два уровня barrel
+Example alias/entry points across projects: `@/api`, `@/types`, `@/core`, `@/store`, `packages/foo`.
 
-1. **Локальный** — `index.ts` модуля/фичи внутри слоя.
-2. **Корневой public API** — barrel слоя (например `src/<layer>/index.ts`).
+## Two barrel levels
 
-**Внутри** слоя — относительные импорты и пути между подмодулями. **Снаружи** — только корневой barrel и **явно разрешённые** вторичные entry points (если зафиксированы в правилах проекта, напр. `@/types/enums`).
+1. **Local** — `index.ts` of a module/feature inside the layer.
+2. **Root public API** — layer barrel (e.g. `src/<layer>/index.ts`).
 
-## Что реэкспортировать наружу
+**Inside** the layer — relative imports and paths between submodules. **Outside** — only the root barrel and **explicitly allowed** secondary entry points (if fixed in project rules, e.g. `@/types/enums`).
 
-Только символы, которые **должны быть доступны** потребителям слоя: публичные функции/сервисы/фасады, типы контракта, константы и helpers, нужные другим слоям или тестам.
+## What to re-export outward
 
-**Не реэкспортировать:** внутренние адаптеры, мапперы, детали транспорта, промежуточные объекты для сборки фасада внутри слоя.
+Only symbols that **must be available** to layer consumers: public functions/services/facades, contract types, constants and helpers needed by other layers or tests.
 
-Группировка в корневом barrel — **по конвенции репозитория** (ориентир — соседние модули того же слоя).
+**Do not re-export:** internal adapters, mappers, transport details, intermediate objects used to assemble a facade inside the layer.
 
-## Чеклист агента (обязателен)
+Grouping in the root barrel — **per repository convention** (orient on neighboring modules of the same layer).
 
-При добавлении или существенном расширении **модуля внутри регламентированного слоя**:
+## Agent checklist (required)
 
-1. Определить слой, его **корневой barrel** и доп. entry points (`public-imports.mdc`).
-2. Создать/обновить **локальный** `index.ts` — только публичные символы.
-3. Если в слое есть **фасад/агрегатор** (`*ApiService.ts`, `rootReducer`, …) — подключить модуль там.
-4. Добавить **реэкспорт** новых публичных символов в **корневой barrel** слоя.
-5. **Проверка:** grep по имени символа или пути `./<Module>` в корневом barrel; снаружи слоя нет deep-импортов.
+When adding or substantially extending a **module inside a regulated layer**:
 
-Модуль **не готов**, пока чеклист не пройден.
+1. Identify the layer, its **root barrel**, and extra entry points (`public-imports.mdc`).
+2. Create/update the **local** `index.ts` — public symbols only.
+3. If the layer has a **facade/aggregator** (`*ApiService.ts`, `rootReducer`, …) — wire the module there.
+4. Add a **re-export** of new public symbols in the layer’s **root barrel**.
+5. **Verify:** grep for the symbol name or path `./<Module>` in the root barrel; no deep imports from outside the layer.
 
-## Как найти регламентированные слои в репозитории
+The module is **not ready** until the checklist passes.
 
-1. Правила `public-imports.mdc` в `.cursor/rules/`.
-2. ESLint `no-restricted-imports` — паттерны `@/<layer>/*` с исключением barrel.
-3. `architecture-boundaries.mdc`, README проекта.
+## How to find regulated layers in the repository
 
-## В этом репозитории
+1. `public-imports.mdc` rules in `.cursor/rules/`.
+2. ESLint `no-restricted-imports` — `@/<layer>/*` patterns with barrel exception.
+3. `architecture-boundaries.mdc`, project README.
 
-| Слой | Корневой barrel | Правило импортов |
-|------|-------------------|------------------|
+## In this repository
+
+| Layer | Root barrel | Import rule |
+|-------|-------------|-------------|
 | API | `api/index.ts` | `public-imports.mdc` |
 | Types | `types/index.ts` | `public-imports.mdc` (+ `@/types/enums`) |
 | Core | `core/index.ts` | ESLint: `@/core/index` |
 
-Иллюстрация двух уровней (API): локальный `services/.../<Feature>/index.ts` → фасад `*ApiService.ts` → `api/index.ts`.
+Two-level illustration (API): local `services/.../<Feature>/index.ts` → facade `*ApiService.ts` → `api/index.ts`.
 ## Incorrect
 
 ```ts

package/presets/claude/nuxt/rules/architecture/public-imports.md

@@ -1,5 +1,5 @@
 ---
-description: Импорт доменных типов и API только через публичные barrel @/types и @/api
+description: Import domain types and API only through public barrels @/types and @/api
 paths:
   - pages/**/*
   - components/**/*
@@ -8,16 +8,17 @@ paths:
   - composables/**/*
   - types/**/*
 ---
-# Публичные импорты (`@/types`, `@/api`)
 
-**Коллизии:** импорт типов — раздел `@/types` ниже; API вне `api/**` — раздел `@/api` ниже (дублирует ESLint `no-restricted-imports` в `eslint.config.mjs`).
+# Public imports (`@/types`, `@/api`)
+
+**Collisions:** type imports — `@/types` section below; API outside `api/**` — `@/api` section below (mirrors ESLint `no-restricted-imports` in `eslint.config.mjs`).
 
 ## `@/types`
 
-- **Публичный API типов** — barrel `types/index.ts`; импортировать типы только как `@/types` (или `@/types/index`).
-- **Запрещено** обходить barrel: `@/types/<что‑угодно>`, кроме enum.
-- **Enum** — только `@/types/enums` / `@/types/enums.ts`.
-- Внутри `types/**` — относительные импорты между файлами слоя.
+- **Public types API** — barrel `types/index.ts`; import types only as `@/types` (or `@/types/index`).
+- **Forbidden** to bypass the barrel: `@/types/<anything>`, except enums.
+- **Enums** — only `@/types/enums` / `@/types/enums.ts`.
+- Inside `types/**` — relative imports between layer files.
 
 ```typescript
 // ✅
@@ -28,23 +29,23 @@ import { SomeEnum } from '@/types/enums'
 import type { TUserProfile } from '@/types/User.types'
 ```
 
-Новые публичные типы — реэкспорт в `types/index.ts` по **`layer-barrel-exports.mdc`**.
+New public types — re-export in `types/index.ts` per **`layer-barrel-exports.mdc`**.
 
 ## `@/api`
 
-- **Публичный API** — barrel `api/index.ts`. Вне `api/**` — только `import … from '@/api'` (или `@/api/index`).
-- **Запрещено** снаружи слоя: `@/api/<что‑угодно>`, кроме `@/api/index`.
-- Внутри `api/**` — относительные импорты и `@/api/services/**`, `@/api/clients/**`.
+- **Public API** — barrel `api/index.ts`. Outside `api/**` — only `import … from '@/api'` (or `@/api/index`).
+- **Forbidden** from outside the layer: `@/api/<anything>`, except `@/api/index`.
+- Inside `api/**` — relative imports and `@/api/services/**`, `@/api/clients/**`.
 
 ```typescript
-// ✅ в store, UI, lib вне api
+// ✅ in store, UI, lib outside api
 import { MedcardApiService } from '@/api'
 
-// ❌ снаружи api
+// ❌ outside api
 import { MedcardApiService } from '@/api/services/MedcardApiService/MedcardApiService'
 ```
 
-Новые публичные символы API — реэкспорт в `api/index.ts` по **`layer-barrel-exports.mdc`**.
+New public API symbols — re-export in `api/index.ts` per **`layer-barrel-exports.mdc`**.
 ## Incorrect
 
 ```ts

package/presets/claude/nuxt/rules/architecture/reference-features.md

@@ -1,5 +1,5 @@
 ---
-description: Эталонные фичи репозитория — копировать структуру при реализации новых задач. Заполните пути после init в целевом репо.
+description: Repository reference features — copy structure when implementing new tasks. Fill paths after init in the target repo.
 paths:
   - pages/**/*
   - components/**/*
@@ -8,42 +8,43 @@ paths:
   - composables/**/*
   - types/**/*
 ---
+
 <!-- shared-core: architecture/reference-features.template.md -->
 
-# Эталонные фичи (reference features)
+# Reference features
 
 ## Stack notes
 
-Перед реализацией найди фичу того же типа и **повтори её структуру**, не изобретая новую организацию файлов.
+Before implementing, find a feature of the same type and **mirror its structure**; do not invent a new file organization.
 
 Taxonomy / shared core: [`presets/_shared/README.md`](../../../../_shared/README.md) · [Preset contribution guide](../../../../docs/PRESET-CONTRIBUTION.md).
 
-## Таблица эталонов
+## Reference table
 
-Замени **TBD** на реальные пути после договорённости в команде (или при `ai-rules init` в целевом репо):
+Replace **TBD** with real paths after team agreement (or on `ai-rules init` in the target repo):
 
-| Слой | Эталон | Что копировать |
-|------|--------|----------------|
+| Layer | Reference | What to copy |
+|-------|-----------|--------------|
 | UI page | **TBD** `components/pages/<Example>/` | `components/`, `*.data.ts`, `styles.ts`, barrel |
 | Store | **TBD** `stores/<example>.ts` | `defineStore`, actions, getters, types |
 | API service | **TBD** `api/services/<example>/` | service, mappers, barrel |
 | Types module | **TBD** `types/<example>/` | domain types, JSDoc, barrel export |
-| Unit tests | **TBD** рядом с эталонным mapper/service | `*.spec.ts`, describe/it naming |
+| Unit tests | **TBD** next to the reference mapper/service | `*.spec.ts`, describe/it naming |
 | E2E area | **TBD** `tests/e2e/<Area>/` | `*.cases.md`, page objects, `_shared/` |
 
-## Как использовать
+## How to use
 
-1. Определи затронутые слои из `decomposition.md` или задачи.
-2. Открой эталон из таблицы (после заполнения путей).
-3. Зеркаль именование, порядок файлов, паттерны импортов и тестов.
-4. Если эталона нет — выбери **самую близкую** существующую фичу того же слоя и зафиксируй выбор в handoff.
+1. Identify affected layers from `decomposition.md` or the task.
+2. Open the reference from the table (after paths are filled).
+3. Mirror naming, file order, import patterns, and tests.
+4. If there is no reference — pick the **closest** existing feature of the same layer and record the choice in the handoff.
 
 ## Living conventions
 
 Post-init gotchas / patterns / decisions: **`.cursor/team/conventions.md`** (and the twin tool path if both Cursor and Claude are installed). Consumer-owned; not always-on. See root `AGENTS.md` § Living conventions.
 
-## Связанные правила
+## Related rules
 
-- `code-quality-and-refactoring.mdc` — повторять паттерны, не deep-import.
-- `feature-delivery-workflow.mdc` — порядок слоёв.
-- skill `feature-delivery` — end-to-end сценарий.
+- `code-quality-and-refactoring.mdc` — repeat patterns, no deep-import.
+- `feature-delivery-workflow.mdc` — layer order.
+- skill `feature-delivery` — end-to-end scenario.

package/presets/claude/nuxt/rules/stack/README.md

@@ -1,12 +1,12 @@
 # Stack (Nuxt 3, Vue, TypeScript)
 
-Правила уровня фреймворка и языка.
+Framework- and language-level rules.
 
-| Файл | Содержание | Загрузка |
-|------|------------|----------|
-| `nuxt-app-core.md` | Стек, структура `pages/`/`components/`/`stores/`, слои | session start |
+| File | Contents | Loading |
+|------|----------|---------|
+| `nuxt-app-core.md` | Stack, `pages/`/`components/`/`stores/` structure, layers | session start |
 | `script-setup-conventions.md` | `<script setup>` conventions | `paths: **/*.{vue,ts}` |
-| `no-type-assertion.md` | Ограничение `as` на границах модулей | on-demand |
-| `navigation-router-ui.md` | Навигация в UI-компонентах (slim) | `paths: pages/**,layouts/**,middleware/**,components/**` |
-| `navigation-router.md` | Полный аудит стека навигации (Nuxt file-based routing) | `paths: pages/**,layouts/**,middleware/**,nuxt.config.*` |
-| `types-jsdoc.md` | JSDoc в `types` | `paths: types/**/*.ts` |
+| `no-type-assertion.md` | Limit `as` at module boundaries | on-demand |
+| `navigation-router-ui.md` | Navigation in UI components (slim) | `paths: pages/**,layouts/**,middleware/**,components/**` |
+| `navigation-router.md` | Full navigation stack audit (Nuxt file-based routing) | `paths: pages/**,layouts/**,middleware/**,nuxt.config.*` |
+| `types-jsdoc.md` | JSDoc in `types` | `paths: types/**/*.ts` |

package/presets/claude/nuxt/rules/stack/navigation-router-ui.md

@@ -4,11 +4,11 @@ paths: pages/**/*,layouts/**/*,middleware/**/*,components/**/*
 
 # Navigation in UI components
 
-Перед ссылками, программной навигацией или работой с URL в UI:
+Before links, programmatic navigation, or URL work in UI:
 
-1. **`package.json`** workspace приложения — `nuxt` vs чистый `vue-router` SPA.
-2. **Соседние импорты** той же фичи (`navigateTo`, `<NuxtLink>`, `useRouter` / `useRoute` vs `from 'vue-router'`).
-3. **Обёртки проекта** (`~/components/...` Link) — предпочтительнее сырого API роутера.
-4. **По умолчанию (preset):** Nuxt 3 file-based routing → `navigateTo` + `<NuxtLink>` + `useRouter` / `useRoute` (`stack/nuxt-app-core.md`, `stack/nuxt-pages-routing.md`).
+1. **`package.json`** of the app workspace — `nuxt` vs plain `vue-router` SPA.
+2. **Neighboring imports** in the same feature (`navigateTo`, `<NuxtLink>`, `useRouter` / `useRoute` vs `from 'vue-router'`).
+3. **Project wrappers** (`~/components/...` Link) — preferred over raw router API.
+4. **Default (preset):** Nuxt 3 file-based routing → `navigateTo` + `<NuxtLink>` + `useRouter` / `useRoute` (`nuxt-app-core.mdc`, `nuxt-pages-routing.mdc`).
 
-Полный аудит (дерево маршрутов, гибриды, lockfile): **`stack/navigation-router.md`** — при правках `pages/**`, `layouts/**`, `middleware/**`, `nuxt.config.*`.
+Full audit (route tree, hybrids, lockfile): **`navigation-router-stack.mdc`** — when editing `pages/**`, `layouts/**`, `middleware/**`, `nuxt.config.*`.