Add Ecosystem

---
name: add--ecosystem
description: Consolidated view of the add-pro ecosystem - commands, skills, relationships and dependencies. Loaded by /add as source of truth.
---

# Ecosystem Map - add-pro

<!-- uses:
- mention: add--agents-md-style
- mention: add--architecture-discovery
- mention: add--backend-architecture
- mention: add--backend-development
- mention: add--backlog
- mention: add--code-review
- mention: add--commit
- mention: add--cross-sf-consistency
- mention: add--database-development
- mention: add--delivery-mode
- mention: add--delivery-validation
- mention: add--dev-environment-setup
- mention: add--doc-schemas
- mention: add--feature-discovery
- mention: add--feature-readback
- mention: add--feature-specification
- mention: add--final-report
- mention: add--frontend-architecture
- mention: add--frontend-development
- mention: add--gitnexus
- mention: add--health-check
- mention: add--id-convention
- mention: add--investigation
- mention: add--knowledge-discovery
- mention: add--optimizing-git-workflow
- mention: add--plan-based-features
- mention: add--plan-review
- mention: add--review-discipline
- mention: add--project-scaffolding
- mention: add--qa
- mention: add--qa-migration
- mention: add--qa-spec
- mention: add--resource-path-convention
- mention: add--security-audit
- mention: add--setup-contract
- mention: add--skill-creator
- mention: add--stripe
- mention: add--subagent-driven-development
- mention: add--tasks-checklist
- mention: add--tdd
- mention: add--test-specification
- mention: add--token-efficiency
- mention: add--ux-design
- mention: add--wiki-maintenance
- mention: @architecture-agent
- mention: @backend-agent
- mention: @conformance-agent
- mention: @consistency-agent
- mention: @database-agent
- mention: @discovery-agent
- mention: @e2e-agent
- mention: @failure-analysis-agent
- mention: @feature-history-agent
- mention: @fix-agent
- mention: @frontend-agent
- mention: @git-history-agent
- mention: @plan-reviewer-agent
- mention: @qa-agent
- mention: @readback-agent
- mention: @reviewer-agent
- mention: @security-agent
- mention: @system-design-agent
- mention: @test-agent
- mention: @ux-agent
- mention: @ux-flow-agent
- mention: @ux-layout-agent
- mention: /add
- mention: /add-audit
- mention: /add-brainstorm
- mention: /add-build
- mention: /add-diagnose
- mention: /add-done
- mention: /add-hotfix
- mention: /add-new
- mention: /add-plan
- mention: /add-pull-request
- mention: /add-qa-setup
- mention: /add-review
- mention: /add-wiki
- mention: build-setup.cjs
- mention: build-ledger.cjs
- mention: converge-gates.cjs
- mention: review-package.cjs
- mention: task-brief.cjs
- mention: done.cjs
- mention: get-branch-metadata.cjs
- mention: next-id.cjs
- mention: delivered.cjs
- mention: qa-evidence.cjs
- mention: status.cjs
- mention: hotfix-gates.cjs
- mention: backlog-cli.cjs
- mention: backlog-id.cjs
- mention: backlog-git.cjs
- mention: backlog-commit.cjs
- mention: migrate-context-files.cjs
- mention: init.cjs
- mention: qa-preflight.cjs
-->

## When NOT to Use

- Not a how-to guide — load the specific skill for execution detail.
- Not for authoring new skills/commands → use `add--skill-creator`.
- Not for resource path conventions → use `add--resource-path-convention`.

## Commands

The Skills Loaded column below also includes `add--delivery-mode` for `add-audit`, `add-diagnose`,
`add-done`, `add-hotfix`, `add-pull-request`, `add-qa-setup` and `add-wiki`: each now resolves
continuation eligibility through it. Diagnosis hotfix routes reserve the full `@report` invocation
for accepted manual instructions; the route itself remains unchanged.

| Command | Purpose | Skills Loaded |
|---------|---------|---------------|
| add | Intelligent gateway - answers questions, guides flows, suggests next command | add--dev-environment-setup, add--ecosystem |
| add-audit | Complete technical analysis of project (security, architecture, data, docs). Escalates to add--investigation on ambiguous findings | add--delivery-mode, add--doc-schemas, add--ecosystem, add--final-report, add--health-check, add--investigation, add--subagent-driven-development |
| add-brainstorm | Explore ideas (READ-ONLY) | add--delivery-mode, add--doc-schemas, add--final-report, add--knowledge-discovery |
| add-build | Development Execution Specialist. STEP 2 create-or-checkout of the feature branch via build-setup.cjs (`F[NNNN]` + `--worktree` args). Consumes the review's `## Fix Routing` table and writes the resolution annex back. Generates unit/integration tests via @test-agent (tdd-pipeline) and E2E specs via @e2e-agent (qa-pipeline). `## Final Review` reviews each delivery unit whole (`@reviewer-agent` `MODE: feature`, conditional OWASP, one fix wave) and writes the `Final review:` ledger line `/add-done` accepts; the build then enters its loop end itself — the Checkpoint Sequence on an epic, then the next subfeature or the publish question | add--backend-development, add--code-review, add--commit, add--cross-sf-consistency, add--database-development, add--delivery-mode, add--doc-schemas, add--final-report, add--frontend-development, add--id-convention, add--review-discipline, add--subagent-driven-development, add--tasks-checklist, add--ux-design |
| add-diagnose | Pre-decision investigative triage for ambiguous symptoms. Applies 5-phase methodology in agent-dispatched mode: parallel @feature-history-agent ∥ @git-history-agent, then sequential @architecture-agent. Persists every accepted diagnosis, including no-action. Accepted continuation instructions preserve the hotfix `@docs/diagnose/<file>.md` interface. READ-ONLY | add--delivery-mode, add--doc-schemas, add--ecosystem, add--final-report, add--investigation, add--knowledge-discovery, add--subagent-driven-development |
| add-done | Finalize feature, promote the exact reviewed QA baseline to immutable `_tests/final/run-NNN/`, generate changelog, and merge. Hotfix close-out requires a passed current `about.md` Review receipt via `hotfix-gates.cjs`. Final evidence preserves open findings; it is not a pass certificate | add--delivery-mode, add--doc-schemas, add--ecosystem, add--final-report, add--id-convention, add--wiki-maintenance |
| add-hotfix | Urgent fix with global ID ([NNNN]H). Optional `@docs/diagnose/*.md` reuses an accepted diagnosis and skips duplicated investigation. With tdd-pipeline, pins the confirmed root cause with a coordinator-verified RED test before any edit. After the fix, dispatches @reviewer-agent (conditional OWASP) and one @fix-agent wave, then writes the Review receipt in about.md. Creates isolated doc in docs/features/[NNNN]H-*, recording the user-confirmed cause as typed `caused_by` relations in its about.md | add--delivery-mode, add--doc-schemas, add--ecosystem, add--final-report, add--id-convention, add--investigation, add--knowledge-discovery, add--subagent-driven-development, add--ux-design |
| add-new | Feature discovery, creates about.md (records `branch:` frontmatter — branch created later by add-build) | add--delivery-mode, add--doc-schemas, add--feature-specification, add--final-report, add--id-convention, add--knowledge-discovery, add--plan-review, add--review-discipline, add--subagent-driven-development |
| add-plan | Technical Planning Orchestrator. OWNS the design contract: gated STEP add-plan.ux-design UX pipeline (@ux-flow-agent → @ux-layout-agent → @ux-agent critique → consolidated `design.md`, provenance-hash idempotency). QA-Spec subagent (STEP qa-pipeline.qa-spec) when qa-pipeline feature enabled. STEP add-plan.review dispatches `@plan-reviewer-agent` before completion. **STEP add-plan.cross-sf-review (epic only)** owns cross-SF **completeness of one plan** — shared-resource centralization, fallback/degradation, worker/DI registration — fixed **in place**; it does NOT own divergence between subfeature plans (that is `@consistency-agent`) and **consumes** that agent's API-contract / data-schema findings instead of re-deriving them | add--backend-development, add--cross-sf-consistency, add--database-development, add--delivery-mode, add--doc-schemas, add--feature-discovery, add--final-report, add--frontend-development, add--id-convention, add--knowledge-discovery, add--plan-review, add--review-discipline, add--subagent-driven-development, add--tasks-checklist, add--ux-design |
| add-pull-request | Create or update PR for current branch (idempotent). On feature branches, generates the permanent feature changelog before opening the PR | add--commit, add--delivery-mode, add--doc-schemas, add--final-report, add--id-convention |
| add-qa-setup | End-to-end-verified QA bootstrap — installs the runner, generates `qa-project`, scaffolds config/screens, and materializes the dedicated `.gitignore` block that keeps working runs ephemeral. Identity is the shipped `shape` hash | add--delivery-mode, add--dev-environment-setup, add--doc-schemas, add--final-report, add--qa, add--qa-migration, add--setup-contract, add--subagent-driven-development |
| add-review | Feature Review Specialist — read-only on code. Code review + spec-compliance audit + the absorbed QA validation (preflight / evidence / judgement), which arrives with the `qa-pipeline` feature and then self-gates on the `/add-qa-setup` receipt — two gates: the feature decides whether the steps exist, the receipt decides whether they can run. Dispatches `@reviewer-agent` in `MODE: owasp` alongside the frontend/backend reviewer(s), conditional on the diff touching a sensitive area (auth, payment, upload, input handling, session/token). Consolidates every finding class into one `## Fix Routing` table and writes a versioned `review-NNN.md`; `/add-build` applies the routes and appends the resolution annex. Optional — `/add-done` accepts the build's own final review; the most recent verdict wins | add--commit, add--delivery-mode, add--doc-schemas, add--final-report, add--investigation, add--knowledge-discovery, add--subagent-driven-development, add--tasks-checklist |
| add-ux | Quick UX - loads add--ux-design and applies to user's free-form instruction | add--ux-design |
| add-wiki | Map project architecture, classify apps, generate portable project wiki (`.codeadd/wiki/`) with hub, spine, and per-domain pages. `/add-wiki update` runs incremental maintenance | add--agents-md-style, add--architecture-discovery, add--delivery-mode, add--doc-schemas, add--ecosystem, add--final-report, add--subagent-driven-development, add--wiki-maintenance |

## Skills

| Skill | Purpose | Used By |
|-------|---------|---------|
| add--agents-md-style | AGENTS.md generation guide: migrates legacy context files, content rules, format (JSON/markdown), line budget — load before any AGENTS.md write | add-wiki |
| add--architecture-discovery | Map architecture, detect patterns, dispatch domain analyzers for the project wiki | add-wiki |
| add--backend-architecture | Backend architecture consultant: Simple Modular, Vertical Slice, Clean Architecture, Combined Strategy | (none) |
| add--backend-development | Backend architecture: SOLID, Clean Arch, DTOs, Services, Repository — stack-agnostic | add-build, add-plan |
| add--backlog | Record a ticket on the project backlog, or read, reprioritise, comment on and close what is already there — works mid-flow, inside another command's run | (none) |
| add--code-review | Code review: IoC, RESTful, Contracts, Security (OWASP), Clean Architecture, SOLID | add-build |
| add--commit | Knowledge reference for mid-workflow commits: adaptive message logic, type detection, staging rules | add-build, add-pull-request, add-review |
| add--cross-sf-consistency | Five-dimension rubric, dedupe/precedence rules and finding routes for judging contract consistency across an epic's subfeature plans; loaded by `consistency-agent` | add-build, add-plan |
| add--database-development | Data architecture: entities, repositories, migrations, naming — stack-agnostic | add-build, add-plan |
| add--delivery-mode | The two delivery modes (`confirm` / `automatic`), their carriers and stops, optional manual continuation eligibility, same-session automatic handoff, and its publish-question terminus | add, add-audit, add-brainstorm, add-build, add-diagnose, add-done, add-hotfix, add-new, add-plan, add-pull-request, add-qa-setup, add-review, add-wiki |
| add--delivery-validation | Product validation: Requirements 100% implemented, prerequisites exist, acceptance criteria pass | (none) |
| add--dev-environment-setup | Detect OS, diagnose missing tools, install Node/git/gh and verify the Node floor | add, add-qa-setup |
| add--doc-schemas | Canonical schemas, stable IDs, universal doc rules, validation gate (incl. the `setup-receipt` schema) — single source of truth for all generated docs | add, add-audit, add-brainstorm, add-build, add-diagnose, add-done, add-hotfix, add-new, add-plan, add-pull-request, add-qa-setup, add-review, add-wiki |
| add--ecosystem | Consolidated ecosystem view (source of truth) | add, add-audit, add-diagnose, add-done, add-hotfix, add-wiki |
| add--feature-discovery | Feature discovery process, codebase analysis | add-plan |
| add--feature-readback | Cold-read comprehension readback of a closed doc set — says back what it understood would be built and marks every gap the reader filled in; no questions, no verdict. Runs after the pre-delivery review's fixes land | (none) |
| add--feature-specification | Single writer of about.md — reads the brainstorm intent file, extracts closed decisions without asking, and asks only what's still open | add-new |
| add--final-report | The closing shape every command that finishes work reports in — TL;DR, what was delivered, how it works, files touched, where it plugs in, what is out of scope, what needs attention. Loaded at the closing step, not at STEP 1 | add, add-audit, add-brainstorm, add-build, add-diagnose, add-done, add-hotfix, add-new, add-plan, add-pull-request, add-qa-setup, add-review, add-wiki |
| add--frontend-architecture | Frontend architecture consultant: Simple Component-Based, Feature-Based, FSD — React/Vue/Angular-aware | (none) |
| add--frontend-development | Frontend architecture: state, data fetching, components, forms, routing — stack-agnostic | add-build, add-plan |
| add--gitnexus | [plugin-bound] Code knowledge-graph navigation via GitNexus MCP — call graph, refs, blast-radius, trace flows, safe refactors. Enabled by `codeadd plugins enable gitnexus` | (plugin-bound) |
| add--health-check | Health check of environment and project dependencies | add-audit |
| add--id-convention | Canonical [NNNN][L] ID and branch naming convention for features, hotfixes, refactors, chores, and docs — enforced by scripts (next-id.cjs, get-branch-metadata.cjs, build-setup.cjs, done.cjs) | add-build, add-done, add-hotfix, add-new, add-plan, add-pull-request |
| add--investigation | Rigorous investigation methodology (5 phases with Iron Law) for vague symptoms and information-flow bugs. Adapted from systematic-debugging. Reusable by any command needing RCA before acting | add-audit, add-diagnose, add-hotfix, add-review |
| add--knowledge-discovery | Consult the delivery index, then the docs knowledge graph, then the project wiki at the context/discovery step for minimal token cost — loaded by add-plan, add-hotfix, add-new, add-diagnose, add-review, add-brainstorm | add-brainstorm, add-diagnose, add-hotfix, add-new, add-plan, add-review |
| add--optimizing-git-workflow | Git patterns, commits, branches, aliases | (none) |
| add--plan-based-features | Implement subscription plan-based features | (none) |
| add--plan-review | Pre-delivery executability rubric for about.md and plan.md — verdict (ok / fix-then-ok / blocked) plus required fixes, not questions; loaded by `plan-reviewer-agent` | add-new, add-plan |
| add--project-scaffolding | Create projects from scratch: Starter/Scale, multi-stack Node.js, Starter-to-Scale migration | (none) |
| add--qa | QA methodology (default-shipped); the `playwright` plugin adds live browser driving — Level C judge rubric, severity taxonomy, dual-judge (@ux-agent review ∥ @qa-agent) axis ownership, root-cause taxonomy, report schema/template, config.json/screens.json formats. `references/coordinator.md` holds the **coordinator-only** merge rules + Fix Routing — loaded at the QA merge step `qa-pipeline` adds to /add-review, never by a judge | add-qa-setup, add-review |
| add--qa-migration | Adopt the code-addiction QA pipeline in a project that already runs Cypress/Jest/Vitest/custom QA — autonomous dogfooding sequence (add-new → add-plan → add-build → add-review) and its checkpoints; consumed by /add-qa-setup | add-qa-setup |
| add--qa-spec | Generate a code-free QA/E2E spec (reachability intent, UX acceptance, functional scenarios, capture states, viewports, a11y expectations) from about.md + design.md + plan-*.md, **and** author the `_tests/screens.json` screen catalog by read-merge-write — loaded by add-plan's qa-pipeline QA-Spec step | (none) |
| add--resource-path-convention | Path convention for referencing commands/skills/scripts across providers | (none) |
| add--review-discipline | HOW review is dispatched: the counts, what makes a second dispatch legal (apply then re-gate), how a readback divergence is handled at each of its three sites, and the one boundary where a verdict may reach disk | add-build, add-new, add-plan |
| add--security-audit | OWASP checklist, RLS, secrets, multi-tenancy | (none) |
| add--setup-contract | Compare a project's receipt `setup-shape` to the shipped sidecar `shape` and route FIRST-RUN / CURRENT / STALE | add-qa-setup |
| add--skill-creator | Create and test skills under real pressure | (none) |
| add--stripe | Stripe integration, price versioning, grandfathering | (none) |
| add--subagent-driven-development | Subagent coordination with quality gates | add, add-audit, add-build, add-diagnose, add-hotfix, add-new, add-plan, add-qa-setup, add-review, add-wiki |
| add--tasks-checklist | tasks.md schema: 5 sections, tick rules, [!] semantics, "non-trivial change" rule, architect prompt template — single source of truth | add-build, add-plan, add-review |
| add--tdd | RED-GREEN-REFACTOR execution discipline: failing test confirmed for the right reason before code | (none) |
| add--test-specification | Generate contract test cases (RF/RN → testable cases) into plan-test-spec.md | (none) |
| add--token-efficiency | Compression, compact JSON, minimal tokens | (none) |
| add--ux-design | Components, mobile-first, SaaS patterns, shadcn, Tailwind | add-build, add-hotfix, add-plan, add-review, add-ux |
| add--wiki-maintenance | Incremental project-wiki updates — diff-driven surgical edits, never full rewrites — loaded by `/add-wiki update` and add-done STEP 4.9 | add-done, add-wiki |

## Agents

| Agent | Purpose | Dispatched by |
|-------|---------|---------------|
| ux-flow-agent | Flow & interaction architect — design-system inspection (tokens, shell, component audit, visual patterns) then screen inventory, action classification, entry points, state transitions. Writes temp design-context.md + design-flow.md; early-exits `frontend_false` | add-plan (8.1.1) |
| ux-layout-agent | Layout & component specialist — layout tree + component composition + Design Contract per screen, new-component specs, states, every classified action served by a UI element. Writes temp design-layout.md (needs design-flow.md) | add-plan (8.1.2) |
| ux-agent | UX design owner (three modes) — critique mode: adversarial review of the flow/layout pair vs the Critique Rubric in add--ux-design (writes temp design-review.md); review mode: post-delivery judgement of shipped screens vs the `## Design Contract` (judgement axes + spec-gap); fix mode: amends `design.md`'s Design Contract + Design Review on a routed `design-spec` finding (the ONLY mode that writes, and the only agent permitted to write `design.md`); free-form UX assistance on direct use. No memory | add-plan (critique), add-review (review mode, ∥ qa-agent), add-build (fix mode — routed design-spec fixes) |
| backend-agent | Backend implementation specialist | add-build, add-plan |
| frontend-agent | Frontend implementation specialist | add-build, add-plan |
| reviewer-agent | Code review (read-only) — `MODE: task` (default), `MODE: re-review`, `MODE: feature` (one delivery unit whole, for `/add-build`'s final review), and `MODE: owasp`, a systematic OWASP Top 10 pass dispatched alongside the area reviewer(s) when the diff touches a sensitive area (auth, payment, upload, input handling, session/token). Every finding, in every mode, carries `Confidence: confirmed \| needs-verification` | add-review, add-build, add-hotfix |
| security-agent | OWASP judge for a delivered change — judges the diff against A01-A10 plus XSS and mass assignment, asking first whether the change removed or weakened an existing control. Owns the security axis exclusively; a pre-existing finding is an observation, never a blocker (read-only) | no base command — retained; add-hotfix no longer dispatches it |
| conformance-agent | Documented-rules judge — judges the diff against the wiki when present, AGENTS.md plus surrounding code when absent. Freshness-gates every cited page so a stale page never grounds a blocker, and reports the reverse case as wiki-drift for /add-wiki update (read-only) | no base command — retained; add-hotfix no longer dispatches it |
| failure-analysis-agent | Failure-mode judge — unhandled error paths, null propagation, missing rollback or idempotency, resource leaks, retry and ordering assumptions, reasoned against the blast radius of related features and suspicious commits confirmed earlier in the flow (read-only) | no base command — retained; add-hotfix no longer dispatches it |
| test-agent | Unit + integration test generator for ONE area — reads the area's target files and feature docs, generates tests at the project's conventional location, and ends in one of three declared states — green, BLOCKED naming the assertion and the source symbol when its own correct test caught a real bug, or out of attempts. The cap comes from the caller. Dispatched AFTER its area's implementer, one agent at a time. CORRECTION mode writes one RED test pinning the bug instead of regenerating. Read-write on test files only | add-build (tdd-pipeline feature) |
| fix-agent | Correction specialist for ONE WHOLE WAVE — consumes the review's `## Fix Routing` rows across every area the wave touches (code-review findings, build errors, red validation gates, QA findings), in the table's own order, and applies the fixes. Honours `Blocked by` by deferring a blocked row, continuing, and returning to it once its predecessor lands. One dispatch and one attempt counter per wave, both supplied by the caller, never decided by the agent | add-build, add-hotfix |
| discovery-agent | Feature discovery and specification (read-only) | add-plan |
| architecture-agent | Architecture consultant, layer/module advice (read-only) | add-plan, add-diagnose (Fase B), add-hotfix |
| system-design-agent | System design, data flows, infrastructure | no base command — direct use; carries the gitnexus graph section when that plugin is enabled |
| database-agent | Schema design, migrations, queries | add-build, add-plan |
| plan-reviewer-agent | Fresh-context, fix-oriented pre-delivery review of about.md / plan.md — verdict (ok / fix-then-ok / blocked) plus required fixes (read-only) | add-plan (STEP 12), add-new (STEP 8, full path only) |
| readback-agent | Cold-read comprehension reporter — takes a doc set plus a `scope` (`feature` / `subfeature` / `document`) and restates what it understood would be built, marking every gap it filled in itself. Issues no verdict and asks no questions; the divergence between its restatement and what was actually decided is the signal. Dispatched AFTER `plan-reviewer-agent`'s fixes are applied, never beside it (read-only) | add-plan (STEP 12), add-build (cold readback before the first F-block) |
| consistency-agent | Cross-subfeature consistency judge for an epic — compares contracts declared across subfeature `plan.md` / `about.md` / `design.md`, document against document and never code, on exactly five dimensions (API contracts, data schema, requirements, design tokens when `HAS_DESIGN`, auth/permission model). Anything outside the five is informational and never blocks. FULL pass after each subfeature's plan; DELTA pass at epic end. Read-only — **detects divergence between plans and never edits**. Counterpart to `/add-plan` **STEP add-plan.cross-sf-review**, which owns single-plan **completeness** (shared-resource centralization, fallback/degradation, worker/DI registration) and fixes it in place: those three are never findings here, at any severity, and 9.5 consumes this agent's dimension 1/2 findings rather than re-deriving them | add-plan (STEP 12.3, FULL pass), add-build (Loop End, DELTA pass) |
| feature-history-agent | Scans docs/features/ for symptom-relevant features (read-only, docs only) | add-diagnose (Fase A.1), add-hotfix |
| git-history-agent | Correlates recent git history with a symptom (read-only git) | add-diagnose (Fase A.2), add-hotfix |
| qa-agent | Deterministic + forensic QA judge (the qa-agent half of the dual panel) — functional delivery vs about.md, deterministic Design Contract conformance from measured computed styles, ALL a11y (axe-core), and root-caused failure forensics; judges from persisted run evidence (read-PNG), live-drives with the playwright plugin. No memory | add-review (qa-pipeline feature — per SF, parallel, ∥ ux-agent review), add-plan, add-qa-setup |
| e2e-agent | Cross-cutting E2E spec author — authors `<surface>.qa.spec` (functional assertions + multi-viewport capture + axe a11y), finalizes screens.json reachability recipe, green-confirms via `@playwright/test` (no MCP, test files only) | add-build (qa-pipeline feature; routed selector-drift / spec-defect / coverage fixes), add-qa-setup, add-review |

## Features

| Feature | Default | Injects into | Purpose |
|---------|---------|--------------|---------|
| tdd-pipeline | enabled | add-plan, add-build, add-review, add-hotfix | RED-GREEN-REFACTOR discipline + contract-test specs + unit/integration generation |
| qa-pipeline | disabled | add-plan, add-build, add-review | E2E spec authoring + routed QA correction + the agent QA judgement in add-review |
| docs-pruning | disabled | add-done | Prune post-merge feature scaffolding (discovery, tasks, epic, reviews) after the delivery index entry is written |
| board | disabled | add-brainstorm, add-new, add-plan, add-build, add-done, add-hotfix | Backlog board — the pipeline commands read a ticket and move it through the phase statuses. Off by default: the board app ships as a separate release asset, so a fresh install has neither the board nor `docs/backlog.jsonl` |

Enable/disable via `codeadd features enable|disable|list <name>` — fragments are injected into the installed commands post-install. The split is canonical in add--qa's *Feature vs plugin* statement and is not restated here: `qa-pipeline` decides whether the QA flow exists at all, and the `playwright` plugin below only adds live driving to a judge the feature already supplied — enabling the plugin does not enable the pipeline.

## Plugins

| Plugin | Type | Description | Injects into | Plugin skill |
|--------|------|-------------|--------------|--------------|
| gitnexus | mcp | Code knowledge-graph navigation (calls, refs, blast-radius) via MCP | add-new, add-plan, add-build, add-diagnose, add-hotfix, add-done, add-wiki + 9 agents (discovery, architecture, system-design, backend, database, frontend, ux, ux-flow, reviewer) | add--gitnexus |
| playwright | mcp | Adds live browser driving (screenshots + console/network) to the already-present QA validation via Playwright MCP | add-review (command), qa-agent (agent) | — (add--qa is now default) |

Enable/disable via `codeadd plugins enable|disable|list <name>`. Plugins are disabled by default and require the external tool to be installed.

## Dependency Index

| If you modify... | It impacts... |
|------------------|---------------|
| add--backend-development | add-build, add-plan |
| add--frontend-development | add-build, add-plan |
| add--database-development | add-build, add-plan |
| add--ux-design | add-ux, add-build, add-review, add-hotfix, add-plan; the three UX agents (ux-flow-agent, ux-layout-agent, ux-agent) declare it as a skill — its `critique-rubric.md` is the critic's canonical rubric and `design-contract.md` the layout/contract notation |
| add--code-review | add-build; @reviewer-agent, @security-agent, @conformance-agent and @failure-analysis-agent declare it as a skill |
| add--final-report | add, add-audit, add-brainstorm, add-build, add-diagnose, add-done, add-hotfix, add-new, add-plan, add-pull-request, add-qa-setup, add-review, add-wiki — every command that finishes work. The root `add` command and add-ux are exempt: a router and an instruction transformer finish none |
| add--security-audit | @security-agent and @reviewer-agent declare it as a skill |
| add--setup-contract | add-qa-setup (STEP 1.5 compare + STEP 12 receipt rewrite) |
| add--qa-migration | add-qa-setup (STEP 5, first-run migration + `--migrate`) |
| add--subagent-driven-development | add, add-audit, add-build, add-diagnose, add-hotfix, add-new, add-plan, add-qa-setup, add-review, add-wiki (`references/dispatch-rules.md` — read before any dispatch: a fresh dispatch leaves the engine's resume/session fields empty, only an id an earlier dispatch returned is passed) |
| add--review-discipline | add-plan (STEP 12), add-new (STEP 8), add-build (10.0.4 and `## Final Review`) — the dispatch discipline all three share |
| add--plan-review | add-plan (STEP 12), add-new (STEP 8, full path only) — all via plan-reviewer-agent |
| add--feature-readback | add-plan (STEP 12), add-build (cold readback before the first F-block) — all via readback-agent, each after the plan-review fixes land |
| add--feature-discovery | add-plan (direct) |
| add--feature-specification | add-new (STEP 4, the single writer of about.md), add-plan via discovery-agent |
| add--doc-schemas | add, add-audit, add-brainstorm, add-plan, add-build, add-hotfix, add-done, add-pull-request, add-wiki, add-diagnose, add-qa-setup, add-review |
| add--architecture-discovery | add-wiki (direct); add-diagnose, add-hotfix, add-plan (via architecture-agent) |
| add--ecosystem | add (loses full view), add-audit, add-build, add-diagnose, add-done, add-hotfix, add-plan, add-wiki — the commands that route to next steps |
| add--wiki-maintenance | add-wiki (update mode), add-done (STEP 4.9) |
| add--knowledge-discovery | add-plan, add-hotfix, add-new, add-diagnose, add-review, add-brainstorm |
| add--investigation | add-diagnose (primary, agent-dispatched mode), add-hotfix (STEP 6.1 escalation, agent-dispatched mode), add-review (STEP 5.1 ambiguous findings), add-audit (STEP 7.1 ambiguous findings) |
| add--delivery-mode | add, add-brainstorm, add-new, add-plan, add-build, add-review, add-diagnose, add-done, add-hotfix, add-pull-request, add-qa-setup, add-wiki — the delivery mode, deciding vs confirming stops, the same-session handoff and where the automatic path ends |
| add--commit | add-build, add-pull-request, add-review — every command that commits mid-workflow |
| add--cross-sf-consistency | add-plan (STEP add-plan.cross-sf-review consumes its findings), add-plan (STEP add-plan.consistency, FULL pass) and add-build (Loop End, DELTA pass) via consistency-agent |
| add--dev-environment-setup | add (environment triage), add-qa-setup (runner install) |
| add--qa | add-qa-setup, add-review (QA judgement), add-plan; @qa-agent declares it as a skill |
| add--id-convention | add-plan, add-build, add-hotfix, add-done, add-new, add-pull-request (all ID allocation and branch naming; SF-qualified design IDs cover the `feature-design` doc type from add--doc-schemas' `references/new-feature.md`; add-build's build-setup.cjs enforces the format at branch creation) |
| add--tasks-checklist | add-plan, add-build, add-review (tasks.md schema and tick rules) |
| add--tdd | add-plan, add-build, add-review, add-hotfix (tdd-pipeline RED gate) |
| add--test-specification | add-plan (STEP tdd-pipeline.test-spec) |
| feature-history-agent | add-diagnose (STEP 4 Fase A.1), add-hotfix (STEP 4) |
| git-history-agent | add-diagnose (STEP 4 Fase A.2), add-hotfix (STEP 4) |
| qa-agent | add-review (dispatched per SF, parallel with ux-agent review), add-plan, add-qa-setup |
| e2e-agent | add-build (dispatched when qa-pipeline feature enabled; also routed test-file fixes), add-qa-setup, add-review |
| ux-flow-agent | add-plan (STEP 7.1.1) — and everything downstream of `design.md`: add-plan 7.4 frontend, add-review UX axis, add--qa-spec |
| ux-layout-agent | add-plan (STEP 7.1.2) — depends on ux-flow-agent's design-flow.md |
| ux-agent | add-plan (STEP 7.1.3 critique), add-review (STEP 10.1 review mode, ∥ qa-agent), add-build (fix mode — routed design-spec amendments), free-form direct use |
| add--qa-spec | add-plan (STEP qa-pipeline.qa-spec, qa-pipeline feature) — owns `plan-qa-spec.md` AND `_tests/screens.json` authoring |
| add--feature-specification (about.md) | add-review (functional axis reads acceptance criteria — QA quality is bounded by spec quality) |
| add--ux-design (design.md) | add-review (@ux-agent review judges the judgement axes vs the `## Design Contract`; @qa-agent checks deterministic conformance vs the computed-style rows) |
| playwright (plugin) | add-review (drive), qa-agent (drive) — enhancement/live arm; the QA judgement runs without it (read-PNG) |
| status.cjs | add, add-brainstorm, add-build, add-diagnose, add-hotfix, add-new, add-plan, add-qa-setup, add-review, add-ux |
| init.cjs | add-new — seeds the feature's documents on first use |
| qa-preflight.cjs | add-qa-setup, add-review — checks the QA runner is installed and configured before any evidence is gathered |
| hotfix-gates.cjs | add-diagnose (diagnosis-baseline), add-hotfix (check, snapshot, fingerprint), add-done (review-validate) |
| build-setup.cjs | add-build (STEP 2 branch creation) — enforces the `F[NNNN]` branch format |
| done.cjs | add-build, add-done |
| delivered.cjs | add-done, add-hotfix — delivery-index queries for the iteration log |
| qa-evidence.cjs | add-done, add-qa-setup, add-review — QA evidence gathering and baseline snapshotting |
| converge-gates.cjs | add-build (Checkpoint Sequence and epic-wide gate), add-done (STEP 4, delivery-gate preflight) — read-only probe for the five gates (review, QA baseline, epic, coverage, build ledger); one script backs both commands' verdicts so they can't drift apart |
| build-ledger.cjs | add-build (10.0.1 pre-flight scan, 11.3 commit, 12.2 fix rounds, 16.2 iteration), add--subagent-driven-development — appends one line to the feature's build ledger, creating it with its identity header when absent. The ledger is what survives a compaction: a task with a `complete` line is never re-dispatched |
| task-brief.cjs | add-build (STEP 10 dispatch), add--subagent-driven-development — extracts one `tasks.md` task with all six sub-bullets to its own file, so an implementer reads its requirements instead of the whole plan |
| backlog-cli.cjs | add--backlog — the native local entry: the positional grammar, `--record-file` records and native allocation (through `backlog-id.cjs` at the operation root), calling the canonical core — the single reader of `docs/backlog.jsonl`, shared with the board app. Reads print a seven-field summary (`--full`/`--ids` opt-in) and `get <id>` answers the exact detail read |
| backlog-id.cjs | add--backlog — the native global id allocator: immediate `docs/features` slugs plus the raw backlog text, anchored on the raw text exactly as the retired shell calculators grepped; 9999 overflows refuse rather than wrap |
| backlog-commit.cjs | add--backlog — the git route for a backlog write: the ticket reaches the BASE branch whatever branch the caller stood on, direct when already there and through a detached locked worktree otherwise, with durable recovery refs on every failed publication |
| backlog-git.cjs | add--backlog — the git primitives the publication entry composes: base discovery, the path-scoped commit, fetch/rebase/push with verified aborts, and the recovery refs |
| migrate-context-files.cjs | add-wiki, add--agents-md-style — folds any legacy context file into `AGENTS.md` without losing a line, because a leftover one hides or overrides it |
| review-package.cjs | add-build (12.2 re-review only — STEP 11 forbids it, since nothing is committed there yet), add--subagent-driven-development — writes the scoped `BASE..HEAD` diff to one file for the reviewer, and refuses an empty range |

## Main Flows

| Flow | Sequence | When to use |
|------|----------|-------------|
| Complete | brainstorm → new → plan → build → review → done | Complex features with UI (design is produced inside plan STEP 7.1) |
| QA-validated | new → plan → build → **review ⇄ build** → done | UI features that ran `/add-qa-setup`. The review judges the rendered result and routes every finding; the build applies them and closes the round in the same `review-NNN.md`. Working runs stay local; done snapshots them before merge |
| Standard | new → plan → build → review → done | Features without complex UI |
| Lean | new → build → done | Small changes, quick tasks |
| Automatic | brainstorm → new → plan → **build (its own final review)** → publish question | Chosen once at `/add-brainstorm`'s approval. Each stage hands off without waiting until a deciding stop or the build's PR question; an epic asks automatic or semi-automatic at the split. `/add-done` always waits for the user |
| Emergency | hotfix → done | Critical production bug |
| Diagnose-backed hotfix | diagnose → hotfix @report → done | Accepted diagnosis reused; never `/add-review` |
| Exploration | brainstorm → new → ... | Don't know where to start |
| Triage | diagnose → (hotfix @report OR new OR no-action) | Vague symptom, unsure if bug/feature |
| Analysis | wiki / audit | Check project health |

> **Branch creation:** the documental steps (brainstorm → new → plan) make no git writes — `/add-new` only records the branch name in `about.md` (`branch:`). The branch is created at the **build** step via `build-setup.cjs`.

## Command Next-Steps Routing

Conditions evaluated top-to-bottom — use FIRST match.

**This table resolves a NEXT ACTIVITY. It does not decide how that activity is delivered to the
user.** On a manual run the finishing command offers optional fresh-context instructions rather than
printing an invocation — `chat-continuation-eligibility-v1` in `add--delivery-mode` owns when that
offer is made, and `chat-continuation-output-v1` in `add--final-report` owns what an accepted answer
contains. This skill names the rows and stays out of both.

**Read the Next activity column as routing, not as text to paste.** A row whose value is `none`, or
which names a wait (`none — wait for review`) or staying put (`continue brainstorm`), is the absence of
a next activity — and a command resolving one of those rows offers nothing at all.

| After | Condition | Next activity | Why |
|-------|-----------|---------------|-----|
| add-brainstorm | idea ready to formalize | `/add-new` | Capture as feature |
| add-brainstorm | needs more exploration | continue brainstorm | Not ready to commit |
| add-brainstorm | bug suspected, needs investigation | `/add-diagnose` | Structured triage needed |
| add-brainstorm | clear bug discovered | `/add-hotfix` | Urgent fix needed |
| add-diagnose | route=hotfix | `/add-hotfix @docs/diagnose/<file>.md` | Confirmed bug requiring urgent fix |
| add-diagnose | route=feature | `/add-new` | Confirmed functional gap |
| add-diagnose | route=extend | `/add-new` or `/add-plan` | Extend existing feature — load prior context |
| add-diagnose | route=no-action | none | No real problem — stop here |
| add-new | feature needs technical planning | `/add-plan` | Architect before building. STEP 7.1 produces the UX contract when the feature touches UI |
| add-new | feature is simple (1-2 files) | `/add-build` | Skip planning, build directly |
| add-new | delivery mode is `automatic` (chosen at `/add-brainstorm`'s approval) | (hands off itself) | `/add-new` follows `{{cmd:add-plan}}` from its first step — see `add--delivery-mode` |
| add-plan | default | `/add-build` | Most common path |
| add-plan | delivery mode is `automatic` | (hands off itself) | `/add-plan` follows `{{cmd:add-build}}` from its first step — see `add--delivery-mode` |
| add-build | final review passed or ruled | `/add-done` | The build reviewed the whole unit; `/add-review` is optional, for detail and the QA judgement |
| add-build | final review blocked | each `Blocker suggestion:` command | The build names them; `/add-done` blocks until one clears it |
| add-build | mode=CORRECTION | `/add-done` | The correction wrote a newer `Final review:` verdict — no second review needed |
| add-build | epic, more subfeatures pending | `/add-plan` for the next subfeature (automatic delivery does this itself) | Next subfeature in epic |
| add-review | status=BLOCKED with only manual remedies | none — manual action required | No agent-runnable correction is selected |
| add-review | status=BLOCKED with agent-routed rows | `/add-build` | It consumes `## Fix Routing`, applies the fixes and appends the resolution annex |
| add-review | status=PASSED | `/add-done` | All gates green, finalize |
| add-review | status=BLOCKED | fix + `/add-build` | The build's verdict after the fix supersedes this review |
| add-hotfix | always | `/add-done` | Hotfix ready, finalize branch |
| add-review | needs team review before merge | `/add-pull-request` | PR for human review |
| add-pull-request | PR open, awaiting review | none — wait for review | Human review pending; there is no agent activity to continue into |
| add-pull-request | PR merged on GitHub | `/add-done` | Cleanup local branch + tags |
| add-pull-request | scope grew, need to update PR | `/add-pull-request` | Idempotent — appends update section |
| add-done | no next goal stated for this work | none | The delivery is closed — see the prohibition below. Evaluated FIRST, because a merged branch carries no goal of its own |
| add-done | was feature, back on main, next feature stated | `/add-new` | Start that feature |
| add-done | was epic, more subfeatures pending, next one stated | `/add-build feature N` | Next subfeature |
| add-done | was hotfix, and the user said what comes next | `/add-new` | Return to feature work |
| add-ux | within active feature | return to current flow | UX applied, resume workflow |
| add-ux | standalone | none | One-off UX task |
| add-wiki | issues found | `/add-audit` | Deep health check |
| add-wiki | context mapped, ready to build | `/add-new` | Start building with context |
| add-wiki | standalone analysis | none | Analysis delivered |
| add-audit | critical issues found | `/add-new` per issue | Create features to fix findings |
| add-qa-setup | prereqs + config ready | `/add-review` | Its QA sections validate the rendered result (UX + functional) — optionally `codeadd plugins enable playwright` first for live driving |
| add-audit | project healthy | none | No action needed |

⛔ **Never propose a feature nobody asked for at `add-done`.** The `was feature / was epic / was
hotfix` rows fire on the branch's own history, which is a fact. A branch merged with no stated next
goal is a completed delivery, and inventing an epic to fill the column is how a close-out starts work
its user never requested.

**Two rows are exempt from the offer by role, not by state.** `add` routes and transforms; `add-ux`
rewrites an instruction. Neither finishes work, so neither reports, and neither offers — a
continuation question from a router leaves the user two threads and no delivery to attach either to.