@bonesofspring/ai-rules 0.1.41 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+## 0.2.0
+
+### Breaking
+
+- **Import rules merged:** `types-public-imports.mdc` and `api-public-imports.mdc` → **`public-imports.mdc`** (Claude: `architecture/public-imports.md`). Old filenames remain as deprecated stubs for one release cycle.
+- **`feature-delivery-flow.mdc` removed** — content merged into `feature-delivery-workflow.mdc`.
+- **`agent-team-intake`** no longer always-on (Cursor: `alwaysApply: false`; Claude: `paths:` on commands/team). Use orchestrator or `/task`.
+
+### Changed
+
+- Slimmed always-on rules: `next-app-core`, `code-quality-and-refactoring`, `post-change-lint`, `package-manager` (~9 KB baseline vs ~21 KB).
+- Narrowed globs: `css-property-order-stylelint`, `no-type-assertion-as-import-export`, `reference-features`, `public-imports`.
+- `css-property-order` stub — property list delegated to Stylelint `--fix`.
+- Slimmed `task-router` agent; pipeline JSON examples moved to `agents/README.md`.
+- Agents reference skills as SSOT; scoped lint for `feature-developer` when next step is `build-verifier`.
+- Orchestrator: explicit fast-path when to skip pipeline.
+
+## 0.1.42
+
+Prior releases — see git history.

package/README.md

@@ -13,7 +13,16 @@ npx @bonesofspring/ai-rules clean cursor
 
 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`.
+`init` merges into the **current working directory** (or `--cwd <dir>`): dirs are created, matching files are **overwritten**. `--preset` defaults to **`next`**. Supported forms:
+
+```bash
+npx @bonesofspring/ai-rules init cursor --preset next
+npx @bonesofspring/ai-rules init cursor next
+npx @bonesofspring/ai-rules init cursor          # preset next by default
+npx @bonesofspring/ai-rules cursor init --preset next
+```
+
+If `.cursor` does not appear, check the command output for errors and confirm you run init from the **target project root** (where the app lives), not from `node_modules`. Success ends with: `Done. .cursor installed at <absolute-path>`.
 
 `clean cursor` / `clean claude` removes what this CLI installs: `rules`, `commands`, optional `agents`, `hooks`, `skills`, `team`, Cursor `hooks.json` / `BUGBOT.md`, and Claude `CLAUDE.md` when present. Other files under `.cursor/` or `.claude/` are left intact.
 

package/bin/cli.js

@@ -5,58 +5,86 @@
 const fs = require('fs');
 const path = require('path');
 
-const packageRoot = path.join(__dirname, '..');
-
 /** Single path segment: letters, digits, dot, underscore, hyphen; no separators or "..". */
 const PRESET_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+const DEFAULT_PRESET = 'next';
+const TOOLS = new Set(['cursor', 'claude']);
 
 const PRESETS = {
   cursor: {
     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',
-    /** Optional files under preset root → under `.cursor/`. */
     toolRootFiles: ['BUGBOT.md', 'AGENTS.md'],
   },
   claude: {
     rulesDir: '.claude/rules',
     commandsDir: '.claude/commands',
     relBase: ['presets', 'claude'],
-    /** Optional dirs under preset root → under `.claude/` (recursive copy). */
     optionalClaudeDirs: ['skills', 'agents', 'hooks', 'team'],
-    /** Copied from preset root to `.claude/CLAUDE.md` when present. */
     claudeMdSrc: 'CLAUDE.md',
   },
 };
 
+function getPackageRoot() {
+  try {
+    return path.dirname(require.resolve('@bonesofspring/ai-rules/package.json'));
+  } catch {
+    return path.join(__dirname, '..');
+  }
+}
+
 function printHelp() {
   console.log(`@bonesofspring/ai-rules
 
 Usage:
-  ai-rules init <cursor|claude> --preset <name>   Copy preset rules and commands into the current directory
-  ai-rules clean <cursor|claude>                 Remove preset target rules and commands directories
+  ai-rules init <cursor|claude> [--preset <name>]
+  ai-rules init <cursor|claude> <preset-name>
+  ai-rules clean <cursor|claude> [--cwd <dir>]
+
+Options:
+  --preset <name>   Preset name (default: ${DEFAULT_PRESET})
+  --cwd <dir>       Target project directory (default: current working directory)
 
 Notes:
-  init merges into existing target folders; same-named files are overwritten.
-  Cursor init also copies agents/, hooks/, skills/, team/, hooks.json, BUGBOT.md, and AGENTS.md 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).
+  init merges into the target directory; same-named files are overwritten.
+  Cursor init copies rules, commands, agents, hooks, skills, team, hooks.json, BUGBOT.md, AGENTS.md.
+  Claude init copies rules, commands, skills, agents, hooks, team, and CLAUDE.md when present.
+  Command forms: "init cursor --preset next", "init cursor next", "--preset next init cursor", "cursor init --preset next".
 
 Examples:
   npx @bonesofspring/ai-rules init cursor --preset next
-  npx @bonesofspring/ai-rules clean claude
+  npx @bonesofspring/ai-rules init cursor next
+  npx @bonesofspring/ai-rules init claude
+  npx @bonesofspring/ai-rules clean cursor
 `);
 }
 
 function parseArgs(argv) {
-  const args = { _: [] };
+  const args = { _: [], cwd: undefined, preset: undefined, presetError: undefined };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
+    if (a === '--cwd') {
+      const value = argv[i + 1];
+      if (value === undefined || value.startsWith('-')) {
+        args.cwdError = 'Missing value for --cwd';
+        continue;
+      }
+      args.cwd = value;
+      i++;
+      continue;
+    }
+    if (a.startsWith('--cwd=')) {
+      const value = a.slice('--cwd='.length);
+      if (value === '') {
+        args.cwdError = 'Missing value after --cwd=';
+        continue;
+      }
+      args.cwd = value;
+      continue;
+    }
     if (a === '--preset') {
       const value = argv[i + 1];
       if (value === undefined || value.startsWith('-')) {
@@ -77,17 +105,53 @@ function parseArgs(argv) {
       args.preset = value;
       continue;
     }
+    if (a === '-h' || a === '--help') {
+      args.help = true;
+      continue;
+    }
     args._.push(a);
   }
   return args;
 }
 
+/**
+ * Supports: init cursor, cursor init, init cursor next (positional preset).
+ */
+function normalizeInitClean(parsed) {
+  const positional = [...parsed._];
+  let command;
+  let tool;
+  let presetFromPositional;
+
+  if (positional.length >= 2 && TOOLS.has(positional[0]) && positional[1] === 'init') {
+    command = 'init';
+    tool = positional[0];
+    presetFromPositional = positional[2];
+  } else if (positional.length >= 2 && positional[0] === 'init' && TOOLS.has(positional[1])) {
+    command = 'init';
+    tool = positional[1];
+    presetFromPositional = positional[2];
+  } else if (positional.length >= 2 && positional[0] === 'clean' && TOOLS.has(positional[1])) {
+    command = 'clean';
+    tool = positional[1];
+  } else if (positional.length >= 1) {
+    command = positional[0];
+    tool = positional[1];
+    if (command === 'init' && positional[2] && PRESET_NAME_RE.test(positional[2])) {
+      presetFromPositional = positional[2];
+    }
+  }
+
+  const preset = parsed.preset || presetFromPositional;
+  return { command, tool, preset };
+}
+
 /**
  * @returns {string | null} Error message or null if valid.
  */
 function validatePresetName(preset) {
   if (preset === undefined || preset === '') {
-    return 'Missing --preset <name>';
+    return 'Missing preset name (use --preset <name>, e.g. --preset next)';
   }
   if (!PRESET_NAME_RE.test(preset) || preset.includes('..')) {
     return (
@@ -98,9 +162,6 @@ function validatePresetName(preset) {
   return null;
 }
 
-/**
- * Ensures resolved preset dir stays under the tool presets root (defense in depth).
- */
 function assertPresetDirInsideRoot(presetsRoot, presetBase) {
   const root = path.resolve(presetsRoot);
   const resolved = path.resolve(presetBase);
@@ -147,6 +208,17 @@ function removeFileIfExists(filePath) {
   }
 }
 
+function listPresetNames(presetsRoot) {
+  if (!fs.existsSync(presetsRoot)) {
+    return [];
+  }
+  return fs
+    .readdirSync(presetsRoot, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => e.name)
+    .filter((name) => PRESET_NAME_RE.test(name));
+}
+
 function presetHasAnySource(base, cfg) {
   const rulesSrc = path.join(base, 'rules');
   const commandsSrc = path.join(base, 'commands');
@@ -172,74 +244,121 @@ function presetHasAnySource(base, cfg) {
   return false;
 }
 
-function cmdInit(tool, preset) {
-  const cfg = PRESETS[tool];
-  if (!cfg) {
-    console.error(`Unknown tool: ${tool}. Use cursor or claude.`);
+function resolveTargetCwd(cwdOption) {
+  const cwd = cwdOption ? path.resolve(cwdOption) : process.cwd();
+  if (!fs.existsSync(cwd)) {
+    console.error(`Target directory does not exist: ${cwd}`);
     process.exit(1);
   }
-  const nameErr = validatePresetName(preset);
+  if (!fs.statSync(cwd).isDirectory()) {
+    console.error(`Target path is not a directory: ${cwd}`);
+    process.exit(1);
+  }
+  return cwd;
+}
+
+function resolvePresetName(tool, preset, packageRoot) {
+  const cfg = PRESETS[tool];
+  const presetsRoot = path.join(packageRoot, ...cfg.relBase);
+  let name = preset || DEFAULT_PRESET;
+
+  const nameErr = validatePresetName(name);
   if (nameErr) {
     console.error(nameErr);
     process.exit(1);
   }
-  const presetsRoot = path.join(packageRoot, ...cfg.relBase);
-  const base = path.join(presetsRoot, preset);
+
+  let base = path.join(presetsRoot, name);
+  if (!presetHasAnySource(base, cfg)) {
+    const available = listPresetNames(presetsRoot);
+    if (!preset && available.includes(DEFAULT_PRESET)) {
+      name = DEFAULT_PRESET;
+      base = path.join(presetsRoot, name);
+    } else {
+      console.error(`Preset "${name}" for ${tool} not found.`);
+      console.error(`Looked in: ${base}`);
+      console.error(`Package root: ${packageRoot}`);
+      if (available.length > 0) {
+        console.error(`Available presets: ${available.join(', ')}`);
+      } else {
+        console.error(`No presets directory at: ${presetsRoot}`);
+        console.error(
+          'The installed package may be incomplete. Reinstall @bonesofspring/ai-rules or run from the package source.',
+        );
+      }
+      process.exit(1);
+    }
+  }
+
   assertPresetDirInsideRoot(presetsRoot, base);
+  return { name, base, presetsRoot };
+}
+
+function cmdInit(tool, preset, cwdOption) {
+  const cfg = PRESETS[tool];
+  if (!cfg) {
+    console.error(`Unknown tool: ${tool}. Use cursor or claude.`);
+    process.exit(1);
+  }
+
+  const packageRoot = getPackageRoot();
+  const cwd = resolveTargetCwd(cwdOption);
+  const { name: presetName, base } = resolvePresetName(tool, preset, packageRoot);
 
   const rulesSrc = path.join(base, 'rules');
   const commandsSrc = path.join(base, 'commands');
-  const cwd = process.cwd();
+  const toolRoot = tool === 'cursor' ? '.cursor' : '.claude';
+  const toolRootAbs = path.join(cwd, toolRoot);
 
-  if (!presetHasAnySource(base, cfg)) {
-    console.error(`Preset "${preset}" for ${tool} not found under ${base}`);
-    process.exit(1);
-  }
+  fs.mkdirSync(toolRootAbs, { recursive: true });
+
+  let copiedSteps = 0;
 
   try {
     if (tool === 'claude' && cfg.claudeMdSrc) {
       const mdFrom = path.join(base, cfg.claudeMdSrc);
       if (fs.existsSync(mdFrom)) {
-        const claudeRoot = path.join(cwd, '.claude');
-        fs.mkdirSync(claudeRoot, { recursive: true });
-        fs.copyFileSync(mdFrom, path.join(claudeRoot, 'CLAUDE.md'));
-        console.log('Copied CLAUDE.md → .claude/CLAUDE.md');
+        fs.copyFileSync(mdFrom, path.join(toolRootAbs, 'CLAUDE.md'));
+        console.log(`Copied CLAUDE.md → ${path.join(toolRoot, 'CLAUDE.md')}`);
+        copiedSteps++;
       }
     }
 
     if (fs.existsSync(rulesSrc)) {
       copyDir(rulesSrc, path.join(cwd, cfg.rulesDir));
       console.log(`Copied rules → ${cfg.rulesDir}`);
+      copiedSteps++;
     }
     if (fs.existsSync(commandsSrc)) {
       copyDir(commandsSrc, path.join(cwd, cfg.commandsDir));
       console.log(`Copied commands → ${cfg.commandsDir}`);
+      copiedSteps++;
     }
 
-    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));
+        copyDir(src, path.join(toolRootAbs, name));
         console.log(`Copied ${name}/ → ${toolRoot}/${name}/`);
+        copiedSteps++;
       }
     }
 
     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');
+        fs.copyFileSync(hooksFrom, path.join(toolRootAbs, 'hooks.json'));
+        console.log(`Copied hooks.json → ${toolRoot}/hooks.json`);
+        copiedSteps++;
       }
     }
 
     for (const name of cfg.toolRootFiles || []) {
       const from = path.join(base, name);
       if (fs.existsSync(from)) {
-        fs.mkdirSync(path.join(cwd, toolRoot), { recursive: true });
-        fs.copyFileSync(from, path.join(cwd, toolRoot, name));
+        fs.copyFileSync(from, path.join(toolRootAbs, name));
         console.log(`Copied ${name} → ${toolRoot}/${name}`);
+        copiedSteps++;
       }
     }
   } catch (err) {
@@ -247,15 +366,27 @@ function cmdInit(tool, preset) {
     console.error(`init failed: ${msg}`);
     process.exit(1);
   }
+
+  if (copiedSteps === 0) {
+    console.error(`init failed: preset "${presetName}" had no files to copy from ${base}`);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(toolRootAbs)) {
+    console.error(`init failed: ${toolRootAbs} was not created`);
+    process.exit(1);
+  }
+
+  console.log(`Done. ${toolRoot} installed at ${toolRootAbs} (preset: ${presetName})`);
 }
 
-function cmdClean(tool) {
+function cmdClean(tool, cwdOption) {
   const cfg = PRESETS[tool];
   if (!cfg) {
     console.error(`Unknown tool: ${tool}. Use cursor or claude.`);
     process.exit(1);
   }
-  const cwd = process.cwd();
+  const cwd = resolveTargetCwd(cwdOption);
   const toolRoot = tool === 'cursor' ? '.cursor' : '.claude';
   const removedParts = [cfg.rulesDir, cfg.commandsDir];
 
@@ -288,33 +419,42 @@ function cmdClean(tool) {
 
 function main() {
   const argv = process.argv.slice(2);
-  if (argv.length === 0 || argv.includes('-h') || argv.includes('--help')) {
+  if (argv.length === 0) {
     printHelp();
     process.exit(0);
   }
 
   const parsed = parseArgs(argv);
-  const [command, tool] = parsed._;
+  if (parsed.help) {
+    printHelp();
+    process.exit(0);
+  }
 
   if (parsed.presetError) {
     console.error(parsed.presetError);
     process.exit(1);
   }
+  if (parsed.cwdError) {
+    console.error(parsed.cwdError);
+    process.exit(1);
+  }
+
+  const { command, tool, preset } = normalizeInitClean(parsed);
 
   if (command === 'init') {
-    if (!tool) {
-      console.error('Missing <cursor|claude> after init.');
+    if (!tool || !TOOLS.has(tool)) {
+      console.error('Missing or invalid tool. Use: init cursor|claude [--preset next]');
       process.exit(1);
     }
-    cmdInit(tool, parsed.preset);
+    cmdInit(tool, preset, parsed.cwd);
     return;
   }
   if (command === 'clean') {
-    if (!tool) {
-      console.error('Missing <cursor|claude> after clean.');
+    if (!tool || !TOOLS.has(tool)) {
+      console.error('Missing or invalid tool. Use: clean cursor|claude');
       process.exit(1);
     }
-    cmdClean(tool);
+    cmdClean(tool, parsed.cwd);
     return;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonesofspring/ai-rules",
-  "version": "0.1.41",
+  "version": "0.2.0",
   "description": "Presets of Cursor and Claude rules/commands for Revy Ross personal use",
   "license": "MIT",
   "author": "Revy Ross",

package/presets/claude/next/CLAUDE.md

@@ -7,7 +7,7 @@ See @rules/README.md for the full catalog and loading strategy.
 ## Conventions
 
 - **Одна тема на файл**; для больших областей — подпапки в `rules/<topic>/`.
-- **Session-start rules** — только базовые инварианты (`next-app-core`, lint, package manager, intake, code-quality).
+- **Session-start rules** — только базовые инварианты (`next-app-core`, lint, package manager, code-quality).
 - **Domain-specific rules** — YAML frontmatter `paths:` (подгружаются при работе с matching-файлами).
 - Slash-команды — в `commands/`; сценарии — в `skills/`; subagents — в `agents/`.
 

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

@@ -67,3 +67,64 @@
 | `docs-only` | analyst → tech-writer |
 
 Опциональные шаги (router добавляет по контексту): `api-contract-reviewer`, `accessibility-reviewer`, `security-reviewer`, `performance-auditor`, `tech-writer`.
+
+## pipeline.json reference
+
+### Step fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `agent` | yes | Subagent name (kebab-case) or array for `parallel: true` |
+| `label` | yes | Short human-readable step name |
+| `scope` | no | e.g. `unit-in-dev`, `e2e-only`, `regression`, `full` |
+| `skipIf` | no | `debugger.fixed` \| `ci-investigator.resolved` |
+| `parallel` | no | When `true` and `agent` is array — invoke all in one turn |
+
+### Minimal template
+
+```json
+{
+  "slug": "<slug>",
+  "intent": "feature",
+  "summary": "One-line task summary",
+  "steps": [
+    { "agent": "task-analyst", "label": "Clarify and decompose" },
+    { "agent": "feature-developer", "label": "Implement + unit tests", "scope": "unit-in-dev" },
+    { "agent": "build-verifier", "label": "Lint, type-check, unit smoke" },
+    { "agent": "code-reviewer", "label": "Code review" }
+  ],
+  "humanGates": ["after:task-analyst"],
+  "autoChain": true,
+  "skipped": []
+}
+```
+
+### Example: bugfix skipIf
+
+```json
+{
+  "intent": "bugfix",
+  "steps": [
+    { "agent": "debugger", "label": "Root cause" },
+    { "agent": "feature-developer", "label": "Fix if needed", "skipIf": "debugger.fixed" },
+    { "agent": "build-verifier", "label": "Validation" },
+    { "agent": "code-reviewer", "label": "Review" }
+  ],
+  "humanGates": []
+}
+```
+
+### Initial status.json
+
+```json
+{
+  "slug": "<slug>",
+  "intent": "<intent>",
+  "pipelineIndex": 0,
+  "currentAgent": "<steps[0].agent>",
+  "phase": "executing",
+  "state": "in_progress",
+  "awaitingHumanGate": false,
+  "updatedAt": "<ISO8601>"
+}
+```

package/presets/claude/next/agents/api-contract-reviewer.md

@@ -12,7 +12,7 @@ You are an API contract reviewer for a layered Next.js frontend (`@/types`, `@/a
 2. OpenAPI/Swagger spec, ticket API description, or backend contract docs from the user.
 3. Changed files in `app/src/types/**`, `app/src/api/**`, mocks, store thunks.
 
-Apply **`rules/architecture/types-public-imports.md`**, **`rules/architecture/api-public-imports.md`**, **`rules/api-and-data/api-services.md`**, **`rules/api-and-data/http-client.md`**.
+Apply **`rules/architecture/public-imports.md`**, **`rules/api-and-data/api-services.md`**, **`rules/api-and-data/http-client.md`**.
 
 ## Review scope
 

package/presets/claude/next/agents/build-verifier.md

@@ -6,6 +6,8 @@ model: fast
 
 You are a build verification specialist. You **validate** implementation quality before code review — you do not edit production code or tests.
 
+**SSOT for full validation in pipeline:** run complete **`lint:js`**, **`lint:css`**, and **`type-check`** from `app/` even if feature-developer ran scoped checks.
+
 ## Inputs
 
 1. `.claude/team/tasks/<slug>/brief.md` and `decomposition.md`.

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

@@ -8,33 +8,20 @@ You are a senior frontend developer working in a Next.js monorepo with strict la
 
 ## Before coding
 
-1. Read `.claude/team/tasks/<slug>/brief.md` and `decomposition.md`.
-2. Read `architecture.md`, `migration-plan.md`, `api-contract-review.md`, `debug-report.md`, `validation-report.md`, and `review.md` if present.
-3. Read `status.json` — proceed if `state` is `in_progress`, `approved`, or continuing after fix loop (`retryAfterFix`).
-4. Read **`architecture/reference-features.md`** and mirror the closest reference feature structure.
-5. Use the **`feature-delivery` skill** and **`rules/architecture/feature-delivery-workflow.md`**.
+1. Read `.claude/team/tasks/<slug>/brief.md`, `decomposition.md`, and prior artifacts if present.
+2. Read `status.json` — proceed if `in_progress`, `approved`, or `retryAfterFix`.
+3. Read `pipeline.json` for step context and scope.
+4. Follow the **`feature-delivery` skill** (layer order, reference features, validation handoff).
 
 ## Task execution rules
 
 - Work tasks in dependency order (types → api → mocks → store → ui → **unit** → e2e).
-- **Unit tests are mandatory before handoff** for mappers, store logic, and non-trivial pure functions (`rules/testing/tests-unit.md`).
-- Mark completed tasks in `decomposition.md` with `[x]` or update **Done** column.
-- After code changes run **`rules/tooling-and-review/post-change-lint.md`**: `lint:js`, `lint:css`, `type-check` from `app/`.
+- **Unit tests mandatory before handoff** for mappers, store logic, and non-trivial pure functions.
+- Mark completed tasks in `decomposition.md`.
+- Validation: **`rules/tooling-and-review/post-change-lint.md`**. If pipeline next step is **`build-verifier`**, scoped lint/type-check on **changed files** is enough; full project lint is build-verifier's job.
 
 ## On completion
 
-Update `status.json`:
-
-```json
-{
-  "slug": "<slug>",
-  "currentAgent": "feature-developer",
-  "phase": "executing",
-  "state": "completed",
-  "updatedAt": "<ISO8601>"
-}
-```
-
-Handoff summary: tasks done, files by layer, unit specs added, lint/type-check result, known gaps.
+Update `status.json` (`currentAgent`: `feature-developer`, `state`: `completed`). Handoff: tasks done, files by layer, unit specs, validation result, gaps for build-verifier/reviewer.
 
 Do not perform formal code review — that is the code-reviewer subagent's job.