DELIVER — Value-Flow Production System

Plugin deliver from marketplace idea-to-production in agentic-underground/idea-to-production. Commands read from the repo's manifest — 1 month ago.

Skills (19)

• builder

  DELIVER's production orchestrator — ingests a ROADMAP, tiers items by a token budget, decomposes the backlog into parallel subagents, and drives each through the DEV_SYSTEM pipeline (EARS, FEATURE, TEST, IMPLEMENT, STORY). Trigger with /deliver:build (or "run DELIVER", "ship the backlog", "build eve

• check

  Verify DELIVER's external tool dependencies are installed and reachable — a ✓/✗ table by tier. Trigger with /deliver:check (or "check DELIVER prerequisites", "what build tools are installed?"). Advisory: a missing tool narrows a capability, never breaks DELIVER; --strict fails on a missing required

• code-quality

  Deep code-quality analysis across Clean Code, SOLID, DRY, Clean/Hexagonal Architecture, TDD/BDD/DDD, 12-Factor, and Pragmatic Programming. Trigger by "review my architecture", "is this clean?", "find smells", "chase coverage". Guard: ASSURE only. Also drives the /coverage-loop command (pins behaviou

• development-system-core

  Use when orchestrating lifecycle execution of an IDEATE item across SDLC steps 0-9, including stage maturity checks, quality gates, and iterative progress to Definition Of Done.

• founder-method

  The FOUNDER method — how a production house turns an idea into a product one vertical slice at a time through value-stations and value-handlers, under a five-level test contract. Trigger by "founder method", "value stations", "who owns this stage", "how does our process work". Guard: DELIVER only. U

• frontend

  Design-system skill for data-bound vanilla-JS UIs (forms, tables, dashboards, INTENT markers). Trigger with /frontend (or "build this UI", "critique this screen"). Guard: DESIGN / BUILD only; dormant during DISCOVER/IDEATE. Emits components + a11y-checked markup. phase: [DESIGN, BUILD]

• handoff-protocol

  Use when one lifecycle agent transfers value to its downstream partner and must package artifacts, risks, review status, and next instructions in a strict schema. Complements the DELIVER context sentinel protocol — sentinels carry machine-readable state, handoffs carry human-readable intent.

• ideate

  Refine a broad or vague idea into a production-ready project artefact — clarify, scope, and translate it into a brief + scoped README, then hand off to the development system. Trigger by "I have an idea", "new feature:", "turn this into a project", "now what?". Guard: IDEATE only (deliver's fallback

• lifecycle-states

  The lifecycle-state router for the DELIVER conveyor — at each maturity boundary, validate the current state's exit criteria before advancing. Covers all five boundaries: discovery, specification (EARS + Gherkin), verification (test-first + gap map), delivery (sync + commit), and production-readiness

• phase-sensor

  DEV_SYSTEM Phase Sensor for DELIVER. Detects the current development phase of each IN PROGRESS ROADMAP feature by inspecting existing artifacts, then installs the skill for that phase automatically. Triggered via PostToolUse hook on ROADMAP.md edits. Also invocable directly as /phase-sensor. phase:

• pr-review

  Run an ADVERSARIAL review of a PR or local diff → one gating verdict (PASS / NEEDS_REVISION / BLOCK). Trigger with /deliver:pr-review (or "review this PR", "is this branch mergeable?"). Guard: ASSURE only. Runs ONE composed reviewer whose lenses auto-select for the diff (or a project review-profile

• prerequisites

  Generate a project-local PREREQUISITES.md — the software the installed marketplace plugins need, why, how to install it, and what's currently missing on this machine. Trigger with /deliver:prerequisites (or "what does this project need?", "generate prerequisites"). Reads each plugin's requirements m

• reviewer-gate

  Use when a stage agent generates or updates a document and must pass it through a critical reviewer agent for professional standards and state-of-the-art quality checks.

• roadmapper

  Manage a project ROADMAP / FLEET v2 pipeline — capture an idea, write EARS specs, decompose into dependency-ordered EPIC/PLAN slices, and drive features test-first. Trigger with /deliver:roadmapper (or "add to the roadmap", "what's on the roadmap", "feature request:", "pull the next feature"). Guard

• rust-webapp-rollout

  One-shot rollout of a full-Rust web app + Vercel serverless API (shared pure core + Dioxus/WASM + the official Rust runtime) — empty dir to verified production. Trigger with /deliver:rust-webapp-rollout (or "roll out a Rust web app", "scaffold a Rust+Vercel app"). Guard: BUILD only. Ends at a deploy

• scorecard

  Keep score — deterministic, artifact-measured scorecards proving the PRODUCT you build and the MARKETPLACE that builds it improve over time (coverage, FP-rate, security verdict, tokens/wall-clock; inspection findings, self-improve PRs, portability). Trigger with /deliver:scorecard. Guard: DELIVER on

• self-improve

  Reflect on ONE marketplace element (agent/skill/command/knowledge doc) against the KAIZEN covenant and improve it — usually by self-cleaving an over-broad element or replacing restated knowledge with a reference. Trigger with /deliver:self-improve. Applies on a branch, then /deliver:pr-review, then

• value-station-handoff

  The precise input/exit contract for each value-station — written so a fresh gate-keeping agent (reviewer, security-auditor) can pick up an artifact with zero history and know what to verify. Trigger by "handoff contract", "what does done mean here", "station contract", "ready for review". phase: [cr

• vertical-slice

  Cut and drive ONE thin, end-to-end, independently shippable increment through every value-station and gate. Use whenever starting a new piece of work, when a change is getting too big to review, or when asked "what's the next slice?". Trigger phrases: "next slice", "cut a slice", "this is too big",

Slash commands (13)

• /deliver:build

  Run the DELIVER production cycle — ingest the ROADMAP, plan, tier by token budget, and drive items idea→product through the value-flow conveyor.

• /deliver:check

  Verify DELIVER's external tool dependencies are installed and reachable — a ✓/✗ table by tier (advisory; --strict to fail on a missing required tool).

• /deliver:coverage-loop

  Pin unpinned behaviour — find the behaviour least covered by tests, add the missing coordinate(s), and loop until every behaviour is pinned (100% coverage is the floor that results).

• /deliver:frontend

  Design, build, critique, or extend a data-bound vanilla-JS UI with the frontend design system — forms, tables, dashboards, cards, instruments — as a11y-checked, INTENT-marked markup.

• /deliver:inspect

  Inspect the DELIVER system itself — audit skills, agents, and knowledge for drift, gaps, and duplication; produce a severity-ranked report.

• /deliver:phase-sensor

  Detect the current development phase of each IN_PROGRESS roadmap feature and install the right skill for the next stage.

• /deliver:pr-review

  Adversarial review of a PR or local diff → a single verdict (PASS / NEEDS_REVISION / BLOCK). Runs ONE composed DELIVER reviewer whose lenses are auto-selected for the diff (or pinned by a project review-profile); composes the SECURE plugin's scan-all when present; writes PR_REVIEW.md.

• /deliver:prerequisites

  Generate a project-local PREREQUISITES.md — the software the installed marketplace plugins need, why, how to install it, and what's currently missing on this machine.

• /deliver:roadmapper

  Manage a project ROADMAP.md / FLEET v2 pipeline — capture an idea, write EARS specs, decompose into dependency-ordered EPIC/PLAN slices, and drive features through a test-first development system. The DELIVER station's front door.

• /deliver:rust-webapp-rollout

  One-shot rollout of a full-Rust web app + Vercel serverless API (shared pure core + Dioxus/WASM + official Rust runtime) — empty dir to verified production.

• /deliver:scorecard

  Keep score — emit deterministic, artifact-measured scorecards proving the PRODUCT you build and the MARKETPLACE that builds it are getting better over time. Coverage, corpus FP-rate, test/rule counts, security verdict, real tokens/wall-clock (product); inspection findings, self-improve PRs, integrit

• /deliver:self-improve

  Reflect on ONE marketplace element (agent/skill/command/knowledge doc) against the KAIZEN covenant + pillars and improve it — usually by self-cleaving an over-broad element into smaller single-purpose ones, or replacing restated knowledge with a reference. Applies on a branch → /deliver:pr-review →

• /deliver:sync-plan

  Pipe an approved plan-mode plan onto its board issue — resolve a roadmap ORDER (NNNN.SSS) → issue and write the plan into `## Plan`, preserving Summary/marker/annotations. Also the reviewer re-sync verb. Graceful no-op when the board is unreachable.

Subagents (32)

• builder-lead

  DELIVER LEAD ENGINEER — the orchestration architect of a DELIVER cycle. Ingests a complete ROADMAP, analyses the full codebase, determines the required stack, identifies shared infrastructure across roadmap items, decomposes every item into parallelisable tasks, estimates token budgets, and produces

• coverage-loop-agent

  Automated behaviour-pinning agent. Finds the behaviour least pinned by tests (the file with the most unpinned lines), adds the missing coordinate(s) that locate its correct implementation, and loops until every behaviour is pinned or the user stops. 100% coverage is the floor that results, never the

• ds-step-0-plan

  Creates and maintains the implementation plan artifact with checklist and resumption instructions. Spawned by the lifecycle-orchestrator or DELIVER at the start of a new roadmap item's lifecycle.

• ds-step-1-ears

  Produces EARS specification updates with unique requirement IDs and traceability hooks. Spawned after step-0-plan completes and PLAN_COMPLETE sentinel is present.

• ds-step-2-feature-docs

  Writes .feature behavior documentation with happy, unhappy, and abuse scenarios mapped to EARS IDs. Spawned after EARS_COMPLETE sentinel is present and EARS-REVIEWER has passed.

• ds-step-3-tests

  Authors failing test suite aligned to EARS and Gherkin contracts, without implementing production code. Spawned after FEATURE_COMPLETE sentinel is present and BDD-REVIEWER has passed.

• ds-step-4-first-test-run

  Runs full test suite to confirm expected new failures and document the feature gap map. Spawned after TESTS_WRITTEN::RED sentinel is present.

• ds-step-5-implementation

  Implements minimum production code to satisfy failing tests while preserving architecture and quality constraints. Spawned after GAP_MAP_COMPLETE sentinel is present and TEST-DESIGN-REVIEWER has passed.

• ds-step-6-green-run

  Drives full test suite to green, validates regression-free status, and confirms behavior intent is met. Spawned after IMPL_COMPLETE::GREEN sentinel is present.

• ds-step-7-sync

  Synchronizes branch with upstream and revalidates green status after conflict resolution. Spawned after GREEN_RUN_COMPLETE sentinel is present.

• ds-step-8-commit-message

  Produces structured commit narrative with motivation, scope, testing evidence, and roadmap linkage. Spawned after SYNC_COMPLETE sentinel is present.

• ds-step-9-commit-push

  Finalizes delivery. Standalone cycle — executes commit + push, updates roadmap/plan completion metadata, returns delivery evidence. Engine PLAN-scope (FLEET) — commits the green slice to the build branch and emits DELIVERY_COMPLETE keyed to branch HEAD for the engine to land (NO push, NO roadmap/STA

• ds-step-story-tests

  Authors story-level and end-to-end (E2E) tests that exercise the feature through its real interface — browser, CLI, or API. Spawned after IMPL_COMPLETE::GREEN sentinel is present and before ds-step-7-sync. Owner of STORY_PROVEN sentinel.

• flaky-test-fixer

  Diagnoses and eliminates flaky tests. A flaky test is one that sometimes passes and sometimes fails without any code change. Root causes are: arbitrary timing waits (waitForTimeout, sleep), implicit async ordering assumptions, shared mutable state between tests, and race conditions in the production

• founder

  The COO orchestrator of the production house. Invoke FOUNDER (subtype FOUNDER_COO) when you need to turn an idea into a disciplined, value-stationed path to product — one vertical slice at a time. FOUNDER does not write domain code itself; it discovers the local build system (`deliver`) and design s

• handler-ansible

  DELIVER VALUE_HANDLER for Ansible / infrastructure-as-code projects. Expert in idempotent playbooks and roles, FQCN modules over raw `command`/`shell`, `ansible-vault` for secrets, Molecule + `ansible-lint` + `--syntax-check` gating, check-mode/idempotence proof, and the privilege-boundary and authe

• handler-architect

  DELIVER VALUE_HANDLER for application architecture decisions. Chooses the architectural pattern (Hexagonal/Ports-Adapters, Clean Architecture, Layered, Event-Driven, CQRS, Pipeline/Filter, Modular Monolith, Microservices, MVC/MVVM, Repository) that fits a given EARS specification, Gherkin scenarios,

• handler-css

  DELIVER VALUE_HANDLER for CSS and SCSS projects. Expert in CSS3, SCSS/Sass, CSS custom properties, BEM, responsive design, accessibility (WCAG 2.1), CSS-in-JS patterns, and visual regression testing. Spawned by TEST-AGENT, IMPLEMENT-AGENT, and STORY-AGENT during DELIVER pipeline phases when the proj

• handler-fastapi

  DELIVER VALUE_HANDLER for FastAPI projects. Expert in FastAPI, Pydantic v2, SQLAlchemy 2.0, Alembic, httpx, pytest-asyncio, and Python async API testing patterns. Spawned by TEST-AGENT, IMPLEMENT-AGENT, and STORY-AGENT during DELIVER pipeline phases when the project stack includes FastAPI. Carries t

• handler-github-actions

  DELIVER VALUE_HANDLER for GitHub Actions CI/CD-as-code. Expert in declarative idempotent workflows, full-commit-SHA action pinning, least-privilege explicit `permissions:`, OIDC over long-lived secrets, reusable/composite workflows, and the `actionlint` + `act` dry-run gate. Spawned by TEST-AGENT, I

• handler-js

  DELIVER VALUE_HANDLER for JavaScript and TypeScript projects. Expert in Node.js 18+, ES2022+, TypeScript 5+, Jest, Vitest, Testing Library, ESM, and standard JS/TS testing patterns. Spawned by TEST-AGENT, IMPLEMENT-AGENT, and STORY-AGENT during DELIVER pipeline phases when the project stack includes

• handler-playwright

  DELIVER VALUE_HANDLER for E2E and story tests using Playwright. Expert in Playwright (npx playwright test), page object model, accessibility testing, visual regression, and cross-browser testing. Spawned by STORY-AGENT during DELIVER Phase 5 when the project has a web UI, REST API surface, or any us

• handler-python

  DELIVER VALUE_HANDLER for Python projects. Expert in Python 3.10+, pytest, pytest-bdd, pytest-cov, FastAPI, Django, Flask, SQLAlchemy, Pydantic, and standard Python testing patterns. Spawned by TEST-AGENT, IMPLEMENT-AGENT, and STORY-AGENT during DELIVER pipeline phases when the project stack include

• handler-react

  DELIVER VALUE_HANDLER for React projects. Expert in React 18+, TypeScript, React Testing Library, user-event, Jest/Vitest, component testing patterns, hooks, context, and accessibility-first testing. Spawned by TEST-AGENT, IMPLEMENT-AGENT, and STORY-AGENT during DELIVER pipeline phases when the proj

• handler-roadmap-decomposition

  DELIVER VALUE_HANDLER for roadmap-item decomposition / atomic job breakdown. Expert in INVEST right-sizing, vertical-slice carving, EARS-scoped jobs, topological dependency-graph ordering (NetworkX / Kahn's algorithm), shared-infrastructure detection, and the DELIVER PHASE_POOL (Phase 0→6) + model-t

• handler-rust-tauri

  DELIVER VALUE_HANDLER for Rust + Tauri desktop apps. Expert in Tauri v2 (the `src-tauri/` IPC adapter crate, `tauri.conf.json`, capability allowlists, `#[tauri::command]` boundaries, the trusted-Rust / untrusted-WebView trust boundary), with the pure domain core deferred to handler-rust and a `cargo

• handler-rust-webapp

  DELIVER VALUE_HANDLER for the RUST_WEBAPP_API class — a full-Rust vertical slice with a shared pure domain core, a Dioxus/WASM web frontend, and a Rust serverless function on Vercel's official Rust runtime, deployed prebuilt and verified in production. Spawned by IMPLEMENT-AGENT and STORY-AGENT when

• handler-rust

  DELIVER VALUE_HANDLER for Rust projects. Expert in Rust 2021/2024, a pure-domain-core architecture, typed `thiserror` errors, parse-don't-validate construction, `proptest` invariants, and the `fmt --check` + `clippy -D warnings` + `test --workspace` gate. Spawned by TEST-AGENT, IMPLEMENT-AGENT, and

• handler-vanilla-js

  DELIVER VALUE_HANDLER for vanilla-JavaScript front-end projects. Expert in ES2022+ modules, the DOM API, event delegation, custom elements, CSS custom properties, one-way data binding, and accessibility-first DOM testing with @testing-library/dom + user-event (no framework, no build step). Spawned b

• inspector

  DELIVER INSPECTOR — on-demand agent that audits the DELIVER plugin it ships in (its skills, agents, knowledge, commands, and hooks under ${CLAUDE_PLUGIN_ROOT}), and the companion plugins (secure, publish) when present. Triggered by user command only ("inspect DELIVER" / "run the inspector"). Reads e

• lifecycle-orchestrator

  Orchestrates IDEATE items across SDLC stages 0-9, enforces Definition Of Done, invokes stage agents and reviewer checks, and loops until all quality gates pass. Integrates with DELIVER's PHASE_POOL by naming and sequencing the ds-step-* agents explicitly.

• reviewer

  DELIVER REVIEWER — the composable quality-gate panel invoked at every phase transition in the conveyor. Receives a role parameter that determines which specialised reviewer persona to embody. Roles: EARS-REVIEWER, SMU-REVIEWER, BDD-REVIEWER, COVERAGE-REVIEWER, TEST-DESIGN-REVIEWER, DESIGN-REVIEWER,

MCP servers (1)

• context7

  runs: npx -y @upstash/[email protected]

Hooks (2)

• PostToolUse

  bash ${CLAUDE_PLUGIN_ROOT}/skills/phase-sensor/scripts/check-phase.sh 2>/dev/null || true

• SessionStart

  bash ${CLAUDE_PLUGIN_ROOT}/hooks/inject-kaizen.sh 2>/dev/null || true

Similar plugins