Orchestrated planning, security auditing, and code quality for Claude Code.
claude --plugin-dir /path/to/this/repo
/orc:installThe main entry point for planning. Takes a feature description and runs four phases: codebase discovery scans your project structure, parallel web researchers gather ecosystem context, interactive clarification sharpens requirements through Q&A, and plan generation produces a phased roadmap with per-phase PLANs. Each phase PLAN goes through a planner-checker convergence loop where two teammates iterate until the plan passes 9 verification dimensions.
/orc:spec "feature description"
│
├─ discover ──── scans codebase ──────────────── STATE.md
├─ research ──── 4× parallel web researchers ─── research/SUMMARY.md
├─ clarify ───── interactive Q&A ─────────────── CONTEXT.md
└─ generate ──── per-phase planner + checker ─── ROADMAP.md + PLAN.md per phase
/orc:spec "add user authentication with OAuth"Spawns 10 agents in parallel to analyze your codebase from different angles — architecture, conventions, testing quality, type design, git history, dependencies, and more. Each agent writes a document directly to .claude/context/. Run this before /orc:spec on brownfield projects so the planning pipeline has codebase awareness.
/orc:map
│
└─ 10× parallel agents ─── each writes to .claude/context/
├─ 4× codebase-mapper ── STACK.md, ARCHITECTURE.md, STRUCTURE.md, CONVENTIONS.md, ...
└─ 6× specialists ────── PATTERNS.md, HISTORY.md, TYPES.md, TEST-QUALITY.md, ...
/orc:mapResearches an architectural decision by spawning 4 parallel agents that search the web, GitHub, Twitter/X, and official docs for evidence. Synthesizes findings into a structured ADR document with context, options considered, decision rationale, and consequences. Use between planning and implementation when a phase requires a non-obvious technical choice.
/orc:adr "slug phase-num"
│
├─ 4× parallel researchers
│ ├─ web ────── best practices + blog posts
│ ├─ twitter ── KOL opinions + real-world takes
│ ├─ github ─── production examples + patterns
│ └─ docs ───── official documentation
└─ synthesize ── docs/adr/ADR-{slug}.{NNN}-{title}.md
/orc:adr "auth-strategy 1"Takes a phase PLAN.md and designs a multi-agent team to implement it. Explores the codebase to understand scope, then produces a TEAM-PLAN.md with named teammates, task assignments, and wave ordering. The plan enters plan mode for your approval before execution. You then spawn the team from the generated prompts — an executor teammate writes code and commits, while a verifier teammate validates the work through a convergence loop.
/orc:swarm "task description"
│
├─ 1-3× Explore agents ── scope + patterns
├─ plan mode ──────────── TEAM-PLAN.md (user approves)
└─ user spawns team:
├─ orc-executor ────── implements tasks, git commits
└─ orc-impl-verifier ─ validates work (convergence loop, max 3 rounds)
/orc:swarm "implement phase 1: authentication"Parallel security audit for Solidity codebases. Creates a team of 20 teammates organized across 5 sequential waves — recon first, then domain-specific scans (lending, reentrancy, oracles, liquidation, signatures, staking, slippage), then deep analysis. Each teammate invokes one specialized audit skill and writes findings to .audit-work/. After all waves complete, the orchestrator synthesizes a single report with deduplicated, severity-normalized findings. Requires Audit skill pack via /orc:install.
/orc:audit [path]
│
├─ Wave 1 ── 3× recon ──────── entry points, context, prep
├─ Wave 2 ── 5× domain A ───── lending, reentrancy, math, oracle, signature
├─ Wave 3 ── 5× domain B ───── staking, state, slippage, liquidation, auction
├─ Wave 4 ── 5× domain C ───── liq-dos, liq-calc, unfair-liq, clm, pashov
├─ Wave 5 ── 2× deep ───────── token integration, guidelines
└─ synthesize ───────────────── .audit-work/REPORT.md
/orc:audit ~/git/my-defi-protocolUI design with a loaded design system and browser-automated visual testing. Reads your design system spec (colors, typography, spacing, components), implements the UI, then launches a browser to screenshot the result and compare against the spec. Iterates through a design-iterator agent that makes one visual change per cycle until the implementation matches. Finishes with a frontend-verifier agent that checks forms, interactions, and responsive layouts.
/orc:vibe-code "component description"
│
├─ load design system ──── spec.md (colors, typography, layout)
├─ implement UI ────────── code files
├─ design-iterator ─────── screenshot → analyze → 1 fix → repeat
└─ frontend-verifier ───── browser automation QA
/orc:vibe-code my-design-system "dashboard layout with sidebar navigation"
/orc:vibe-code my-design-system verify http://localhost:3000Generates a single documentation page from codebase exploration. Spawns 3-5 research agents in parallel (selected based on topic — code explorers, pattern analyzers, type analysts, etc.), collects their findings, then synthesizes everything into a styled doc page in docs/. Optionally generates draw.io diagrams. The result goes through a user review loop before finalizing.
/orc:document "topic"
│
├─ select 3-5 agents ─── topic-adaptive
├─ spawn in parallel ─── each returns findings
├─ synthesize ─────────── docs/{NNN}-{slug}.md
├─ diagram (optional) ── docs/diagrams/{slug}.drawio + .png
└─ user review loop ──── iterate until approved
/orc:document "how the auth middleware works"Generates draw.io diagrams from codebase analysis. Spawns a drawio agent that explores the codebase, builds an accurate representation of the architecture or flow you specify, and exports both the .drawio source and a .png render. Requires draw.io desktop and cli-anything-drawio (install via /orc:install).
/orc:diagram "focus"
│
├─ explore codebase ─── verify all components are real
├─ generate ─────────── docs/diagrams/{slug}.drawio
└─ export + verify ──── docs/diagrams/{slug}.png
/orc:diagram "system architecture"Pre-PR documentation pipeline. Spawns research agents to analyze your branch changes (git diff, commit history, modified files), then synthesis agents produce a review-ready docs page with summary, test plan, and architectural context. Designed to run right before gh pr create.
/orc:compound-pr
│
├─ research agents ──── analyze diff, commits, modified files
├─ synthesis agents ─── produce structured docs page
└─ output ───────────── docs/CHANGELOG/{slug}.md
/orc:compound-prReviews recent conversations to find improvements for CLAUDE.md files. Analyzes patterns in how you've been working — repeated corrections, tool preferences, workflow conventions — and suggests additions to project or user CLAUDE.md files.
/orc:compound-md
│
├─ analyze conversations ─── patterns, corrections, preferences
└─ suggest edits ──────────── CLAUDE.md improvements
/orc:compound-mdExtracts patterns from the current session's transcript — decisions you made, corrections you gave, workflow preferences, project context — and saves them as structured memory files. Reads the conversation history, identifies what's worth remembering across sessions, and writes to the project memory system so future conversations have that context automatically.
/orc:compound-memory
│
├─ read transcript ────── current session history
├─ extract patterns ───── decisions, corrections, preferences, context
└─ write memory files ─── .claude/projects/*/memory/
/orc:compound-memoryClones the later half of the current conversation into a new session, discarding the earlier context to free tokens. Useful when a long session has accumulated too much context but you want to keep the recent work. The original conversation is untouched — the clone is a new .jsonl file you resume with claude -r.
/orc:half-clone
│
├─ find current session ─── ~/.claude/history.jsonl
├─ count messages ───────── calculate halfway point
├─ single-pass transform ── remap UUIDs, strip thinking, halve token counts
└─ write new session ────── <new-session>.jsonl + history entry
/orc:half-cloneInteractive setup wizard. Walks through permissions, optional dependencies (draw.io, Exa, Ref), skill packs (Rust for /orc:arch, Solidity audit for /orc:audit), a guided tour of all commands, and CLAUDE.md template generation for your project type.
/orc:install
│
├─ Step 1-2 ─── verify Claude Code + detect plugin context
├─ Step 3 ───── script permissions (chmod +x)
├─ Step 4 ───── optional dependencies (draw.io, Exa, Ref)
├─ Step 4b ──── skill packs (Rust 492K / Audit 256K → .claude/skills/)
├─ Step 5 ───── tutorial (quick overview or interactive walkthrough)
└─ Step 6 ───── generate CLAUDE.md from template (Rust/Solidity/TypeScript)
/orc:installMore commands and detailed documentation in docs/.
MIT