@bonesofspring/ai-rules 0.2.9 → 0.2.11

package/presets/claude/mcp-ts/commands/technical-retro.md

@@ -0,0 +1,81 @@
+---
+name: technical-retro
+description: Facilitate a technical retrospective for a period, incident, release, or completed agent-team task slug.
+---
+
+# Техническое ретро
+
+Агент выступает как **нейтральный фасилитатор технической ретроспективы**, а не как ревьюер кода или оценщик людей. **Phase 1:** следуй этому command-файлу (skill `technical-retro` — Phase 2, не обязателен).
+
+## Когда включать
+
+- Пользователь просит: «ретро», «техническое ретро», «разбор спринта/итерации», «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/claude/mcp-ts/hooks/README.md

@@ -0,0 +1,12 @@
+# `hooks` (preset mcp-ts)
+
+| File | Purpose |
+|------|---------|
+| `guard-shell-command.sh` | Destructive git / JS package-manager mismatch; allows npm/npx/node/tsc |
+| `chain-team-phases.sh` | Auto-chain pipeline steps on `subagentStop` (Phase 1: build-verifier, security-reviewer; **no** `contract-test-*`) |
+
+Claude: register hooks per Claude Code project conventions.
+
+## Optional cookbook
+
+See `hooks/examples/README.md` — secret-guard / format-edited / test-on-save. **Not** in default `hooks.json`.

package/presets/claude/mcp-ts/hooks/chain-team-phases.sh

@@ -0,0 +1,346 @@
+#!/usr/bin/env bash
+# preset: mcp-ts (TypeScript MCP) — chain handoffs use build-verifier + security-reviewer; no contract-test-*
+# 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');
+
+// mcp-ts Phase-1 chain: validation via typecheck/tests + security-reviewer (no contract-test-* handoffs)
+const TEAM_ROOT = path.join(process.cwd(), '.claude', 'team');
+
+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 activePath = path.join(TEAM_ROOT, '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(TEAM_ROOT, '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 }));
+}
+
+function readArtifact(name) {
+  const p = path.join(taskDir, name);
+  if (!fs.existsSync(p)) return '';
+  try {
+    return fs.readFileSync(p, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function getStepAgents(step) {
+  if (!step) return [];
+  return Array.isArray(step.agent) ? step.agent : [step.agent];
+}
+
+function skipIfMatches(skipIf, dir) {
+  if (!skipIf) return false;
+  // Phase-2 reserved: debugger / ci-investigator are not in mcp-ts Phase 1 roster.
+  if (skipIf === 'debugger.fixed') {
+    const text = readArtifact('debug-report.md');
+    return /fixApplied:\s*true/i.test(text) || /\*\*Fix applied:\*\*\s*true/i.test(text);
+  }
+  if (skipIf === 'ci-investigator.resolved') {
+    const text = readArtifact('ci-report.md');
+    return /fixApplied:\s*true/i.test(text) || /## Verdict\s*\nPASS/i.test(text);
+  }
+  return false;
+}
+
+function findNextExecutableStep(steps, startIdx, dir) {
+  for (let i = startIdx; i < steps.length; i++) {
+    if (!skipIfMatches(steps[i].skipIf, dir)) {
+      return { step: steps[i], index: i };
+    }
+  }
+  return null;
+}
+
+const AGENT_HANDOFF = {
+  'task-analyst': (s) =>
+    `Invoke task-analyst for slug "${s}". Write brief.md and decomposition.md under .claude/team/tasks/${s}/. ` +
+    `Set status.json: phase executing, state awaiting_approval if human gate applies. Do not use legacy phase analysis.`,
+  'solution-architect': (s) =>
+    `Invoke solution-architect for slug "${s}". Read brief.md; write architecture.md for MCP tool/resource/prompt contracts and module boundaries. Update status.json when done.`,
+  'feature-developer': (s) =>
+    `Invoke feature-developer for slug "${s}". Read brief.md, decomposition.md, validation-report.md, architecture.md, security-review.md, debug-report.md if present. ` +
+    `Follow feature-delivery-workflow.mdc and reference-features.mdc. Mandatory flow: contract → schema → handler → registration → unit/contract verification → package validation. ` +
+    `Include schema/handler unit tests before handoff. Update status.json when done.`,
+  'build-verifier': (s) =>
+    `Invoke build-verifier (readonly) for slug "${s}". Follow mcp-ts-tooling.mdc and post-change-test.mdc. ` +
+    `Discover package manager; run typecheck + project tests — never Playwright/XCUITest/Next lint recipes/Go tools as required gates. ` +
+    `For preset packaging: yarn check:preset-structure (mcp-ts STACKS + MCP_TS_FORBIDDEN_*). Write validation-report.md. Set state completed or validation_failed. Do not edit production code.`,
+  'security-reviewer': (s) =>
+    `Invoke security-reviewer (readonly) for slug "${s}". Follow security-mcp.mdc and mcp-auth-secrets.mdc; write security-review.md. Update status.json when done.`,
+};
+
+const REVIEW_AGENTS = new Set([
+  'security-reviewer',
+]);
+
+
+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 handoffForParallelStep(step) {
+  const agents = getStepAgents(step);
+  return (
+    `Invoke IN PARALLEL (one message, multiple Task calls): ${agents.join(' AND ')} for slug "${slug}". ` +
+    `Each agent writes its artifact and appends itself to status.json parallelCompleted when done.`
+  );
+}
+
+function hasGateAfter(agent, humanGates) {
+  return Array.isArray(humanGates) && humanGates.includes(`after:${agent}`);
+}
+
+function hasGateAfterStep(step, humanGates) {
+  return getStepAgents(step).some((a) => hasGateAfter(a, humanGates));
+}
+
+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: 'executing', state: 'in_progress', currentAgent: 'build-verifier' });
+    out(handoffForAgent('build-verifier'));
+    process.exit(0);
+  }
+  if (status.currentAgent === 'build-verifier' && status.state === 'completed') {
+    writeStatus({ phase: 'executing', state: 'in_progress', currentAgent: 'security-reviewer' });
+    out(handoffForAgent('security-reviewer'));
+    process.exit(0);
+  }
+  if (status.phase === 'review' && status.state === 'completed') {
+    writeStatus({ phase: 'done', state: 'completed' });
+    out(`Pipeline complete for "${slug}". Run /technical-retro ${slug}.`);
+    process.exit(0);
+  }
+  if (status.state === 'changes_requested' && REVIEW_AGENTS.has(status.currentAgent)) {
+    writeStatus({
+      currentAgent: 'feature-developer',
+      state: 'in_progress',
+      phase: 'executing',
+      retryAfterFix: status.currentAgent,
+    });
+    out(
+      handoffForAgent('feature-developer') +
+        ` After fixes, re-run ${status.currentAgent}.`,
+    );
+    process.exit(0);
+  }
+  if (status.state === 'validation_failed' && status.currentAgent === 'build-verifier') {
+    writeStatus({
+      currentAgent: 'feature-developer',
+      state: 'in_progress',
+      phase: 'executing',
+      retryAfterFix: 'build-verifier',
+    });
+    out(
+      handoffForAgent('feature-developer') +
+        ` Read validation-report.md. After fixes, re-run build-verifier.`,
+    );
+    process.exit(0);
+  }
+  if (status.state === 'completed' && status.retryAfterFix) {
+    const retry = status.retryAfterFix;
+    writeStatus({ currentAgent: retry, state: 'in_progress', retryAfterFix: null });
+    out(handoffForAgent(retry));
+    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);
+}
+
+if (status.awaitingHumanGate || status.state === 'awaiting_approval') {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+if (status.state === 'changes_requested' && REVIEW_AGENTS.has(status.currentAgent)) {
+  const reviewer = status.currentAgent;
+  writeStatus({
+    currentAgent: 'feature-developer',
+    state: 'in_progress',
+    phase: 'executing',
+    retryAfterFix: reviewer,
+  });
+  out(
+    handoffForAgent('feature-developer') +
+      ` After fixes, re-run ${reviewer}.`,
+  );
+  process.exit(0);
+}
+
+if (status.state === 'validation_failed' && status.currentAgent === 'build-verifier') {
+  writeStatus({
+    currentAgent: 'feature-developer',
+    state: 'in_progress',
+    phase: 'executing',
+    retryAfterFix: 'build-verifier',
+  });
+  out(
+    handoffForAgent('feature-developer') +
+      ` Read validation-report.md. After fixes, re-run build-verifier.`,
+  );
+  process.exit(0);
+}
+
+if (status.state === 'completed' && status.retryAfterFix) {
+  const retry = status.retryAfterFix;
+  writeStatus({ currentAgent: retry, state: 'in_progress', retryAfterFix: null });
+  out(handoffForAgent(retry));
+  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 || getStepAgents(currentStep)[0];
+const stepAgents = getStepAgents(currentStep);
+
+if (currentStep.parallel && stepAgents.length > 1) {
+  const done = [...(status.parallelCompleted || [])];
+  if (completedAgent && !done.includes(completedAgent)) {
+    done.push(completedAgent);
+  }
+  writeStatus({ parallelCompleted: done });
+  const remaining = stepAgents.filter((a) => !done.includes(a));
+  if (remaining.length > 0) {
+    process.stdout.write('{}');
+    process.exit(0);
+  }
+  writeStatus({ parallelCompleted: [] });
+}
+
+if (hasGateAfterStep(currentStep, pipeline.humanGates)) {
+  writeStatus({
+    awaitingHumanGate: true,
+    state: 'awaiting_approval',
+    currentAgent: completedAgent,
+  });
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+const next = findNextExecutableStep(steps, idx + 1, taskDir);
+if (!next) {
+  writeStatus({
+    pipelineIndex: steps.length,
+    phase: 'done',
+    state: 'completed',
+    currentAgent: null,
+    awaitingHumanGate: false,
+  });
+  out(`Pipeline complete for "${slug}". Run /technical-retro ${slug}.`);
+  process.exit(0);
+}
+
+const { step: nextStep, index: nextIdx } = next;
+const nextAgents = getStepAgents(nextStep);
+
+writeStatus({
+  pipelineIndex: nextIdx,
+  currentAgent: nextAgents[0],
+  phase: 'executing',
+  state: 'in_progress',
+  awaitingHumanGate: false,
+  parallelCompleted: [],
+});
+
+if (nextStep.parallel && nextAgents.length > 1) {
+  out(handoffForParallelStep(nextStep));
+} else {
+  out(handoffForAgent(nextAgents[0], nextStep.scope));
+}
+NODE

package/presets/claude/mcp-ts/hooks/examples/README.md

@@ -0,0 +1,11 @@
+# Hook examples (mcp-ts)
+
+Optional cookbook scripts — **not** wired into default `hooks.json`.
+
+| Example | Idea |
+|---------|------|
+| `secret-guard.example.sh` | Block committing obvious secrets |
+| `format-edited.example.sh` | Format touched files with project formatter |
+| `test-on-save.example.sh` | Run scoped tests after edits |
+
+Adapt commands to the repository package manager (`mcp-ts-tooling`).

package/presets/claude/mcp-ts/hooks/examples/format-edited.example.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+# Optional: format / lint touched TypeScript files with project tooling.
+# NOT in default hooks.json. Discover package manager before running scripts.
+set -euo pipefail
+changed=$(git diff --name-only --diff-filter=ACMR HEAD 2>/dev/null | grep -E '\.(ts|tsx|js|mjs)$' || true)
+if [[ -z "${changed:-}" ]]; then
+  exit 0
+fi
+if [[ -f yarn.lock ]]; then
+  yarn -s prettier --write $changed 2>/dev/null || true
+elif [[ -f pnpm-lock.yaml ]]; then
+  pnpm exec prettier --write $changed 2>/dev/null || true
+elif [[ -f package-lock.json ]]; then
+  npx prettier --write $changed 2>/dev/null || true
+fi
+exit 0

package/presets/claude/mcp-ts/hooks/examples/secret-guard.example.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+# Optional cookbook: block committing likely secrets in staged diffs.
+# NOT wired in default hooks.json — copy to hooks/ and register manually.
+set -euo pipefail
+PATTERN='(AKIA[0-9A-Z]{16}|-----BEGIN (RSA |OPENSSH )?PRIVATE KEY-----|api[_-]?key\s*[:=]\s*['\''\"][^'\''\"]{12,})'
+if git diff --cached -U0 2>/dev/null | grep -Eiq "$PATTERN"; then
+  echo "secret-guard: possible secret in staged diff — review before commit" >&2
+  exit 1
+fi
+exit 0

package/presets/claude/mcp-ts/hooks/examples/test-on-save.example.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# Optional: scoped unit tests after TypeScript edits.
+# NOT in default hooks.json. Prefer repository test scripts (Vitest/Jest).
+set -euo pipefail
+changed=$(git diff --name-only --diff-filter=ACMR HEAD 2>/dev/null | grep -E '\.(ts|tsx)$' || true)
+if [[ -z "${changed:-}" ]]; then
+  exit 0
+fi
+run_test() {
+  local pm="$1"
+  if $pm run -s test -- --runRelated "$changed" 2>/dev/null; then
+    return 0
+  fi
+  $pm run -s test 2>/dev/null || true
+}
+if [[ -f yarn.lock ]]; then
+  run_test yarn
+elif [[ -f pnpm-lock.yaml ]]; then
+  run_test pnpm
+elif [[ -f package-lock.json ]]; then
+  npm test --silent 2>/dev/null || true
+elif [[ -f bun.lockb || -f bun.lock ]]; then
+  bun test 2>/dev/null || true
+fi
+exit 0

package/presets/claude/mcp-ts/hooks/guard-shell-command.sh

@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+# Lightweight shell guard for Claude Code projects using this preset.
+# TypeScript MCP: allow npm/npx/node/tsc/vitest/jest; package-manager mismatch checks when lockfile exists.
+# Package-manager mismatch checks apply only when a JS lockfile/package.json exists.
+
+set -euo pipefail
+
+input=$(cat)
+
+INPUT="$input" node <<'NODE'
+const fs = require('fs');
+
+const raw = process.env.INPUT || '';
+let event;
+try {
+  event = JSON.parse(raw);
+} catch {
+  process.stdout.write('{ "permission": "allow" }');
+  process.exit(0);
+}
+
+const command = String(event.command || event.input?.command || '');
+if (!command.trim()) {
+  process.stdout.write('{ "permission": "allow" }');
+  process.exit(0);
+}
+
+function out(permission, userMessage, agentMessage) {
+  process.stdout.write(JSON.stringify({
+    permission,
+    user_message: userMessage,
+    agent_message: agentMessage || userMessage,
+  }));
+}
+
+const dangerousGit = /\bgit\s+(reset\s+--hard|clean\s+-[^\n]*f|push\s+--force|push\s+-f|checkout\s+--\s+)/;
+if (dangerousGit.test(command)) {
+  out(
+    'ask',
+    'This command looks destructive for git state. Review it before continuing.',
+    'A project hook flagged a destructive git command. Ask the user before running it.',
+  );
+  process.exit(0);
+}
+
+const managerByFile = [
+  ['yarn.lock', 'yarn'],
+  ['pnpm-lock.yaml', 'pnpm'],
+  ['package-lock.json', 'npm'],
+].find(([file]) => fs.existsSync(file));
+
+let expected = managerByFile?.[1];
+if (!expected && fs.existsSync('package.json')) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+    const pm = typeof pkg.packageManager === 'string' ? pkg.packageManager : '';
+    expected = pm.split('@')[0] || undefined;
+  } catch {
+    // Ignore invalid package.json in the hook; the agent can diagnose it later.
+  }
+}
+
+if (!expected) {
+  process.stdout.write('{ "permission": "allow" }');
+  process.exit(0);
+}
+
+const used = command.match(/(^|[;&|]\s*)(npm|yarn|pnpm)\s+/)?.[2];
+if (used && used !== expected) {
+  out(
+    'ask',
+    `This repository appears to use ${expected}, but the command uses ${used}. Confirm before continuing.`,
+    `Use ${expected} for package scripts and installs unless the user explicitly approves ${used}.`,
+  );
+  process.exit(0);
+}
+
+process.stdout.write('{ "permission": "allow" }');
+NODE

package/presets/claude/mcp-ts/mcp.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "context7": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@upstash/context7-mcp@3.2.5"
+      ]
+    }
+  }
+}

package/presets/claude/mcp-ts/rules/README.md

@@ -0,0 +1,52 @@
+# `.claude/rules` (preset mcp-ts)
+
+Claude topic `.md` files are **derived** from Cursor SoT `presets/cursor/mcp-ts/rules/*.mdc`.
+
+## SoT sync
+
+| Principle | Detail |
+|-----------|--------|
+| **SoT** | `presets/cursor/mcp-ts/rules/*.mdc` |
+| **Derive** | Claude topic `.md` + `paths:` (drop `alwaysApply`) |
+| **Checklist** | change Cursor → update Claude twin **same PR** (**FAIL** if missing — see `preset-twin-sync` / build-verifier) |
+
+## Loading budget
+
+- **Session-start (no `paths:`):** exactly **3** — `mcp-ts-app-core`, `mcp-server-boundaries`, `code-quality`
+- All others — with `paths:`
+- **Twin depth:** domain rules target ≥15 body lines; thin aliases: `agent-team-intake`, `technical-retro`
+
+## Cursor → Claude mapping
+
+| Cursor `.mdc` (SoT) | Claude topic |
+|---------------------|--------------|
+| `agent-team-intake.mdc` | `tooling-and-review/agent-team-intake.md` |
+| `agent-team-orchestrator.mdc` | `tooling-and-review/agent-team-orchestrator.md` |
+| `anti-sycophancy-discipline.mdc` | `tooling-and-review/anti-sycophancy-discipline.md` |
+| `code-quality-and-refactoring.mdc` | `tooling-and-review/code-quality.md` |
+| `code-review-mr.mdc` | `tooling-and-review/code-review.md` |
+| `design-guidance.mdc` | `tooling-and-review/design-guidance.md` |
+| `feature-delivery-workflow.mdc` | `architecture/feature-delivery.md` |
+| `mcp-auth-secrets.mdc` | `api-and-data/mcp-auth-secrets.md` |
+| `mcp-contract-testing.mdc` | `api-and-data/mcp-contract-testing.md` |
+| `mcp-server-boundaries.mdc` | `architecture/mcp-server-boundaries.md` |
+| `mcp-tool-design.mdc` | `api-and-data/mcp-tool-design.md` |
+| `mcp-transport-packaging.mdc` | `api-and-data/mcp-transport-packaging.md` |
+| `mcp-ts-app-core.mdc` | `stack/mcp-ts-app-core.md` |
+| `mcp-ts-conventions.mdc` | `stack/mcp-ts-conventions.md` |
+| `mcp-ts-tooling.mdc` | `tooling-and-review/mcp-ts-tooling.md` |
+| `post-change-test.mdc` | `tooling-and-review/post-change-test.md` |
+| `preset-layering.mdc` | `tooling-and-review/preset-layering.md` |
+| `preset-no-cross-stack-leakage.mdc` | `tooling-and-review/preset-no-cross-stack-leakage.md` |
+| `preset-pr-checklist.mdc` | `tooling-and-review/preset-pr-checklist.md` |
+| `preset-token-budget.mdc` | `tooling-and-review/preset-token-budget.md` |
+| `preset-twin-sync.mdc` | `tooling-and-review/preset-twin-sync.md` |
+| `reference-features.mdc` | `architecture/reference-features.md` |
+| `security-mcp.mdc` | `tooling-and-review/security-mcp.md` |
+| `technical-retro.mdc` | `tooling-and-review/technical-retro.md` |
+| `tests-unit.mdc` | `testing/unit.md` |
+
+## Topics
+
+`architecture/`, `stack/`, `api-and-data/`, `testing/`, `tooling-and-review/`.  
+`ui-and-accessibility/` — README stub only (N/A for MCP server authoring).

package/presets/claude/mcp-ts/rules/api-and-data/README.md

@@ -0,0 +1,3 @@
+# api-and-data
+
+MCP tool design, transport, auth, contract testing.