@bonesofspring/ai-rules 0.2.6 → 0.2.8

package/presets/claude/java/commands/feature-continue.md

@@ -0,0 +1,51 @@
+---
+name: feature-continue
+description: Legacy alias for /task-continue that resumes a feature pipeline after human approval or pause.
+---
+
+# Feature continue — продолжение после утверждения brief
+
+Legacy-команда для продолжения после human gate. Для новых пайплайнов с `pipeline.json` используй те же правила, что в `/task-continue`.
+
+## Аргументы
+
+`<slug>` — идентификатор задачи из `.claude/team/tasks/<slug>/`.
+
+## Preconditions
+
+1. Прочитай `.claude/team/tasks/<slug>/brief.md` и `decomposition.md`.
+2. Если есть `pipeline.json`, делегируй поведение `/task-continue <slug>`.
+3. Если `pipeline.json` нет, прочитай `status.json`. Продолжай только если:
+   - `phase` is `analysis` and `state` is `awaiting_approval` (user explicitly approved via this command), **or**
+   - `phase` is `development`/`review`/`testing` and work should resume.
+
+## Legacy алгоритм без `pipeline.json`
+
+1. Обнови `status.json`:
+   ```json
+   {
+     "slug": "<slug>",
+     "phase": "development",
+     "state": "approved",
+     "updatedAt": "<ISO8601>"
+   }
+   ```
+   Затем сразу установи `"state": "in_progress"` перед вызовом developer.
+
+2. Запиши `.claude/team/active-task.json` → `{ "slug": "<slug>" }`.
+
+3. Вызови subagent **feature-developer** с контекстом:
+   - пути к `brief.md`, `decomposition.md`, `status.json`;
+   - указание следовать `rules/architecture/feature-delivery-workflow.md`.
+
+4. После завершения developer продолжи review → QA по `rules/tooling-and-review/agent-team-orchestrator.md`.
+
+## Если review вернул changes_requested
+
+- Верни `phase` в `development`, `state` в `in_progress`.
+- Снова вызови **feature-developer** с списком правок от reviewer.
+
+## Не делать
+
+- Не пропускать human gate без явного `/feature-continue`.
+- Не совмещать роли developer и reviewer в одном subagent-вызове.

package/presets/claude/java/commands/feature-start.md

@@ -0,0 +1,30 @@
+---
+name: feature-start
+description: Legacy analyst-only feature intake. Prefer /task for new work because it uses router and dynamic pipeline.
+---
+
+# Feature start — legacy команда агентов
+
+Запуск **фазы анализа** для новой задачи. Для новых задач предпочтительнее `/task`, потому что он сначала строит dynamic pipeline через `task-router`.
+
+## Что делать
+
+1. Извлеки описание задачи из аргументов команды (всё после `/feature-start`).
+2. Сгенерируй **slug** (kebab-case, до 48 символов) из заголовка задачи.
+3. Создай `.claude/team/tasks/<slug>/` если его ещё нет — через запись файла (Write / Edit), не через Shell `mkdir`.
+4. Запиши `.claude/team/active-task.json` → `{ "slug": "<slug>" }`.
+5. Вызови subagent **task-analyst** с полным описанием задачи и путём к артефактам.
+6. Дождись завершения аналитика. **Не вызывай developer** на этом этапе.
+
+## Human gate
+
+После аналитика:
+
+- Покажи пользователю ссылки на `brief.md` и `decomposition.md`.
+- Попроси проверить и утвердить или прислать правки.
+- Для продолжения: `/feature-continue <slug>` или `/task-continue <slug>`.
+
+## Если slug уже существует
+
+- Если `status.json` в `awaiting_approval` — предложи ревью или `/feature-continue`.
+- Если задача в работе — спроси, продолжать или начать новый slug.

package/presets/claude/java/commands/task-continue.md

@@ -0,0 +1,49 @@
+---
+name: task-continue
+description: Continue an agent-team task after a human gate, pause, or review changes request using pipeline.json and status.json.
+---
+
+# Task continue — после human gate или паузы
+
+Продолжение пайплайна из `pipeline.json`. Алиас по смыслу: `/feature-continue`.
+
+## Аргументы
+
+`<slug>` — идентификатор задачи.
+
+## Preconditions
+
+1. Прочитай `.claude/team/tasks/<slug>/pipeline.json` и `status.json`.
+2. Продолжай если:
+   - `awaitingHumanGate: true` или `state: awaiting_approval`, **или**
+   - `state: changes_requested` (после review), **или**
+   - задача прервана и нужно возобновить с `pipelineIndex`.
+
+## Алгоритм
+
+1. Запиши `.claude/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` включён в проекте и `autoChain: true`, он продолжит цепочку по `pipeline.json`; иначе продолжай следующий шаг вручную.
+
+## Артефакты для handoff
+
+| Agent | Прочитать |
+|-------|-----------|
+| feature-developer | brief.md, decomposition.md, validation-report.md (if retry), review.md (if retry), architecture.md |
+| build-verifier | git diff, decomposition.md |
+| code-reviewer | brief.md, validation-report.md, git diff |
+| qa-tester | brief.md, decomposition.md, scope from pipeline step |

package/presets/claude/java/commands/task.md

@@ -0,0 +1,49 @@
+---
+name: task
+description: Route a natural-language task through the agent-team pipeline: task-router, pipeline.json, and the first planned specialist.
+---
+
+# Task — единая точка входа
+
+Главная команда для постановки задачи в Claude Code. Родительский агент = оркестратор (`rules/tooling-and-review/agent-team-orchestrator.md`). Intake — `rules/tooling-and-review/agent-team-intake.md`.
+
+## Аргументы
+
+Всё после `/task` — описание задачи на естественном языке.
+
+Примеры:
+
+- `/task Добавить use case отмены заказа`
+- `/task Handler падает при пустом body — пофикси`
+- `/task CI упал на mvn test / gradlew test в PR`
+- `/task Миграция на новый JDK / обновление Maven-Gradle модуля`
+- `/task Покрой unit-тестами OrderService`
+- `/task Напиши changelog для релиза фильтров`
+- `/task Сделай ревью моих изменений в application/`
+- `/task Напиши integration tests для persistence adapter`
+
+## Алгоритм
+
+1. **Slug** — kebab-case из описания (≤48 символов). Создай `.claude/team/tasks/<slug>/` через запись файла (Write / Edit) — **не** полагайся на Shell `mkdir` как единственный способ создать каталог.
+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/claude/java/commands/technical-retro.md

@@ -0,0 +1,58 @@
+---
+name: technical-retro
+description: Facilitate a technical retrospective for a period, incident, release, or completed agent-team task slug.
+---
+
+# Техническое ретро — роль агента
+
+Агент выступает как **нейтральный фасилитатор технической ретроспективы**, а не как ревьюер кода или оценщик людей. Цель — вынести уроки, согласовать действия и улучшить процесс разработки. Используй skill **`technical-retro`** как основной сценарий.
+
+## Когда включать
+
+- Пользователь просит: «ретро», «техническое ретро», «разбор спринта/итерации», «что пошло хорошо / плохо», «action items после релиза».
+- Есть контекст: период (спринт, квартал), тема (релиз, инцидент, миграция), или приложены заметки/линки.
+
+## Входные данные (запросить при нехватке)
+
+- **Период и фокус** (например: две недели, релиз X, постмортем).
+- **Участники/роли** (если важно для формулировок): только разработка или весь кросс‑функциональный поток.
+- **Ограничения**: время (15 / 30 / 60 мин), формат (async в чате vs синхронная повестка).
+- По желанию: список deliverables, метрики, ссылки на тикеты/MR — **без выдумывания** фактов, которых нет в сообщении или репозитории.
+
+Если контекста мало — задать **1–3 коротких уточняющих вопроса**, затем продолжить с явными допущениями в шапке вывода.
+
+## Принципы фасилитации
+
+- **Безопасность и нейтральность**: формулировки про процесс и систему, не про «виноватых»; избегать ярлыков к людям.
+- **Конкретика**: от абстрактного «надо лучше общаться» — к наблюдаемым событиям и договорённостям.
+- **Баланс**: зафиксировать и позитив (что усилить), и зоны роста.
+- **Один владелец и срок** у каждого action item; избегать списка «сделает команда» без имени/роли.
+- **Не смешивать с code review**: ретро не заменяет построчный разбор диффа; при запросе «и ретро, и ревью» — развести два блока в ответе.
+
+## Рекомендуемая структура сессии (по умолчанию)
+
+Подстроить под указанное время. Для короткого async‑формата — сжать до шагов 2–4.
+
+1. **Цель и рамки** (1–2 предложения): зачем встреча, что в фокусе / что вне скоупа.
+2. **Сбор фактов** (молча в чате — списком от пользователя; агент структурирует):
+   - что шло хорошо,
+   - что мешало / вызывало риски,
+   - сюрпризы (технический долг, узкие места, зависимости).
+3. **Группировка тем**: объединить дубли, выделить 3–7 тем для обсуждения (приоритет — влияние × изменяемость).
+4. **Корневые причины (легко)**: для 1–2 самых болезненных тем — кратко «5 почему» или «что в процессе/артефактах позволило этому случиться», без морализаторства.
+5. **Эксперименты на следующий цикл**: не больше 1–3 изменений процесса/инструментов; каждое — измеримое или с явным критерием «успех/не успех».
+6. **Action items**: таблица или список с **что / владелец / до когда / как поймём, что сработало**.
+
+## Формат ответа агента
+
+- Краткая **шапка**: период, фокус, допущения (если были).
+- **Повестка** или итог по этапам выше.
+- **Темы** — буллеты; по спорным местам — **вопросы команде**, а не окончательные выводы без данных.
+- **Решения и эксперименты** отдельным блоком.
+- **Action items** — в конце, каждый пункт с владельцем и дедлайном (или пометка «нужно назначить на встрече»).
+
+## Ограничения
+
+- Не приписывать команде цитаты или факты, которых не было во входе.
+- Не выдавать юридические/HR‑рекомендации; при явных конфликтах или токсичности — мягко предложить эскалацию человеку, ответственному за команду, без детализации «наказаний».
+- Если пользователь просит только шаблон — выдать **шаблон повестки и доски** (колонки, таймбоксы) без выдуманного контента.

package/presets/claude/java/hooks/README.md

@@ -0,0 +1,16 @@
+# `.claude/hooks` (preset java)
+
+| File | Purpose |
+|------|---------|
+| `chain-team-phases.sh` | Pipeline chaining after subagent stop (`TEAM_ROOT=.claude/team`) |
+| `guard-shell-command.sh` | Destructive git / JS package-manager guard; **allows** `mvn test / ./gradlew test` / `compiler/IDE inspections` / `configured static analysis` / `repo static analysis` |
+
+Claude Code may not use Cursor `hooks.json`. Wire scripts per project docs when enabling agent-team auto-chain.
+
+**No `hooks.json` in Claude preset** (platform limit — same as next Claude).
+
+## Optional cookbook
+
+Example scripts live in `hooks/examples/` (secret-guard, format-edited, test-on-save). They are **not** auto-enabled.
+
+To wire in Claude Code: copy an `.example.sh` into `hooks/`, make executable, and register per [Claude Code hooks](https://code.claude.com/docs/en/hooks) for your project. Keep stack-safe recipes (this preset: **java**). Cursor twin examples under `presets/cursor/java/hooks/examples/` are the same allowlist forks.

package/presets/claude/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(), '.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;
+  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.`,
+  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/claude/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/claude/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