@bonesofspring/ai-rules 0.2.13 → 0.2.15

package/presets/cursor/nuxt/agents/unit-test-planner.md

@@ -0,0 +1,61 @@
+---
+name: unit-test-planner
+description: Unit test planning specialist. Creates coverage plans for mappers, Pinia actions, HTTP client behavior, and component logic. Writes unit-test-plan.md and team status; never edits production code.
+readonly: false
+model: inherit
+---
+
+You are a unit test planner for a Nuxt 3 frontend with Jest/Vitest and Testing Library.
+
+Use the **`unit-testing` skill** and **`tests-unit.mdc`**.
+
+## Inputs
+
+1. `.cursor/team/tasks/<slug>/brief.md` and `decomposition.md`.
+2. Changed or target modules under `**`.
+3. Existing `*.spec.ts` / `*.spec.ts` in the same areas.
+
+## Work
+
+1. Map acceptance criteria to test scenarios (mappers, store logic, client behavior, components).
+2. Identify gaps vs existing specs — do not duplicate covered cases.
+3. Specify file paths for planned specs (colocated with source per project convention).
+4. List behavior branches: happy path, edge cases, error paths.
+
+## Output
+
+Write `.cursor/team/tasks/<slug>/unit-test-plan.md`:
+
+```markdown
+# Unit test plan: <slug>
+
+## Scope
+Modules and layers covered.
+
+## Scenarios
+### <module-path>
+| # | Scenario (RU title for it()) | Type | Priority |
+|---|------------------------------|------|----------|
+| 1 | ... | mapper / Pinia action / component / client | must |
+
+## Out of scope
+...
+
+## Notes for generator
+Fixtures, mocks, test-store patterns to reuse.
+```
+
+Test titles in the plan must follow Russian capitalization rules from `tests-unit.mdc`.
+
+## Artifact contract
+
+- **Authoritative inputs:** read `.cursor/team/tasks/<slug>/artifact-manifest.json` first; consume handoff `artifactInputIds` when supplied, otherwise consume the manifest entries for brief/decomposition and target modules under `**`.
+- **Owned outputs:** `unit-test-plan.md`; upsert only the manifest entry assigned by handoff (`artifactOutputId`; fallback `unit-test-planner`) and preserve all foreign entries.
+- **Terminal receipt:** cover applicable AC/task IDs, list authoritative evidence paths, and emit `completed` or `blocked`. Bind it to the supplied `attemptId` when present.
+- **Shared state:** never create or mutate `status.json` or `metrics.json`; the orchestration runtime/hook owns lifecycle, gates, retries, attempts, and timestamps.
+
+Do not write `*.spec.ts` files — that is `unit-test-generator`'s job.
+
+## Design guidance
+
+- Load `design-guidance` (rule stem) when assessing structure, smells, or pattern fit.

package/presets/cursor/nuxt/commands/README.md

@@ -0,0 +1,51 @@
+# Cursor commands (nuxt preset)
+
+Slash commands are copied to `.cursor/commands/` on `ai-rules init cursor --preset nuxt`.
+
+## Agent team commands
+
+| Command | Purpose |
+|---------|---------|
+| **`/task <description>`** | **Main entry:** router → pipeline.json → roles in order |
+| `/task-continue <slug>` | After a human gate or pause |
+| `/feature-start <description>` | Legacy: analyst only (no router) |
+| `/feature-continue <slug>` | Alias of task-continue |
+| `/technical-retro [slug]` | Retro; with slug — “Agent work” block |
+
+## `/task` examples
+
+```
+/task Add a date filter to Order History
+→ analyst → developer → reviewer → QA
+
+/task Order History crashes on an empty list
+→ debugger → developer → reviewer → QA (regression)
+
+/task CI failed on lint in PR #142
+→ ci-investigator → developer → reviewer
+
+/task Migrate to Nuxt 15
+→ analyst → migration-specialist → developer → reviewer → QA
+
+/task Check accessibility of the payment modal
+→ analyst → developer → a11y-reviewer → code-reviewer
+
+/task Cover the orders mapper with unit tests
+→ unit-planner → unit-generator
+
+/task Write a README for the new filters feature
+→ analyst → tech-writer
+
+/task Review changes in store/orders
+→ reviewer only
+```
+
+## Related files
+
+- Subagents: `../agents/` (**22** roles, including `task-router.md`, `codebase-analyzer.md`)
+- Orchestrator: `../rules/agent-team-orchestrator.mdc`
+- Skills: `../skills/` (`feature-delivery`, `code-review`, `debug-investigation`, `ci-investigation`, `unit-testing`, `playwright-e2e`, `technical-retro`)
+- Artifacts: `../team/README.md` (`pipeline.json`, `status.json`)
+- Hooks: `../hooks.json`, `../hooks/chain-team-phases.sh`
+
+Create and edit commands via `/commands` in Cursor or directly in this preset folder.

package/presets/cursor/nuxt/commands/feature-continue.md

@@ -0,0 +1,19 @@
+---
+name: feature-continue
+description: Legacy alias for /task-continue that resumes a feature pipeline after human approval or pause.
+---
+
+# Feature continue — legacy alias
+
+> **Prefer:** `/task-continue <slug>` — same behavior, respects `pipeline.json`.
+
+Continue after a human gate. Full logic — in **`task-continue.md`**.
+
+## Short form
+
+1. Read `pipeline.json` (if present) and `status.json`.
+2. Clear `awaitingHumanGate`; determine the next step from `pipelineIndex`.
+3. Invoke the subagent for `currentAgent`.
+4. The hook continues the chain when `autoChain: true`.
+
+See `task-continue.md` for details and the handoff table.

package/presets/cursor/nuxt/commands/feature-start.md

@@ -0,0 +1,33 @@
+---
+name: feature-start
+description: Legacy analyst-only feature intake. Prefer /task for new work because it uses router and dynamic pipeline.
+---
+
+# Feature start — legacy (analyst only)
+
+> **Prefer:** `/task <description>` — the router picks roles and order automatically.
+
+Starts the **analysis phase** without the router. The parent agent acts as orchestrator (see `agent-team-orchestrator.mdc`).
+
+## What to do
+
+1. Extract the task description from the command arguments (everything after `/feature-start`).
+2. Generate a **slug** (kebab-case, up to 48 characters) from the task title.
+3. Create `.cursor/team/tasks/<slug>/` if it does not exist yet — via **Write** of an artifact (not Shell `mkdir`).
+4. Write `.cursor/team/active-task.json` → `{ "slug": "<slug>" }`.
+5. Optionally: a minimal `pipeline.json` with fixed steps (analyst → developer → reviewer → qa-tester).
+6. Invoke subagent **task-analyst** (Task tool) with the full task description and artifact paths.
+7. Wait for the analyst to finish. **Do not invoke the developer** at this stage.
+
+## Human gate
+
+After the analyst:
+
+- Show the user links to `brief.md` and `decomposition.md`.
+- Ask them to review and approve or send edits.
+- To continue: `/task-continue <slug>` or `/feature-continue <slug>`.
+
+## If the slug already exists
+
+- If `status.json` is `awaiting_approval` — suggest review or continue.
+- If the task is in progress — ask whether to continue or start a new slug.

package/presets/cursor/nuxt/commands/task-continue.md

@@ -0,0 +1,50 @@
+---
+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 — after a human gate or pause
+
+Continue the pipeline from `pipeline.json`. Semantic alias: `/feature-continue`.
+
+## Arguments
+
+`<slug>` — task identifier.
+
+## Preconditions
+
+1. Read `.cursor/team/tasks/<slug>/pipeline.json` and `status.json`.
+2. Continue if:
+   - `awaitingHumanGate: true` or `state: awaiting_approval`, **or**
+   - `state: changes_requested` (after review), **or**
+   - the task was interrupted and needs resume from `pipelineIndex`.
+
+## Algorithm
+
+1. Write `.cursor/team/active-task.json` → `{ "slug": "<slug>" }`.
+2. **Human gate resume** (`awaitingHumanGate` / `awaiting_approval`):
+   1. **Do not** manually increment `pipelineIndex` or invent `currentAgent` first.
+   2. Close the gate + activate the next attempt via the **installed** hook (single authority for ledger + status):
+
+```bash
+printf '%s\n' '{"status":"completed","action":"end_human_gate","activateNext":true}' | bash .cursor/hooks/chain-team-phases.sh
+```
+
+   3. Re-read `status.json` (and the hook `followup_message`).
+   4. Invoke the subagent named in `status.currentAgent` / followup — do **not** advance the pipeline a second time.
+3. **Review `changes_requested`** (not a human gate): set `currentAgent` to `feature-developer` (same index / find developer in steps), `state: in_progress`, then invoke developer. Do **not** call `end_human_gate` unless `activeHumanGateEventId` is set.
+4. **Other resume**: restore `pipelineIndex` / `currentAgent` from status and invoke that agent.
+5. After the invoked agent completes, `chain-team-phases.sh` on `subagentStop` continues the chain when `autoChain: true`.
+
+## Artifacts for handoff
+
+| Agent | Read |
+|-------|------|
+| 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 |
+
+## Metrics
+
+On human-gate resume, the hook action above appends `human_gate_ended` under the per-task lock **before** any new `attempt_started`. Agents must not calculate durations.

package/presets/cursor/nuxt/commands/task.md

@@ -0,0 +1,56 @@
+---
+name: task
+description: Route a natural-language task through the agent-team pipeline: task-router, pipeline.json, and the first planned specialist.
+---
+
+# Task — single entry point (router + pipeline)
+
+Main command for filing a task. Parent agent = orchestrator (`agent-team-orchestrator.mdc`). Intake for work requests without `/task` — `agent-team-intake.mdc`.
+
+## Arguments
+
+Everything after `/task` is the natural-language task description.
+
+Examples:
+
+- `/task Add a date filter to Order History`
+- `/task Order History crashes on an empty list — fix it`
+- `/task CI failed on typecheck in the PR`
+- `/task Migrate the HTTP client to fetch`
+- `/task Check a11y of the login form`
+- `/task Cover the payments mapper with unit tests`
+- `/task Write a changelog for the filters release`
+- `/task Review my changes in store/orders`
+- `/task Write e2e for the payment scenario`
+
+## Algorithm
+
+1. **Slug** — kebab-case from the description (≤48 characters). Create `.cursor/team/tasks/<slug>/` via **Write** (e.g. placeholder `pipeline.json` or empty marker) — runtime/hook owns `status.json` — **not** via Shell `mkdir` (sandbox → `Operation not permitted`).
+2. **Router** — invoke subagent **task-router** with the task description and slug path.
+3. **Plan** — show the user the table from `pipeline.json`: intent, steps, skipped, humanGates.
+4. **Intent retro** — if `intent === "retro"`, run `/technical-retro` and **stop**.
+5. **Start** — after the router:
+   - confirm `pipeline.json` and `active-task.json`;
+   - **do not** write `status.json` / `metrics.json` lifecycle fields yourself — the orchestration runtime/hook owns them (see **agent-artifact-contracts**). If `status.json` is missing, only a minimal bootstrap is allowed (`slug`, `intent`, `pipelineIndex: 0`, `currentAgent: steps[0]`, `state: in_progress`) — **do not** increment `pipelineIndex` by hand;
+   - invoke the subagent for `pipeline.steps[0].agent` (slug, artifact paths, scope).
+6. **After each agent** — wait for hook handoff / reconciliation terminal receipt → `status.state`; do not start the next step until `status.json` reflects the handoff (or until there is a hook `followup_message`).
+7. **Human gate** — if after the current step there is a gate in `humanGates` (`after:<agent>`), after the agent finishes **stop** and ask for `/task-continue <slug>` (or `/feature-continue <slug>`).
+
+## Do not
+
+- Do not invoke the developer before the router and (if in the pipeline) analyst/architect.
+- Do not hardcode role order — only `pipeline.json`.
+- Do not skip a human gate without an explicit continue.
+
+## If the slug is busy
+
+- `awaitingHumanGate` / `state: awaiting_approval` → suggest reviewing artifacts or `/task-continue <slug>`.
+- `in_progress` → ask: continue or a new slug.
+
+## Legacy
+
+`/feature-start` and `/feature-continue` remain compatible; prefer `/task` for new work.
+
+## Metrics
+
+Runtime/hook owns `metrics.json` and `status.json` attempt ledgers. Before the first invocation ensure `task_started` and one `activeAttempts[attemptId]` + `attempt_started` exist (router/runtime bootstrap — parent must not invent parallel indices). On `/task-continue`, run the installed chain hook `end_human_gate` action (or wrapper) so `human_gate_ended` lands before the next attempt. Do not calculate durations in agents.

package/presets/cursor/nuxt/commands/technical-retro.md

@@ -0,0 +1,85 @@
+---
+name: technical-retro
+description: Facilitate a technical retrospective for a period, incident, release, or completed agent-team task slug.
+---
+
+# Technical retro
+
+The agent acts as a **neutral facilitator of a technical retrospective**, not as a code reviewer or people evaluator. Use skill **`technical-retro`** as the main scenario.
+
+## When to use
+
+- The user asks for: “retro”, “technical retro”, “sprint/iteration review”, “action items after release”.
+- After an agent-team pipeline finishes (`/feature-start` → `/feature-continue`).
+- Context exists: period, topic (release, incident), task slug, notes.
+
+## Inputs (gather, do not invent)
+
+Ask when missing:
+
+- **Period and focus**.
+- **Task slug** (if the retro is about agent-team work).
+- **Participants/roles** (if relevant).
+- **Constraints**: time, format (async vs sync).
+
+### Agent-team artifacts (when there is a slug)
+
+Read from the repository:
+
+- `.cursor/team/tasks/<slug>/pipeline.json`
+- `.cursor/team/tasks/<slug>/brief.md`
+- `.cursor/team/tasks/<slug>/decomposition.md`
+- `.cursor/team/tasks/<slug>/status.json`
+- Git diff / `git status` for changed files
+
+Do not invent facts that are not in artifacts, the diff, or the user message.
+
+## Facilitation principles
+
+- **Safety**: process and system, not “who is to blame”.
+- **Specifics**: from abstractions to observed events.
+- **Balance**: positives and growth areas.
+- **Action items**: owner and due date for each.
+- **Do not mix with code review** — separate the blocks if both are requested.
+
+## Session structure (default)
+
+1. **Goal and scope**.
+2. **Gather facts**: what went well / what blocked / surprises.
+3. **Cluster themes** (3–7).
+4. **Root causes** for 1–2 painful themes.
+5. **Experiments** (1–3 process changes).
+6. **Action items**: what / owner / by when / success criterion.
+
+## “Agent work” block (required when there is a slug)
+
+If the retro is tied to a `/feature-start` pipeline:
+
+| Question | What to record |
+|----------|----------------|
+| Router | Wrong intent, extra/missing steps in pipeline |
+| Analyst | Wrong assumptions, missed AC, extra/missing tasks |
+| Decomposition | Incomplete layer coverage, wrong order, blocked dependencies |
+| Developer | Scope creep, missed rules, lint/type gaps |
+| Reviewer | Missed defects, false positives, checklist quality |
+| QA | AC coverage by tests, flakiness, gaps in e2e plans |
+
+**Action items** in this block — improve **prompts, subagents, and rules** (not only code).
+
+## Response format
+
+- Header: period, focus, slug (if any), assumptions.
+- Agenda by stages.
+- **“Agent work”** block (when applicable).
+- Themes — bullets; disputed points — **questions for the team**.
+- **Action items** at the end.
+
+## Constraints
+
+- Do not invent quotes or facts without input.
+- Do not give HR recommendations.
+- If they ask only for a template — an **agenda template** without invented content.
+
+### Metrics evidence
+
+When `metrics.json` exists, run the local aggregation script and report the cohort, sample size, incomplete artifacts, attribution confidence, active attempt duration, and human-gate wait separately. Do not treat gate wait or malformed ledgers as agent duration.

package/presets/cursor/nuxt/hooks/README.md

@@ -0,0 +1,12 @@
+# `.cursor/hooks` (preset nuxt)
+
+| File | Purpose |
+|------|---------|
+| `chain-team-phases.sh` | Continues pipeline after subagent completes; supports `skipIf`, parallel steps, `validation_failed`, `retryAfterFix` |
+| `guard-shell-command.sh` | Blocks/asks on destructive git commands and package-manager mismatches (`failClosed: true`) |
+
+`hooks.json`: `loop_limit: 15` for long pipelines (build-verifier + parallel reviewers + e2e).
+
+## Optional cookbook
+
+See `hooks/examples/README.md` — secret-guard / format-edited / test-on-save. **Not** in default `hooks.json`.