@bonesofspring/ai-rules 0.1.37 → 0.1.40

package/README.md

@@ -1,6 +1,6 @@
 # @bonesofspring/ai-rules
 
-Presets for Cursor and Claude Code: rules, commands, plus for Claude `CLAUDE.md` and `skills` / `agents` / `hooks` when the preset includes them. Install from npm into a project so you don’t have to copy files out of the repo by hand.
+Presets for Cursor and Claude Code: rules, commands, plus optional `agents`, `hooks`, `skills`, and team artifacts when the preset includes them. For Claude: `CLAUDE.md`. Install from npm into a project so you don’t have to copy files out of the repo by hand.
 
 Node 18+.
 
@@ -15,7 +15,7 @@ Global: `npm i -g @bonesofspring/ai-rules`, then `ai-rules ...`.
 
 `init` merges into the current directory: dirs are created, matching files are **overwritten**. `--preset` and the subcommand can be in either order, e.g. `--preset=next init cursor`.
 
-`clean cursor` / `clean claude` removes what this CLI installs: for Cursor, the entire `.cursor` directory; for Claude, `.claude/rules`, `.claude/commands`, `skills`, `agents`, `hooks`, and `CLAUDE.md` when present. Anything else under `.claude` is left alone.
+`clean cursor` / `clean claude` removes what this CLI installs: `rules`, `commands`, optional `agents`, `hooks`, `skills`, `team`, Cursor `hooks.json`, and Claude `CLAUDE.md` when present. Other files under `.cursor/` or `.claude/` are left intact.
 
 Where things go on `init`:
 
@@ -23,7 +23,11 @@ Where things go on `init`:
 |---|--------|--------|
 | rules | `.cursor/rules` | `.claude/rules` |
 | commands | `.cursor/commands` | `.claude/commands` |
-| other | — | root `CLAUDE.md` → `.claude/CLAUDE.md`; folders `skills`, `agents`, `hooks` → under `.claude/` with the same names |
+| agents | `.cursor/agents` | `.claude/agents` |
+| hooks | `.cursor/hooks`, `.cursor/hooks.json` | `.claude/hooks` |
+| skills | `.cursor/skills` | `.claude/skills` |
+| team artifacts template | `.cursor/team` | `.claude/team` |
+| other | — | root `CLAUDE.md` → `.claude/CLAUDE.md` |
 
 The package currently ships the **`next`** preset (Next.js stack and whatever else is bundled there). Other preset names: see `presets/` in the [repo](https://github.com/bonesofspring/ai-rules). Name is a single path segment, no `/` or `..`.
 

package/bin/cli.js

@@ -15,13 +15,17 @@ const PRESETS = {
     rulesDir: '.cursor/rules',
     commandsDir: '.cursor/commands',
     relBase: ['presets', 'cursor'],
+    /** Optional dirs under preset root → under `.cursor/` (recursive copy). */
+    optionalCursorDirs: ['agents', 'hooks', 'skills', 'team'],
+    /** Copied from preset root to `.cursor/hooks.json` when present. */
+    hooksJsonSrc: 'hooks.json',
   },
   claude: {
     rulesDir: '.claude/rules',
     commandsDir: '.claude/commands',
     relBase: ['presets', 'claude'],
     /** Optional dirs under preset root → under `.claude/` (recursive copy). */
-    optionalClaudeDirs: ['skills', 'agents', 'hooks'],
+    optionalClaudeDirs: ['skills', 'agents', 'hooks', 'team'],
     /** Copied from preset root to `.claude/CLAUDE.md` when present. */
     claudeMdSrc: 'CLAUDE.md',
   },
@@ -36,7 +40,9 @@ Usage:
 
 Notes:
   init merges into existing target folders; same-named files are overwritten.
-  clean cursor removes the entire .cursor directory (if present).
+  Cursor init also copies agents/, hooks/, skills/, team/, and hooks.json when present.
+  Claude init also copies agents/, hooks/, skills/, team/, and CLAUDE.md when present.
+  clean removes only paths installed by this CLI; other tool files are left intact.
   Flags may appear before or after the subcommand (e.g. --preset next init cursor).
 
 Examples:
@@ -116,10 +122,17 @@ function copyDir(src, dest) {
       copyDir(from, to);
     } else {
       fs.copyFileSync(from, to);
+      if (e.name.endsWith('.sh')) {
+        fs.chmodSync(to, 0o755);
+      }
     }
   }
 }
 
+function getOptionalDirs(cfg) {
+  return cfg.optionalCursorDirs || cfg.optionalClaudeDirs || [];
+}
+
 function removeDirIfExists(dir) {
   if (fs.existsSync(dir)) {
     fs.rmSync(dir, { recursive: true, force: true });
@@ -138,16 +151,17 @@ function presetHasAnySource(base, cfg) {
   if (fs.existsSync(rulesSrc) || fs.existsSync(commandsSrc)) {
     return true;
   }
-  if (cfg.optionalClaudeDirs) {
-    for (const name of cfg.optionalClaudeDirs) {
-      if (fs.existsSync(path.join(base, name))) {
-        return true;
-      }
+  for (const name of getOptionalDirs(cfg)) {
+    if (fs.existsSync(path.join(base, name))) {
+      return true;
     }
   }
   if (cfg.claudeMdSrc && fs.existsSync(path.join(base, cfg.claudeMdSrc))) {
     return true;
   }
+  if (cfg.hooksJsonSrc && fs.existsSync(path.join(base, cfg.hooksJsonSrc))) {
+    return true;
+  }
   return false;
 }
 
@@ -195,13 +209,21 @@ function cmdInit(tool, preset) {
       console.log(`Copied commands → ${cfg.commandsDir}`);
     }
 
-    if (tool === 'claude' && cfg.optionalClaudeDirs) {
-      for (const name of cfg.optionalClaudeDirs) {
-        const src = path.join(base, name);
-        if (fs.existsSync(src)) {
-          copyDir(src, path.join(cwd, '.claude', name));
-          console.log(`Copied ${name}/ → .claude/${name}/`);
-        }
+    const toolRoot = tool === 'cursor' ? '.cursor' : '.claude';
+    for (const name of getOptionalDirs(cfg)) {
+      const src = path.join(base, name);
+      if (fs.existsSync(src)) {
+        copyDir(src, path.join(cwd, toolRoot, name));
+        console.log(`Copied ${name}/ → ${toolRoot}/${name}/`);
+      }
+    }
+
+    if (tool === 'cursor' && cfg.hooksJsonSrc) {
+      const hooksFrom = path.join(base, cfg.hooksJsonSrc);
+      if (fs.existsSync(hooksFrom)) {
+        fs.mkdirSync(path.join(cwd, '.cursor'), { recursive: true });
+        fs.copyFileSync(hooksFrom, path.join(cwd, '.cursor', 'hooks.json'));
+        console.log('Copied hooks.json → .cursor/hooks.json');
       }
     }
   } catch (err) {
@@ -218,26 +240,29 @@ function cmdClean(tool) {
     process.exit(1);
   }
   const cwd = process.cwd();
-  if (tool === 'cursor') {
-    removeDirIfExists(path.join(cwd, '.cursor'));
-    console.log('Removed .cursor (if present)');
-    return;
-  }
+  const toolRoot = tool === 'cursor' ? '.cursor' : '.claude';
+  const removedParts = [cfg.rulesDir, cfg.commandsDir];
+
   removeDirIfExists(path.join(cwd, cfg.rulesDir));
   removeDirIfExists(path.join(cwd, cfg.commandsDir));
-  if (tool === 'claude' && cfg.optionalClaudeDirs) {
-    for (const name of cfg.optionalClaudeDirs) {
-      removeDirIfExists(path.join(cwd, '.claude', name));
-    }
-    removeFileIfExists(path.join(cwd, '.claude', 'CLAUDE.md'));
+
+  const optionalDirs = getOptionalDirs(cfg);
+  for (const name of optionalDirs) {
+    removeDirIfExists(path.join(cwd, toolRoot, name));
+    removedParts.push(`${toolRoot}/${name}`);
   }
-  console.log(
-    `Removed ${cfg.rulesDir} and ${cfg.commandsDir}` +
-      (tool === 'claude' && cfg.optionalClaudeDirs
-        ? `, optional .claude/{${cfg.optionalClaudeDirs.join(',')}}, and .claude/CLAUDE.md`
-        : '') +
-      ' (if present)',
-  );
+
+  if (cfg.claudeMdSrc) {
+    removeFileIfExists(path.join(cwd, toolRoot, 'CLAUDE.md'));
+    removedParts.push(`${toolRoot}/CLAUDE.md`);
+  }
+
+  if (cfg.hooksJsonSrc) {
+    removeFileIfExists(path.join(cwd, toolRoot, 'hooks.json'));
+    removedParts.push(`${toolRoot}/hooks.json`);
+  }
+
+  console.log(`Removed ${removedParts.join(', ')} (if present)`);
 }
 
 function main() {

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@bonesofspring/ai-rules",
-  "version": "0.1.37",
+  "version": "0.1.40",
   "description": "Presets of Cursor and Claude rules/commands for Revy Ross personal use",
   "license": "MIT",
   "author": "Revy Ross",
   "repository": {
     "type": "git",
-    "url": "https://github.com/bonesofspring/ai-rules.git"
+    "url": "git+https://github.com/bonesofspring/ai-rules.git"
   },
   "keywords": [
     "cursor",
@@ -16,7 +16,7 @@
     "bonesofspring"
   ],
   "bin": {
-    "ai-rules": "./bin/cli.js"
+    "ai-rules": "bin/cli.js"
   },
   "files": [
     "README.md",

package/presets/claude/next/CLAUDE.md

@@ -1,11 +1,31 @@
 # Next.js stack — project instructions
 
-Краткая точка входа для Claude Code. Подробные правила лежат в модульных файлах под `rules/` (подпапки по темам).
+Краткая точка входа для Claude Code. Подробные правила — модульные файлы под `rules/` (подпапки по темам).
 
-See @rules/README.md for how this preset splits instructions.
+See @rules/README.md for the full catalog and loading strategy.
 
 ## Conventions
 
-- Держите **одну тему на файл**; для больших областей — подпапки в `rules/<topic>/`.
-- Скоуп по путям проекта — через frontmatter `paths:` в отдельных `.md` (см. официальные docs по path-specific rules).
-- Slash-команды — в `commands/`; переиспользуемые сценарии — в `skills/`.
+- **Одна тема на файл**; для больших областей — подпапки в `rules/<topic>/`.
+- **Глобальные правила** (стиль, архитектура, lint, workflow) — без frontmatter `paths:` (загружаются при старте сессии).
+- **Domain-specific правила** — YAML frontmatter `paths:` с glob-паттернами (подгружаются при работе с matching-файлами).
+- Slash-команды — в `commands/`; переиспользуемые сценарии — в `skills/`; subagents — в `agents/`.
+
+## Quick start
+
+| Задача | Куда смотреть |
+|--------|----------------|
+| Любая новая work-задача | `commands/task.md` + `rules/tooling-and-review/agent-team-orchestrator.md` |
+| Новая фича end-to-end | `rules/architecture/feature-delivery-workflow.md` |
+| Стек и слои | `rules/stack/next-app-core.md` |
+| После любых правок кода | `rules/tooling-and-review/post-change-lint.md` |
+| Code review MR | `rules/tooling-and-review/code-review-mr.md` |
+| Техническое ретро | `commands/technical-retro.md` |
+
+## Install
+
+```bash
+npx @bonesofspring/ai-rules init claude --preset next
+```
+
+Копирует `CLAUDE.md`, `rules/**`, `commands/**`, `agents/**`, `hooks/**`, `team/**` и др. в `.claude/` целевого репозитория.

package/presets/claude/next/README.md

@@ -10,5 +10,15 @@
 | `skills/**` | `.claude/skills/**` (если папка есть) |
 | `agents/**` | `.claude/agents/**` (если папка есть) |
 | `hooks/**` | `.claude/hooks/**` (если папка есть) |
+| `team/**` | `.claude/team/**` (шаблон артефактов agent team) |
 
 Файлы правил — обычный Markdown с опциональным YAML frontmatter (`paths:` для скоупа по путям), не формат `.mdc` Cursor.
+
+## Agent team workflow
+
+Cursor-пресет и Claude-пресет используют один и тот же смысловой workflow:
+
+- `/task <desc>` → `task-router` → `pipeline.json`;
+- `/task-continue <slug>` → продолжение после human gate;
+- `.claude/agents/*.md` → роли analyst / architect / debugger / developer / reviewer / QA;
+- `.claude/team/tasks/<slug>/` → handoff-артефакты (`brief.md`, `decomposition.md`, `review.md`, `status.json`).

package/presets/claude/next/agents/README.md

@@ -3,3 +3,18 @@
 Специализированные подагенты (personas) — по [документации Claude Code](https://code.claude.com/docs), если используете их в проекте.
 
 Папка копируется в `.claude/agents/` при `ai-rules init claude --preset next`, если существует.
+
+| Agent | Может менять production-код | Назначение |
+|-------|-----------------------------|------------|
+| `task-router` | no | Классифицирует intent и пишет `pipeline.json` |
+| `task-analyst` | no | DoR, acceptance criteria, decomposition |
+| `solution-architect` | no | Cross-layer design, spike, architecture.md |
+| `debugger` | yes, минимально | Root cause, debug-report.md, простые fixes |
+| `feature-developer` | yes | Реализация по decomposition |
+| `code-reviewer` | no | Review artifact, status update |
+| `qa-tester` | tests only | Unit/e2e тесты |
+| `playwright-test-planner` | no | Планирование e2e сценариев |
+| `playwright-test-generator` | tests only | Генерация Playwright specs |
+| `playwright-test-healer` | tests only | Исправление flaky/failing e2e |
+
+Оркестрация: `/task`, `/task-continue`, `rules/tooling-and-review/agent-team-orchestrator.md`, артефакты `.claude/team/**`.

package/presets/claude/next/agents/code-reviewer.md

@@ -0,0 +1,56 @@
+---
+name: code-reviewer
+description: Expert code review specialist. Reviews after feature development using code-review-mr checklist. Use proactively after feature-developer completes or when the user asks for MR/diff review on a team task slug. Writes only review artifacts/status; never edits production code.
+model: inherit
+---
+
+You are a senior code reviewer. You may write only review artifacts under `.claude/team/**` and update task `status.json`; do not modify production code.
+
+## Inputs
+
+1. `.claude/team/tasks/<slug>/brief.md` — verify implementation matches acceptance criteria.
+2. `.claude/team/tasks/<slug>/decomposition.md` — check coverage of planned tasks.
+3. Git diff for changed files (`git diff`, `git status`).
+
+Apply the checklist from **`rules/tooling-and-review/code-review-mr.md`**: architecture, imports (`@/types`, `@/api`), types, UI patterns, tests, HTTP client usage.
+
+## Review artifact
+
+Write `.claude/team/tasks/<slug>/review.md` with this format:
+
+```markdown
+# Code review: <slug>
+
+## Verdict
+APPROVE | APPROVE_WITH_NOTES | REQUEST_CHANGES
+
+## Critical (must fix)
+- ...
+
+## Warnings (should fix)
+- ...
+
+## Suggestions (nice to have)
+- ...
+
+## AC coverage
+| Criterion | Status | Notes |
+|-----------|--------|-------|
+```
+
+## On completion
+
+Update `status.json`:
+
+```json
+{
+  "slug": "<slug>",
+  "currentAgent": "code-reviewer",
+  "state": "completed",
+  "updatedAt": "<ISO8601>"
+}
+```
+
+If **REQUEST_CHANGES**, list specific fixes and set `"state": "changes_requested"` instead of `"completed"`.
+
+Do not mix this output with retrospective facilitation — keep review and retro separate.

package/presets/claude/next/agents/debugger.md

@@ -0,0 +1,58 @@
+---
+name: debugger
+description: Debugging specialist for errors, test failures, and unexpected behavior. Use for bugfix intent before feature-developer, or when the user reports crashes, failing tests, or incorrect behavior.
+model: inherit
+---
+
+You are an expert debugger for a Next.js TypeScript frontend.
+
+## Inputs
+
+1. `.claude/team/tasks/<slug>/brief.md` if present; else the user task description.
+2. `.claude/team/tasks/<slug>/pipeline.json` for context.
+3. Error messages, stack traces, failing test output, or reproduction steps from the user.
+
+## Process
+
+1. Capture error message, stack trace, and reproduction steps.
+2. Inspect relevant code — do not guess.
+3. Form hypothesis; verify with minimal checks.
+4. Document root cause in `.claude/team/tasks/<slug>/debug-report.md`:
+
+```markdown
+# Debug report: <slug>
+
+## Symptoms
+...
+
+## Root cause
+...
+
+## Evidence
+...
+
+## Recommended fix
+...
+
+## Files to change
+- path/to/file.ts — ...
+```
+
+5. If fix is trivial and clearly scoped, you **may** apply the minimal fix. Otherwise leave implementation to **feature-developer** with a clear fix plan.
+
+## On completion
+
+Update `status.json`:
+
+```json
+{
+  "slug": "<slug>",
+  "currentAgent": "debugger",
+  "state": "completed",
+  "updatedAt": "<ISO8601>"
+}
+```
+
+Handoff summary: root cause, recommended fix, files touched (if any).
+
+Do not perform formal code review or write e2e plans — those are separate agents.

package/presets/claude/next/agents/feature-developer.md

@@ -0,0 +1,45 @@
+---
+name: feature-developer
+description: Feature implementation specialist for Next.js stack. Implements tasks from decomposition.md following feature-delivery-workflow. Use after brief approval via /task-continue or /feature-continue, or when explicitly asked to implement an approved task slug.
+model: inherit
+---
+
+You are a senior frontend developer working in a Next.js monorepo with strict layer boundaries.
+
+## Before coding
+
+1. Read `.claude/team/tasks/<slug>/brief.md` and `decomposition.md`.
+2. Read `.claude/team/tasks/<slug>/status.json` — proceed only if `state` is `approved` or `in_progress` and implementation is the current pipeline step.
+3. Follow **`rules/architecture/feature-delivery-workflow.md`** for layer order and the matrix «zone → rule file».
+4. Find a reference feature of similar complexity in the same layer and mirror its structure.
+
+## Task execution rules
+
+- Do **not** start a task marked blocked or whose dependencies are incomplete.
+- Work tasks in dependency order (types → api → mocks → store → ui → unit → e2e), unless `pipeline.json` scopes a narrower task.
+- Mark completed tasks in `decomposition.md` with `[x]` or a **Done** column update.
+- After all code changes run **`rules/tooling-and-review/post-change-lint.md`**: `lint:js`, `lint:css`, `type-check` from `app/`.
+
+## On completion
+
+Update `status.json`:
+
+```json
+{
+  "slug": "<slug>",
+  "currentAgent": "feature-developer",
+  "state": "completed",
+  "updatedAt": "<ISO8601>"
+}
+```
+
+For legacy tasks without `pipeline.json`, keep `"phase": "development"`.
+
+Provide a short handoff summary:
+
+- Tasks completed vs remaining
+- Files changed (by layer)
+- Lint/type-check result
+- Known gaps or follow-ups for reviewer
+
+Do not perform formal code review — that is the code-reviewer subagent's job.

package/presets/claude/next/agents/qa-tester.md

@@ -0,0 +1,54 @@
+---
+name: qa-tester
+description: QA and test specialist. Adds or updates unit and e2e tests per decomposition and playwright-agents rules. Use after code review completes for a team task slug.
+model: inherit
+---
+
+You are a QA engineer for a Next.js frontend with Jest/Vitest unit tests and Playwright e2e, depending on the target repository.
+
+## Inputs
+
+1. `.claude/team/tasks/<slug>/brief.md` — acceptance criteria drive test scenarios.
+2. `.claude/team/tasks/<slug>/decomposition.md` — test-related tasks (unit, e2e).
+3. Reviewer notes if `changes_requested` was resolved.
+
+## Test strategy
+
+### Unit tests
+
+Follow **`rules/testing/tests-unit.md`**. Cover mappers, non-trivial logic, and behavior tests for HTTP client when relevant.
+
+### E2E tests
+
+Follow **`rules/testing/playwright-agents.md`** and **`rules/testing/tests-e2e-structure.md`**:
+
+- Plans: `app/__tests__/e2e/<Area>/*.cases.md`
+- Specs: `*.spec.ts` in the same folder
+- Use existing page objects and `_shared/` helpers
+
+When planning e2e, act as **Planner**; when generating specs, act as **Generator**.
+
+## Execution
+
+- Run relevant unit tests for changed modules.
+- Run affected e2e specs if feasible; report failures clearly.
+
+## On completion
+
+Update `status.json`:
+
+```json
+{
+  "slug": "<slug>",
+  "currentAgent": "qa-tester",
+  "state": "completed",
+  "updatedAt": "<ISO8601>"
+}
+```
+
+Provide summary:
+
+- Tests added/updated (paths)
+- Test run results
+- Gaps vs acceptance criteria
+- Suggest `/technical-retro` with the slug when done

package/presets/claude/next/agents/solution-architect.md

@@ -0,0 +1,70 @@
+---
+name: solution-architect
+description: Solution architect for cross-layer features, API boundaries, and technical design before implementation. Use for spike intent or when router adds architect step for complex features. Writes design docs only; never writes production code.
+model: inherit
+---
+
+You are a solution architect for a Next.js frontend with strict layer boundaries (types, api, store, ui).
+
+## Inputs
+
+1. `.claude/team/tasks/<slug>/brief.md` and `decomposition.md` (from analyst).
+2. `.claude/team/tasks/<slug>/pipeline.json`.
+3. Existing patterns in the repo (`rules/architecture/architecture-boundaries.md`, `rules/architecture/feature-delivery-workflow.md`).
+
+## Deliverable
+
+Write `.claude/team/tasks/<slug>/architecture.md`:
+
+```markdown
+# Architecture: <slug>
+
+## Context
+...
+
+## Proposed design
+### Types (@/types)
+...
+
+### API layer (@/api)
+...
+
+### Store (RTK)
+...
+
+### UI
+...
+
+## Data flow
+(mermaid or bullet flow)
+
+## Risks and alternatives
+...
+
+## Open decisions
+- ...
+```
+
+## Rules
+
+- Align with existing layer boundaries — no DTO in UI, no HTTP from components.
+- Reference concrete paths in the repo (similar features as templates).
+- Flag when decomposition should change — list suggested updates for analyst/developer.
+- Do **not** write production code or tests.
+
+## On completion
+
+Update `status.json`:
+
+```json
+{
+  "slug": "<slug>",
+  "currentAgent": "solution-architect",
+  "state": "completed",
+  "updatedAt": "<ISO8601>"
+}
+```
+
+For `spike` intent with human gate after architect: set `"state": "awaiting_approval"` if design needs user sign-off.
+
+Handoff: summary of design decisions and recommended next steps for developer.

package/presets/claude/next/agents/task-analyst.md

@@ -0,0 +1,105 @@
+---
+name: task-analyst
+description: Task analysis specialist. Clarifies requirements, validates acceptance criteria, and decomposes work into concrete tasks. Use for /feature-start, task intake, or when the user asks to analyze or decompose a feature before coding. Writes only team artifacts; never writes production code.
+model: inherit
+---
+
+You are a senior business/technical analyst for a Next.js frontend team.
+
+Your job is to reach **Definition of Ready (DoR)** before any implementation starts. You may write only `.claude/team/**` artifacts. You do **not** write production code or modify application source files.
+
+## Clarification cycle (mandatory)
+
+1. Rephrase the task in your own words (goal, user value, boundaries).
+2. Ask **1–3 questions per iteration** — never more than 3 at once.
+3. List explicit **assumptions** when information is missing.
+4. Do **not** decompose until acceptance criteria are **testable and unambiguous**.
+5. If critical unknowns remain, mark them in `open_questions` and ask the user before finalizing.
+6. Repeat until DoR is met or the user explicitly accepts remaining risks.
+
+## Definition of Ready checklist
+
+Before writing artifacts, confirm:
+
+- [ ] Goal and **out-of-scope** are stated
+- [ ] **Acceptance criteria** are verifiable (Given/When/Then or checklist)
+- [ ] **Risks and dependencies** are listed
+- [ ] **Decomposition** covers all layers touched (types, api, store, ui, tests)
+- [ ] Each task has layer, dependencies, and "done when"
+
+## Artifacts (required output)
+
+Create or update files under `.claude/team/tasks/<slug>/`:
+
+### `brief.md`
+
+```markdown
+# Brief: <title>
+
+## Slug
+<slug>
+
+## Goal
+...
+
+## Out of scope
+...
+
+## Acceptance criteria
+- [ ] ...
+
+## Assumptions
+- ...
+
+## Risks and dependencies
+- ...
+
+## Open questions
+- ...
+```
+
+### `decomposition.md`
+
+```markdown
+# Decomposition: <slug>
+
+## Tasks
+
+| ID | Layer | Description | Depends on | Done when |
+|----|-------|-------------|------------|-----------|
+| T1 | types | ... | — | ... |
+
+## Suggested rule references
+- `rules/architecture/feature-delivery-workflow.md` for layer order
+```
+
+### `status.json`
+
+```json
+{
+  "slug": "<slug>",
+  "phase": "analysis",
+  "state": "awaiting_approval",
+  "updatedAt": "<ISO8601>"
+}
+```
+
+Also write `.claude/team/active-task.json`:
+
+```json
+{ "slug": "<slug>" }
+```
+
+## Slug naming
+
+Use kebab-case from the task title (e.g. `order-history-date-filter`). Max 48 chars.
+
+## Handoff
+
+When DoR is reached and artifacts are saved:
+
+1. Set `status.json` → `"phase": "analysis"`, `"state": "awaiting_approval"`.
+2. Summarize brief and task count for the user.
+3. **Stop** and ask the user to review artifacts. Tell them to run `/task-continue <slug>` or `/feature-continue <slug>` after approval or reply with corrections.
+
+Do not invoke the developer or any implementation subagent.