@bonesofspring/ai-rules 0.2.13 → 0.2.15

package/presets/claude/next/rules/api-and-data/store-rtk.md

@@ -4,66 +4,66 @@ paths:
 impact: HIGH
 ---
 
-# Общие принципы
-
-- Использовать **Redux Toolkit**:
-  - `createSlice`, `createAsyncThunk`, RTK Query (если используется).
-- Хранить в store **доменные модели**, не «сырые» DTO из API.
-- Все вычисления и преобразования данных (включая вычисляемые поля, булевые флаги, агрегаты, человеко‑читаемые строки и т.п.) должны выполняться **между ответом API и записью в store** — в мапперах или отдельном слое подготовки данных. Store хранит уже подготовленную доменную модель.
-- Разделять:
-  - «серверное» состояние (данные из API) и
-  - локальное UI‑состояние (выбор/фильтры/флаги).
-
-# Структура слайсов
-
-- Каждый доменный модуль — свой слайс в `app/src/store/slices/**`.
-- Слайс экспортирует:
-  - `reducer` по умолчанию;
-  - `actions` именованным экспортом;
-  - селекторы `selectSomething(state: RootState): Type`.
-- Состояние:
-  - явный тип для state;
-  - аккуратная инициализация initialState.
-
-# Асинхронность и сайд‑эффекты
-
-- Асинхронные запросы:
-  - через `createAsyncThunk` или RTK Query.
-  - внутри thunk:
-    - вызывать API через сервисы, импортированные из `@/api` (**`architecture/public-imports.md`**);
-    - не вызывать HTTP‑клиент напрямую — только через эти сервисы.
-- Сайд‑эффекты (логирование, аналитика, работа с файлами):
-  - выносить в middleware (`app/src/store/middleware/**`) или специализированные слайсы.
-
-# Типизация
-
-- Использовать `RootState`, `AppDispatch` и типизированные хуки `useAppDispatch`, `useAppSelector` (если есть).
-- **HTTP и ошибки API**:
-  - не импортировать типы **сторонних HTTP‑библиотек**, которых нет в актуальных зависимостях и существующих слайсах (ориентир — **`package.json`** и соседние файлы);
-  - когда сервис возвращает **обёртку ответа** прикладного клиента — использовать **соответствующий тип из `@/types`** (как в barrel и в аналогичных thunk’ах);
-  - при ошибках после вызова сервиса — опираться на **тот же класс/контракт ошибки транспорта**, что использует общий клиент (из `@/types`), и разбирать тело/статус **по полям текущей реализации**, а не по воображаемому API;
-  - в **`catch`** предпочитать **`instanceof`** на класс ошибки транспорта из `@/types` (если он есть в коде) вместо голого `as`, когда это выразимо без шума (см. `stack/no-type-assertion.md`).
-- Для сущностей:
-  - доменные типы (включая вычисляемые поля) определять в `app/src/types/**`, экспортировать через barrel и импортировать в слайсы из `@/types` как **источник правды** (`architecture/public-imports.md`);
-  - избегать дублирования описаний сущностей в нескольких местах.
-- **Граница домена**: в **state** хранить доменные модели; тип **обёртки ответа клиента** допустим как тип **возвращаемого значения thunk** или промежуточно до маппинга — без дублирования DTO в полях state без нужды (согласовано с `api-and-data/api-services.md` и `api-and-data/http-client.md`).
-
-# Тестирование слайсов
-
-- Для важных слайсов:
-  - тестировать редюсеры (инициализация, основные переходы состояний);
-  - тестировать селекторы (включая edge cases).
-- Thunk’и:
-  - по возможности покрывать тестами с моками API‑слоя.
-
-# Требование к агенту
-
-При изменении/создании слайса:
-
-- Не класть логику API внутрь редюсеров/компонентов.
-- Строго типизировать state и actions.
-- Использовать **единый стиль именования actions и селекторов**, как в существующих слайсах.
-- При работе с ошибками и ответами HTTP опираться на **`api-and-data/http-client.md`** и контракты из `@/types`, а не на типы внешних HTTP‑библиотек вне зависимостей проекта.
+# General principles
+
+- Use **Redux Toolkit**:
+  - `createSlice`, `createAsyncThunk`, RTK Query (if used).
+- Store **domain models**, not "raw" DTOs from the API.
+- All data computations and transformations (including computed fields, boolean flags, aggregates, human-readable strings, etc.) must happen **between the API response and writing to store** — in mappers or a separate data-preparation layer. Store holds the prepared domain model.
+- Separate:
+  - "server" state (data from API) and
+  - local UI state (selection/filters/flags).
+
+# Slice structure
+
+- Each domain module — its own slice in `app/src/store/slices/**`.
+- A slice exports:
+  - default `reducer`;
+  - `actions` as named exports;
+  - selectors `selectSomething(state: RootState): Type`.
+- State:
+  - explicit state type;
+  - careful `initialState` initialization.
+
+# Async and side effects
+
+- Async requests:
+  - via `createAsyncThunk` or RTK Query.
+  - inside thunks:
+    - call API through services imported from `@/api` (**`architecture/public-imports.md`**);
+    - do not call the HTTP client directly — only through those services.
+- Side effects (logging, analytics, file handling):
+  - move to middleware (`app/src/store/middleware/**`) or specialized slices.
+
+# Typing
+
+- Use `RootState`, `AppDispatch`, and typed hooks `useAppDispatch`, `useAppSelector` (if present).
+- **HTTP and API errors**:
+  - do not import types from **third-party HTTP libraries** that are not in current dependencies and existing slices (guide — **`package.json`** and neighboring files);
+  - when a service returns the application client's **response wrapper** — use the **matching type from `@/types`** (as in the barrel and similar thunks);
+  - on errors after a service call — rely on the **same transport error class/contract** the shared client uses (from `@/types`), and parse body/status **by fields of the current implementation**, not an imagined API;
+  - in **`catch`**, prefer **`instanceof`** on the transport error class from `@/types` (if present in code) over bare `as`, when expressible without noise (see `stack/no-type-assertion.md`).
+- For entities:
+  - define domain types (including computed fields) in `app/src/types/**`, export through barrel, import in slices from `@/types` as **source of truth** for data shape (`architecture/public-imports.md`);
+  - avoid duplicating entity descriptions in multiple places.
+- **Domain boundary**: in **state**, store domain models; the client **response wrapper** type is acceptable as a thunk **return type** or interim before mapping — without duplicating DTOs in state fields unnecessarily (aligned with `api-and-data/api-services.md` and `api-and-data/http-client.md`).
+
+# Slice testing
+
+- For important slices:
+  - test reducers (initialization, main state transitions).
+  - test selectors (including edge cases).
+- Thunks:
+  - cover with tests and API-layer mocks when possible.
+
+# Agent requirement
+
+When changing/creating a slice:
+
+- Do not put API logic inside reducers/components.
+- Strictly type state and actions.
+- Use a **consistent naming style for actions and selectors**, as in existing slices.
+- For HTTP errors and responses, rely on **`api-and-data/http-client.md`** and contracts from `@/types`, not external HTTP library types outside project dependencies.
 ## Incorrect
 
 ```ts

package/presets/claude/next/rules/architecture/README.md

@@ -1,12 +1,12 @@
 # Architecture rules
 
-| Файл | Назначение |
-|------|------------|
-| `public-imports.md` | Импорты `@/types`, `@/types/enums`, `@/api` (вне `app/src/api/**`) |
-| `architecture-boundaries-ui.md` | Slim границы UI при правках компонентов |
-| `architecture-boundaries.md` | Полная карта UI / store / API (api, store, types, lib) |
-| `layer-barrel-exports.md` | Двухуровневые barrel для слоёв с public API |
-| `feature-delivery-workflow.md` | Сквозной чеклист новой фичи |
-| `reference-features.md` | Эталонные пути UI/store/API/types |
+| File | Purpose |
+|------|---------|
+| `public-imports.md` | Imports of `@/types`, `@/types/enums`, `@/api` (outside `app/src/api/**`) |
+| `architecture-boundaries-ui.md` | Slim UI boundaries when editing components |
+| `architecture-boundaries.md` | Full UI / store / API map (api, store, types, lib) |
+| `layer-barrel-exports.md` | Two-level barrels for layers with a public API |
+| `feature-delivery-workflow.md` | End-to-end checklist for a new feature |
+| `reference-features.md` | Reference paths for UI/store/API/types |
 
 Deprecated stubs `types-public-imports.md` / `api-public-imports.md` **removed** — use `public-imports.md`.

package/presets/claude/next/rules/architecture/architecture-boundaries-ui.md

@@ -6,10 +6,10 @@ paths:
 
 # UI layer boundaries (slim)
 
-- **Импорты:** `@/ui/**`, `@/store/**`, типы из `@/types` и enum из `@/types/enums`, API — только `from '@/api'` (`architecture/public-imports.md`).
-- **Запрещено:** прямой HTTP‑клиент; знание DTO — только доменные типы.
-- **Состояние:** сценарии с записью и координация шагов — через store/thunk; узкие прямые вызовы `@/api` для чтения — только как в соседних фичах.
-- **Организация:** алиас `@/`; без deep‑импортов в чужие фичи; только public API.
-- **Barrel:** при новых публичных символах — реэкспорт по `architecture/layer-barrel-exports.md` (правило грузится на `index.ts`).
+- **Imports:** `@/ui/**`, `@/store/**`, types from `@/types` and enums from `@/types/enums`, API — only `from '@/api'` (`architecture/public-imports.md`).
+- **Forbidden:** direct HTTP client; DTO knowledge — domain types only.
+- **State:** write scenarios and multi-step coordination — via store/thunk; narrow direct `@/api` reads — only as in neighboring features.
+- **Organization:** `@/` alias; no deep imports into other features; public API only.
+- **Barrel:** for new public symbols — re-export per `architecture/layer-barrel-exports.md` (rule loads on `index.ts`).
 
-Полная карта слоёв (store, API, порты‑адаптеры): **`architecture/architecture-boundaries.md`** — при правках `app/src/api`, `store`, `types`, `lib`.
+Full layer map (store, API, ports/adapters): **`architecture/architecture-boundaries.md`** — when editing `app/src/api`, `store`, `types`, `lib`.

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

@@ -7,73 +7,73 @@ paths:
 impact: CRITICAL
 ---
 
-# Границы между слоями
+# Layer boundaries
 
 ## UI (`app/src/ui/**`)
 
-- Может импортировать: `@/ui/**`, `@/store/**`, типы из `@/types` и enum из `@/types/enums` (**только как в `architecture/public-imports.md`**), контракт к API — **только** `import … from '@/api'` (**`architecture/public-imports.md`**).
-- Не должен:
-  - обращаться к HTTP‑клиенту напрямую;
-  - знать детали DTO backend — только доменные типы.
+- May import: `@/ui/**`, `@/store/**`, types from `@/types` and enums from `@/types/enums` (**only as in `architecture/public-imports.md`**), API contract — **only** `import … from '@/api'` (**`architecture/public-imports.md`**).
+- Must not:
+  - call the HTTP client directly;
+  - know backend DTO details — only domain types.
 
 ## Store (`app/src/store/**`)
 
-- Может импортировать: `@/store/**`, сервисы и публичные сущности API — **только** из `@/api` (**`architecture/public-imports.md`**), типы из `@/types` и enum из `@/types/enums` (**`architecture/public-imports.md`**).
-- Не должен:
-  - зависеть от конкретных UI‑компонентов;
-  - напрямую работать с global/window API.
-- Вызовы к backend — только через сервисы, импортируемые из `@/api`; **транспортные** типы ответа и ошибки (из `@/types`, в том же виде, что у прикладного HTTP‑клиента) во thunk допустимы, если так выстроен API‑слой (`api-and-data/http-client.md`, `api-and-data/store-rtk.md`).
+- May import: `@/store/**`, services and public API entities — **only** from `@/api` (**`architecture/public-imports.md`**), types from `@/types` and enums from `@/types/enums` (**`architecture/public-imports.md`**).
+- Must not:
+  - depend on specific UI components;
+  - work with global/window API directly.
+- Backend calls — only through services imported from `@/api`; **transport** response and error types (from `@/types`, same shape as the application HTTP client) in thunks are acceptable if the API layer is structured that way (`api-and-data/http-client.md`, `api-and-data/store-rtk.md`).
 
 ## API (`app/src/api/**`)
 
-Реализация в `services/**`, `clients/**`, реэкспорт в `app/src/api/index.ts`:
+Implementation in `services/**`, `clients/**`, re-export in `app/src/api/index.ts`:
 
-- Внутри слоя: типы из `@/types` и enum из `@/types/enums` (**`architecture/public-imports.md`**); импорты `@/api/services/**`, `@/api/clients/**`, относительные пути между файлами слоя (`api-and-data/http-client.md`, `api-and-data/api-services.md`).
-- Не должен:
-  - тянуть в себя UI или store;
-  - смешивать HTTP‑слой и доменный слой — использовать мапперы.
+- Inside the layer: types from `@/types` and enums from `@/types/enums` (**`architecture/public-imports.md`**); imports `@/api/services/**`, `@/api/clients/**`, relative paths between layer files (`api-and-data/http-client.md`, `api-and-data/api-services.md`).
+- Must not:
+  - pull in UI or store;
+  - mix HTTP and domain layers — use mappers.
 
-## UI и обращение к API (`@/api`)
+## UI and API access (`@/api`)
 
-- По умолчанию сценарии с **изменением серверного состояния** и координация нескольких шагов — через **store** (`createAsyncThunk`, dispatch, паттерн фичи в репозитории).
-- Прямой вызов методов сервисов, импортированных из **`@/api`**, из UI допустим только в **узких случаях**: преимущественно **чтение** или действие **без необходимости держать результат в Redux**; те же **доменные типы**, что использовал бы thunk; **не** дублировать уже существующий сценарий из store и **не** протаскивать DTO в компоненты.
-- Предпочтительно оформлять такие вызовы так же, как в **соседних фичах** репозитория (хук‑фасад, отдельный хук и т.д.).
+- By default, scenarios that **change server state** and coordinate multiple steps go through **store** (`createAsyncThunk`, dispatch, feature pattern in the repository).
+- Direct calls to service methods imported from **`@/api`** from UI are allowed only in **narrow cases**: mainly **reads** or actions **without needing the result in Redux**; same **domain types** a thunk 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 (hook facade, dedicated hook, etc.).
 
-## Порты и адаптеры (краткая карта)
+## Ports and adapters (short map)
 
-- **Входящий адаптер**: UI — ввод пользователя, отображение; зависит от store и доменных типов, не от транспорта.
-- **Оркестрация сценариев**: store (slices, thunk) — вызывает сервисы, кладёт в state **доменные** модели после маппинга.
-- **Исходящий порт (контракт к backend)**: публичный API **`@/api`** (barrel `app/src/api/index.ts`; реализация — в `app/src/api/services/**` и т.д., см. `architecture/public-imports.md`).
-- **Исходящий адаптер**: общая реализация HTTP в **`app/src/lib/clients/**`** и экземпляры в **`app/src/api/clients/**`**.
+- **Inbound adapter**: UI — user input, display; depends on store and domain types, not transport.
+- **Scenario orchestration**: store (slices, thunk) — calls services, puts **domain** models in state after mapping.
+- **Outbound port (backend contract)**: public API **`@/api`** (barrel `app/src/api/index.ts`; implementation — in `app/src/api/services/**`, etc., see `architecture/public-imports.md`).
+- **Outbound adapter**: shared HTTP implementation in **`app/src/lib/clients/**`** and instances in **`app/src/api/clients/**`**.
 
-## Фича как срез
+## Feature as a slice
 
-- Для сложной фичи выравниваются имена и термины (**единый язык** предметной области) в типах, селекторах, сервисах и UI; структура папок — как в соседних фичах репозитория.
+- For a complex feature, align names and terms (**ubiquitous language** of the domain) in types, selectors, services, and UI; folder structure — as in neighboring features in the repository.
 
-# Правила импортов
+# Import rules
 
-- Всегда использовать алиас `@/...` для импортов между слоями.
-- Внутри одного модуля/фичи можно использовать относительные импорты, но **без подъёма выше корня фичи** (избегать `../../../`).
-- При обращении из компонентов, хуков, утилит и других модулей к чужому слою или фиче использовать только **public API** (barrel/index‑файлы и явно экспортируемые сущности), не делать deep‑импорты внутренних файлов других фич; для регламентированных слоёв — **`architecture/layer-barrel-exports.md`** и `architecture/public-imports.md`; для API‑слоя снаружи `app/src/api/**` — **`architecture/public-imports.md`** (только `@/api`).
-- При добавлении нового кода проверять:
-  - если модуль переиспользуемый — он должен зависеть только от более "низких" слоёв (types, utils, api), но не от страниц.
+- Always use the `@/...` alias for cross-layer imports.
+- Within one module/feature, relative imports are OK, but **without climbing above the feature root** (avoid `../../../`).
+- When components, hooks, 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 — **`architecture/layer-barrel-exports.md`** and `architecture/public-imports.md`; for the API layer from outside `app/src/api/**` — **`architecture/public-imports.md`** (only `@/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
 
-- Для сложных фич (например, `OrderCheckout`):
-  - Страница: `app/src/ui/pages/OrderCheckoutPage/**`.
-  - Локальные компоненты: поддиректории `components/**` внутри страницы.
-  - Связанный store: `app/src/store/slices/OrderCheckout/**`.
-  - API: `app/src/api/services/OrdersApi/OrderCheckout/**` (имя корневого сервиса взять из принятой в проекте схемы).
-  - Типы: `app/src/types/**` с экспортом через barrel **`app/src/types/index.ts`** (`architecture/public-imports.md`).
+- For complex features (for example, `OrderCheckout`):
+  - Page: `app/src/ui/pages/OrderCheckoutPage/**`.
+  - Local components: `components/**` subdirectories inside the page.
+  - Related store: `app/src/store/slices/OrderCheckout/**`.
+  - API: `app/src/api/services/OrdersApi/OrderCheckout/**` (root service name from the project scheme).
+  - Types: `app/src/types/**` with export through barrel **`app/src/types/index.ts`** (`architecture/public-imports.md`).
 
-# Требование к агенту
+# Agent requirement
 
-При добавлении новой функциональности:
+When adding new functionality:
 
-- Разместить файлы в **соответствующих слоях**.
-- Проверить существующие фичи с аналогичной структурой и **повторить их организацию**.
-- Не "коротить" слои (например, не вызывать API прямо из компонента только ради упрощения).
+- 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).
 ## Incorrect
 
 ```ts

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

@@ -9,71 +9,71 @@ paths:
 <!-- shared-core: architecture/feature-delivery-workflow.md -->
 
 
-# Доставка фичи (сквозной порядок)
+# Feature delivery (end-to-end order)
 
-Типичная фича с данными с backend и общим состоянием. Детали слоёв — `architecture/architecture-boundaries.md`, `stack/next-app-core.md`.
+Typical feature with backend data and shared state. Layer details — `architecture/architecture-boundaries.md`, `stack/next-app-core.md`.
 
-## Чеклист (порядок работ)
+## Checklist (work order)
 
-1. **Доменные типы** — `app/src/types/**`, barrel (`architecture/public-imports.md`, **`architecture/layer-barrel-exports.md`**); JSDoc — `stack/types-jsdoc.md`.
-2. **Контракт API** — DTO там, где принято; доменные типы в `@/types`.
-3. **Мапперы** — DTO → домен (`api-and-data/api-services.md`).
-4. **Сервисы** — клиенты `app/src/api/clients/**`, barrel `@/api` (`api-and-data/api-services.md`, `api-and-data/http-client.md`, **`architecture/layer-barrel-exports.md`**).
-5. **Состояние** — slice/thunk (`api-and-data/store-rtk.md`); thunk → `@/api`.
-6. **UI** — `@/types`, без DTO (`ui-and-accessibility/react-ui.md`, `architecture/architecture-boundaries-ui.md`, `ui-and-accessibility/no-props-spread.md`).
-7. **Моки** — `app/src/mocks/**`; регистрация в `handlers.ts` (см. ниже).
-8. **Тесты** — unit (`testing/tests-unit.md`); e2e (`testing/tests-e2e-structure.md`, `testing/playwright-agents.md`).
-9. **Завершение** — **`tooling-and-review/post-change-lint.md`**.
+1. **Domain types** — `app/src/types/**`, barrel (`architecture/public-imports.md`, **`architecture/layer-barrel-exports.md`**); JSDoc — `stack/types-jsdoc.md`.
+2. **API contract** — DTOs where the repo uses them; domain types in `@/types`.
+3. **Mappers** — DTO → domain (`api-and-data/api-services.md`).
+4. **Services** — clients `app/src/api/clients/**`, barrel `@/api` (`api-and-data/api-services.md`, `api-and-data/http-client.md`, **`architecture/layer-barrel-exports.md`**).
+5. **State** — slice/thunk (`api-and-data/store-rtk.md`); thunk → `@/api`.
+6. **UI** — `@/types`, no DTOs (`ui-and-accessibility/react-ui.md`, `architecture/architecture-boundaries-ui.md`, `ui-and-accessibility/no-props-spread.md`).
+7. **Mocks** — `app/src/mocks/**`; register in `handlers.ts` (see below).
+8. **Tests** — unit (`testing/tests-unit.md`); e2e (`testing/tests-e2e-structure.md`, `testing/playwright-agents.md`).
+9. **Completion** — **`tooling-and-review/post-change-lint.md`**.
 
-## Поток данных
+## Data flow
 
 ```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 --> Thunk[Thunk]
   Thunk --> Store[Store]
   Store --> UI[UI]
 ```
 
-## Регистрация по слоям
+## Registration by layer
 
-1. **Типы** — `app/src/types/**`.
-2. **API** — `app/src/api/services/<ServiceRoot>/<Segment>/`; публичные экспорты → **`app/src/api/index.ts`**.
-3. **Моки** — `app/src/mocks/data/<feature>/`; **`app/src/mocks/handlers.ts`**; пути из `@/api`.
+1. **Types** — `app/src/types/**`.
+2. **API** — `app/src/api/services/<ServiceRoot>/<Segment>/`; public exports → **`app/src/api/index.ts`**.
+3. **Mocks** — `app/src/mocks/data/<feature>/`; **`app/src/mocks/handlers.ts`**; paths from `@/api`.
 4. **Store** — `app/src/store/slices/<FeatureName>/`; **`app/src/store/reducers.ts`**; middleware → **`app/src/store/index.ts`**.
 5. **UI** — pages/components; store/hooks.
-6. **Unit** — `*.spec.ts(x)`; мапперы обязательно.
+6. **Unit** — `*.spec.ts(x)`; mappers required.
 7. **E2E** — `app/__tests__/e2e/<Area>/<plan>.cases.md` + spec.
 
-## Частичные сценарии
+## Partial scenarios
 
-| Задача | Минимум действий |
-|--------|------------------|
-| Только API + типы | Типы, сервис, мапперы, `@/api` barrel; unit на маппер. |
-| Только моки | Путь в `@/api`; handlers + `mocks/handlers.ts`. |
-| Только store | Thunk на `@/api`; slice + `reducers.ts`. |
-| Только UI | Store state; без HTTP/DTO. |
-| Только e2e | `*.cases.md` + spec. |
+| 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 | Thunk via `@/api`; slice + `reducers.ts`. |
+| UI only | Store state; no HTTP/DTO. |
+| E2E only | `*.cases.md` + spec. |
 
-## Антипаттерны
+## Anti-patterns
 
-- DTO в UI или нетипизированном store.
-- HTTP-клиент из компонента/thunk в обход сервиса.
-- Deep-import `@/api/services/**` из UI/store.
+- DTO in UI or untyped store.
+- HTTP client from a component/thunk bypassing the service.
+- Deep-import `@/api/services/**` from UI/store.
 - `{...props}` — `ui-and-accessibility/no-props-spread.md`.
-- **Ubiquitous language:** имена Domain/типов отражают предметную область фичи — не смешивать транспорт/фреймворк-термины в домен без нужды.
+- **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 |
+|------|-------|
 | `app/src/api/clients/**`, `app/src/lib/clients/**` | `api-and-data/http-client.md`, `testing/tests-unit.md` |
 | `app/src/api/services/**` | `api-and-data/api-services.md`, `architecture/layer-barrel-exports.md` |
 | `app/src/store/**` | `api-and-data/store-rtk.md`, `architecture/architecture-boundaries.md`, `architecture/public-imports.md` |
@@ -81,4 +81,4 @@ flowchart LR
 | `app/src/types/**` | `architecture/public-imports.md`, `stack/types-jsdoc.md`, `architecture/layer-barrel-exports.md` |
 | `app/__tests__/e2e/**` | `testing/tests-e2e-structure.md`, `testing/playwright-agents.md` |
 
-При добавлении или расширении фичи **пройти чеклист** и правила из таблицы для затронутых зон.
+When adding or extending a feature, **walk the checklist** and the rules from the table for affected zones.

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

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