vinhnxv

Full codebase audit using Agent Teams. Sets scope=full and depth=deep (by default), then delegates to the shared Roundtable Circle orchestration phases. Summons up to 7 built-in Ashes (custom Ashes wired in orchestration layer in v3.x). Optional `--deep` runs multi-wave investigation with deep Ashes. Phase 0.45 context building spawns context-builder agent to map trust boundaries, invariants, and

Expert guidance for creating Claude Code skills and slash commands. Use when working with SKILL.md files, authoring new skills, improving existing skills, creating slash commands, or understanding skill structure and best practices.

Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, update or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.

Multi-agent code review using Agent Teams. Summons up to 7 built-in Ashes in standard mode, each with their own dedicated context window. Handles scope selection, team creation, review orchestration, aggregation, verification, and cleanup. Optional `--deep` runs multi-wave deep review with up to 18 Ashes across 3 waves. Phase 1.5 adds UX reviewers when frontend files are detected (UX subsystem har

Full plan-to-merged-PR pipeline with checkpoint framework, QA phases, and multi-agent orchestration. Use when running end-to-end from plan to merge, resuming an interrupted arc with --resume after a crash or session end, or when any named phase fails (forge, work, code-review, mend, test, ship, merge, etc. — see body for full phase list). Keywords: arc, pipeline, --resume, checkpoint, convergence,

Multi-agent planning workflow using Agent Teams. Combines brainstorm, research, validation, synthesis, shatter assessment, forge enrichment, and review into a single orchestrated pipeline with dependency-aware task scheduling.

Proof-based orchestration discipline for spec-compliant multi-agent systems. Five layers: DECOMPOSITION, COMPREHENSION, VERIFICATION, ENFORCEMENT, ACCOUNTABILITY. Use when: workers need discipline context, proof schemas, anti-rationalization guidance. Keywords: discipline, proof, verification, compliance, spec, acceptance criteria, rationalization, evidence, SOW, spec continuity

Use when summoning Rune agents, when encountering "agent not found" errors, when selecting which review agents to use, or when checking agent capabilities and tools. Quick reference for all 116 agents across 8 categories (74 core in agents/ — investigation, meta-qa, qa, research, review, utility, work + 42 extended in registry/ — investigation, review, testing, utility, work). Plus 13 shared resou

Use when spawning 4+ agents, when "Prompt is too long" errors appear, when sessions exceed 50 messages, or when context feels degraded. Prevents overflow before agent summoning, compresses long sessions, and offloads verbose content to filesystem. Keywords: context overflow, prompt too long, glyph budget, compression, long session.

Use when comparing multiple approaches, when a decision has security or architecture implications, when root cause analysis is needed, or when thinking needs structure. Provides 24 reasoning methods (Tree of Thoughts, Pre-mortem, Red Team, 5 Whys, ADR). Auto-loaded by plan, forge, and review commands for eligible sections. Keywords: structured reasoning, trade-off, decision, compare approaches, ri

Structured file-based todo tracking for Rune workflows. Each todo is a markdown file with YAML frontmatter and lifecycle status. Source-aware templates adapt for review findings, work tasks, PR comments, tech debt, and audit findings. Session-scoped: todos live in tmp/{workflow}/{timestamp}/todos/, cleaned by /rune:rest. Use when creating, triaging, resolving, or querying todos from any Rune workf

Use when assessing blast radius of changes, when understanding WHY code was written a certain way, when planning risky modifications, or when a refactor could have hidden side effects. Traces WHAT changes, WHY it exists (git archaeology), and HOW RISKY the area is (churn + ownership metrics). Keywords: impact analysis, blast radius, risk assessment, code archaeology, why was this written.

Plan-vs-implementation deep audit using Agent Teams. Parses a plan file (or inline description), extracts requirements, and summons 4 Inspector Ashes to measure implementation completeness, quality across 11 dimensions, and gaps across 9 categories. Produces a VERDICT.md with requirement matrix, dimension scores, gap analysis, and actionable recommendations. Also use `--verify-tome <tome-path>` to

Post Rune review findings to a GitHub PR as a formatted comment. Parses TOME.md findings, formats as collapsible markdown, posts via gh api. Use after /rune:appraise or /rune:arc to share findings with team. Trigger keywords: post findings, PR comments, share review, post to PR, post review to GitHub, comment on PR with findings, share findings.

Meta-QA self-audit for Rune's own workflow system. Audits agent definitions, workflow phases, rules, hooks for inconsistencies, contradictions, and drift. Produces SELF-AUDIT-REPORT.md with per-dimension scores and actionable findings. Use when: "audit rune itself", "check rune health", "self-audit", "meta-qa", "rune consistency check", "lint agents", "validate workflow", "check hooks". Covers: Wo

Multi-agent work execution using Agent Teams. Parses a plan into tasks, summons swarm workers that claim and complete tasks independently, and runs quality gates before completion.

Collaborative exploration of features and ideas through structured dialogue. Explore WHAT to build before planning HOW. Three modes: Solo (conversation), Roundtable (agent advisors engage user), Deep (advisors + elicitation sages). Produces persistent brainstorm documents in docs/brainstorms/. Use when: "brainstorm", "explore idea", "what should we build", "discuss feature", "thao luan", "kham pha

Claude Code runtime environment inspector. Comprehensive diagnostic tool that reports all Claude Code environment variables, session identity, config directory, plugin paths, system toolchain versions, Rune runtime state, and platform details. Use when debugging environment issues, verifying session isolation, checking config directory resolution, or diagnosing plugin loading. Trigger keywords: cc

ACH-based parallel debugging. Spawns multiple hypothesis-investigator agents to investigate competing hypotheses simultaneously. Use when bugs are complex, when single-agent debugging hits 3+ failures, or when root cause is unclear. Also triggers when test-failure-analyst returns LOW confidence during arc Phase 7.7. Keywords: debug, investigate, hypothesis, root cause, parallel debugging, ACH, com

Parallel finding resolution from TOME. Parses structured findings, groups by file, summons mend-fixer teammates to apply targeted fixes, runs ward check once after all fixers complete, and produces a resolution report.

Automated PR guardian loop — schedules a recurring cron (every 5 min) that checks review comments, CI/CD status, branch freshness, runs browser tests, and auto-merges when everything is green. Use when you want hands-off PR shepherding to merge. Triggers on "pr guardian", "auto merge loop", "watch my PR", "shepherd PR", "auto merge", "monitor PR", "drive PR to merge".

Batch resolve all unresolved PR review comments. Fetches review threads AND issue comments (bot feedback) with pagination. Categorizes, auto-resolves outdated, groups related comments, and batches fixes into a single commit. Handles all known review bots with hallucination checking. Keywords: resolve all, PR comments, batch, review, bot, GitHub.

Use when running /rune:strive with --worktree flag or when work.worktree.enabled is set in talisman. Use when a worker's direct commit fails due to parallel isolation conflicts, when a merge conflict is detected during wave merge (merge broker escalation), or when branches from multiple workers need sequential merging into the feature branch. Covers: worktree lifecycle, wave-based execution, merge

Display monitoring dashboard for active Rune agent teams and any background-dispatched workers. Shows team members, task progress, completion percentage, health indicators, pending questions, and dispatch state. Use when checking what's running, diagnosing stuck workflows, or auditing dispatch progress. Keywords: status, team status, dashboard, check progress, monitor, team management, dispatch, b

Deepen an existing plan with Forge Gaze topic-aware enrichment. Summons specialized Ashes to enrich each section with expert perspectives. Can target a specific plan or auto-detect the most recent one.

Universal self-review protocol for all Rune teammates. Adapts checklist per agent role (worker, fixer, reviewer, researcher, forger, aggregator). Enforces completeness verification, hallucination detection, codebase rule compliance, and value assessment before any task can be marked complete. Use when: Any teammate is about to mark a task complete or send a Seal. Keywords: self-review, inner-flame

Resolve a specific GitHub PR review comment. Supports review thread comments (line-level) and issue comments (PR-level from bots). Handles copilot, gemini-code-assist, coderabbitai, cubic-dev-ai, before applying fixes. Can be used standalone or invoked from arc Phase 9.2 for individual comment resolution. Keywords: resolve, PR comment, review, bot feedback, GitHub.

Resolve file-based TODOs using Agent Teams with verify-before-fix pipeline. Each TODO is reviewed before any fix is applied, preventing hallucinated fixes. Uses parallel batch processing with file ownership enforcement. Keywords: resolve, todos, fix, batch, parallel, verify, file-todos.

Use when running /rune:appraise or /rune:audit, when spawning multiple review agents, when TOME aggregation fails or produces malformed output, or when a TeammateIdle hook fires before expected output is written. Handles 7-phase lifecycle (pre-flight, Rune Gaze, inscription, spawn, monitor, aggregate, cleanup) for up to 8 parallel reviewers. Use when team cleanup fails after a review, when on-team

Use when choosing between supervisor, swarm, or pipeline coordination for multi-agent workflows, when two agents produce conflicting findings and deduplication is needed, when TOME aggregation fails or produces duplicate prefixes, or when output format mismatch causes downstream parse errors. Use when defining inscription contracts for file-based handoff, or when detecting which Ash type to use fo

Use when creating new skills, auditing existing skill compliance, verifying agent behavior under pressure, or when agents bypass rules despite explicit instructions. Provides a TDD methodology for documentation: write a failing scenario first, then write the skill to address it. Also use when observed agent output contradicts skill requirements, when rationalizations appear in agent messages, or w

Stack-Aware Intelligence — auto-detects project tech stack (Python, TypeScript, Rust, PHP) from manifest files, routes context to domain-relevant skills, and selects specialist review agents. Covers detection, context routing, knowledge profiles, and enforcement agents. Trigger keywords: stack detection, context router, language profile, framework checklist, specialist agent, stack awareness.

Use when a worker hits repeated failures (3+ attempts on the same task), when test failures have unclear root causes, when build errors persist after obvious fixes, when runtime behavior doesn't match expectations, or when "it works locally but fails in CI." Also use when test-failure-analyst returns LOW confidence, when ward check fails after a fix attempt, or when mend-fixer cannot reproduce a f

Analyze project dependencies for supply chain risks. Checks maintainer count, commit frequency, CVE history, abandonment signals, bus factor, and security policy presence for each direct dependency. Supports npm, pip, cargo, go mod, and composer. Use when: "supply chain audit", "dependency risk", "check dependencies", "maintainer risk", "abandoned packages", "dependency health", "package security"

Master command — natural-language router for all Rune workflows. Parses VN+EN input, chains multi-step workflows, checks prerequisites. Also a Rune expert for guidance and education ("how does rune work", "what should I do"). Use for: "/tarnished plan|work|review|arc ...", "rune help", "which command", "do everything", "thảo luận", "khám phá", master command, routing, custom agent, agent list.

Centralized team management SDK for Rune workflows. Provides ExecutionEngine interface (TeamEngine), shared lifecycle protocols (teamTransition, cleanup, session isolation), preset system, and monitoring utilities. Use when spawning agent teams, monitoring teammates, or cleaning up workflows. Loaded automatically by workflow skills (appraise, strive, devise, mend, etc). Keywords: team management,

Test orchestration pipeline for arc Phase 7.7 — 4-tier testing (unit, property-based, integration, E2E/browser) with diff-scoped discovery and structured reporting. Extended tier covers contract validation, visual regression, design tokens, a11y, test history, and flaky detection. Auto-loaded by the arc orchestrator during the test phase. Keywords: testing, test pipeline, unit test, integration, E

Use when the user asks to review code, plan features, brainstorm ideas, audit a codebase, implement a plan, fix review findings, debug failed builds, analyze code impact, or run end-to-end workflows. Also use when the user seems unsure which Rune command to use, when the user says "review", "plan", "brainstorm", "explore idea", "audit", "implement", "fix findings", "ship it", "check my code", "wha

Find similar bugs across the codebase based on a confirmed finding. Takes a TOME finding ID or pattern description, extracts the root cause, and systematically searches for variants using progressive generalization. Use when: "find more like this", "variant analysis", "similar bugs", "same pattern elsewhere", "hunt for variants", "variant hunt".

Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).