bee

Add a new phase to the current spec's phases.md and STATE.md

Archive the current spec to .bee/archive/, reset STATE.md, and bump plugin version

Convert audit findings into actionable specs -- generates bee:new or bee:quick tasks from AUDIT-REPORT.md

Run a comprehensive code audit with specialized agents -- security, errors, database, architecture, API, frontend, performance, testing, and end-to-end bug detection

Show diff summary and create a commit with user approval

Smart compact -- preserve bee context, then compress conversation

Create a custom project-local agent extension for bee

Create a custom project-local skill extension for bee

Launch a guided codebase-grounded discussion to clarify requirements before creating a spec

Run end-of-day integrity check with 4 parallel audits

Execute a planned phase with wave-based parallel TDD implementation

Read most recent review output and apply confirmed findings using fixer agents

Initialize BeeDev for a project -- detect stack, create .bee/, configure workflow

View and manage user preferences stored in .bee/user.md

Create a new feature specification through conversational discovery

Plan all unplanned phases sequentially with plan review and cross-plan consistency check

Create a detailed execution plan for a spec phase with researched tasks and wave grouping

Review a phase plan (TASKS.md) against the original spec to find coverage gaps and discrepancies

Show current BeeDev project state and suggest next action

Execute a quick task without the full spec pipeline — just describe, execute, commit

Re-run codebase context extraction, overwriting CONTEXT.md with fresh analysis

Resume BeeDev work from where you left off with full context restoration

Context-aware implementation review -- full spec compliance or ad-hoc code review with four-agent pipeline

Review current phase implementation against spec, standards, and quality checklist

Execute all plan-reviewed phases autonomously with review loops, decision logging, and final implementation review

Generate and run Playwright E2E tests for the current feature or ad-hoc scenarios

Generate manual test scenarios and verify with developer

Update bee statusline and clean up legacy local copies

Audits API design -- endpoint validation, response consistency, error formats, rate limiting, CORS

Audits codebase architecture -- separation of concerns, code organization, duplication, dependency patterns

Traces end-to-end feature flows to find bugs that category-specific auditors miss -- follows data from UI to DB and back

Independently validates audit findings -- reads actual code, verifies evidence, classifies as CONFIRMED / FALSE POSITIVE / NEEDS CONTEXT

Merges validated findings from all audit agents into a structured AUDIT-REPORT.md with severity grouping and recommendations

Detects bugs, logic errors, and security issues in code

Scans codebase and extracts observed patterns into CONTEXT.md

Audits database layer -- schema design, queries, migrations, indexes, data integrity, N+1 patterns

Scans codebase to ground a discussion, then produces structured discussion notes

Audits codebase for missing error handling, unhandled exceptions, and crash-prone patterns

Independently validates review findings as REAL BUG, FALSE POSITIVE, or STYLISTIC

Applies minimal, targeted fixes for confirmed review findings

Audits frontend code -- missing states, memory leaks, accessibility, UX patterns, component health

Full-stack TDD implementer for Bee tasks. Writes failing tests first, then minimal implementation, then refactors.

Verifies STATE.md matches reality on disk -- files exist, statuses consistent, no orphans

Reviews code against established project patterns

Audits codebase for performance issues -- bundle size, caching, async bottlenecks, resource optimization

Decomposes phases into tasks with acceptance criteria and groups into parallel waves

Reviews code against spec and acceptance criteria, or reviews planned tasks against spec requirements with coverage matrix

Reviews TASKS.md plan against spec.md and requirements.md to find coverage gaps and discrepancies

TDD-enforced implementer for quick tasks. Reads plan file for acceptance criteria, writes failing tests first, then minimal implementation.

Researches codebase patterns, Context7 docs, and reusable code for implementation tasks

Audits codebase for security vulnerabilities -- OWASP Top 10, auth bypass, injection, secrets exposure

Reviews spec documents for completeness, consistency, clarity, and scope before implementation planning

Interactive requirements gathering through targeted questions and visual analysis

Writes specification document and phase breakdown from gathered requirements

Reviews code against stack-specific best practices loaded dynamically from skill files

Detects bugs, logic errors, and security issues in Laravel + Inertia + Vue code

TDD implementer for Laravel + Inertia + Vue projects. Writes failing tests first, then minimal implementation, then refactors. Runs pint, phpstan, and parallel tests as compliance gate.

Reviews code against established project patterns for Laravel + Inertia + Vue projects

Audits test suite health -- runs tests, detects stale tests, identifies coverage gaps

Generates manual test scenarios with stack-aware edge cases

Audits test coverage -- missing tests, stale tests, coverage gaps, test quality, testing patterns

Core audit knowledge -- severity definitions, finding format, output templates, validation rules. Used by all audit agents.

Context7 MCP usage patterns for framework documentation lookups

BeeDev workflow rules -- TDD mandatory, disk-is-truth, no auto-commit. Spec-driven development with phase lifecycle.

Use when project uses NestJS with RabbitMQ microservices. Covers transport config, message/event patterns, manual ACK, CQRS, hybrid apps, dead letters, health checks, and testing. Detection: check package.json for @nestjs/microservices + amqplib or amqp-connection-manager.

shadcn/ui component library conventions -- use when project has components.json or @/components/ui/ directory. Covers component usage, customization, theming, composition patterns, and common pitfalls.

Code review methodology -- checklist, severity levels, categories, false positive rules

Angular 19+ standalone conventions with signals, zoneless change detection, inject(), reactive forms, and modern patterns

Claude Code plugin (bee) development conventions and patterns

Kotlin Multiplatform + Compose Multiplatform conventions with Voyager, Koin, Ktor, Kotlinx Serialization

Laravel 12 + Inertia 2 + React 19 + TailwindCSS conventions and patterns

Laravel 12 + Inertia 2 + Vue 3.5 + TailwindCSS conventions and patterns

NestJS backend conventions and patterns

Next.js 15 App Router conventions and patterns

React Native + Expo managed workflow conventions and patterns

React 19 standalone conventions and patterns with Vite, React Router v7, TypeScript strict mode

Vue 3.5 standalone conventions with Vite, Vue Router 4, Pinia, TypeScript

Universal backend standards -- API design, database, migrations, query optimization

Universal frontend standards -- component architecture, accessibility, responsive design, CSS methodology, design quality. Applies to ALL frontend stacks automatically.

Universal coding standards -- naming, DRY, KISS, error handling, git conventions

Testing standards -- TDD mandatory, test naming, mocking strategy, gap analysis

Use when writing or reviewing Playwright end-to-end tests. Covers Page Object Model, fixtures, selectors, assertions, authentication, network mocking, visual testing, and test organization. Invoke explicitly -- not loaded by default.

32 hooks across 8 events