stack-turbo-nest-react

agents-foundation — Claude Code plugin marketplace

A reusable delivery foundation for Claude Code, packaged as a plugin marketplace. Install it into any project to get a team of role agents, a work/ markdown kanban, and deterministic gates that keep the board honest.

📄 Design article: Agents create and judge. Code enforces. — the rationale, architecture, and how it compares to prompt-canvas methods like SPDD. (GitHub Pages, served from /docs.)

It ships two plugins — install one or both:

• delivery-team — the agnostic process: role agents (planner, reviewer, docs, qa, product-delivery-manager), the work/ kanban, the deterministic board/docs/verdict gates, and the /delivery-team:init scaffolder. Carries how work flows, not which stack you use.
• stack-turbo-nest-react — an opinionated stack layer (v0, as-built): NestJS + React/Turborepo implementer agents and their conventions. Depends on delivery-team. The stack-* prefix is the convention for future stacks.

How it works

Agents create and judge; deterministic steps apply state; hooks enforce it. The reviewer returns a structured verdict → /delivery-team:apply-verdict ticks the Acceptance Criteria and moves the task → a board gate refuses done/ without a verdict + ticked criteria → a docs gate refuses a migration without an ERD/docs update. Bookkeeping is code, not an agent's memory.

Gates run in two layers: agent-time PreToolUse hooks ship in the plugin (resolved via ${CLAUDE_PLUGIN_ROOT}); the commit-time git gate is wired by /delivery-team:init, which copies the validators into the consumer repo because git hooks can't see ${CLAUDE_PLUGIN_ROOT}.

Roles & org chart

The team splits into a process layer (delivery-team, agnostic) and a stack layer (stack-turbo-nest-react, opinionated). The Delivery Manager orchestrates: the planner specifies, implementers build, docs and QA run alongside when warranted, and the reviewer is the gate.

flowchart TD
  DM["Delivery Manager<br/>(orchestrator)"]
  PL["Planner<br/>PO + Tech Lead"]
  RV["Reviewer<br/>Quality Gate"]
  subgraph ENG["Engineering — stack layer"]
    BE["Backend"]
    FE["Frontend"]
    IN["Platform / DevOps"]
  end
  DOC["Technical Writer"]
  QA["QA<br/>(specialist)"]
  DM --> PL
  DM --> ENG
  DM --> DOC
  DM --> QA
  DM --> RV
  PL -. specifies tasks .-> ENG
  ENG -. implements + unit/e2e .-> RV
  QA -. load / journeys / resilience .-> RV
  DOC -. living docs .-> RV
  RV -. "approve / changes-requested" .-> DM

Agent	Persona	Layer	Role
planner	Product Owner + Tech Lead	delivery-team	turns a goal into a well-formed task (Spec + Plan + Todo + Verdict + Log)
reviewer	Quality Gate	delivery-team	judges the diff vs the contract; its verdict drives apply-verdict + the gate
docs	Technical Writer	delivery-team	living C4 docs and ERDs
qa	QA Engineer (specialist)	delivery-team	load / journeys / resilience / coverage — not the per-feature path
product-delivery-manager	Delivery Manager	delivery-team	reads the board, dispatches, integrates, ships
backend	Software Engineer	stack-turbo-nest-react	server-side feature work + its own tests
frontend	Software Engineer	stack-turbo-nest-react	UI/app feature work + its own tests
infra	Platform / DevOps	stack-turbo-nest-react	platform / CI / deploy tasks

Backlog replenishment (/delivery-team:task-promote) and verdict application (/delivery-team:apply-verdict) are deterministic skills, not agents — bookkeeping is code, not an agent's discretion.

Structure

agents-foundation/
├── .claude-plugin/marketplace.json     # marketplace manifest (lists the plugins)
└── plugins/
    ├── delivery-team/                  # Plugin A — agnostic process
    │   ├── .claude-plugin/plugin.json
    │   ├── agents/ commands/ hooks/ scripts/ rules/ templates/
    │   └── README.md
    └── stack-turbo-nest-react/         # Plugin B — opinionated stack (v0)
        ├── .claude-plugin/plugin.json
        ├── agents/ rules/
        └── README.md