flux

Start Claude cloud auto-fix on a submitted PR.

Report a Flux bug and create a PR to fix it

React visual-jank audit and diagnosis via the optional Dejank skill installed through /flux:setup.

Compare multiple interface designs for a module or API using parallel sub-agents.

Systematic codebase quality improvement using desloppify

Epic completion review - verify implementation matches spec

Export RepoPrompt review context for use with external LLMs.

Validate staging after merge and promote toward production.

Behavioral stress test for completed epics and implemented workflows.

John Carmack-level implementation review via RepoPrompt or Codex

Restructure AGENTS.md or CLAUDE.md for stronger conditional instruction adherence.

Analyze sessions/environment, surface inefficiencies, and recommend workflow optimizations

Connect Flux to your Universe profile via device flow

Disconnect Flux from Universe on this machine

Audit and evolve the brain vault - prune outdated content, discover new principles

Carmack-level plan review via RepoPrompt or Codex

Draft a structured build plan from a short request

Analyze codebase for agent readiness and propose improvements

Export, share, view, and import SDLC setup profiles

Stakeholder-facing feature proposal flow with engineering pushback and handoff.

Scaffold repo-local Ralph autonomous harness (scripts/ralph/)

Root cause analysis for bugs, regressions, and broken behavior.

Capture learnings from the current session into the brain vault

Cut a Flux release with synced manifests, changelog, tag, and release notes.

Explicit memory capture alias for remember/don't forget requests.

Mine past session transcripts for uncaptured patterns and learnings

Full Product OS-style scoping workflow for features, bugs, and refactors. Default is shallow mode; use --deep for the full staged experience. Use --linear or LIN-123 to pull context from Linear.

Compute AI-native capability score from legacy session transcript data

Comprehensive security review with STRIDE analysis and vulnerability validation

Scan code changes for security vulnerabilities using STRIDE threat modeling

Optional local install of fluxctl CLI and project docs

Autonomously create production-grade agent skills from a brief description

Show Flux ↔ Universe connection state

Manually trigger plan-sync to update downstream task specs after implementation drift

Test-driven development with red-green-refactor vertical slices.

Generate a STRIDE-based security threat model for the repository

Extract and formalize domain terminology into a DDD-style glossary.

Remove flux files from project (scoped or full machine)

Upgrade Flux and optionally refresh project setup

Validate security findings for exploitability and generate proof-of-concept

Execute a plan end-to-end with checks

Used by /flux:prime to analyze build system, scripts, and CI configuration. Do not invoke directly.

Used by /flux:prime to analyze CLAUDE.md and AGENTS.md quality and completeness. Do not invoke directly.

Token-efficient codebase exploration using RepoPrompt codemaps and slices. Use when you need deep codebase understanding without bloating context.

Identify documentation that may need updates based on the planned changes.

Find the most relevant framework/library docs for the requested change.

Used by /flux:prime to scan for environment setup, .env templates, Docker, and devcontainer configuration. Do not invoke directly.

Scan existing epics to find dependencies and relationships for a new plan.

Map user flows, edge cases, and missing requirements from a brief spec.

Search GitHub repos (public + private) for code patterns, implementations, and examples.

Used by /flux:prime to scan for observability setup including logging, tracing, metrics, and health endpoints. Do not invoke directly.

Synchronizes downstream task specs after implementation. Spawned by flux-work after each task completes. Do not invoke directly.

Gather modern best practices and pitfalls for the requested change.

Review recent changes for correctness, simplicity, security, and test coverage.

Scan repo to find existing patterns, conventions, and related code paths for a requested change.

Used by /flux:prime to scan for security configuration including GitHub settings, CODEOWNERS, and dependency updates. Do not invoke directly.

Used by /flux:prime to analyze test framework setup, coverage configuration, and test commands. Do not invoke directly.

Used by /flux:prime to scan for linting, formatting, type checking, and pre-commit configuration. Do not invoke directly.

Task implementation worker. Spawned by flux-work to implement a single task with fresh context. Do not invoke directly - use /flux:work instead.

Used by /flux:prime to scan for CI/CD, PR templates, issue templates, and workflow automation. Do not invoke directly.

Browser automation via agent-browser CLI. Use when you need to navigate websites, verify deployed UI, test web apps, read online documentation, scrape data, fill forms, capture baseline screenshots before design work, or inspect current page state. Triggers on "check the page", "verify UI", "test the site", "read docs at", "look up API", "visit URL", "browse", "screenshot", "scrape", "e2e test", "login flow", "capture baseline", "see how it looks", "inspect current", "before redesign".

Use when handing a submitted PR to Claude's optional cloud auto-fix after submit. Watches for CI failures and review comments, pushes fixes remotely so you can walk away. Runs automatically after /flux:work submits a PR (when enabled via /flux:setup). Also invocable manually via /flux:autofix.

Read/write brain files in .flux/brain/. Use for any task that persists knowledge — reflection, planning, or direct edits. Handles the "Remember" flow: classifies content as CLAUDE.md (short rules for every session) or .flux/brain/ (deeper context), asks user to confirm, then writes. Triggers: brain/ modifications, "add to brain", "remember X", "don't forget X", "keep in mind X", "from now on X", "note that X".

Use when contributing fixes to Flux itself or deciding whether a reported Flux issue actually needs a PR. Reproduce first, exhaust setup/workaround causes, and only create a PR for verified product bugs. Triggers on literal `/flux:contribute` and requests like "report a Flux bug" or "contribute a fix to Flux".

Show epic dependency graph and execution order. Use when asking 'what's blocking what', 'execution order', 'dependency graph', 'what order should epics run', 'critical path', 'which epics can run in parallel'.

Generate multiple radically different interface designs for a module using parallel sub-agents, then compare and synthesize. Based on "Design It Twice" from "A Philosophy of Software Design". Use when user wants to design an API, explore interface options, compare module shapes, or says "design it twice".

Use when improving codebase quality systematically across dead code, duplication, complexity, naming, and architecture issues. Runs the desloppify scoring flow and favors real maintainability gains over cosmetic score-chasing. Triggers on literal `/flux:desloppify`.

Epic completion review - adversarial dual-model review, external bot self-heal, browser QA, and learning capture. Full thorough review at epic level. Triggers on /flux:epic-review.

Export RepoPrompt context for external LLM review (ChatGPT, Claude web, etc.). Use when you want to review code or plans with an external model. Triggers on /flux:export-context.

Validate a staging deployment after merge and promote to production. Runs browser QA or manual review against the staging URL, then creates a promotion PR (staging → production). Triggers on /flux:gate.

Relentless behavioral review after epic completion. Walks every branch of the design tree, verifying implemented behavior matches intent. Use when user says "grill me", "stress test the behavior", wants to verify an epic's behavioral coverage before shipping, or after /flux:epic-review to stress-test what was built.

Per-task implementation review via RepoPrompt or Codex. Lightweight single-model pass to catch obvious issues before moving to next task. Full adversarial review runs at epic level. Triggers on /flux:impl-review.

Restructure CLAUDE.md for better agent adherence by adding <important if> conditional blocks. Separates foundational content (always relevant) from task-specific instructions (wrapped in conditional tags). Preserves <!-- BEGIN FLUX --> markers. Triggers: /flux:improve-claude-md.

Analyze environment and recommend workflow optimizations (MCPs, plugins, skills, CLI tools, patterns). Use when user wants to discover and install development workflow improvements. Triggers on literal `/flux:improve` and requests like "find me tools for X", "what MCP should I use", or "optimize my workflow".

Audit and evolve the brain vault — prune outdated content, discover cross-cutting principles, review skills for structural encoding opportunities. Triggers: /flux:meditate, "meditate", "audit the brain".

Use when 2 or more investigations, scaffolds, reviews, or fixes are independent enough to run in parallel without shared files, shared state, or sequential dependency.

Carmack-level plan review via RepoPrompt or Codex. Use when reviewing Flow epic specs or design docs. Triggers on /flux:plan-review.

Create structured build plans from feature, bugfix, upgrade, or refactor requests, or from Flow IDs. Use when planning implementation after the workflow envelope is explicit. Triggers on /flux:plan with text descriptions or Flow IDs (fn-1-add-oauth, fn-1-add-oauth.2, or legacy fn-1, fn-1.2, fn-1-xxx, fn-1-xxx.2).

Comprehensive codebase assessment for agent and production readiness. Scans 8 pillars (48 criteria), verifies commands work, checks GitHub settings. Reports everything, fixes agent readiness only. Triggers on literal `/flux:prime`.

Use when exporting, publishing, importing, or tombstoning Flux SDLC profiles for reusable setup links, team replication, or immutable environment snapshots. Triggers on literal `/flux:profile`.

Stakeholder-facing feature proposal flow. Guides non-technical team members through a conversational planning session — probes for business context, pushes back like an engineer, estimates complexity and cost, then documents the proposal and creates a PR for engineering handoff. Triggers: /flux:propose, or detected implicitly when a non-technical user describes a feature, bugfix request, or upgrade without implementation detail during /flux:scope or /flux:plan.

Scaffold repo-local Ralph autonomous harness under scripts/ralph/. Use when user runs /flux:ralph-init.

Root cause analysis workflow for bugs. Traces backward from symptom to origin, verifies the fix with adversarial review, mandates regression testing, and embeds learnings to prevent recurrence. Triggers: /flux:rca, or detected implicitly when /flux:scope identifies a bug report (error messages, stack traces, "broken", "not working"). Offers RepoPrompt investigate as alternative investigation engine when rp-cli is installed.

Use when handling review feedback from humans, RepoPrompt, Codex, Greptile, CodeRabbit, or GitHub PR comments before implementing requested changes.

Reflect on the conversation and persist learnings — brain vault notes, skill extraction, or structural enforcement. Use when wrapping up, after mistakes or corrections, after non-obvious debugging, or when significant codebase knowledge was gained. Triggers: /flux:reflect, "reflect", "save this as a skill". Note: "remember X" routes to flux-brain, not here. This skill is for session-wide reflection.

Use when cutting a new Flux release. Bump all manifest versions in sync, tag the release, create GitHub release notes, and prevent stale plugin metadata from drifting from the published tag. Triggers on literal `/flux:release`.

Smart "remember" routing — when user says "remember X", "don't forget X", or "keep in mind X", this skill decides whether to store in CLAUDE.md (short actionable rules for every session) or the brain vault (deeper context, decisions, business knowledge). Routes through flux-brain's "Remember" flow. Triggers: /flux:remember, "remember", "don't forget", "keep in mind", "note that".

Token-efficient codebase exploration using RepoPrompt CLI. Use when user says "use rp to..." or "use repoprompt to..." followed by explore, find, understand, search, or similar actions.

Mine past session transcripts for uncaptured patterns, corrections, and knowledge. Cross-references with existing brain content. Triggers: /flux:ruminate, "ruminate", "mine my history".

Use when scoping a new feature, bugfix, upgrade to an existing feature, or refactor into a concrete Flow objective. Guides Start, Discover, Define, Stress Test, Future Pressure, Develop, Deliver, and Handoff; requires an explicit shallow-vs-deep choice before scoping continues. Triggers on literal `/flux:scope`, including prompts like `/flux:scope Add OAuth login` or `/flux:scope fn-1 --deep`.

Comprehensive security review using STRIDE threat modeling. Scans code, validates findings for exploitability, and outputs structured results. Supports PR review, scheduled scans, and full repository audits. Triggers on /flux:security-review.

Analyze code changes for security vulnerabilities using LLM reasoning and threat model patterns. Use for PR reviews, pre-commit checks, or branch comparisons. Triggers on /flux:security-scan.

Optional local install of fluxctl CLI and AGENTS.md/legacy CLAUDE.md instructions. Use when user runs /flux:setup. Triggers on literal `/flux:setup`.

Autonomously create production-grade agent skills from a brief description. Use when user says "build a skill", "create a skill for X", "I need a skill that does Y", or wants to turn a repeated workflow into a reusable skill. Handles research, drafting, validation, and installation without interactive gates. Do NOT use for editing existing skills (use direct file editing) or for Flux plugin development (use flux-contribute).

Manually trigger plan-sync to update downstream task specs after implementation drift. Use when code changes outpace specs.

Test-driven development with red-green-refactor vertical slices. Use when implementing features or fixes TDD-style, when user says "TDD", "test first", "red green refactor", or wants to build a feature one test at a time. Triggers on literal `/flux:tdd`. Works standalone or inside /flux:work.

Generate a STRIDE-based security threat model for a repository. Use when setting up security monitoring, after architecture changes, during /flux:scope, or for security audits. Triggers on /flux:threat-model.

Extract a DDD-style ubiquitous language glossary from conversation and codebase, flagging ambiguities and proposing canonical terms. Saves to .flux/brain/business/glossary.md. Use when user wants to define domain terms, build a glossary, harden terminology, create a ubiquitous language, or mentions "domain model" or "DDD". Triggers on literal `/flux:ubiquitous-language`.

Use when upgrading Flux itself after a new release or when legacy plugin metadata/cache drift leaves Flux on an older version. Refresh marketplace metadata, clear plugin cache, update the install record, and route literal `/flux:upgrade` prompts.

Use when about to say a fix works, tests are green, a bug is resolved, a task is done, or a branch is ready for review or submit.

Validate security findings by assessing exploitability, filtering false positives, and generating proof-of-concept exploits. Use after running flux-security-scan to confirm vulnerabilities. Triggers on /flux:vuln-validate.

Execute a Flow epic or task systematically with git setup, task tracking, quality checks, and commit workflow. Use when implementing a plan or working through a spec. Triggers on literal `/flux:work` prompts with Flow IDs (fn-1-add-oauth, fn-1-add-oauth.2, or legacy fn-1, fn-1.2, fn-1-xxx, fn-1-xxx.2).

Manage git worktrees (create/list/switch/cleanup) and copy .env files. Use for parallel feature work, isolated review, clean workspace, or when user mentions worktrees.

Manage .flux/ tasks, epics, and config. Triggers: 'show me my tasks', 'list epics', 'what tasks are there', 'add a task', 'create task', 'what's ready', 'task status', 'show fn-1-add-oauth', 'show my Flux config', 'what did setup configure', 'edit Flux settings'. NOT for /flux:plan or /flux:work.

Review code at a high level for subtle design papercuts that create long-term slop creep. Use when the user asks for an engineering taste review, wants a high-level code quality pass, asks "does this feel clean?", "what feels off?", "what are the papercut decisions here?", or wants to catch problematic small decisions before they calcify into local conventions.

10 hooks across 6 events