bee-default

Interactive design refinement using Socratic method

Run comprehensive parallel code review with all 6 specialized reviewers

Organize and create atomic git commits with intelligent change grouping

Create a handoff document capturing current session state for future resumption

Execute plan in batches with review checkpoints

Autonomous two-phase codebase exploration with adaptive agents

Proactive requirements gathering through structured user interview

Run lint checks and dispatch parallel agents to fix all issues

Transform a markdown file into a standalone, styled HTML page

Generate an Ops Update Guide from git diff between two refs

Resume work from a handoff document after context clear

Create isolated git worktree with interactive setup

Create detailed implementation plan with bite-sized tasks

Correctness Review: reviews domain correctness, business rules, edge cases, and requirements. Uses mental execution to trace code paths and analyzes full file context, not just changes. Runs in parallel with bee:code-reviewer, bee:security-reviewer, bee:test-reviewer, bee:nil-safety-reviewer, and bee:consequences-reviewer for fast feedback.

Foundation Review: Reviews code quality, architecture, design patterns, algorithmic flow, and maintainability. Runs in parallel with bee:business-logic-reviewer, bee:security-reviewer, bee:test-reviewer, bee:nil-safety-reviewer, and bee:consequences-reviewer for fast feedback.

Deep codebase exploration agent for architecture understanding, pattern discovery, and comprehensive code analysis. Uses Opus for thorough analysis vs built-in Explore's Haiku speed-focus.

Ripple Effect Review: traces how code changes propagate through the codebase beyond the changed files. Walks caller chains, consumer contracts, shared state, and implicit dependencies to find breakage invisible in isolated review. Runs in parallel with bee:code-reviewer, bee:business-logic-reviewer, bee:security-reviewer, bee:test-reviewer, and bee:nil-safety-reviewer for fast feedback.

Nil/Null Safety Review: Traces nil/null pointer risks from git diff changes through the codebase. Identifies missing guards, unsafe dereferences, fatal error paths, and API response consistency in PHP and TypeScript. Runs in parallel with bee:code-reviewer, bee:business-logic-reviewer, bee:security-reviewer, bee:test-reviewer, and bee:consequences-reviewer.

Safety Review: Reviews vulnerabilities, authentication, input validation, and OWASP risks. Runs in parallel with bee:code-reviewer, bee:business-logic-reviewer, bee:test-reviewer, bee:nil-safety-reviewer, and bee:consequences-reviewer for fast feedback.

Test Quality Review: Reviews test coverage, edge cases, test independence, assertion quality, and test anti-patterns across unit, integration, and E2E tests. Runs in parallel with bee:code-reviewer, bee:business-logic-reviewer, bee:security-reviewer, bee:nil-safety-reviewer, and bee:consequences-reviewer for fast feedback.

Implementation Planning: Creates comprehensive plans for engineers with zero codebase context. Plans are executable by developers unfamiliar with the codebase, with bite-sized tasks (2-5 min each) and code review checkpoints.

Socratic design refinement - transforms rough ideas into validated designs through structured questioning, alternative exploration, and incremental validation.

Flaky test fix pattern - replaces arbitrary timeouts with condition polling that waits for actual state changes.

Multi-layer validation pattern - validates data at EVERY layer it passes through to make bugs structurally impossible, not just caught.

Concurrent investigation pattern - dispatches multiple AI agents to investigate and fix independent problems simultaneously.

Controlled plan execution with human review checkpoints - loads plan, executes in batches, pauses for feedback. Supports one-go (autonomous) or batch modes.

Autonomous two-phase codebase exploration - first discovers natural perspectives (layers, components, boundaries), then dispatches adaptive deep-dive explorers based on what was discovered. Synthesizes findings into actionable insights.

Branch completion workflow - guides merge/PR/cleanup decisions after implementation is verified complete.

Proactive requirements gathering - systematically interviews the user to uncover ambiguities, preferences, and constraints BEFORE implementation begins.

Parallel lint fixing pattern - runs lint checks, groups issues into independent streams, and dispatches AI agents to fix all issues until the codebase is clean.

External code review via OpenCode CLI - sends diff to a second AI model (e.g., Qwen3-Max, GPT-5-Nano) for independent review. Use after Bee's 6 parallel reviewers complete, as a complementary external perspective. Integrates with bee:requesting-code-review pipeline.

Review reception protocol - requires technical verification before implementing suggestions. Prevents performative agreement and blind implementation.

Generate Ops Update Guide from Git Diff. Produces internal Operations-facing update/migration guides based on git diff analysis. Supports STRICT_NO_TOUCH (default) and TEMP_CLONE_FOR_FRESH_REFS modes. Includes tag auto-detection and commit log analysis.

Backward call-chain tracing - systematically trace bugs from error location back through call stack to original trigger. Adds instrumentation when needed.

Autonomous plan execution - fresh subagent per task with automated code review between tasks. No human-in-loop, high throughput with quality gates.

Four-phase debugging framework - root cause investigation, pattern analysis, hypothesis testing, implementation. Ensures understanding before attempting fixes.

RED-GREEN-REFACTOR implementation methodology - write failing test first, minimal implementation to pass, then refactor. Ensures tests verify behavior.

Agent testing methodology - run agents with test inputs, observe outputs, iterate until outputs are accurate and well-structured.

Test quality guard - prevents testing mock behavior, production pollution with test-only methods, and mocking without understanding dependencies.

Skill testing methodology - run scenarios without skill (RED), observe failures, write skill (GREEN), close loopholes (REFACTOR).

Mandatory orchestrator protocol - establishes ORCHESTRATOR principle (dispatch agents, don't operate directly) and skill discovery workflow for every conversation.

Isolated workspace creation - creates git worktrees with smart directory selection and safety verification for parallel feature development.

Evidence-first completion gate - requires running verification commands and confirming output before making any success claims.

Generate beautiful, self-contained HTML pages that visually explain systems, code changes, plans, and data. Use when the user asks for a diagram, architecture overview, diff review, plan review, project recap, comparison table, or any visual explanation of technical concepts. Also use proactively when you are about to render a complex ASCII table (4+ rows or 3+ columns) — present it as a styled HTML page instead.

Creates comprehensive implementation plans with exact file paths, complete code examples, and verification steps for engineers with zero codebase context.

TDD for process documentation - write test cases (pressure scenarios), watch baseline fail, write skill, iterate until bulletproof against rationalization.

2 hooks across 2 events