clavain

Scan open beads for stale trackers that are already implemented — deterministic checks first, LLM verification second

Collaborative brainstorm workflow — explore ideas through structured dialogue (assess clarity, research repo, explore approaches, capture design) with auto-handoff to /write-plan.

Orchestrate epic execution — read children, topo-sort by dependencies, dispatch phases sequentially with parallel features

Create engaging changelogs for recent merges to main branch

Toggle interserve execution mode

Bootstrap or check Clavain Codex installation health (install + wrapper sync + doctor)

Document a recently solved problem to compound your team's knowledge

Create or edit Claude Code skills with expert guidance on structure and best practices

Run a structured Claude↔Codex debate before implementing a complex task

Generate PR title and description from current branch commits

Synthesize accumulated docs into categorized solutions and generate missing SKILL-compact.md files

Quick health check — verifies MCP servers, external tools, beads, and plugin configuration without making changes

Execute plan in batches with review checkpoints

Run build, capture error, fix it, re-run — fast loop for type errors and build failures without heavyweight debugging

Discipline analytics — view KPIs, report defects, or reset cache

Create a new custom slash command following conventions and best practices

Generate a concise session handoff summary for pasting into a new conversation

Fix incorrect SKILL.md files when a skill has wrong instructions or outdated API references

Show Clavain commands organized by daily drivers first, then by workflow stage

Scaffold .clavain/ agent memory directory in the current project

Run Codex-first execution flow for larger scope work

Run the landing workflow for trunk-based handoff

Orchestrate database migration and data-risk work with consistent safety checks — combines data integrity, migration, and deployment verification agents

Toggle subagent model routing between economy (smart defaults) and quality (all opus) mode

Have multiple specialized agents review a plan in parallel

Triage all open PRs — batch by theme, review with parallel agents, generate report, walk through decisions

Gate orchestrator — prepares diff, delegates review to flux-drive, enforces pass/fail gate

Search across all knowledge systems — curated docs, memory files, legacy entries

Plan and execute safe refactors with explicit risk controls

Capture sprint learnings and advance from reflect to done

Disciplined bug investigation that enforces "reproduce first, then diagnose" — composes debugging agents into a structured workflow

Resolve findings from any source — auto-detects TODOs, PR comments, or todo files, then resolves in parallel

Run disciplined code review and feedback triage

Quick single-pass document refinement — assess clarity, score quality, fix issues, offer iteration

Perform exhaustive code reviews using multi-agent analysis and deep inspection

Universal entry point — discovers work, resumes sprints, classifies tasks, and dispatches to /sprint or /work

Bootstrap Clavain for the active runtime (Codex or Claude Code) and verify health

Run smoke tests against a running app — detect dev server, walk critical user journeys, report results

Visualize sprint execution as a DAG — shows phases, dispatches, and artifacts

Deep scan of sprint workflow state — session continuity, pipeline health, plan progress, beads, and recommendations

Phase sequencer — brainstorm, strategize, plan, execute, review, ship. Use /route for smart dispatch.

Unified status view across Clavain, artifact generation, doc drift, and coordination

Structure brainstorm output into a PRD with features, create beads for tracking, and validate before detailed planning

Run disciplined test-driven development (RED-GREEN-REFACTOR) for a task

Create and maintain file-based todo tracking

Triage and categorize findings for the CLI todo system

Conservative update check — reports available Sylveste/Clavain/Codex updates without changing anything

Check upstream repos (beads, oracle, superpowers, compound-engineering) for updates and generate upgrade checklist

Run completion verification before claiming work is done

Execute work plans efficiently while maintaining quality and finishing features

Create detailed implementation plan with bite-sized tasks

```

- Codex sync operations: `docs/runbooks/codex-sync.md`

- Flat `.md` files in `commands/`

- Run `scripts/bump-version.sh <version>` (or `/interpub:release <version>` in Claude Code) for any released changes.

- Registration in `hooks/hooks.json` — specifies event, matcher regex, and command

Agents can publish interface contracts during sprint execution to enable parallel work against shared interfaces. This is Pattern 1 from the WCM (When Claudes Meet) analysis.

Validates data migrations, backfills, and production data transformations against reality. Use when PRs involve ID mappings, column renames, enum conversions, or schema changes.

Use this agent when a major project step has been completed and needs to be reviewed against the original plan and coding standards. Examples: <example>Context: The user is creating a code-review agent that should be called after a logical chunk of code is written. user: "I've finished implementing the user authentication system as outlined in step 3 of our plan" assistant: "Great work! Now let me use the plan-reviewer agent to review the implementation against our plan and coding standards" <commentary>Since a major project step has been completed, use the plan-reviewer agent to validate the work against the plan and identify any issues.</commentary></example> <example>Context: User has completed a significant feature implementation. user: "The API endpoints for the task management system are now complete - that covers step 2 from our architecture document" assistant: "Excellent! Let me have the plan-reviewer agent examine this implementation to ensure it aligns with our plan and follows best practices" <commentary>A numbered step from the planning document has been completed, so the plan-reviewer agent should review the work.</commentary></example>

- One directory per skill: `skills/<kebab-case-name>/SKILL.md`

Systematically reproduces and validates bug reports to confirm whether reported behavior is an actual bug. Use when you receive a bug report or issue that needs verification.

Delegates well-scoped tasks to Codex CLI for cost-efficient execution. Use proactively for implementation, exploration, search, test generation, and code review when the task has clear scope and success criteria. Keep architecture, brainstorming, and interactive work in Claude.

Addresses PR review comments by implementing requested changes and reporting resolutions. Use when code review feedback needs to be resolved with code changes.

Iterates on UI refinements — tooltips, labels, layouts, mobile fixes, spacing, chart styling. Takes a screenshot or URL + natural language instruction and makes targeted frontend edits. Use when the user provides visual feedback about a web or TUI interface.

Use when requesting or receiving code review — covers dispatching reviewer subagents, handling feedback with technical rigor, and avoiding performative agreement

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies

Use when capturing a solved problem as categorized documentation with YAML frontmatter for fast lookup

Use when you have a written implementation plan to execute in a separate session with review checkpoints

This skill should be used when managing the file-based todo tracking system in the todos/ directory. It provides workflows for creating todos, managing status and dependencies, conducting triage, and integrating with slash commands and code review processes.

Show discipline analytics — defect escape rate, override rate, cost metrics, and agent scorecard

Dispatch tasks to Codex CLI agents — single megaprompt for one task, parallel delegation for many. Includes structured debate triggers and Oracle escalation.

Use when implementation is complete and all tests pass — guides the disciplined process of verifying, documenting, and landing a change on trunk

Manage thematic work lanes — discover, create, tag beads, show velocity and starvation scores

Use when setting up any project (new or existing) in the Sylveste ecosystem — introspects infrastructure, creates GitHub repo if needed, conducts guided interview, scaffolds docs and automation, configures observability, seeds content via interpath. Replaces the former project-kickstart command.

Use when performing significant refactoring — guides a disciplined process that leverages duplication detection, characterization tests, staged execution, and continuous simplicity review

Use when work is done and you need to commit, push, close beads, and sync in one shot. The quick session-close ceremony.

Use when executing implementation plans with independent tasks in the current session

Use when checking for updates from upstream tool repos (beads, oracle, superpowers, compound-engineering) or when the /clavain:upstream-sync command is invoked

Use when starting any conversation - establishes how to find and use skills, agents, and commands, requiring Skill tool invocation before ANY response including clarifying questions

Use when you need to run interactive CLI tools (vim, git rebase -i, Python REPL, etc.) that require real-time input/output - provides tmux-based approach for controlling interactive sessions through detached sessions and send-keys

Use when you have a spec or requirements for a multi-step task, before touching code

11 hooks across 5 events