@bonesofspring/ai-rules 0.1.36 → 0.1.39

package/presets/cursor/next/agents/task-router.md

@@ -0,0 +1,106 @@
+---
+name: task-router
+description: Task routing specialist. Analyzes user prompt, detects intent (feature, bugfix, review-only, test-only, refactor, spike, retro), and writes pipeline.json with ordered agent steps. Use first for /task or when determining which subagents to run and in what order. Readonly — never writes production code.
+readonly: true
+model: fast
+---
+
+You are a task router for a Next.js frontend agent team. You **do not** implement tasks — you classify intent and plan the agent pipeline.
+
+## Inputs
+
+- User task description (from `/task` or orchestrator).
+- Optional: existing files under `.cursor/team/tasks/<slug>/`.
+
+## Intent detection
+
+| intent | Signals in prompt | Default steps |
+|--------|-------------------|---------------|
+| `feature` | «добавь», «новая», «реализуй», «сделай», new UI/API/store | task-analyst → feature-developer → code-reviewer → qa-tester |
+| `bugfix` | «баг», «fix», «не работает», «падает», «ошибка», regression | debugger → feature-developer → code-reviewer → qa-tester (scope regression) |
+| `review-only` | «ревью», «review MR», «проверь diff», «code review» | code-reviewer |
+| `test-only` | «e2e», «покрой тестами», «напиши тесты» (no impl) | task-analyst → qa-tester |
+| `refactor` | «рефакторинг», «без изменения поведения», «почисти» | task-analyst → feature-developer → code-reviewer |
+| `spike` | «исследуй», «оцени», «можно ли», «spike», proof of concept | task-analyst → solution-architect |
+| `retro` | «ретро», «разбор», «postmortem» | (no pipeline — orchestrator runs /technical-retro) |
+
+Adjust steps when context is clear:
+
+- **Skip task-analyst** if AC and scope are fully specified in the prompt (document reason in `skipped`).
+- **Add solution-architect** for cross-layer features (API + store + UI), new public APIs, or architecture uncertainty.
+- **Skip qa-tester** for review-only, spike (no code), or trivial one-line fixes (document risk).
+- **Skip feature-developer** for review-only, test-only (tests only), retro.
+
+## Output: pipeline.json
+
+Write to `.cursor/team/tasks/<slug>/pipeline.json`:
+
+```json
+{
+  "slug": "<slug>",
+  "intent": "feature",
+  "summary": "One-line task summary",
+  "steps": [
+    { "agent": "task-analyst", "label": "Clarify and decompose" },
+    { "agent": "feature-developer", "label": "Implement" },
+    { "agent": "code-reviewer", "label": "Code review" },
+    { "agent": "qa-tester", "label": "Unit and e2e tests", "scope": "full" }
+  ],
+  "humanGates": ["after:task-analyst"],
+  "autoChain": true,
+  "skipped": []
+}
+```
+
+### Step fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `agent` | yes | Subagent name (kebab-case) |
+| `label` | yes | Short human-readable step name |
+| `scope` | no | e.g. `full`, `regression`, `e2e-only` — passed to qa-tester |
+
+### humanGates
+
+Values: `after:<agent-name>` — orchestrator stops after that agent; user runs `/task-continue <slug>` or `/feature-continue <slug>`.
+
+- Default for `feature`, `refactor`, `test-only`: `["after:task-analyst"]`
+- Default for `bugfix`, `review-only`: `[]` (unless analyst added)
+- `spike`: `["after:solution-architect"]`
+
+### skipped (optional)
+
+```json
+"skipped": [{ "agent": "task-analyst", "reason": "AC provided in ticket" }]
+```
+
+## Initial status.json
+
+After writing pipeline.json, write:
+
+```json
+{
+  "slug": "<slug>",
+  "intent": "<intent>",
+  "pipelineIndex": 0,
+  "currentAgent": "<steps[0].agent>",
+  "phase": "executing",
+  "state": "in_progress",
+  "awaitingHumanGate": false,
+  "updatedAt": "<ISO8601>"
+}
+```
+
+Also write `.cursor/team/active-task.json` → `{ "slug": "<slug>" }`.
+
+## Handoff to orchestrator
+
+Respond with:
+
+1. **Intent** and one-line summary.
+2. **Planned steps** (table: #, agent, label).
+3. **Skipped roles** and why.
+4. **Human gates** (if any).
+5. Tell orchestrator to invoke `steps[0].agent` now (unless intent is `retro` — then run `/technical-retro`).
+
+Do not invoke implementation agents yourself.

package/presets/cursor/next/commands/README.md

@@ -1,3 +1,35 @@
 # Cursor commands (next preset)
 
-Place command definitions for this preset here. They are copied to `.cursor/commands` when you run `ai-rules init cursor --preset next`.
+Slash-команды копируются в `.cursor/commands/` при `ai-rules init cursor --preset next`.
+
+## Команда агентов
+
+| Command | Назначение |
+|---------|------------|
+| **`/task <описание>`** | **Главная точка входа:** router → pipeline.json → нужные роли по порядку |
+| `/task-continue <slug>` | После human gate или паузы |
+| `/feature-start <описание>` | Legacy: только analyst (без router) |
+| `/feature-continue <slug>` | Alias task-continue |
+| `/technical-retro [slug]` | Ретро; с slug — блок «Работа агентов» |
+
+## Примеры `/task`
+
+```
+/task Добавить фильтр по дате в Order History
+→ analyst → developer → reviewer → QA
+
+/task Order History падает при пустом списке
+→ debugger → developer → reviewer → QA (regression)
+
+/task Сделай ревью изменений в store/orders
+→ reviewer only
+```
+
+## Связанные файлы
+
+- Subagents: `../agents/` (включая `task-router.md`)
+- Оркестратор: `../rules/agent-team-orchestrator.mdc`
+- Артефакты: `../team/README.md` (`pipeline.json`, `status.json`)
+- Hooks: `../hooks.json`, `../hooks/chain-team-phases.sh`
+
+Создавать и редактировать команды можно через `/commands` в Cursor или напрямую в этой папке пресета.

package/presets/cursor/next/commands/feature-continue.md

@@ -0,0 +1,14 @@
+# Feature continue — legacy alias
+
+> **Предпочтительно:** `/task-continue <slug>` — то же поведение, учитывает `pipeline.json`.
+
+Продолжение после human gate. Полная логика — в **`task-continue.md`**.
+
+## Кратко
+
+1. Прочитай `pipeline.json` (если есть) и `status.json`.
+2. Сбрось `awaitingHumanGate`; определи следующий step по `pipelineIndex`.
+3. Вызови subagent для `currentAgent`.
+4. Hook продолжит цепочку при `autoChain: true`.
+
+См. `task-continue.md` для деталей и таблицы handoff.

package/presets/cursor/next/commands/feature-start.md

@@ -0,0 +1,28 @@
+# Feature start — legacy (analyst only)
+
+> **Предпочтительно:** `/task <описание>` — router выберет роли и порядок автоматически.
+
+Запуск **фазы анализа** без router. Родительский агент действует как оркестратор (см. `agent-team-orchestrator.mdc`).
+
+## Что делать
+
+1. Извлеки описание задачи из аргументов команды (всё после `/feature-start`).
+2. Сгенерируй **slug** (kebab-case, до 48 символов) из заголовка задачи.
+3. Создай каталог `.cursor/team/tasks/<slug>/` если его ещё нет.
+4. Запиши `.cursor/team/active-task.json` → `{ "slug": "<slug>" }`.
+5. Опционально: минимальный `pipeline.json` с фиксированными steps (analyst → developer → reviewer → qa-tester).
+6. Вызови subagent **task-analyst** (Task tool) с полным описанием задачи и путём к артефактам.
+7. Дождись завершения аналитика. **Не вызывай developer** на этом этапе.
+
+## Human gate
+
+После аналитика:
+
+- Покажи пользователю ссылки на `brief.md` и `decomposition.md`.
+- Попроси проверить и утвердить или прислать правки.
+- Для продолжения: `/task-continue <slug>` или `/feature-continue <slug>`.
+
+## Если slug уже существует
+
+- Если `status.json` в `awaiting_approval` — предложи ревью или continue.
+- Если задача в работе — спроси, продолжать или начать новый slug.

package/presets/cursor/next/commands/task-continue.md

@@ -0,0 +1,43 @@
+# Task continue — после human gate или паузы
+
+Продолжение пайплайна из `pipeline.json`. Алиас по смыслу: `/feature-continue`.
+
+## Аргументы
+
+`<slug>` — идентификатор задачи.
+
+## Preconditions
+
+1. Прочитай `.cursor/team/tasks/<slug>/pipeline.json` и `status.json`.
+2. Продолжай если:
+   - `awaitingHumanGate: true` или `state: awaiting_approval`, **или**
+   - `state: changes_requested` (после review), **или**
+   - задача прервана и нужно возобновить с `pipelineIndex`.
+
+## Алгоритм
+
+1. Запиши `.cursor/team/active-task.json` → `{ "slug": "<slug>" }`.
+2. Сбрось gate: `awaitingHumanGate: false`.
+3. Определи **следующий шаг**:
+   - После approval analyst/architect: `pipelineIndex + 1` → следующий agent в `steps`.
+   - После `changes_requested`: снова **feature-developer** (тот же index или найди developer в steps).
+4. Обнови `status.json`:
+   ```json
+   {
+     "pipelineIndex": <n>,
+     "currentAgent": "<steps[n].agent>",
+     "phase": "executing",
+     "state": "in_progress",
+     "awaitingHumanGate": false
+   }
+   ```
+5. Вызови subagent для `currentAgent` с контекстом slug и артефактов.
+6. Hook `chain-team-phases.sh` продолжит цепочку по `pipeline.json`, если `autoChain: true`.
+
+## Артефакты для handoff
+
+| Agent | Прочитать |
+|-------|-----------|
+| feature-developer | brief.md, decomposition.md, architecture.md (if exists), debug-report.md (if exists) |
+| code-reviewer | brief.md, git diff |
+| qa-tester | brief.md, decomposition.md, scope from pipeline step |

package/presets/cursor/next/commands/task.md

@@ -0,0 +1,40 @@
+# Task — единая точка входа (router + pipeline)
+
+Главная команда для постановки задачи. Родительский агент = оркестратор (`agent-team-orchestrator.mdc`).
+
+## Аргументы
+
+Всё после `/task` — описание задачи на естественном языке.
+
+Примеры:
+
+- `/task Добавить фильтр по дате в Order History`
+- `/task Order History падает при пустом списке — пофикси`
+- `/task Сделай ревью моих изменений в store/orders`
+- `/task Напиши e2e для сценария оплаты`
+
+## Алгоритм
+
+1. **Slug** — kebab-case из описания (≤48 символов). Создай `.cursor/team/tasks/<slug>/`.
+2. **Router** — вызови subagent **task-router** с описанием задачи и путём к slug.
+3. **План** — покажи пользователю таблицу из `pipeline.json`: intent, steps, skipped, humanGates.
+4. **Intent retro** — если `intent === "retro"`, выполни `/technical-retro` и **остановись**.
+5. **Старт** — вызови subagent для `pipeline.steps[0].agent`:
+   - передай slug, пути к артефактам, scope из step (если есть);
+   - обнови `status.json`: `pipelineIndex: 0`, `currentAgent`, `state: in_progress`.
+6. **Human gate** — если после текущего шага есть gate в `humanGates` (`after:<agent>`), после завершения агента **остановись** и попроси `/task-continue <slug>` (или `/feature-continue <slug>`).
+
+## Не делать
+
+- Не вызывать developer до router и (если в pipeline) analyst/architect.
+- Не hardcode порядок ролей — только `pipeline.json`.
+- Не пропускать human gate без явного continue.
+
+## Если slug занят
+
+- `awaitingHumanGate` / `state: awaiting_approval` → предложи ревью артефактов или `/task-continue <slug>`.
+- `in_progress` → спроси: продолжить или новый slug.
+
+## Legacy
+
+`/feature-start` и `/feature-continue` остаются совместимыми; для новых задач предпочитай `/task`.

package/presets/cursor/next/commands/technical-retro.md

@@ -0,0 +1,76 @@
+# Техническое ретро
+
+Агент выступает как **нейтральный фасилитатор технической ретроспективы**, а не как ревьюер кода или оценщик людей.
+
+## Когда включать
+
+- Пользователь просит: «ретро», «техническое ретро», «разбор спринта/итерации», «action items после релиза».
+- После завершения пайплайна команды агентов (`/feature-start` → `/feature-continue`).
+- Есть контекст: период, тема (релиз, инцидент), slug задачи, заметки.
+
+## Входные данные (собрать, не выдумывать)
+
+Запросить при нехватке:
+
+- **Период и фокус**.
+- **Slug задачи** (если ретро по работе команды агентов).
+- **Участники/роли** (если важно).
+- **Ограничения**: время, формат (async vs синхрон).
+
+### Артефакты команды агентов (если есть slug)
+
+Прочитать из репозитория:
+
+- `.cursor/team/tasks/<slug>/pipeline.json`
+- `.cursor/team/tasks/<slug>/brief.md`
+- `.cursor/team/tasks/<slug>/decomposition.md`
+- `.cursor/team/tasks/<slug>/status.json`
+- Git diff / `git status` для изменённых файлов
+
+Не приписывать факты, которых нет в артефактах, diff или сообщении пользователя.
+
+## Принципы фасилитации
+
+- **Безопасность**: процесс и система, не «виноватые».
+- **Конкретика**: от абстракций к наблюдаемым событиям.
+- **Баланс**: позитив и зоны роста.
+- **Action items**: владелец и срок у каждого.
+- **Не смешивать с code review** — развести блоки, если запросили оба.
+
+## Структура сессии (по умолчанию)
+
+1. **Цель и рамки**.
+2. **Сбор фактов**: хорошо / мешало / сюрпризы.
+3. **Группировка тем** (3–7).
+4. **Корневые причины** для 1–2 болезненных тем.
+5. **Эксперименты** (1–3 изменения процесса).
+6. **Action items**: что / владелец / до когда / критерий успеха.
+
+## Блок «Работа агентов» (обязателен при slug)
+
+Если ретро связано с пайплайном `/feature-start`:
+
+| Вопрос | Что фиксировать |
+|--------|-----------------|
+| Router | Ошибка intent, лишние/пропущенные steps в pipeline |
+| Аналитик | Ошибки в assumptions, пропущенные AC, лишние/недостающие таски |
+| Декомпозиция | Неполное покрытие слоёв, неверный порядок, blocked-зависимости |
+| Developer | Scope creep, пропущенные правила, lint/type gaps |
+| Reviewer | Пропущенные дефекты, false positives, качество чеклиста |
+| QA | Покрытие AC тестами, flakiness, пробелы в e2e планах |
+
+**Action items** в этом блоке — на улучшение **промптов, subagents и rules** (не только кода).
+
+## Формат ответа
+
+- Шапка: период, фокус, slug (если есть), допущения.
+- Повестка по этапам.
+- Блок **«Работа агентов»** (если применимо).
+- Темы — буллеты; спорное — **вопросы команде**.
+- **Action items** в конце.
+
+## Ограничения
+
+- Не приписывать цитаты и факты без входа.
+- Не выдавать HR‑рекомендации.
+- Если просят только шаблон — **шаблон повестки** без выдуманного контента.

package/presets/cursor/next/hooks/chain-team-phases.sh

@@ -0,0 +1,216 @@
+#!/usr/bin/env bash
+# Chains agent team steps from pipeline.json after subagentStop.
+# Falls back to legacy phase-based flow when pipeline.json is absent.
+
+set -euo pipefail
+
+input=$(cat)
+
+INPUT="$input" node <<'NODE'
+const fs = require('fs');
+const path = require('path');
+
+const inputRaw = process.env.INPUT || '';
+let hookInput;
+try {
+  hookInput = JSON.parse(inputRaw);
+} catch {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+if (hookInput.status !== 'completed') {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+const teamRoot = path.join(process.cwd(), '.cursor', 'team');
+const activePath = path.join(teamRoot, 'active-task.json');
+
+if (!fs.existsSync(activePath)) {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+let active;
+try {
+  active = JSON.parse(fs.readFileSync(activePath, 'utf8'));
+} catch {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+const slug = active.slug;
+if (!slug) {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+const taskDir = path.join(teamRoot, 'tasks', slug);
+const statusPath = path.join(taskDir, 'status.json');
+const pipelinePath = path.join(taskDir, 'pipeline.json');
+
+if (!fs.existsSync(statusPath)) {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+let status;
+try {
+  status = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+} catch {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+const now = new Date().toISOString();
+
+function writeStatus(next) {
+  status = { ...status, ...next, slug, updatedAt: now };
+  fs.writeFileSync(statusPath, JSON.stringify(status, null, 2) + '\n');
+}
+
+function out(message) {
+  process.stdout.write(JSON.stringify({ followup_message: message }));
+}
+
+const AGENT_HANDOFF = {
+  'task-analyst': (s) =>
+    `Invoke task-analyst for slug "${s}". Write brief.md and decomposition.md under .cursor/team/tasks/${s}/. ` +
+    `Set status.json state to awaiting_approval if human gate applies.`,
+  debugger: (s) =>
+    `Invoke debugger subagent for slug "${s}". Investigate root cause; write debug-report.md. ` +
+    `Update status.json when done.`,
+  'solution-architect': (s) =>
+    `Invoke solution-architect for slug "${s}". Read brief.md; write architecture.md. ` +
+    `Update status.json when done.`,
+  'feature-developer': (s) =>
+    `Invoke feature-developer for slug "${s}". Read brief.md, decomposition.md, architecture.md and debug-report.md if present. ` +
+    `Follow feature-delivery-workflow.mdc. Update status.json when done.`,
+  'code-reviewer': (s) =>
+    `Invoke code-reviewer subagent (readonly) for slug "${s}". Review git diff vs brief.md per code-review-mr.mdc. ` +
+    `Update status.json when done.`,
+  'qa-tester': (s, scope) =>
+    `Invoke qa-tester for slug "${s}"${scope ? ` (scope: ${scope})` : ''}. ` +
+    `Add/update unit and e2e tests per brief. Follow playwright-agents.mdc. Update status.json when done.`,
+};
+
+function handoffForAgent(agent, scope) {
+  const fn = AGENT_HANDOFF[agent];
+  return fn ? fn(slug, scope) : `Invoke ${agent} subagent for slug "${slug}". Update status.json when done.`;
+}
+
+function hasGateAfter(agent, humanGates) {
+  return Array.isArray(humanGates) && humanGates.includes(`after:${agent}`);
+}
+
+// --- Legacy flow (no pipeline.json) ---
+function legacyFlow() {
+  if (status.phase === 'analysis') {
+    process.stdout.write('{}');
+    process.exit(0);
+  }
+  if (status.phase === 'development' && (status.state === 'completed' || status.state === 'in_progress')) {
+    writeStatus({ phase: 'review', state: 'in_progress', currentAgent: 'code-reviewer' });
+    out(handoffForAgent('code-reviewer'));
+    process.exit(0);
+  }
+  if (status.phase === 'review' && status.state === 'completed') {
+    writeStatus({ phase: 'testing', state: 'in_progress', currentAgent: 'qa-tester' });
+    out(handoffForAgent('qa-tester'));
+    process.exit(0);
+  }
+  if (status.phase === 'review' && status.state === 'changes_requested') {
+    out(
+      `Review requested changes for slug "${slug}". Invoke feature-developer with fix list, then code-reviewer.`,
+    );
+    process.exit(0);
+  }
+  if (status.phase === 'testing' && status.state === 'completed') {
+    writeStatus({ phase: 'done', state: 'completed' });
+    out(`Pipeline complete for "${slug}". Run /technical-retro ${slug}.`);
+    process.exit(0);
+  }
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+if (!fs.existsSync(pipelinePath)) {
+  legacyFlow();
+}
+
+let pipeline;
+try {
+  pipeline = JSON.parse(fs.readFileSync(pipelinePath, 'utf8'));
+} catch {
+  legacyFlow();
+}
+
+const steps = pipeline.steps || [];
+if (steps.length === 0 || pipeline.autoChain === false) {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+// Human gate active — do not chain
+if (status.awaitingHumanGate || status.state === 'awaiting_approval') {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+// Review blocked — re-run developer
+if (status.state === 'changes_requested' && status.currentAgent === 'code-reviewer') {
+  writeStatus({
+    currentAgent: 'feature-developer',
+    state: 'in_progress',
+    phase: 'executing',
+  });
+  out(handoffForAgent('feature-developer'));
+  process.exit(0);
+}
+
+const idx = typeof status.pipelineIndex === 'number' ? status.pipelineIndex : 0;
+const currentStep = steps[idx];
+if (!currentStep) {
+  writeStatus({ phase: 'done', state: 'completed', currentAgent: null });
+  out(`Pipeline complete for "${slug}". Run /technical-retro ${slug}.`);
+  process.exit(0);
+}
+
+const completedAgent = status.currentAgent || currentStep.agent;
+
+// Gate after the step that just finished
+if (hasGateAfter(completedAgent, pipeline.humanGates)) {
+  writeStatus({
+    awaitingHumanGate: true,
+    state: 'awaiting_approval',
+    currentAgent: completedAgent,
+  });
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+const nextIdx = idx + 1;
+if (nextIdx >= steps.length) {
+  writeStatus({
+    pipelineIndex: nextIdx,
+    phase: 'done',
+    state: 'completed',
+    currentAgent: null,
+    awaitingHumanGate: false,
+  });
+  out(`Pipeline complete for "${slug}". Run /technical-retro ${slug}.`);
+  process.exit(0);
+}
+
+const nextStep = steps[nextIdx];
+writeStatus({
+  pipelineIndex: nextIdx,
+  currentAgent: nextStep.agent,
+  phase: 'executing',
+  state: 'in_progress',
+  awaitingHumanGate: false,
+});
+
+out(handoffForAgent(nextStep.agent, nextStep.scope));
+NODE

package/presets/cursor/next/hooks.json

@@ -0,0 +1,11 @@
+{
+  "version": 1,
+  "hooks": {
+    "subagentStop": [
+      {
+        "command": ".cursor/hooks/chain-team-phases.sh",
+        "loop_limit": 5
+      }
+    ]
+  }
+}

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

@@ -11,9 +11,11 @@
 
 - То есть .mdc = “markdown + config для Cursor”, .md = просто текст без управляющего смысла для ассистента.
 
-### С чего начать новую фичу
+### С чего начать новую задачу
 
-См. **`feature-delivery-workflow.mdc`** (сквозной чеклист слоёв и матрица «зона репозитория → какое правило перечитать»).
+- **Команда агентов (рекомендуется):** `/task <описание>` — router выберет роли и порядок; при human gate — `/task-continue <slug>`. См. **`agent-team-orchestrator.mdc`** и `.cursor/team/README.md`.
+- **Legacy:** `/feature-start` → `/feature-continue`.
+- **Сквозной чеклист слоёв (для developer):** **`feature-delivery-workflow.mdc`**.
 
 ### Эталонные фичи (заполняет команда)
 
@@ -23,19 +25,25 @@
 
 | Файл | Назначение |
 |------|------------|
+| `agent-team-orchestrator.mdc` | `/task`, router, `pipeline.json`, динамический пайплайн subagents |
+| `agent-team-intake.mdc` | Автоподсказка `/task` при постановке задачи (alwaysApply) |
+| `package-manager.mdc` | Перед `install` / `run` в терминале определить менеджер пакетов репо (lockfile, `packageManager`) и использовать только его |
 | `feature-delivery-workflow.mdc` | Сквозной порядок работ по фиче, mermaid‑поток, матрица слой → правило `.mdc` |
-| `next-app-core.mdc` | Стек, слои, порты‑адаптеры (кратко), доменная логика vs state, общие требования к агенту и линтам |
+| `next-app-core.mdc` | Стек, слои, порты‑адаптеры (кратко), доменная логика vs state, общие требования к агенту |
+| `post-change-lint.mdc` | **Обязательный** прогон ESLint + Stylelint после любых изменений кода, исправление срабатываний |
 | `architecture-boundaries.mdc` | Границы UI / store / API, импорты (`@/types`, `@/api`), порты‑адаптеры, фича как срез |
 | `http-client.mdc` | Один HTTP‑стек, контракты из `@/types`, без разбросанного низкоуровневого API |
 | `api-services.mdc` | Сервисы, мапперы, вызовы через прикладные API‑клиенты |
 | `store-rtk.mdc` | Redux Toolkit, thunk’и, типизация ошибок/ответов как в коде репо |
 | `types-public-imports.mdc` | Импорты только через barrel `@/types` |
 | `api-public-imports.mdc` | Импорты только через barrel `@/api` (вне `app/src/api/**`) |
+| `layer-barrel-exports.mdc` | Двухуровневые barrel для слоёв с public API (`@/api`, `@/types`, `@/core`, …) |
 | `types-jsdoc.mdc` | JSDoc для типов в `app/src/types` (русский текст, `[computed]`, без `@param`/`@returns`) |
 | `no-type-assertion-as-import-export.mdc` | Ограничение `as`, в т.ч. `instanceof` для ошибок транспорта в `catch` |
 | `code-review-mr.mdc` | Чеклист ревью MR, в т.ч. HTTP‑клиент и тесты |
 | `tests-unit.mdc` | Unit‑тесты и behavior‑тесты HTTP‑клиента |
 | `playwright-agents.mdc`, `tests-e2e-structure.mdc` | E2E |
+| `react-ui.mdc` | React/Next UI: структура компонентов, соседние `ComponentName.data.ts` / `.utils.ts`, стили, пропсы |
 
 **Коллизии формулировок:** если в разных `.mdc` расходятся детали **импорта типов**, источник правды — **`types-public-imports.mdc`** (`@/types`, `@/types/enums`); по **импорту из API‑слоя** (store, UI, прочий код вне `app/src/api/**`) — **`api-public-imports.mdc`** (`@/api`), в том же смысле что правило ESLint `no-restricted-imports` в `app/eslint.config.mjs`.
 

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

@@ -0,0 +1,14 @@
+---
+description: When the user describes a new task, feature, bug, or implementation request (not a pure question), suggest or use /task to run the agent team router. Lightweight intake hint only.
+alwaysApply: true
+---
+
+# 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.