Multi-agent engineering orchestration for Claude Code, enhancing code quality and compliance.

Rune

Multi-agent engineering orchestration for Claude Code.

Built on Discipline Engineering — a proof-based architecture that treats specification compliance, not just code quality, as the primary metric.

Plan, implement, review, test, and audit your codebase using coordinated Agent Teams — each teammate with its own dedicated context window.

What Is This?

Rune is a Claude Code plugin that turns a single-agent coding session into a coordinated multi-agent engineering team. It provides 152 specialized AI agents, 69 skills, and a 45-phase end-to-end pipeline that handles planning, implementation, code review, testing, and PR creation — all orchestrated through Claude Code's Agent Teams.

Compatibility: Requires Claude Code 2.1.81+ with Agent Teams support. macOS 12+ or Linux. See full requirements.

Why This Exists

Claude Code is powerful on its own — but a single agent has a single context window. As tasks grow in scope (reviewing a 50-file diff, planning a feature across multiple services, running a full implementation pipeline), one context window becomes the bottleneck:

Context saturation — A single agent reviewing 40 files loses focus on file 35. Rune gives each reviewer its own full context window, so the last file gets the same attention as the first.
Specialization over generalization — One agent trying to catch security issues, performance bugs, and naming inconsistencies simultaneously does none of them well. Rune dispatches Ward Sentinel for security, Ember Oracle for performance, and Pattern Seer for consistency — each focused on what it does best.
Parallelism — Sequential work on 6 implementation tasks takes 6x as long. Swarm workers claim and complete tasks independently, bounded only by file-level conflicts.
Separation of concerns — Planning, implementing, reviewing, and testing in one context creates confirmation bias (the same agent reviews code it just wrote). Rune enforces phase boundaries: different agents plan, build, and critique.

These problems are symptoms of a deeper issue: AI agents optimize for completion signals, not specification compliance. Rune's architecture is designed around the Discipline Engineering framework — five layers of decomposition, comprehension verification, proof-based completion, and anti-rationalization gates that ensure agents deliver what was specified, not just what compiles.

The trade-off is token cost — multi-agent workflows consume more tokens than a single session. Rune is designed for cases where quality, thoroughness, and coverage matter more than minimizing API usage.

[!WARNING] Rune is token-intensive and time-intensive.

Each workflow spawns multiple agents, each with its own dedicated context window. This means higher token consumption and longer runtimes than single-agent usage.

Workflow Typical Duration Why
/rune:devise 10–30 min Up to 7 agents across 7 phases (brainstorm, research, synthesize, forge, review)
/rune:appraise 5–20 min Up to 8 review agents analyzing your diff in parallel — scales with LOC changed
/rune:audit 10–30 min Full codebase scan — same agents, broader scope
/rune:strive 10–30 min Swarm workers implementing tasks in parallel
/rune:arc 1–2 hours Full 45-phase pipeline (forge → plan review → work → gap analysis → code review → mend → test → ship → merge)
/rune:arc (complex) up to 3 hours Large plans with multiple review-mend convergence loops

/rune:arc is intentionally slow because it runs the entire software development lifecycle autonomously — planning enrichment, parallel implementation, multi-agent code review, automated fixes, 3-tier testing, and PR creation. Each phase spawns and tears down a separate agent team. The result is higher quality, but it takes time.

Want faster iterations? Run the steps individually instead of the full pipeline:
/rune:plan   →  /rune:work   →  /rune:review
 (10–30 min)    (10–30 min)     (5–20 min)
This gives you the same core workflow (plan → implement → review) in 25–80 minutes with manual control between steps — versus 1–3 hours for /rune:arc which adds forge enrichment, gap analysis, automated mend loops, 3-tier testing, and PR creation on top.

Claude Max ($200/month) or higher recommended. Use --dry-run where available to preview scope before committing.

Workflow	Typical Duration	Why
`/rune:devise`	10–30 min	Up to 7 agents across 7 phases (brainstorm, research, synthesize, forge, review)
`/rune:appraise`	5–20 min	Up to 8 review agents analyzing your diff in parallel — scales with LOC changed
`/rune:audit`	10–30 min	Full codebase scan — same agents, broader scope
`/rune:strive`	10–30 min	Swarm workers implementing tasks in parallel
`/rune:arc`	1–2 hours	Full 45-phase pipeline (forge → plan review → work → gap analysis → code review → mend → test → ship → merge)
`/rune:arc` (complex)	up to 3 hours	Large plans with multiple review-mend convergence loops

Install

/plugin marketplace add https://github.com/vinhnxv/rune
/plugin install rune

Restart Claude Code after installation.

<details> <summary>Local development</summary>

claude --plugin-dir /path/to/rune

</details>

Setup

Rune requires Agent Teams. Enable it in .claude/settings.json or .claude/settings.local.json:

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  },
  "includedGitignorePatterns": [
    "plans/",
    "todos/",
    "tmp/",
    "reviews/",
    ".rune/",
    ".claude/CLAUDE.local.md"
  ]
}

includedGitignorePatterns lets Claude Code read Rune's output directories that are typically gitignored.

Quick Configuration (Optional)

Generate a talisman.yml tailored to your project's tech stack:

/rune:talisman init      # Auto-detect stack and generate .rune/talisman.yml
/rune:talisman audit     # Check existing config for missing/outdated sections
/rune:talisman status    # Overview of current configuration health

See the Talisman deep dive for full configuration coverage.

How It Works

Rune orchestrates multi-agent workflows where specialized AI teammates collaborate through shared task lists and file-based communication. Instead of one agent doing everything in a single context window, Rune splits work across purpose-built agents — each with its own full context window.

You ──► /rune:devise ──► Plan
                           │
         /rune:arc ◄───────┘
             │
             ├─ Forge & Validate     enrich plan, review architecture, refine
             ├─ Work                 swarm workers implement in parallel
             ├─ Gap Analysis         detect and remediate implementation gaps
             ├─ Review & Mend        multi-agent code review + auto-fix findings
             ├─ Test                 3-tier testing (unit → integration → E2E)
             ├─ Ship                 validate and create PR
             └─ Merge               rebase and merge

Workflows

Quick Start (New Users)

Command	What it does	Alias for
`/rune:plan`	Plan a feature or task	`/rune:devise`
`/rune:work`	Implement a plan with AI workers	`/rune:strive`
`/rune:review`	Review your code changes	`/rune:appraise`
`/rune:brainstorm`	Explore ideas through dialogue	`/rune:brainstorm`
`/rune:quick`	Quick 3-phase pipeline (plan -> work -> review)	`/rune:arc-quick`

`/rune:tarnished` — The Unified Entry Point

Don't remember which command to use? /rune:tarnished is the intelligent master command that routes natural language to the correct Rune workflow. It understands both English and Vietnamese.

# Route by keyword — passes through to the right skill
/rune:tarnished plan add user authentication
/rune:tarnished work plans/my-plan.md
/rune:tarnished review
/rune:tarnished arc plans/my-plan.md
/rune:tarnished arc-batch plans/*.md
/rune:tarnished arc-issues --label "rune:ready"

# Chain workflows — multi-step with confirmation between steps
/rune:tarnished review and fix
/rune:tarnished plan then work

# Natural language — classifies intent automatically
/rune:tarnished implement the latest plan
/rune:tarnished fix the findings from the last review

# Guidance — ask Rune anything
/rune:tarnished help
/rune:tarnished what should I do next?
/rune:tarnished khi nào nên dùng audit vs review?

When run with no arguments, /rune:tarnished scans your project state (plans, reviews, git changes) and suggests the most logical next action.

Core Commands

Command	What it does	Agents	Duration
`/rune:devise`	Turn ideas into structured plans with parallel research	up to 7	10–30 min
`/rune:strive`	Execute plans with self-organizing swarm workers	2-6	10–30 min
`/rune:appraise`	Multi-agent code review on your diff	up to 8	5–20 min
`/rune:audit`	Full codebase audit with specialized reviewers	up to 8	10–30 min
`/rune:arc-quick`	Quick pipeline: plan → work → review → mend (4 phases)	varies	25–60 min
`/rune:arc`	End-to-end pipeline: plan → work → review → test → ship	varies	1–3 hours
`/rune:mend`	Parallel resolution of review findings	1-5	3–10 min
`/rune:forge`	Deepen a plan with topic-aware research enrichment	3-12	5–15 min
`/rune:goldmask`	Impact analysis — what breaks if you change this?	8	5–10 min
`/rune:inspect`	Plan-vs-implementation gap audit (10 dimensions)	4	5–10 min
`/rune:elicit`	Structured reasoning (Tree of Thoughts, Pre-mortem, 5 Whys)	0	2–5 min

Batch & Automation

Command	What it does
`/rune:arc-batch`	Run `/rune:arc` across multiple plans sequentially
`/rune:arc-issues`	Fetch GitHub issues by label, generate plans, run arc for each
`/rune:arc-hierarchy`	Execute hierarchical parent/child plan decompositions

Utilities

Command	What it does
`/rune:rest`	Clean up `tmp/` artifacts from completed workflows
`/rune:echoes`	Manage persistent agent memory (show, prune, reset)
`/rune:learn`	Extract CLI corrections and review recurrences from session history into Echoes
`/rune:file-todos`	Structured file-based todo tracking with YAML frontmatter
`/rune:cancel-arc`	Gracefully stop a running arc pipeline
`/rune:cancel-review`	Stop an active code review
`/rune:cancel-audit`	Stop an active audit
`/rune:cancel-arc-batch`	Stop an active arc-batch loop
`/rune:cancel-arc-hierarchy`	Stop an active arc-hierarchy loop
`/rune:cancel-arc-issues`	Stop an active arc-issues loop
`/rune:cancel-codex-review`	Stop an active codex review
`/rune:team-delegate`	Task delegation dashboard
`/rune:plan-review`	Review plan code samples for correctness
`/rune:pr-guardian`	Automated PR shepherd — lint, CI, rebase, migrations, browser test, auto-merge (cron every 5 min)

Workflow Details

<a name="devise"></a> `/rune:devise` — Planning

Transforms a feature idea into a structured plan through a multi-phase pipeline:

Brainstorm — structured exploration with elicitation methods
Research — parallel agents scan your repo, git history, echoes, and external docs
Solution Arena — competing approaches evaluated on weighted dimensions
Synthesize — consolidate findings into a plan document
Predictive Goldmask — risk scoring for files the plan will touch
Forge — topic-aware enrichment by specialist agents
Review — automated verification + optional technical review

/rune:devise                  # Full pipeline
/rune:devise --quick          # Skip brainstorm + forge (faster)

Output: plans/YYYY-MM-DD-{type}-{name}-plan.md

<a name="arc"></a> `/rune:arc` — End-to-End Pipeline

The full pipeline from plan to merged PR, with 45 phases:

Forge → Plan Review → Refinement → Verification → Semantic Verification
  → Design Extraction → Task Decomposition → Work → Storybook Verification
  → Design Verification → UX Verification → Gap Analysis → Codex Gap Analysis
  → Gap Remediation → Goldmask Verification → Code Review (--deep)
  → Goldmask Correlation → Mend → Verify Mend → Design Iteration
  → Test → Test Coverage Critique → Pre-Ship Validation → Release Quality Check
  → Ship → Bot Review Wait → PR Comment Resolution → Merge

/rune:arc plans/my-plan.md
/rune:arc plans/my-plan.md --resume        # Resume from checkpoint
/rune:arc plans/my-plan.md --no-forge      # Skip forge enrichment
/rune:arc plans/my-plan.md --skip-freshness  # Bypass plan freshness check

Features: checkpoint-based resume, adaptive review-mend convergence loop (3 tiers: LIGHT/STANDARD/THOROUGH), diff-scoped review, co-author propagation.

How arc phases work: Arc uses Claude Code's Stop hook to drive the phase loop — when one phase finishes, the stop hook reads state from .rune/arc-phase-loop.local.md, determines the next phase, and re-injects a prompt. Each phase is literally a new Claude Code turn with its own fresh context window. This solves the context degradation problem (phase 18 gets the same quality as phase 1) but means the stop hook chain is a critical path — a bug in any hook silently breaks the pipeline. See docs/state-machine.md for the full phase graph.

<a name="strive"></a> `/rune:strive` — Swarm Execution

Self-organizing workers parse a plan into tasks and claim them independently:

/rune:strive plans/my-plan.md
/rune:strive plans/my-plan.md --approve    # Require human approval per task

<a name="appraise"></a> `/rune:appraise` — Code Review

Multi-agent review of your git diff with up to 8 specialized Ashes:

/rune:appraise                # Standard review
/rune:appraise --deep         # Multi-wave deep review (up to 18 Ashes across 3 waves)

Built-in reviewers include: Ward Sentinel (security), Pattern Seer (consistency), Flaw Hunter (logic bugs), Ember Oracle (performance), Depth Seer (missing logic), and more. Stack-aware intelligence auto-adds specialist reviewers based on your tech stack.

<a name="audit"></a> `/rune:audit` — Codebase Audit

Full-scope analysis of your entire codebase (not just the diff):

/rune:audit                   # Deep audit (default)
/rune:audit --standard        # Standard depth
/rune:audit --deep            # Multi-wave investigation
/rune:audit --incremental     # Stateful audit with priority scoring and coverage tracking

<a name="mend"></a> `/rune:mend` — Fix Findings

Parse a TOME (aggregated review findings) and dispatch parallel fixers:

/rune:mend tmp/reviews/{id}/TOME.md

<a name="forge"></a> `/rune:forge` — Plan Enrichment

Deepen a plan with Forge Gaze — topic-aware agent matching that selects the best specialists for each section:

/rune:forge plans/my-plan.md
/rune:forge plans/my-plan.md --exhaustive  # Lower threshold, more agents

<a name="goldmask"></a> `/rune:goldmask` — Impact Analysis

Three-layer analysis: Impact (what changes), Wisdom (why it was written that way), Lore (how risky the area is):

/rune:goldmask                # Analyze current diff

<a name="inspect"></a> `/rune:inspect` — Gap Audit

Compares a plan against its implementation across 10 quality dimensions:

/rune:inspect plans/my-plan.md
/rune:inspect plans/my-plan.md --focus "auth module"

<a name="elicit"></a> `/rune:elicit` — Structured Reasoning

24 curated methods for structured thinking: Tree of Thoughts, Pre-mortem Analysis, Red Team vs Blue Team, 5 Whys, ADR, and more.

/rune:elicit

Agents

152 specialized agents across 8 categories:

Review Agents (50)

Core reviewers active in every /rune:appraise and /rune:audit run. UX and design reviewers (below) are conditionally activated for frontend files. Stack specialists are additionally auto-activated based on detected tech stack:

Agent	Focus
Ward Sentinel	Security (OWASP Top 10, auth, secrets)
Pattern Seer	Cross-cutting consistency (naming, error handling, API design)
Flaw Hunter	Logic bugs (null handling, race conditions, silent failures)
Ember Oracle	Performance (N+1 queries, algorithmic complexity)
Depth Seer	Missing logic (error handling gaps, state machine incompleteness)
Void Analyzer	Incomplete implementations (TODOs, stubs, placeholders)
Wraith Finder	Dead code (unused exports, orphaned files, unwired DI)
Phantom Warden	Phantom implementations (spec-to-code gaps, dead specs, unenforced rules)
Tide Watcher	Async/concurrency (waterfall awaits, race conditions)
Forge Keeper	Data integrity (migration safety, transaction boundaries)
Trial Oracle	Test quality (TDD compliance, assertion quality)
Simplicity Warden	Over-engineering (YAGNI violations, premature abstractions)
Rune Architect	Architecture (layer boundaries, SOLID, dependency direction)
Mimic Detector	Code duplication (DRY violations)
Blight Seer	Design anti-patterns (God Service, leaky abstractions)
Refactor Guardian	Refactoring completeness (orphaned callers, broken imports)
Reference Validator	Import paths and config reference correctness
Phantom Checker	Dynamic references (getattr, decorators, string dispatch)
Naming Intent Analyzer	Name-behavior mismatches
Type Warden	Type safety (mypy strict, modern Python idioms)
Doubt Seer	Cross-agent claim verification
Assumption Slayer	Premise validation (solving the right problem?)
Reality Arbiter	Production viability (works in isolation vs. real conditions)
Entropy Prophet	Long-term consequence prediction
Schema Drift Detector	Schema drift between migrations and ORM/model definitions
Agent Parity Reviewer	Agent-native parity, orphan features, context starvation
Senior Engineer Reviewer	Persona-based senior engineer review, production thinking
Cross-Shard Sentinel	Cross-shard consistency for Inscription Sharding (naming drift, pattern inconsistency, auth boundary gaps)
Shard Reviewer	Universal sharded review — all dimensions for assigned file subset
Sediment Detector	Feature sediment detection (dead code paths, unused config)

UX & Design Reviewers (conditionally activated for frontend files):

Agent	Focus
Aesthetic Quality Reviewer	Visual quality beyond pixel-perfect fidelity (AI slop detection, generic layouts)
Design System Compliance Reviewer	Design system convention adherence (token usage, variant patterns)
UX Heuristic Reviewer	Nielsen Norman + Baymard heuristic evaluation (50+ items)
UX Flow Validator	User flow completeness (loading, error, empty states, confirmations)
UX Interaction Auditor	Micro-interactions (hover/focus, keyboard a11y, touch targets, animation)
UX Cognitive Walker	First-time user cognitive walkthrough (discoverability, learnability)

Stack Specialists (auto-activated by detected tech stack):

Agent	Stack
Python Reviewer	Python 3.10+ (type hints, async, Result patterns)
TypeScript Reviewer	Strict TypeScript (discriminated unions, exhaustive matching)
Rust Reviewer	Rust (ownership, unsafe, tokio)
PHP Reviewer	PHP 8.1+ (type declarations, enums, readonly)
FastAPI Reviewer	FastAPI (Pydantic, IDOR, dependency injection)
Django Reviewer	Django + DRF (ORM, CSRF, admin, migrations)
Laravel Reviewer	Laravel (Eloquent, Blade, middleware, gates)
Axum Reviewer	Axum/SQLx (extractor ordering, N+1 queries, IDOR, transaction boundaries)
SQLAlchemy Reviewer	SQLAlchemy (async sessions, N+1, eager loading)
TDD Compliance Reviewer	TDD practices (test-first, coverage, assertion quality)
DDD Reviewer	Domain-Driven Design (aggregates, bounded contexts)
DI Reviewer	Dependency Injection (scope, circular deps, service locator)
Design Implementation Reviewer	Design-to-code fidelity (tokens, layout, responsive, a11y, variants)

Investigation Agents (32)

Used by /rune:goldmask, /rune:inspect, and /rune:audit --deep:

Category	Agents
Impact Tracers	API Contract, Business Logic, Data Layer, Config Dependency, Event Message
Quality Inspectors	Grace Warden (+ inspect, plan-review variants), Ruin Prophet (+ inspect, plan-review), Sight Oracle (+ inspect, plan-review), Vigil Keeper (+ inspect, plan-review)
Deep Analysis	Breach Hunter, Decay Tracer, Decree Auditor, Ember Seer, Fringe Watcher, Hypothesis Investigator, Order Auditor, Rot Seeker, Ruin Watcher, Signal Watcher, Strand Tracer, Truth Seeker
Synthesis	Goldmask Coordinator, Lore Analyst, Wisdom Sage

Research Agents (7)

Agent	Purpose
Repo Surveyor	Codebase structure and pattern analysis
Echo Reader	Surfaces relevant past learnings from Rune Echoes
Git Miner	Git archaeology — commit history, contributors, code evolution
Lore Scholar	Framework docs via Context7 MCP + web search fallback
Practice Seeker	External best practices and industry patterns
Activation Pathfinder	Maps activation path for new code (migrations, config, deployment)
Wiring Cartographer	Maps integration points where new code connects to existing system

Work Agents (8)

Agent	Purpose
Rune Smith	TDD-driven code implementation
Proto Worker	Design prototype synthesis from Figma references
Trial Forger	Test generation following project patterns
Design Sync Agent	Figma extraction and Visual Spec Map creation
Design Iterator	Iterative design refinement (screenshot-analyze-fix loop)
Storybook Reviewer	Component verification via screenshots (Mode A/B quality checks)
Storybook Fixer	Applies Storybook finding fixes with re-verification
Gap Fixer	Automated remediation of inspection gaps from VERDICT.md

Utility Agents (22)

Agent	Purpose
Runebinder	Aggregates multi-agent review outputs into TOME
Mend Fixer	Applies targeted code fixes for review findings
Elicitation Sage	Structured reasoning method execution
Scroll Reviewer	Document quality review
Flow Seer	Feature spec analysis for completeness
Decree Arbiter	Technical soundness validation
Knowledge Keeper	Documentation coverage review
Horizon Sage	Strategic depth assessment
State Weaver	Plan state machine validation (phases, transitions, I/O contracts)
Veil Piercer	Plan reality-gap analysis
Evidence Verifier	Factual claim validation with grounding scores
Research Verifier	Research output quality verification
Truthseer Validator	Audit coverage quality validation
Deployment Verifier	Deployment artifact generation (Go/No-Go checklists, rollback plans)
Design Analyst	Figma frame relationship classifier (5-signal weighted composite)
Todo Verifier	TODO staleness verification — classifies TODOs as VALID or FALSE_POSITIVE
UX Pattern Analyzer	Codebase UX maturity assessment (loading, error, form, navigation patterns)
Codex Phase Handler	Isolated Codex phase execution (codex-exec.sh wrapper)
Tome Digest	TOME finding extraction (P1/P2/P3 counts, recurring patterns) — shell-based
Forge Warden	Multi-perspective backend code review for forge enrichment
Verdict Binder	Inspection aggregator — merges Inspector findings into VERDICT.md
Veil Piercer (Plan)	Plan-level reality-gap analysis and assumption validation

Testing Agents (6)

Agent	Purpose
Unit Test Runner	Diff-scoped unit test execution
Integration Test Runner	API, database, and business logic tests
E2E Browser Tester	Browser automation via agent-browser CLI
Test Failure Analyst	Root cause analysis of test failures
Extended Test Runner	Extended-tier test execution with checkpoint/resume protocol
Contract Validator	API contract validation (request/response schemas)

QA Agents (8)

Agent	Purpose
Phase QA Verifier	Independent arc phase completion artifact verification
Code Review QA Verifier	Verifies code review phase TOME existence and finding quality
Forge QA Verifier	Verifies forge phase enrichment depth and structural preservation
Gap Analysis QA Verifier	Verifies gap analysis compliance matrix and criteria coverage
Mend QA Verifier	Verifies mend resolution report and per-finding status
Test QA Verifier	Verifies test phase SEAL markers and tier coverage
Work QA Verifier	Verifies work phase delegation manifests and task completeness
Design QA Verifier	Verifies design verification phase report and criteria matrix

Meta-QA Agents (8)

Agent	Purpose
Prompt Linter	Lints agent definition files for consistency (15 rules)
Workflow Auditor	Audits arc workflow definitions for structural integrity
Rule Consistency Auditor	Detects contradictions between CLAUDE.md, skills, and talisman
Hook Integrity Auditor	Validates hooks.json entries match actual scripts
Improvement Advisor	Generates fix proposals for meta-QA findings
Hallucination Detector	Detects phantom claims and evidence fabrication in arc artifacts
Effectiveness Analyzer	Per-agent finding accuracy and false-positive tracking
Convergence Analyzer	Retry efficiency, quality trajectory, stagnation detection

Skills

69 skills providing background knowledge, workflow orchestration, and tool integration:

Skill	Type	Purpose
`devise`	Workflow	Multi-agent planning pipeline
`strive`	Workflow	Swarm work execution
`appraise`	Workflow	Multi-agent code review
`audit`	Workflow	Full codebase audit
`arc`	Workflow	End-to-end pipeline orchestration
`arc-batch`	Workflow	Sequential batch arc execution
`arc-hierarchy`	Workflow	Hierarchical plan execution
`arc-issues`	Workflow	GitHub Issues-driven batch arc
`forge`	Workflow	Plan enrichment with Forge Gaze
`goldmask`	Workflow	Cross-layer impact analysis
`inspect`	Workflow	Plan-vs-implementation gap audit
`mend`	Workflow	Parallel finding resolution
`elicitation`	Reasoning	24 structured reasoning methods
`roundtable-circle`	Orchestration	Review/audit 7-phase lifecycle
`rune-orchestration`	Orchestration	Core coordination patterns
`context-weaving`	Orchestration	Context overflow prevention
`rune-echoes`	Memory	5-tier persistent agent memory
`stacks`	Intelligence	Stack-aware detection and routing
`frontend-design-patterns`	Intelligence	Design-to-code patterns (tokens, a11y, responsive, components)
`design-sync`	Workflow	Figma design sync (extraction, implementation, fidelity review)
`inner-flame`	Quality	Universal self-review protocol
`ash-guide`	Reference	Agent invocation guide
`tarnished`	Routing	Unified entry point — natural language to workflow
`using-rune`	Reference	Workflow discovery and routing
`codex-cli`	Integration	Cross-model verification
`testing`	Testing	3-tier test orchestration
`agent-browser`	Testing	E2E browser automation knowledge
`systematic-debugging`	Debugging	4-phase debugging methodology
`file-todos`	Tracking	Structured file-based todos
`git-worktree`	Isolation	Worktree-based parallel execution
`polling-guard`	Reliability	Monitoring loop fidelity
`zsh-compat`	Compatibility	macOS zsh shell safety
`chome-pattern`	Compatibility	Multi-account config resolution
`resolve-gh-pr-comment`	Workflow	Resolve a single GitHub PR review comment
`resolve-all-gh-pr-comments`	Workflow	Batch resolve all open PR review comments
`skill-testing`	Development	TDD for skill development
`debug`	Debugging	ACH-based parallel hypothesis debugging
`codex-review`	Workflow	Cross-model code review (Claude + Codex in parallel)
`learn`	Memory	Session self-learning (CLI corrections, review recurrences)
`figma-to-react`	Integration	Figma-to-React MCP server knowledge
`status`	Reporting	Worker status reporting for swarm execution
`brainstorm`	Workflow	Collaborative idea exploration (solo, roundtable, deep modes)
`design-prototype`	Workflow	Standalone Figma-to-Storybook prototype generator (extract, match, synthesize, verify)
`design-system-discovery`	Intelligence	Design system auto-detection (libraries, tokens, variants)
`resolve-todos`	Workflow	File-based TODO resolution with verify-before-fix pipeline
`runs`	Reporting	Inspect per-agent structured artifacts from workflow runs
`storybook`	Intelligence	Storybook component verification knowledge (CSF3, MCP tools)
`elevate`	Memory	Promote project echoes to global scope with domain tagging
`team-sdk`	Orchestration	Centralized team management SDK (ExecutionEngine, lifecycle)
`team-status`	Reporting	Active agent team monitoring dashboard
`test-browser`	Testing	Standalone browser E2E testing (no agent teams)
`untitledui-mcp`	Integration	UntitledUI MCP integration (6 tools, builder-protocol)
`ux-design-process`	Intelligence	UX design methodology (heuristic evaluation, flow validation)
`talisman`	Configuration	Deep talisman.yml management (init, audit, update, guide, status)
`cc-inspect`	Workflow	Run Claude Code built-in inspection script
`discipline`	Quality	Proof-based orchestration discipline for spec compliance
`post-findings`	Workflow	Post review findings to GitHub PR as formatted comment
`self-audit`	Quality	Meta-QA self-audit of Rune's own plugin infrastructure
`arc-quick`	Workflow	Quick 4-phase pipeline: plan → work → review → mend
`variant-hunt`	Analysis	Systematic variant analysis — "find more like this" for confirmed findings
`supply-chain-audit`	Security	Dependency risk analysis (maintainer count, CVE history, abandonment)
`pr-guardian`	Automation	Cron-based PR shepherd loop — comments, lint, CI, rebase, migrations, browser test, auto-merge
`codex-status`	Reporting	Codex activity summary for current/recent arc run
`verify`	Workflow	Verify TOME findings before mend (TRUE_POSITIVE/FALSE_POSITIVE classification)
`react-composition-patterns`	Intelligence	React compound components, state lifting, explicit variants, React 19 APIs
`react-native-patterns`	Intelligence	React Native/Expo best practices (FlashList, Reanimated, native navigation)
`react-performance-rules`	Intelligence	React/Next.js performance — 69 rules across 8 categories
`react-view-transitions`	Intelligence	React View Transition API — placement, types, CSS recipes, Next.js integration
`web-interface-rules`	Intelligence	Web interface quality — 100+ UI/UX/a11y rules across 15 categories

Configuration

Rune is configured via talisman.yml (dozens of top-level sections, 100+ keys):

# Project-level (highest priority)
.rune/talisman.yml

# User-global
~/.rune/talisman.yml

Quickest way to configure: Run /rune:talisman init to auto-detect your stack and generate a tailored config.

<details> <summary>Example configuration</summary>

version: 1

# File classification — decides which Ashes get summoned
rune-gaze:
  backend_extensions: [.py]
  skip_patterns: ["**/migrations/**", "**/__pycache__/**"]

# Work execution
work:
  ward_commands: ["ruff check .", "mypy .", "pytest --tb=short -q"]
  max_workers: 3

# Arc pipeline
arc:
  timeouts:
    forge: 900000               # 15 min
    work: 2100000               # 35 min
    code_review: 900000         # 15 min
  ship:
    auto_pr: true
    merge_strategy: "squash"

# Review settings
review:
  diff_scope:
    enabled: true
    expansion: 8

# Goldmask impact analysis
goldmask:
  enabled: true
  devise:
    depth: enhanced             # basic | enhanced | full

# Cross-model verification
codex:
  enabled: true
  workflows: [devise, arc, appraise]

# Custom Ashes
ashes:
  custom:
    - name: "my-reviewer"
      agent: "my-custom-agent"
      source: ".claude/agents/my-custom-agent.md"

</details>

See talisman.example.yml for the full schema with all options.

Codex CLI Integration (Optional)

Rune supports OpenAI Codex CLI as a cross-model verification layer. If you have a ChatGPT Pro subscription, you can enable Codex to add a second AI perspective alongside Claude — giving you higher-confidence results through independent cross-verification.

What Codex adds

Workflow	Codex Role
`/rune:arc`	Gap analysis phase — Codex independently reviews implementation gaps
`/rune:appraise`	Cross-model review — Claude and Codex review in parallel, findings are cross-verified
`/rune:devise`	Plan validation — Codex provides a second opinion on plan feasibility
`/rune:codex-review`	Dedicated cross-model review — runs Claude + Codex agents side by side

Findings are tagged with confidence levels: CROSS-VERIFIED (both models agree), STANDARD (single model), or DISPUTED (models disagree).

Trade-off: quality vs. time

Enabling Codex increases runtime for every workflow that uses it — each Codex invocation adds an extra verification pass. For /rune:arc, this can add 10–20 minutes on top of the already 1–3 hour pipeline. Enable it when correctness matters more than speed.

Enable / Disable

Codex integration is controlled via talisman.yml:

# .rune/talisman.yml
codex:
  enabled: true                          # Set to false to disable entirely
  workflows: [devise, arc, appraise]     # Which workflows use Codex

To disable: set codex.enabled: false or remove the codex section. Rune auto-detects whether the codex CLI is installed and authenticated — if not available, Codex phases are silently skipped.

Prerequisites

ChatGPT Pro subscription (for Codex API access)
Codex CLI installed: npm install -g @openai/codex
Authenticated: codex login
.codexignore file in project root (required for --full-auto mode)

MCP Tool Integrations (Optional)

Rune supports third-party MCP servers for component libraries and design tools. Declare them in talisman.yml and Rune routes them into the right workflow phases automatically.

UI Builder Protocol (v1.133.0+)

The UI Builder Protocol integrates any component library MCP (UntitledUI, shadcn/ui, custom) into Rune's full pipeline — planning, implementation, design sync, and code review:

Integration Point	What happens
`/rune:devise`	Plan includes `ui_builder` frontmatter section + Component Strategy
`/rune:strive`	Workers injected with builder workflow (search → get → customize)
`/rune:design-sync`	Phase 1.5 Component Match: reference code → library search → annotated VSM
`/rune:appraise`	Compliance reviewer generates `DSYS-BLD-*` findings for convention violations

UntitledUI is supported out of the box — register the MCP server and add talisman config. No project skill needed.

shadcn/ui and custom libraries: create a builder skill with builder-protocol frontmatter.

# .rune/talisman.yml — minimal builder integration
integrations:
  mcp_tools:
    untitledui:
      server_name: "untitledui"
      tools:
        - { name: "search_components", category: "search" }
        - { name: "get_component", category: "details" }
      phases: { devise: true, strive: true, arc: true }
      skill_binding: "untitledui-mcp"   # built-in plugin skill
      trigger:
        extensions: [".tsx", ".ts"]
        keywords: ["ui", "component"]
        always: false

See docs/guides/ui-builder-protocol.en.md for the full developer guide.

MCP Integration Framework (v1.131.0+)

Declarative integrations.mcp_tools talisman config routes any MCP tool into the right workflow phases, with trigger conditions, rules injection, and companion skill auto-loading.

See docs/guides/mcp-integration-spec.en.md for the full spec (3 integration levels, schema reference, trigger system, worked examples).

Architecture

rune/
├── .claude-plugin/
│   └── marketplace.json          # Marketplace registry
└── plugins/
    └── rune/                     # Main plugin
        ├── .claude-plugin/
        │   └── plugin.json       # Plugin manifest (v1.128.0)
        ├── agents/               # 109 core agent definitions
        │   ├── review/           #   17 review agents
        │   ├── investigation/    #   31 investigation agents
        │   ├── utility/          #   17 utility agents
        │   ├── research/         #    8 research agents
        │   ├── work/             #    7 work agents
        │   ├── qa/               #    8 QA agents
        │   └── meta-qa/          #    9 meta-QA agents
        ├── registry/             # 43 extended agents
        ├── skills/               # 69 skills
        ├── commands/             # 16 slash commands
        ├── hooks/                # Event-driven hooks
        │   └── hooks.json
        ├── scripts/              # Hook & utility scripts (256 .sh/.py files)
        ├── .mcp.json             # MCP server config (5 servers: echo-search, figma-to-react, agent-search, context7, figma-context)
        ├── talisman.example.yml  # Configuration reference
        ├── CLAUDE.md             # Plugin instructions
        ├── CHANGELOG.md
        └── README.md             # Detailed component reference

State Machine Reference

Every Rune workflow is an explicit state machine with named phases, conditional gates, and error recovery tiers. See docs/state-machine.md for mermaid diagrams of all 10 workflows — useful for debugging pipeline failures, understanding phase transitions, and verifying correctness.

Key Concepts

Term	Meaning
Tarnished	The orchestrator/lead agent that coordinates workflows
Ash	Any teammate agent (reviewer, worker, researcher)
TOME	Aggregated findings document from a review
Talisman	Configuration file (`talisman.yml`)
Forge Gaze	Topic-aware agent matching for plan enrichment
Rune Echoes	5-tier persistent agent memory (`.rune/echoes/`)
Inscription	Contract file (`inscription.json`) for agent coordination
Seal	Deterministic completion marker emitted by Ashes
Discipline Engineering	The architectural backbone — 5-layer proof-based system ensuring spec compliance over task completion. See full document

Known Gotchas

A few things to know when working with Rune — especially if you're debugging a pipeline failure or writing custom hooks/scripts:

Gotcha	Details
macOS bash is 3.2	The system `bash` on macOS is ancient (3.2). No associative arrays, no `readarray`, no `\|&`. Rune's `enforce-zsh-compat.sh` hook auto-fixes 5 common patterns at runtime, but custom scripts must target bash 3.2.
`status` is read-only in zsh	zsh (macOS default shell) treats `status` as read-only. Using `status=` in any script will silently fail or crash. Use `task_status` or `tstat` instead. Enforced by `enforce-zsh-compat.sh`.
Hook timeout budget is tight	PreToolUse hooks: 5s. Stop hooks: 15s (arc-phase) or 30s (detect-workflow). A slow `git` or `gh` call in a hook can cause silent timeout — the hook is killed and the phase loop breaks.
Stop hooks chain in sequence	6 Stop hooks fire in order: `arc-phase-stop-hook.sh` (inner) → `arc-batch-stop-hook.sh` → `arc-hierarchy-stop-hook.sh` → `arc-issues-stop-hook.sh` → `detect-workflow-complete.sh` → `on-session-stop.sh` (outer). A crash in an inner hook breaks all outer hooks.
SEAL convention for completion	Ashes emit `<seal>TAG</seal>` as their last output line. The `on-teammate-idle.sh` hook checks for this marker to distinguish "done writing" from "idle mid-task". Missing seals cause premature aggregation.

See the Troubleshooting guide for more operational details.

Torrent — Tmux Arc Orchestrator

Torrent is a standalone Rust TUI tool that manages rune:arc execution across multiple Claude Code sessions using tmux:

Multi-config support — use different CLAUDE_CONFIG_DIR accounts
tmux isolation — each arc gets its own Claude Code instance with clean context
Crash resilience — tmux sessions survive if torrent exits
Channels bridge (--channels) — bidirectional communication with Claude Code via Channels API. Bridge View ([b] key) provides full-screen chat with message history and persistence

Install

# Install to ~/.local/bin (recommended)
curl -fsSL https://raw.githubusercontent.com/vinhnxv/rune/main/torrent/install.sh | bash

# Or install system-wide
curl -fsSL https://raw.githubusercontent.com/vinhnxv/rune/main/torrent/install.sh | bash -s -- --system

See torrent/README.md for full documentation.

Requirements & Compatibility

Requirement	Minimum	Recommended
Claude Code	2.1.81+	Latest
OS	macOS 12+, Linux (Ubuntu 20.04+)	macOS 14+, Ubuntu 22.04+
Shell	bash 3.2+ or zsh 5.0+	zsh (macOS default)
Python	3.11+ (for MCP servers)	3.12+
Node.js	18+ (for Context7 MCP)	20+
jq	1.6+	Latest
git	2.25+	Latest
Claude Plan	Pro ($20/mo) for basic use	Max ($200/mo) for full Arc pipeline

Windows: Not currently supported. WSL2 with Ubuntu may work but is untested.

Resources Overview

Resource	What you'll find
Getting Started	First-time walkthrough — plan, work, review in 3 commands
Plugin Component Reference	All agents, skills, commands, hooks in detail
Arc & Batch Guide	End-to-end pipeline, batch mode, GitHub Issues
Talisman Configuration	Full configuration reference
Troubleshooting	Debugging, cost optimization, common issues
Documentation Hub	All guides, English + Vietnamese
State Machines	Mermaid diagrams of all 10 workflow state machines
Torrent TUI	Tmux-based multi-session arc orchestrator
Changelog	Release history

License

MIT

Rune

Rune

What Is This?

Why This Exists

Install

Setup

Quick Configuration (Optional)

How It Works

Workflows

Quick Start (New Users)

/rune:tarnished — The Unified Entry Point

Core Commands

Batch & Automation

Utilities

Workflow Details

<a name="devise"></a> /rune:devise — Planning

<a name="arc"></a> /rune:arc — End-to-End Pipeline

<a name="strive"></a> /rune:strive — Swarm Execution

<a name="appraise"></a> /rune:appraise — Code Review

<a name="audit"></a> /rune:audit — Codebase Audit

<a name="mend"></a> /rune:mend — Fix Findings

<a name="forge"></a> /rune:forge — Plan Enrichment

<a name="goldmask"></a> /rune:goldmask — Impact Analysis

<a name="inspect"></a> /rune:inspect — Gap Audit

<a name="elicit"></a> /rune:elicit — Structured Reasoning

Agents

Review Agents (50)

Investigation Agents (32)

Research Agents (7)

Work Agents (8)

Utility Agents (22)

Testing Agents (6)

QA Agents (8)

Meta-QA Agents (8)

Skills

Configuration

Codex CLI Integration (Optional)

What Codex adds

Trade-off: quality vs. time

Enable / Disable

Prerequisites

MCP Tool Integrations (Optional)

UI Builder Protocol (v1.133.0+)

MCP Integration Framework (v1.131.0+)

Architecture

State Machine Reference

Key Concepts

Known Gotchas

Torrent — Tmux Arc Orchestrator

Install

Requirements & Compatibility

Resources Overview

Links

License

`/rune:tarnished` — The Unified Entry Point

<a name="devise"></a> `/rune:devise` — Planning

<a name="arc"></a> `/rune:arc` — End-to-End Pipeline

<a name="strive"></a> `/rune:strive` — Swarm Execution

<a name="appraise"></a> `/rune:appraise` — Code Review

<a name="audit"></a> `/rune:audit` — Codebase Audit

<a name="mend"></a> `/rune:mend` — Fix Findings

<a name="forge"></a> `/rune:forge` — Plan Enrichment

<a name="goldmask"></a> `/rune:goldmask` — Impact Analysis

<a name="inspect"></a> `/rune:inspect` — Gap Audit

<a name="elicit"></a> `/rune:elicit` — Structured Reasoning