advanceAdvance the project to the next SDLC phase. Reads projectId from vibeflow.config.json, invokes the sdlc_advance_phase MCP tool, and surfaces the phase-gate's pass/fail reason. Supports humanOverrideNote for advancing under HUMAN_APPROVAL_REQUIRED consensus (Sprint 17-C).
apply-arbiter-patchReads the patch manifest produced by consensus-arbiter, shows a git-style diff summary, archives every target file to .vibeflow/archive/ (a timestamped version trail) AND snapshots it for one-command rollback before touching anything, asks for explicit operator confirmation (unless --yes), and appli
arch-guardrailsValidates proposed changes against architectural rules — layering, allowed dependencies, forbidden imports, naming conventions. Use before merging or when reviewing a refactor that touches cross-module boundaries. Blocks work that violates ADR-recorded constraints.
architecture-bootstrapThe ARCHITECTURE-phase author-side guide — the counterpart to design-bootstrap. architecture-validator VALIDATES docs/architecture.md but nothing authors it, so a greenfield ARCHITECTURE phase had no skill to produce the doc. This authors docs/architecture.md (logical/component architecture, data mo
architecture-validatorValidates a proposed software architecture against domain policies, the approved PRD, and (optionally) the current codebase's import graph. Writes .vibeflow/reports/architecture-report.md and one .vibeflow/reports/adr-NNN-<slug>.md per accepted decision. Blocks advance if any criticalPolicyViolation
bible-assembleAssembles the Product Bible into one coherent, navigable, shareable export at project end (Sprint 71) — the final "we shipped, here's the whole book" deliverable. Reads bible-status, builds a curated index (docs/product-bible/README.md) with a per-category table of contents linking every canonical d
bible-intakeProduct Bible ingestion (Sprint 69) — review the input documents you bring INTO a project (a vision doc, Gartner/analyst summaries, competitor decks, an existing PRD/spec/SRS, persona research, an API style guide, …) and file them into the bible. It discovers candidate inputs, classifies each into t
bible-updateGrows the Product Bible's LIVING documents at a phase boundary (Sprint 70) so they accrete instead of going stale. For the current SDLC phase, it reads that phase's artifacts (the PRD/design-spec/architecture/test-strategy + the increment diff) and appends what's new into each living bible-native do
brownfield-intakeThe brownfield on-ramp. After onboard on an existing codebase, this fingerprints the repo (languages, frameworks, structure, hotspots, tech debt via codebase-intel) so you don't have to explain the architecture, then ASKS how you want to define the work — describe it in plain language, point to an e
business-rule-validatorExtracts business rules from the PRD as a structured catalog, generates a test case per rule, and runs semantic gap analysis against existing tests. Produces business-rules.md + br-test-suite.test.ts + semantic-gaps.md. Gate contract — zero uncovered P0 rules. PIPELINE-1 step 4.
chaos-injectorInjects controlled failures (network, dependency, clock, resource) into a running test environment at one of three intensity profiles (gentle/moderate/brutal), observes whether the system degrades gracefully, and computes a resilience score. Every injection has a mandatory recovery step; blast-radiu
checklist-generatorEmits context-aware review checklists (PR review, release, feature sign-off, accessibility) driven by platform (web / mobile / backend / all) and enriched with scenario-set.md coverage gaps. Every item must be verifiable (action + source of truth + binary outcome) — vague prose is rejected. PIPELINE
component-test-writerGenerates component-level unit tests from source files and (optionally) a scenario-set.md. Framework-aware (vitest | jest) via repo-fingerprint, never guesses. Enforces strict Arrange-Act-Assert structure, preserves every scenario as a test case, and refuses to overwrite existing tests. PIPELINE-1 s
consensus-arbiterReads the verdict + reviewer suggestions from a consensus session, evaluates each suggestion against the current SDLC phase + domain, and emits diff-first patches for the ones that should APPLY. Never writes to source files — only to `.vibeflow/state/patches/<session>/` and `.vibeflow/reports/arbite
consensus-orchestratorOrchestrates multi-AI review process. Coordinates Claude, ChatGPT (codex CLI), and Gemini (gemini CLI) reviews. Each CLI's verdict is appended to the session jsonl the aggregator reads, per-CLI timeout (consensus.cliTimeoutSeconds, default 90) so the aggregator never falls through to its 600s global
consensus-specialistDispatches a phase-specific specialist subagent (prd-rewriter, adr-author, test-strategy-refiner, coverage-gap-filler, design-spec-refiner, or runbook-editor) to deeply rewrite an artifact based on multi-AI reviewer feedback. Diff-first contract — never writes to source directly. Use when the arbite
contract-test-writerGenerates consumer + provider contract tests from an OpenAPI (2.x/3.x) or GraphQL SDL file, and diffs the current spec against the previous one to classify breaking changes (MAJOR/MINOR/PATCH). Emits contract.test.ts + contract-report.md. MAJOR diffs block the release gate. PIPELINE-1 step 4.
coverage-analyzerParses vitest/jest/istanbul coverage JSON, rolls up line/branch/function coverage to the requirement level via RTM, ranks uncovered gaps by risk, and enforces domain-specific thresholds. Gate contract — every P0 requirement has 100% coverage of its mapped lines, overall coverage meets the domain thr
cross-run-consistencyRuns the same test N times in one session, diffs the outputs, and classifies non-determinism by root cause. Complements observability's historical flake tracking with an immediate "does this test agree with itself right now?" answer. Gate contract — P0 scenarios must be strict-consistent (same outpu
decision-recommenderProduces structured decision packages (problem statement + options + trade-offs + recommendation + effort estimate) from any findings report. Used when a decision needs framing, not auto-gating. Consumes learning-loop-engine recommendations + L2 skill reports + team context, and emits decision-packa
deploy-verifierVerify a completed deployment by cross-checking the CI pipeline status (dev-ops MCP) + service health dashboard (observability MCP) + optional smoke-test endpoints. Auto-satisfies the DEPLOYMENT phase's `deployment.verified` and `health.checks.passed` exit criteria when every declared check returns
design-bootstrapThe DESIGN-phase guide. Produces the design artifacts (design spec, design tokens, wireframes) that DESIGN consensus reviews. It classifies whether the increment is UI-facing, then ASKS the operator which design source — Claude-native (zero-setup attractive accessible UI spec + tokens + wireframes),
e2e-test-writerGenerates end-to-end tests from scenario-set.md. Web target → Playwright; mobile target → Detox. Every test imports a Page Object (never touches raw selectors), uses a named auth strategy, waits on observable conditions (never sleeps), and preserves scenario ids as trace anchors. Gate contract — zer
environment-orchestratorProduces env-setup.md — a reproducible, teardown-safe environment recipe for a given test profile (unit/integration/e2e/uat/perf) and platform. Assembles components from a catalog, pins image versions, declares healthchecks, and never inlines secrets. Gate contract — every component has a healthchec
flow-statusShows current VibeFlow project status including SDLC phase, pending tasks, quality metrics, and recent review results. Use when asking about project progress. Renamed from `status` in v2.20.0 to avoid colliding with Claude Code's built-in `/status` (usage/quota).
frontend-render-checkActually stands up the front-end and verifies it RENDERS and MATCHES THE DESIGN — the step that ends the "dark tunnel" where a UI ships unit-tested but never once rendered or compared to the design. Detects the web framework, boots the dev server (catching startup bugs like a broken alias on a path
input-validation-matrixFor every input field in the UI, generates and runs a systematic data-validation test matrix — required/presence, type (numeric vs alphanumeric vs email/date/currency), boundary (min/max value + length, just-inside/just-outside), format (regex/IBAN/phone/precision), type-mismatch, and injection-safe
integrateThe merge point for parallel work-streams. When teams develop features as independent per-branch work-streams (streams.enabled), each feature reaches its own DEPLOYMENT readiness in isolation — but the combined product was never verified together. Run this on the integration/release branch AFTER fea
integration-verifierFor a full-stack increment, proves the front-end actually talks to a REAL back-end end-to-end with seeded test data — locally, no deployed staging required. Stack-agnostic (Node / Python / Go / .NET / Java): boots the back-end, seeds deterministic test data (via test-data-manager), points the real f
invariant-formalizerTurns natural-language invariants from business-rules.md / the PRD into machine-checkable predicates (Zod refinements, runtime guards, Z3 SMT constraints, property-based generators). Emits invariant-matrix.md + invariants.ts. Gate contract — zero unformalized P0 invariants. PIPELINE-3 step 2.
learning-applyCloses the L3 action gap — turns learning-loop-engine recommendations into concrete, diff-first, operator-confirmed changes. Reads .vibeflow/reports/consensus-learning-report.md and classifies each finding into three lanes — config-tune (diff-first patch to vibeflow.config.json), template-route (rec
learning-loop-engineConsumes the full history of reports from every L2 skill, detects recurring patterns, traces production bugs back to missed test opportunities, detects quality drift across sprint baselines, mines the cross-session consensus telemetry for slow-converging phases and recurring reviewer themes, and rec
loop-statusThe autonomous-loop dashboard. Consolidates every loop surface — phase-runner progress, auto-apply outcomes + per-key revert rates, cooled-down keys, the armed revert watch, learning-report findings, and the opt-in cross-project signal — into one read-only view, and writes a durable .vibeflow/report
mobile-stability-runnerMobile crash & stability testing for a UI increment on iOS/Android. Expo-aware — auto-detects Expo (managed/bare) and picks the runner (Expo → Maestro on Expo Go / dev-client, bare React Native → Detox). Runs a crash-focused battery beyond functional E2E — cold-start smoke, background/foreground, lo
mutation-test-runnerGenerates code mutations from a fixed operator catalog, runs the test suite against each mutant, and computes the mutation score. A surviving mutant points directly at an assertion that doesn't actually check what it claims. Gate contract — zero surviving mutants in P0 code + domain-specific mutatio
observability-analyzerParses HAR files, Playwright traces, browser console logs, and Chrome DevTools Protocol exports, detects anomalies against a fixed catalog, and emits observability-report.md. Complementary to the observability MCP (which tracks cross-run metrics) — this skill looks at the artifacts a single run prod
onboardOnboard a new VibeFlow project (renamed from init in v2.19.0 to avoid colliding with Claude Code's built-in /init). Sets up vibeflow.config.json with domain and tech stack, creates the .vibeflow/ state directory, and records an optional brownfield fingerprint. Runs exactly once at the start of REQUI
phase-runnerEnd-to-end phase orchestrator. For the current SDLC phase, runs every registered analyzer, then drives a real cross-AI consensus verdict HEADLESSLY via hooks/scripts/consensus-run.sh (runs the codex/gemini reviewer CLIs + finalises verdict.json — no dependency on the disable-model-invocation consens
prd-quality-analyzerAnalyzes PRD documents for ambiguity, conflicts, and missing flows. Produces testability score (0-100). Writes a report to .vibeflow/reports/prd-quality-report.md and a cost-avoidance breakdown to .vibeflow/reports/prd-cost-avoidance.md. Use when reviewing requirements, validating PRDs, or before st
product-bibleThe Product Bible — the curated, living document corpus a project accumulates across its whole lifecycle (business/GTM → product → engineering): vision, competitive intelligence, personas, glossary, domain model, UX principles, API standards, Rule DSL, AI strategy, ADRs, PRDs/SRSs, test strategy, ro
quality-gatesRun the project's lint + typecheck + unit-test commands (resolved from vibeflow.config.json.tech.*) and auto-satisfy the DEVELOPMENT phase's `quality.gates.passed` exit criterion when all three exit 0. Pairs with consensus-orchestrator, which satisfies `code.reviewed` on APPROVED verdicts. Together
reconciliation-simulatorSimulates concurrent ledger operations against a canonical set of financial invariants (double-entry, conservation, sign convention, monetary precision), detects balance drift under contention, and generates reproducible reconciliation test cases. Financial-domain-only — blocks for every other domai
regression-test-runnerRuns the project's existing test suite at the scope appropriate for the trigger (smoke on PR, full on release, incremental on file change), diffs results against regression-baseline.json, classifies every test as passing / new-failure / still-failing / fixed / flaky, and enforces a P0 pass-rate gate
release-decision-engineAggregates all quality signals into a deterministic release decision (GO/CONDITIONAL/BLOCKED). Uses domain-specific weighted scoring. Always runs LAST in staging-uat and release-decision pipelines. Use when deciding whether a release is safe.
repo-fingerprintProduces a brownfield repository fingerprint — languages, frameworks, test runners, build tools, module layout, and risk hotspots. Run once when adopting VibeFlow on an existing codebase; the fingerprint is consumed by planning and test-strategy skills. Never assumes frameworks — detects them.
streamsThe parallel team-work dashboard. When streams.enabled is on, VibeFlow keys state per git branch so multiple developers (each on their own branch / git worktree) progress independent SDLC work-streams that never clobber each other. This skill consolidates every locally-visible work-stream — its bran
test-data-managerGenerates deterministic test data factories and fixtures from TypeScript types, Zod schemas, or JSON Schema. Seeded RNG means same seed → same data on every machine. Injects edge cases (boundary values, nulls, unicode, empty collections) from a canonical catalog and respects declared invariants. Pro
test-priority-engineRanks the test suite by risk so the highest-leverage tests run first. Consumes changed files + regression-baseline.json + ob_track_flaky history, applies a deterministic risk model, and emits priority-plan.md. Gate contract — every affected P0 test appears in the plan, regardless of mode budget. PIP
test-result-analyzerClassifies test failures into bug / flaky / environment / test-defect, links each failure back to its RTM requirement, and generates ready-to-import backlog tickets for the real bugs. Consumes uat-raw-report.md or raw runner JSON via ob_collect_metrics. Gate contract — every failure is classified (n
test-strategy-plannerCreates comprehensive test strategy, scenario set, and requirements traceability matrix from PRD. Writes .vibeflow/reports/scenario-set.md (universal input for ALL downstream test skills) and .vibeflow/reports/test-strategy.md. Must run before any test writing skill.
traceability-engineMaps PRD requirements to test scenarios to source code. Detects untested requirements, orphan tests, and stale traces. Writes the Requirements Traceability Matrix to .vibeflow/reports/rtm.md and a gap summary to .vibeflow/reports/traceability-gaps.md. Use for coverage gap analysis, requirement valid
uat-executorExecutes UAT scenarios against a live staging environment, walks automated steps via a runner (playwright/detox) and human-in-the-loop steps via prompts, collects evidence (screenshots + timings + console) on every step, and emits uat-raw-report.md. Gate contract — every failed step must carry evide
visual-ai-analyzerUses Claude vision to inspect screenshots for layout regressions, accessibility issues, typography drift, and design fidelity. Complementary to design-bridge's db_compare_impl (which does dimension + byte identity) — this skill actually SEES the images and describes what changed. Gate contract — zer