@bonesofspring/ai-rules 0.2.7 → 0.2.8

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

@@ -0,0 +1,381 @@
+#!/usr/bin/env bash
+# preset: java (hexagonal) — chain handoffs use integration-test-* + post-change-test + java-tooling
+# 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 TEAM_ROOT = path.join(process.cwd(), '.cursor', '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;
+  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 .cursor/team/tasks/${s}/. ` +
+    `Set status.json: phase executing, state awaiting_approval if human gate applies. Do not use legacy phase analysis.`,
+  debugger: (s) =>
+    `Invoke debugger subagent for slug "${s}". Investigate root cause with mvn test / ./gradlew test/logs; write debug-report.md with fixApplied: true/false. ` +
+    `Update status.json when done.`,
+  'solution-architect': (s) =>
+    `Invoke solution-architect for slug "${s}". Read brief.md; write architecture.md for Java hexagonal layers. Update status.json when done.`,
+  'migration-specialist': (s) =>
+    `Invoke migration-specialist for slug "${s}". Read brief.md; write migration-plan.md for Java build/toolchain. Update status.json when done.`,
+  'api-contract-reviewer': (s) =>
+    `Invoke api-contract-reviewer (readonly) for slug "${s}". Review OpenAPI/Protobuf vs adapters; write api-contract-review.md. Update status.json when done.`,
+  'ci-investigator': (s) =>
+    `Invoke ci-investigator for slug "${s}". Diagnose CI failure (mvn test / ./gradlew test/vet/lint or preset-structure); write ci-report.md; apply minimal fix. ` +
+    `Use ci-investigation skill. Update status.json when done.`,
+  'feature-developer': (s) =>
+    `Invoke feature-developer for slug "${s}". Read brief.md, decomposition.md, validation-report.md, review.md, architecture.md, migration-plan.md, api-contract-review.md, debug-report.md if present. ` +
+    `Follow feature-delivery-workflow.mdc and reference-features.mdc. Prefer src/main/java domain|application|adapters and configuration/*Application.java composition root. ` +
+    `Include parameterized/JUnit mvn test / ./gradlew test coverage for domain/use cases before handoff. Update status.json when done.`,
+  'build-verifier': (s) =>
+    `Invoke build-verifier (readonly) for slug "${s}". Follow java-tooling.mdc and post-change-test.mdc. ` +
+    `Run mvn test / ./gradlew test and configured static analysis if present in repo/CI — never yarn/ESLint/Stylelint. ` +
+    `For preset packaging: yarn check:preset-structure. Write validation-report.md. Set state completed or validation_failed. Do not edit production code.`,
+  'performance-auditor': (s) =>
+    `Invoke performance-auditor (readonly) for slug "${s}". Audit Java hot paths/allocs/DB N+1/profiler/JFR risks; write perf-report.md. 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 (hexagonal boundaries). ` +
+    `Update status.json when done.`,
+  'security-reviewer': (s) =>
+    `Invoke security-reviewer (readonly) for slug "${s}". Follow security-java.mdc; write security-review.md. Update status.json when done.`,
+  'qa-tester': (s, scope) =>
+    `Invoke qa-tester for slug "${s}"${scope ? ` (scope: ${scope})` : ''}. ` +
+    `Add/update JUnit unit and integration tests per brief. Follow tests-unit.mdc, tests-integration.mdc, and skill integration-testing. Update status.json when done.`,
+  'unit-test-planner': (s) =>
+    `Invoke unit-test-planner for slug "${s}". Write unit-test-plan.md for parameterized/JUnit mvn test / ./gradlew test. Use unit-testing skill. Update status.json when done.`,
+  'unit-test-generator': (s) =>
+    `Invoke unit-test-generator for slug "${s}". Implement *Test.java / *Tests.java from unit-test-plan.md under src/test/java. Use unit-testing skill. Update status.json when done.`,
+  'unit-test-healer': (s) =>
+    `Invoke unit-test-healer for slug "${s}". Fix failing unit tests. Use unit-testing and debug-investigation skills. Update status.json when done.`,
+  'integration-test-planner': (s) =>
+    `Invoke integration-test-planner for slug "${s}". Create/update integration test plans (MockMvc/Testcontainers/testcontainers/adapter contracts). ` +
+    `Follow tests-integration.mdc and the integration-testing skill. Do not use browser e2e tooling. Update status.json when done.`,
+  'integration-test-generator': (s) =>
+    `Invoke integration-test-generator for slug "${s}". Generate/update *IT.java / *IntegrationTest.java from plans. ` +
+    `Follow tests-integration.mdc and the integration-testing skill. Do not use browser e2e tooling. Update status.json when done.`,
+  'integration-test-healer': (s) =>
+    `Invoke integration-test-healer for slug "${s}". Fix failing/flaky integration tests while preserving plan assertions. ` +
+    `Follow tests-integration.mdc, integration-testing, and debug-investigation. Do not use browser e2e tooling. Update status.json when done.`,
+  'tech-writer': (s) =>
+    `Invoke tech-writer for slug "${s}". Write documentation.md from task artifacts. Update status.json when done.`,
+};
+
+const REVIEW_AGENTS = new Set([
+  'code-reviewer',
+  'security-reviewer',
+  'api-contract-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: 'code-reviewer' });
+    out(handoffForAgent('code-reviewer'));
+    process.exit(0);
+  }
+  if (status.phase === 'review' && status.state === 'completed') {
+    writeStatus({ phase: 'executing', state: 'in_progress', currentAgent: 'qa-tester' });
+    out(handoffForAgent('qa-tester'));
+    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/cursor/java/hooks/examples/README.md

@@ -0,0 +1,18 @@
+# Hooks cookbook (examples)
+
+Optional scripts under `hooks/examples/`. **Not** referenced from default `hooks.json` (only `guard-shell-command.sh` + `chain-team-phases.sh`).
+
+| Script | Purpose |
+|--------|---------|
+| `secret-guard.example.sh` | Fail if staged diff looks like secrets |
+| `format-edited.example.sh` | Stack formatter / linter on edited files |
+| `test-on-save.example.sh` | Scoped tests for the stack |
+
+## Wiring (Cursor)
+
+1. Copy an example into `hooks/` (drop `.example` suffix), e.g. `cp hooks/examples/secret-guard.example.sh hooks/secret-guard.sh`.
+2. `chmod +x hooks/secret-guard.sh`.
+3. Add a hook entry in `.cursor/hooks.json` (e.g. `beforeShellExecution` or `afterFileEdit` — see Cursor hooks docs).
+4. Keep cookbook scripts **out** of the default preset `hooks.json` when contributing back upstream.
+
+Stack: **go** — recipes must stay stack-safe (no cross-stack lint/test commands).

package/presets/cursor/java/hooks/examples/format-edited.example.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+# Optional: project formatter / configured static analysis on edited Java sources.
+# NOT in default hooks.json. Discover formatter from repo/CI — do not invent one.
+set -euo pipefail
+changed=$(git diff --name-only --diff-filter=ACMR HEAD 2>/dev/null | grep '\.java$' || true)
+if [[ -n "${changed:-}" ]]; then
+  # Prefer repo wrapper / Spotless / formatter already configured — placeholders only:
+  # ./mvnw spotless:apply  OR  ./gradlew spotlessApply  OR  google-java-format -i $changed
+  true
+fi
+exit 0

package/presets/cursor/java/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/cursor/java/hooks/examples/test-on-save.example.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+# Optional: scoped Maven/Gradle test after Java edits.
+# NOT in default hooks.json. Prefer wrappers when present.
+set -euo pipefail
+changed=$(git diff --name-only --diff-filter=ACMR HEAD 2>/dev/null | grep '\.java$' || true)
+if [[ -z "${changed:-}" ]]; then
+  exit 0
+fi
+if [[ -x ./mvnw ]]; then
+  ./mvnw -q test 2>/dev/null || true
+elif [[ -x ./gradlew ]]; then
+  ./gradlew -q test 2>/dev/null || true
+elif [[ -f pom.xml ]]; then
+  mvn -q test 2>/dev/null || true
+elif [[ -f build.gradle || -f build.gradle.kts ]]; then
+  gradle -q test 2>/dev/null || true
+fi
+exit 0

package/presets/cursor/java/hooks/guard-shell-command.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+# Lightweight shell guard for Java hexagonal preset projects.
+# Java: do NOT blanket-block mvn test / ./gradlew test / compiler/IDE inspections / configured static analysis / repo static analysis.
+# Package-manager mismatch checks apply only when a JS lockfile/package.json exists.
+
+set -euo pipefail
+# JAVA_PRESET_GUARD: allow mvn/gradlew test; no Playwright/XCUITest assumptions
+
+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/cursor/java/hooks.json

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

package/presets/cursor/java/mcp.json

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

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

@@ -0,0 +1,97 @@
+# Rules (preset java)
+
+## alwaysApply (3)
+
+| Rule | Role |
+|------|------|
+| `java-app-core` | Stack + layout (Spring Boot hexagonal default) |
+| `architecture-boundaries` | Hexagonal invariants |
+| `code-quality-and-refactoring` | Shared quality + Java notes |
+
+**Session-start body budget:** sum of the 3 always-on bodies ≤ **120** lines (stretch ≤100).
+
+## Twin depth (Cursor↔Claude)
+
+- **Domain** rules: target ≥15 non-empty body lines (FAIL soft when undocumented stubs).
+- **Thin aliases** (may be shorter): `agent-team-intake`, `technical-retro`.
+- **Documented stubs** (v1): `api-grpc`, `messaging-adapters` — catalog Depth=`stub`; bodies carry an in-file stub banner + when-to-use.
+
+## Loading strategy
+
+- **`alwaysApply: true`** (Cursor) / **без `paths:`** (Claude) — только базовые инварианты (**3**): `java-app-core`, `architecture-boundaries`, `code-quality-and-refactoring`
+- **On-demand / requestable** — `post-change-test`, `java-tooling`, `agent-team-intake`, `agent-team-orchestrator`, hexagonal domain/adapters, tests, feature-delivery-workflow, reference-features, `technical-retro`
+- **Preset author meta** (globs `packages/ai-rules/presets/**`, never alwaysApply): `preset-layering`, `preset-twin-sync`, `preset-token-budget`, `preset-pr-checklist`, `preset-no-cross-stack-leakage`
+- **Skills** — Phase C (deferred): `feature-delivery`, `code-review`, `integration-testing`, …
+
+### Hexagonal edit bundles
+
+| When editing | Load |
+|--------------|------|
+| `**/domain/**` | `domain-layer` + `architecture-boundaries` |
+| `**/application/**` | `application-usecases` + `ports-interfaces` |
+| `**/adapters/inbound/**` or `**/adapters/http|grpc/**` | `adapters-driving` + `api-http` / `api-grpc` + `architecture-boundaries` |
+| `**/adapters/outbound/**` or `**/adapters/persistence|messaging/**` | `adapters-driven` + `persistence-adapters` / `messaging-adapters` |
+| `**/configuration/**`, `*Application.java` | `composition-root` |
+| After `*.java` edits | `post-change-test` (+ `java-tooling`) |
+
+## Shared core → stack mapping
+
+SoT prose: `packages/ai-rules/presets/_shared/core/**` (see `_shared/README.md`). Adapters carry `<!-- shared-core: … -->`.
+
+| Shared core | This stack adapter | Mode | Delta |
+|-------------|--------------------|------|-------|
+| `quality/code-quality-and-refactoring.md` | `code-quality-and-refactoring.mdc` | embed | Stack notes: Java packages/ports, exceptions, `post-change-test` |
+| `quality/design-guidance.md` | `design-guidance.mdc` | embed | requestable smells/GoF; Java Stack notes |
+| `agent-team/agent-team-orchestrator.md` | `agent-team-orchestrator.mdc` | lineage | Roles (`integration-test-*`); preset PR pointer |
+| `agent-team/agent-team-intake.md` | `agent-team-intake.mdc` | embed | thin alias |
+| `architecture/feature-delivery-workflow.md` | `feature-delivery-workflow.mdc` | lineage | Java hexagonal checklist |
+| `architecture/reference-features.template.md` | `reference-features.mdc` | lineage | `src/main/java/**` path table |
+| `review/code-review-mr.md` | `code-review-mr.mdc` | embed | Java checklist |
+| `review/technical-retro.md` | `technical-retro.mdc` | embed | thin alias |
+| `meta/preset-*.md` | `preset-*.mdc` | embed | author-only globs (incl. `preset-no-cross-stack-leakage`) |
+
+Claude twins + Cursor→Claude map: `presets/claude/java/rules/README.md`. Cross-stack leakage policy: `preset-no-cross-stack-leakage`.
+
+## Catalog
+
+| Stem | Depth | Notes |
+|------|-------|-------|
+| `java-app-core` | full | always-on |
+| `architecture-boundaries` | full | always-on |
+| `code-quality-and-refactoring` | full | always-on + shared embed |
+| `design-guidance` | full | requestable embed; Java Stack notes |
+| `feature-delivery-workflow` | full | Java hexagonal checklist + matrix |
+| `reference-features` | full | Java path table filled |
+| `agent-team-orchestrator` | full | Roles table (21) + Java handoffs / `integration-test-*` |
+| `code-review-mr` | full | Java Stack notes checklist |
+| `preset-*` (×5) | full | author meta |
+| `agent-team-intake` | thin-alias | |
+| `technical-retro` | thin-alias | |
+| `api-grpc` | stub | optional transport; stub banner + when-to-use |
+| `domain-layer` | full | framework-free domain |
+| `application-usecases` | full | |
+| `ports-interfaces` | full | |
+| `adapters-driven` | full | outbound persistence/cache/messaging |
+| `adapters-driving` | full | inbound HTTP/gRPC/CLI |
+| `composition-root` | full | Spring `@Configuration` + plain Java bootstrap |
+| `api-http` | full | Spring MVC/Jakarta; DTO validation/mapping |
+| `persistence-adapters` | full | JPA/JDBC; entities do not leak upward |
+| `messaging-adapters` | stub | optional; stub banner + when-to-use |
+| `module-public-api` | full | package/module boundaries |
+| `java-conventions` | full | records, exceptions, naming, no invented APIs |
+| `java-tooling` | full | requestable Maven/Gradle detect |
+| `post-change-test` | full | requestable gate |
+| `security-java` | full | secrets, validation; Spring Security pointer only |
+| `tests-unit` | full | JUnit 5, AssertJ if present, Mockito optional |
+| `tests-integration` | full | Testcontainers, Spring slices when needed |
+| `tests-e2e` | full | optional smoke; prefer integration-test-* |
+
+**Всего topic `.mdc`:** 28 domain + 5 preset-meta (без README) = 33.
+
+## Defaults (human-locked)
+
+- Spring Boot hexagonal = public default; plain Java / Quarkus / Micronaut / Jakarta = documented variants
+- Layer-first single-module = default; multi-module = documented variant
+- gRPC/messaging = documented stubs in v1
+- MCP = Context7 only
+- Static analysis = discover from repo/CI (no mandated Checkstyle/SpotBugs/Error Prone)