Why Rune?

Most skill ecosystems are either too many isolated skills (540+ that don't talk to each other) or rigid pipelines (A → B → C, if B fails everything stops).

Rune is a mesh — 67 skills with 248 connections + 46 signals across a 5-layer architecture. Every declared outbound call is acknowledged by its target, forming resilient workflows that adapt when things go wrong.

Pipeline:  A → B → C → D         (B fails = stuck)
Hub-Spoke: A → HUB → C           (HUB fails = stuck)
Mesh:      A ↔ B ↔ C             (B fails = A reaches C via D→E)
           ↕       ↕
           D ↔ E ↔ F

Benchmark: With Rune vs Without Rune

We ran 10 standardized coding tasks on Claude Code — once without Rune (vanilla), once with Rune — and measured tokens, cost, duration, and correctness.

Headline Results

                Without Rune    With Rune     Delta
Avg Tokens:     541,400         454,491       ↓ 16%
Avg Cost:       $0.69           $0.65         ↓ 6%
Avg Duration:   2.3 min         2.1 min       ↓ 9%
Avg Tool Calls: 14              13            ↓ 7%
Correctness:    9/10            9/10          =

Where Rune Shines: Complex Tasks

| Task | Difficulty | Tokens | Cost | Duration | Tools | |------|-----------|--------|------|----------|-------| | Refactor 450-line component | Medium | -62% | -17% | -32% | -27% | | Full feature (auth + API + tests) | Complex | -36% | -29% | -31% | -27% | | Add Zod validation | Easy | -9% | -28% | -32% | 0% | | Dark mode across 6 components | Hard | ~0% | +10% | -7% | -6% |

Rune doesn't make Claude smarter — Claude already knows how to code. Rune makes Claude disciplined. The more complex the task, the more discipline matters.

"Without Rune, Claude writes code that works. With Rune, Claude writes code that lasts."

| # | Task | Diff | Tokens | Cost | Time | Correct | |---|------|------|--------|------|------|---------| | 1 | Zod Validation | Easy | -9% | -28% | -32% | ✅ → ✅ | | 2 | Fix N+1 Query | Easy | +12% | +25% | +3% | ❌ → ❌ | | 3 | Cursor Pagination | Med | +12% | +19% | -9% | ✅ → ✅ | | 4 | Security Review | Med | +13% | +32% | +3% | ✅ → ✅ | | 5 | Rate Limiting | Med | +12% | +5% | +5% | ✅ → ✅ | | 6 | Refactor Component | Med | -62% | -17% | -32% | ✅ → ✅ | | 7 | Dark Mode (6 files) | Hard | ~0% | +10% | -7% | ✅ → ✅ | | 8 | DB Migration | Hard | +52% | +11% | +49% | ✅ → ✅ | | 9 | Memory Leak Debug | Hard | +13% | +28% | -2% | ✅ → ✅ | | 10 | Full Auth System | Complex | -36% | -29% | -31% | ✅ → ✅ |

Methodology: Claude Code CLI headless mode (claude -p --output-format json), 10 tasks with fixture code, pattern-based correctness evaluation. Source: Benchmark/

Level Up: Rune Pro

Free gives the agent discipline. Pro adds two capabilities the free tier does not:

• Autopilot — approve a plan once and walk away. It executes each phase autonomously (self-reviews with zero-HIGH gates, regression-checks against baselines, commits per phase) and resumes across sessions. cook gets the job done; autopilot gets it done while you sleep.
• Context Intelligence — a live context cockpit with real %, active mesh layer, cost, and predictive compaction timing. Claude Code hosts the executable statusline natively; Codex uses its built-in footer plus the full Pro watcher/HUD. Hooks save decisions and progress to .rune/ before compaction.

Plus 9 domain packs (product, sales, data-science, support, growth, media, personal-brand, ecommerce, vietnam). $49 lifetime, one-time — no subscription.

What's New (v2.32.0 — Drawing the Mesh)

v2.32.0 (2026-08-16): Rune can finally draw. A new diagram skill (media group) renders editorial architecture, flowchart, sequence, state, ER, and swimlane figures as self-contained HTML/SVG — inline CSS, inline SVG, no Mermaid renderer, no remote images. v0.1 shipped ten visual types, seven semantic patterns (fan-in queues, attempt stage frameworks, unbroken policy traces…), a 9-node complexity budget, mandatory orthogonal connectors, and a machine-checked geometry gate (self_check.py + verify_geometry.py). v0.2 added extract-then-redraw for Mermaid sources (.mmd/fenced blocks) behind a hard trust boundary — labels are inert data, never instructions — with exit codes that make parse/usage/integrity failures checkable. v0.3 added loop, layers, data-flow, process, and routing of seven semantic patterns onto layout types; status is always text (PASS/FAIL/BLOCKED), never color-only. ba, scout, docs, slides, and sentinel now offer diagram as suggested_next, and docs hands off with an explicit rune:diagram reference — the mesh is now 67 core skills / 248 connections with a clean orphan gate. Separately, the quarantine hook was silently mute: registered async: true, which Claude Code never lets inject additionalContext; it is now synchronous and block reasons actually reach the model. 1,659 tests.

Previous (v2.31.0 — Measured, Not Grepped)

v2.31.0 (2026-08-01): Three checks that passed without measuring anything, and two motion rules that were confidently wrong. review and preflight checked that prefers-reduced-motion appeared in a file — but a guard existing is not the finding. They now catch the failures that grep clean: a dead branch where if (reduced) return runs before the end-state helper, one-shot matchMedia with no change listener, duration: 0 on sequence-as-content, 0s while something awaits transitionend, and JS timelines (GSAP/Motion/Lenis) that a CSS media query cannot stop. MOTION-CRAFT §10 is now role-first — is the sequence the content, or is it decorating a result that exists either way? — with four reduce strategies instead of "fewer and gentler". Two motion rules were fixed outright: ease-in is wrong on arrival but right on departure and falling, and easing chosen by name says nothing about whether a large rotation strobes — peak = maxSlope × travel / duration against a ~30°/frame ceiling, so a 360° turn needs ~1050ms on ease-out-expo (slope 5.26) and ~365ms on a sine-ish curve (1.82). New §14 SVG motion mechanics covers user units vs screen pixels, pathLength, per-instance ids, and the six SVGO plugins that destroy an animated SVG at build time. Finally, completion-gate gains rule 6 — a tool that measured nothing promotes nothing: "no difference found" and "no measurement taken" are the same output, so a null result promotes a claim to OBSERVED only once the instrument is shown capable of returning something else, and verification now requires every clean result to carry the size of what it examined. 1,653 tests.

Earlier (v2.30.3 — Say What You Mean)

v2.30.3 (2026-07-29): Claude Code 2.1.218 changed context: fork to run in the background by default (opt out with background: false), and six Rune skills were relying on the old default without saying so — cook, team, launch, rescue (every L1 orchestrator), plus scout and docs-seeker. A background fork reports back as a task notification instead of returning in-line, which silently breaks any caller that needs the result: cook waiting on scout is exactly that shape, and it fails looking like the sub-step did nothing. All six now declare background: false, and validate-skills.js fails on any fork skill that leaves it unstated — writing that gate is what surfaced four of the six. Measured honestly: on 2.1.220 in headless mode a 12-second fork returned in-line either way, so this removes a dependency on an unstated default the vendor has announced changing, rather than fixing a reproduced break. 1,653 tests.

Earlier (v2.30.2 — Blocked, With a Reason)

v2.30.2 (2026-07-29): Finishes the hook I/O sweep, plus the fault that sweep uncovered. Claude Code shows the model only stderr for an exit-2 block, and pre-tool-guard explained itself on stdout — so a blocked read surfaced as hook error: […]: No stderr output. The block worked; the model just never learned why, and could only guess whether to stop or route around it. New emitBlock() writes the reason to stderr (Claude Code) and the envelope to stdout (Codex), then exits 2 — verified end-to-end by the model quoting the reason back. Three hooks v2.30.1 missed are also fixed: quarantine hand-built its envelope and shipped it with process.stdout.write right before process.exit(0), while auto-format and typecheck printed bare console.log with no envelope at all (unflushed on Claude Code, rejected outright by Codex). Two new repo-wide gate tests — no hook writes stdout directly, no hook reads stdin asynchronously — so a new hook cannot reintroduce either. 1,651 tests.

Earlier (v2.30.1 — Hooks That Land)

v2.30.1 (2026-07-29): Five hooks had been running, exiting 0, and reaching nobody — nothing logged an error, so the hook layer looked healthy while contributing nothing. Two independent faults, each fatal on its own: process.stdout.write from an exit handler is not guaranteed to reach a piped stdout (most hooks emit via captureConsole, which flushes on exit — the envelope was built, "written", and lost; now fs.writeSync(1, …)), and a hook that collects stdin with an async listener has its stdout discarded by Claude Code even when the write is synchronous (new hooks/lib/hook-stdin.cjs reads with readFileSync(0); intent-router, context-watch, metrics-collector, pre-tool-guard, quarantine converted). Both isolated by differential test — identical hooks, one variable at a time — and confirmed by the model quoting hook-injected context back. Separately, intent-router never had an index to read: skill-index.json is emitted at build time and Claude Code doesn't compile, so all five candidate paths were missing and it exited silently on every prompt since it shipped. New scripts/build-skill-index.js generates it at the plugin root with a --check staleness gate in CI. It was also registered "async": true, which drops additionalContext outright. 1,649 tests.

Earlier (v2.30.0 — Tier Restored)

v2.30.0 (2026-07-29): Rune's model tier table had quietly stopped applying on Claude Code, and had been wrong in 23 of 66 places for longer than that. agents/*.md is a hand-written parallel copy of each skill's tier; nothing generated it from skills/ and no check compared the two, so they drifted — cook said opus in one file and sonnet in the other, verification said sonnet and haiku. skills/*/SKILL.md is now the single source of truth, every pair agrees, and a new validateAgentSync gate fails CI on any future drift, alongside a model-split check and a warning for a top-level model that cannot take effect. Where the two disagreed the tier was decided by role, with one rule overriding both old values: a gate never runs below sonnet — completion-gate, constraint-check, integrity-check, hallucination-guard, and verification exist to catch unverified claims, so running them cheaper than the agent they audit defeats the point. Separately: tiering only ever applied through spawned subagents, and on Opus 5 the harness tells the model not to spawn them unless asked — so every tier assignment had become a silent no-op. scout and docs-seeker now declare context: fork + model: haiku and route through the Skill tool instead; verified end-to-end on Opus 5 by per-model billing showing claude-haiku-4-5. cook deliberately declares no model — an orchestrator inherits the session model, because choosing Opus for a session is a deliberate act. 1,647 tests.

Earlier (v2.29.1 — One-Command Update)

v2.29.1 (2026-07-24): v2.29.0 documented the update flow; this release automates it. New rune update command — one-shot updater for an already-configured project: git pull --ff-only any detected Pro/Business tier repos (env var → sibling dir, same detection as setup; a failed pull aborts loudly, never a silent half-update), re-runs the managed setup rewrite in place non-interactively (your installed platforms, preset, and tiers are detected from the existing hook config — no prompts), then verifies with doctor + hook drift and reminds Codex users to re-trust /hooks only when .codex/hooks.json actually changed. Flags: --no-pull, --preset, --tier, --dry. Plus: "Updating" sections in all three tier READMEs. Docs-and-CLI patch — no skill or mesh changes. 1,641 tests.

Earlier (v2.29.0 — Codex Native)

v2.29.0 (2026-07-23): Codex stops being a compile target that happens to work and becomes a first-class native runtime. The Codex adapter now emits everything current Codex supports natively — .agents/skills/, project-scoped agent TOML (.codex/agents/rune-{heavy,standard,fast}.toml), a dedicated synchronous hook adapter targeting .codex/hooks.json (Codex silently skips async handlers), MCP config, and tier-aware compilation so Free/Pro/Business stacks resolve exactly as on Claude Code. The mesh validator was fixed at the root — Calls (outbound) is now the single authoritative edge inventory, acknowledged by the target's Called By — moving the canonical count from 209 to 248 connections (same mesh, honest count; doctor now fails CI on any stale claim). Doctor also grew a cross-tier audit: Business metadata (28 pack skills, 4 orchestrators), $149 pricing, 13-platform count, and JSON-schema validation of the new docs/config-schema.json + hooks manifest schema. All XLabs remote-MCP references now go through XLABS_MCP_TOKEN — plaintext bearer values are forbidden. 1,615 tests pass.

Earlier (v2.28.0 — Reasoner's Blind Spots)

v2.28.0 (2026-07-22): Completes the reasoning wave. Every addition targets one failure class: a check that feels done because the model re-read its own work and agreed with itself. problem-solver (v0.6.0) gains a model failure-mode table beside its human-bias table — pattern-match satisfaction, template hijack, fluent≠true, prior-as-fact, completion pressure, surface blindness — plus three tells that you are inside one right now (instant confident answer; a stated detail your draft never used; two failed attempts in the same framing). verification (v0.8.0) gains the Constraint Loop for deliverables carrying a mechanically checkable constraint on their own surface form (banned characters, exact counts, strict formats) — a class Rune had no coverage for: expand the constraint before drafting, verify with a tool, re-scan the whole artifact, ship byte-for-byte. design (v0.9.0) gains render blindness — a checklist item ticked from source is a prediction, and the imagined render is always flattering; visual items are marked 👁 and are ticked from a render or marked ASSUMED. Advisory throughout, no new skills.

Earlier (v2.27.0 — Calibrated Output)

v2.27.0 (2026-07-22): Rune had one opinion about response shape — caveman, optimising token count — and no rule for what a style may not compress. That gap had teeth: caveman's "hedging dies" list auto-activates at ORANGE/RED context and deleted phrases like "I'm assuming the migration ran", promoting an unverified claim into observed grammar at exactly the point in a session where the agent is most likely to be wrong. New output-mode layer (context-engine) holds every mode behind one activation contract and a five-rule precedence list — shape is negotiable, substance is not: calibration > evidence > a skill's ## Output Format > safety > actionability > economy. New actionable mode optimises distance-to-doing (next action first, steps numbered, position restated each turn) and stacks with caveman. New claim discipline in completion-gate types every load-bearing statement OBSERVED / DERIVED / PRIOR / ASSUMED — hallucination is an unverified claim wearing the grammar of an observation — and adds a DECLARED verdict so an honest hedge is recorded as an open item, never scored as a lie.

Earlier (v2.26.2 — Hook Output Contract)

v2.26.2 (2026-07-22): The other half of the Codex wiring fix — v2.26.1 made the hook matchers fire, this makes the hooks succeed. Codex parses hook stdout as JSON and reports anything else as hook: <Event> Failed, discarding the output; Rune's hooks printed bare [Rune: ...] lines, so every hook that loaded on Codex ran, exited 0, and had its output thrown away. Hooks now emit the envelope both runtimes accept — hookSpecificOutput.additionalContext for context events, systemMessage otherwise — which is Claude Code's documented contract too, not a Codex branch. Verified live against codex-cli 0.145: the same hook goes SessionStart Failed → SessionStart Completed.

Earlier (v2.26.1 — Codex Wiring)

v2.26.1 (2026-07-22): Rune's runtime hooks were silently inert on Codex CLI. hooks/hooks.json is loaded by both Claude Code and Codex — Codex reads <plugin>/hooks/hooks.json, the same path, and maps the event names — but every tool matcher named only Claude's tools. Codex has no Read, Write, Edit or Bash tool; it issues shell_command, exec, apply_patch, view_image, spawn_agent. So the privacy gate and the secret scanner matched nothing and never fired. Matchers now name both platforms' tools (plain alternation — Claude behaviour is byte-for-byte unchanged), and pre-tool-guard reads the target path out of a Codex apply_patch payload (*** Update File: <path>), which is what makes it an actual gate there instead of a no-op. Codex skips async hooks; current releases therefore ship a separate synchronous hooks/codex-hooks.json through the native Codex plugin manifest.

Earlier (v2.26.0 — Motion Craft)

v2.26.0 (2026-07-18): Rune's UI mesh gains a deep motion authority. New reference skills/design/MOTION-CRAFT.md is the canonical source for animation decisions: the should-it-animate frequency gate (never animate keyboard/100+-per-day actions), easing decision tree with strong custom curves, per-element duration budgets (UI under 300ms, modals/drawers exempt to 500ms), physicality rules (never scale(0), origin-aware popovers, press feedback), spring physics (damping/response, velocity handoff, momentum projection, rubber-banding), interruptibility (transitions vs keyframes, @starting-style), motion performance, reduced-motion, and a reverse-lookup vocabulary glossary. design (v0.8.0) loads it whenever a domain involves motion and gains an advisory motion-audit mode. review (v1.5.0) adds Motion Craft Checks — an advisory lens that fires only on motion diffs, flagging ease-in on UI, scale(0) entrances, animation on high-frequency actions, layout-property animation, and more, citing MOTION-CRAFT for exact fixes. perf (v0.6.0) adds Step 5.5 Motion Performance — GPU-property, Framer-Motion-shorthand, and recalc-storm detection ranked in the Cost Impact Hierarchy. Advisory-first throughout (no new HARD-GATEs) — enrichment only, mesh unchanged at 66 skills.

Earlier (v2.25.0 — Council)

v2.25.0 (2026-07-11): New council L3 primitive — genuinely decorrelated multi-perspective gathering. Detects installed AI CLIs, fans a question across distinct model families (external CLIs when present, subagents when not), gates off-topic/malformed voices, normalizes claims (anchor-first + shared-evidence arbiter fallback — prose similarity never counts), and arbitrates inline with an honest NO_DECORRELATION stamp when fewer than 2 real model families answered. Wired into 4 consumers: adversary (CRITICAL-tier plans), review (high-blast-radius diffs), brainstorm (Design-It-Twice candidate judgment), problem-solver (high-stakes conclusions) — every integration explicitly refuses to launder a same-family run as independent confirmation. Live-dogfooded same day: a real 3-voice self-test (external grok dispatch + 2 subagent fallbacks) independently converged on a real gap — "confirmed" model_family was CLI-brand identity, not verified backend identity, letting two CLIs redirected to the same backend (BYOK/proxy override) defeat the gate — fixed before shipping. Pro: council-cockpit (separate repo) adds a read-only live panel + cost-aware allocation + history-informed family weighting, PRE-council advisory only — Free never depends on Pro. Mesh now 66 skills / 208 connections / 45 signals.

Previous (v2.24.0 — Market Refresh)

v2.24.0 (2026-07-11): Model lineup + platform adapters refreshed to the mid-2026 landscape. Claude tiers across the mesh → Opus 4.8 / Sonnet 5 / Haiku 4.5; the Codex adapter initially targeted GPT-5.6 sol / terra / luna. Current releases use sol plus terra at different reasoning efforts because luna is not a valid current Codex model. Fable 5 is positioned as an API-only frontier oracle target rather than a routing tier (opus stays the ceiling). Windsurf → Devin Desktop rebrand documented (emission kept on .windsurf/, which Devin still reads). New goal-first advisory in plan/ba to leverage native /goal + Managed Agents Outcomes. CI 1572/1572.

v2.23.0 (2026-07-04): Seven platform adapters move to the Agent Skills open standard (dir-per-skill SKILL.md, discovered and lazy-loaded by each platform's native loader). The headline fix: Codex dropped .codex/skills/ from its scan list, so compiled skills were only findable via the AGENTS.md pointer — agents kept "re-finding" the path mid-session. Codex now emits to .agents/skills/ (scanned CWD → repo root). Same treatment across the fleet: cursor .cursor/rules/*.mdc → .cursor/skills/ (Cursor 2.4+ Skills, on-demand instead of always-on), windsurf → .windsurf/skills/ (Cascade Skills), copilot → .github/skills/, qoder → .qoder/skills/, and gemini/qwen drop their all-skills-always-on context bombs (GEMINI.md bundle, QWEN.md @import wall) for native .gemini/skills/ / .qwen/skills/ + slim pointer files — a big context-window win on those platforms. Runtime hooks intentionally stay on .cursor/rules / .windsurf/rules (always-on is correct for hook context). Also fixes a YAML double-escaping bug that corrupted compiled frontmatter for skills with quoted descriptions on 6 platforms, and a duplicate scripts/ copy in dir-per-skill builds. If you previously built for Codex/Cursor/Windsurf/Copilot/Gemini/Qwen/Qoder: re-run npx @rune-kit/rune build and delete the old output dirs. CI 1571/1571.

Previous (v2.22.2 — Convergence, Dogfooded)

v2.22.2 (2026-07-04): Patch: rune setup now installs tier skills into the Claude Code PLUGIN CACHE (newest version dir) instead of the executing package's own root — npx runs were copying Pro skills into npx's ephemeral cache (invisible to the plugin runtime, 'Unknown skill: rune:autopilot' returned), and source-checkout runs polluted the git tree. v2.22.1: tier-hook loader accepts PreCompact + SessionStart lifecycle events — required by Pro hooks v1.2.0 (context-reset). v2.22.0: The v2.21.0 gates went through a live-fire dogfood: fresh executor agents (zero author context) ran converge and verification Level 3.5 against a fixture with a dead Submit button, a handler-less Export button, a navigation-anchor decoy, and a declared placeholder. Both gates caught the dead button with file:line evidence and zero false positives — and the 16 ambiguities the executors reported became spec fixes: converge v0.2.0 adds a deferred-debt class (declared design debt can no longer force a false escalation), a Plan Claims vs Reality section (tasks marked [x] whose code doesn't exist — surfaced first-class), and derived story verdicts; verification v0.7.0 gets FAIL-dominates precedence, per-route reverse checks, and server/static entry-point exemptions. The dogfood fixture itself shipped as the seed of npm run eval — a behavioral eval harness that runs a fresh headless agent against fixture repos and asserts outcomes, because structural validation can't prove a skill makes an agent behave. Pro autopilot v1.6.0 now explicitly runs Phase 6.5 CONVERGE in autonomous mode.

Previous (v2.21.0 — Convergence)

v2.21.0 (2026-07-03): Kills the most expensive silent failure in AI-built apps: the dead button — UI renders, click does nothing, backend never existed. New converge skill (65th) re-reads your spec/plan/contracts as the sole source of intent and scans the ACTUAL code for missing / partial / contradicts / unrequested gaps, appending remediation tasks until spec and code converge (cook Phase 6.5, max 2 rounds then honest escalation). The whole chain got teeth: ba v1.2.0 emits story-sliced specs (P1/P2/P3 priorities, per-story Independent Test, Key Entities), plan v1.7.0 emits contracts-first boundary artifacts (data-model.md + contracts/ + quickstart.md) with a P1 zero-coverage HARD-GATE and a Data→Logic→Endpoint→UI ordering law (UI is structurally last), verification v0.6.0 adds Level 3.5 INTERACTION WIRED (traces button → handler → route across React/Svelte/Vue syntax), completion-gate v1.9.0 makes the E2E flow trace mandatory for UI+data diffs (single-phase included), and deploy v0.8.0 warns before shipping UI+data changes with no wiring evidence. 3 new mesh signals (convergence.gaps, convergence.clean, integration.verified). Every gate is diff-scoped — legacy debt warns, new work fails.

Previous (v2.20.0 — Spec Discipline)

v2.20.0 (2026-07-02): Closes the "plan without spec" gap — a brainstorm → plan → cook chain no longer skips ba. Two new gates (brainstorm spec-presence + cook Phase 0 Spec-Backfill Gate) force requirements before code on every bypass path, not just brainstorm's. Batch also lands ba v1.1.0 (EARS FR-n functional-requirements layer), adversary v0.4.0 (reasoning-mode catalog + steelman-first), and a context-hook fix (session_id keying — no more false "100% compact"). Mesh 204 connections, 1,559 tests.

v2.19.0 (2026-06-20): New rune dashboard verb renders Rune's flagship human-visible artifact — a self-contained HTML "Codebase Briefing + Governance Scorecard" you can open in a meeting with no server, no CDN, no telemetry, nothing leaving the machine. The headline is the governance/value verdict (0-100 score with honest — empty-state), not a code graph — the buyer's codebase graph lives in the Understand tab (node/edge filters, domain view with flow steps, guided tour, node inspector, PNG/SVG/JSON export, keyboard-accessible canvas). Five-tab IA: Verdict → Govern / Measure / Understand / Improve. Tier-aware — Free sees verdict + measure, Pro adds a "My Lens" cost/ROI persona, Business unlocks the full Governance Scorecard (gate-outcome ledger + compliance coverage). Honest by design: empty states render — not fabricated numbers, and Free/Pro see an upsell that describes value rather than fake data. XSS-hardened + 100% self-contained. Internals: comprehension.js split 3584 → 1255 LOC (browser app extracted to comprehension-client.js, byte-identical output). Built on existing onboard / autopsy / analytics / mesh generators — original work, no external dependency. CI 1558/1558.

Previous (v2.18.1 — Setup Installs Tier Skills, Not Just Hooks)

v2.18.1 (2026-05-17): Bug fix — rune setup --tier pro|business now copies the tier's skills/ directories into the Free plugin's skills/ folder. Before this fix, paid tiers shipped hooks only, so rune:autopilot (Pro) returned Unknown skill: rune:autopilot because the SKILL.md was at Pro/skills/autopilot/ but invisible to the Claude Code plugin runtime. New installTierSkills in compiler/commands/setup.js runs after installHooks, copies each <tierRoot>/skills/<name>/ into <runeRoot>/skills/, idempotent (skips existing — protects Free skills from clobber and user-edited Pro skills from stomp), with path-traversal guard + symlink rejection + partial-copy cleanup + version-drift detection. Paired with Pro autopilot-v1.5.0 (Step 0 LOAD now reads user-message context for plan path — same pattern cook uses). 25/26 setup tests pass (1 skipped on Windows — symlink test needs admin/dev-mode). Full CI 1444 tests.

Previous (v2.18.0 — Cross-Platform Reach + Discipline Tightening)

v2.18.0 (2026-05-15): Compiler grew from 8 → 13 platforms with five new adapters: Aider (per-skill aider/rules/ + auto-generated .aider.conf.yml read: array), GitHub Copilot CLI (.github/instructions/*.instructions.md w/ documented applyTo YAML), Gemini CLI (bundled GEMINI.md for single-file context), Qoder (.qoder/rules/ + AGENTS.md), Qwen Coder (qwen/skills/ + QWEN.md with @import). New adapter.generateExtraFiles() hook with path-traversal guard + frozen stats snapshot — replaces ad-hoc adapter special-cases (codex AGENTS.md migrated). Discipline tightening: design v0.6.0 adds Step 2.9 Rules 4/5/6 (measurable constraints, no #000/#fff/lorem ipsum, CJK-first font stack); skill-forge v1.9.0 adds soft examples/ convention for output-format skills; sentinel-env v0.4.0 expands Tier 8 binary detection (Bun, Cargo, Deno, Volta, asdf, proto). New CONTRIBUTING.md "What we don't accept" non-goals section. Source: graft from nexu-io/html-anything (Apache-2.0). CI 1435/1435.

Previous (v2.17.1 — One-Command Setup Wizard)

v2.17.1 (2026-05-06): New rune setup interactive wizard collapses the multi-step cd <project> && export RUNE_PRO_ROOT && rune hooks install --preset gentle --tier pro workflow into one command — auto-detects Pro/Business tiers across env var / sibling / well-known paths, asks for scope (current project / global) + preset, installs hooks. New --global flag on rune hooks install writes to ~/.claude/settings.json (every Claude Code session, regardless of project). Non-interactive mode via --here / --global / --tier / --preset / --dry flags. Anti-paywall — wizard ships in Free, NOT Pro/Business (tier-agnostic infrastructure UX). Doc sweep: README "One-Command Setup", HOOKS.md restructure, agent skill-routing row for "set up rune". CI 1376/1376.

Previous (v2.17.0 — Quarantine + Hook Drift Reporter)

v2.17.0 (2026-05-06): New L3 skill quarantine ships a PostToolUse advisory hook for untrusted external content (MCP user-content, WebFetch, upload Reads). Honest scope: hook lands [QUARANTINE-NOTICE] in next-turn additionalContext, biasing the model to treat prior external content as data — NOT structural defense. Layered against permissions.deny (egress) + integrity-check (state). Default trusted-MCP allowlist (linear / github / jira / atlassian / Drive / neural-memory) skips advisory; operator extends at ~/.claude/quarantine.d/trusted-mcp-allowlist.txt. Per-session disable via QUARANTINE_DISABLE=1. Wired into rune hooks install --preset gentle|strict. New rune doctor --hooks drift reporter. CI 1367/1367.

Previous (v2.16.1 — Skill Enrichment + Triage Workflow + Output Modes)

v2.16.1 patch (2026-05-02): ba v0.13.0 → v1.0.0 first stable major (no functional changes — maturity stamp). Doc/signal hygiene: CLAUDE.md "Current Wave" synced; 4 terminal-observability signals whitelisted in validate-signals.js. CI 1349/1349.

• debug v1.2.0 — Step 0: Build Feedback Loop — 10-rank ladder (failing test → curl → CLI snapshot → headless browser → trace replay → throwaway harness → fuzz → bisection → differential → HITL script). Codifies "the loop is the speed limit" — a fast deterministic pass/fail signal turns debugging into mechanical bisection. Skip if repro is already < 5s and deterministic; > 10 min loop construction triggers 3-Fix Escalation (architecture is the problem).
• plan v1.6.0 — Vertical Slice Mode — tracer-bullet task decomposition. Each task = end-to-end path through schema + API + UI + test, demoable on its own. AFK / HITL classification. Stops "horizontal layer" planning that blocks on the slowest layer.
• context-engine v1.2.0 — Caveman Output Mode — auto-activates on context ORANGE / RED (or /caveman). Strips filler / articles / hedging / pleasantries while preserving full technical accuracy (~75% output reduction). Auto-clarity exceptions for security warnings, destructive-action confirmations, multi-step sequences, root-cause diagnosis.
• ba v1.0.0 — Synthesis Mode + Out-of-Scope WRITE — when prior conversation has rich context (pasted spec, > 1000 words, continuation session), extract Requirements Document with source citations and confirm instead of re-interviewing. Step 1.6 closes the .out-of-scope/ write loop: explicit mid-elicitation rejections produce a durable .out-of-scope/<slug>.md record so future sessions don't re-litigate.
• context-pack v0.3.0 — Agent Brief Variant — durable handoff format for AFK agents (issue tracker queues, autopilot multi-session work). Behavioral over procedural; type names over file:line. Survives codebase drift between handoff and execution.
• review-intake v1.3.0 — Issue Triage Mode — new mode for issue tracker items (PR Review remains default). State machine: needs-triage → needs-info / ready-for-agent / ready-for-human / wontfix. Repro-first HARD-GATE for bugs (calls debug Step 0 if multi-component). Vague issues route to ba Synthesis Mode for grilling. AGENT-BRIEF emission for ready-for-agent.
• 5 new mesh signals — output.density.set, triage.classified, agent.brief.ready, outofscope.recorded + EXTERNAL_TRIGGER_SIGNALS whitelist concept (symmetric to INTENTIONAL_BROADCAST_SIGNALS).
• Validator cleanups — validate-skills.js Done-When regex relaxed (scope-aware, supports mode-based subsections); 9 pre-existing validation errors cleaned. validate-signals.js gained EXTERNAL_TRIGGER_SIGNALS set.
• Provenance — second graft pass from mattpocock/skills (MIT). Round 1 had silently grafted 7 patterns (improve-architecture, CONTEXT.md, design-it-twice, zoom-out, oracle-mode, grill, out-of-scope); Round 2 + 2b documented + extended.

Previous (v2.15.0 — Second Opinion + Cross-Provider + Routing Clarity)

• adversary v0.2.0 — Mode: oracle — when agent.stuck fires from debug (3 disproved hypotheses) or fix (2+ failed attempts), oracle-mode dispatches a stateless second-model pass with explicit "no prior context" framing. Bundle format is regex-validated ([SYSTEM] invariant role-priming + [USER] template + ### File N), token-capped (100k bundle, 4k per file, 12 files max), citation-required reply contract. Secrets auto-redacted. Breaks the confirmation-bias loop that scout's zoom-out (structural pivot) cannot.
• session-bridge v0.8.0 — Detach Mode — async escalation primitive. Heavy-model second-opinion calls (1-10 min wall time) no longer block the primary agent. .rune/oracle-pending/<sessionId>.json is the rendezvous file; idempotent dispatch (bundleHash-keyed); 10min default timeout; 24h orphan cleanup on session start. cook Phase 4 and team Phase 3 reattach via filesystem poll between adjacent tasks.
• context-engine v1.1.0 — Mode: preview — pre-flight cost gate. Caller emits context.preview BEFORE bundle build with file list + estimated tokens (chars × 0.25). Per-caller thresholds: adversary 50k/100k, team 30k/80k (per worker), review 40k/100k, audit 60k/120k. Action enum proceed | warn | block. Override via RUNE_CONTEXT_THRESHOLDS_<CALLER>. Stops team parallel workstreams from silently blowing $20 of Opus tokens.
• Cross-provider model mapping — 5 non-Anthropic adapters now translate model: opus|sonnet|haiku to provider-correct names. codex → gpt-5.6-sol / gpt-5.6-terra / gpt-5.6-terra. antigravity → gemini-3-pro / gemini-3-flash / gemini-3-flash-lite. opencode / openclaw / generic → tier:heavy / tier:mid / tier:light (provider-agnostic). claude / cursor / windsurf remain no-op (Anthropic backend understands native names).
• Routing clarity sweep — all 63 SKILL.md descriptions now double-quoted (YAML safety). 13 ambiguous-name skills got explicit "Use when…" routing hints so skill-router doesn't have to guess: ba, completion-gate, constraint-check, doc-processor, integrity-check, logic-guardian, onboard, preflight, sentinel-env, watchdog, worktree, hallucination-guard, mcp-builder.
• 4 new mesh signals — oracle.dispatched, oracle.response, oracle.failed, context.preview. All registered in Signal Catalog with full emit/listen mapping. agent.stuck listeners updated to include adversary in addition to scout.
• 1,331 tests — +71 from v2.14.0 across 5 new test files: adapter-model-mapping (18), oracle-bundle-format (19), oracle-pending-schema (16), context-preview-signal (13), skill-description-quality (5).

Previous (v2.14.0 — Deep Modules)

• improve-architecture skill (NEW L2, opus) — controlled vocabulary (Module / Interface / Implementation / Depth / Seam / Adapter / Leverage / Locality), numeric depth-leverage-locality scoring (1–5 each), 4 dependency categories, structured proposal payloads.
• TDD vertical-slicing HARD-GATE — test v1.3.0 catches "horizontal slicing" (5 tests before any GREEN), commit-pair audit trail, shape-test smell detector.
• .out-of-scope/ knowledge base — ba v0.11.0 reads, review-intake v1.2.0 writes. Stops re-litigation of rejected features.
• CONTEXT.md inline-sharpen + ADR 3-criteria gate — journal v0.4.0 only opens an ADR when sum ≥ 11 + each axis ≥ 3.
• Agent Brief durability — context-pack v0.2.0 regex smell tests block stale paths/line numbers.
• Design-It-Twice mode — brainstorm v0.6.0 with constraint-pinned parallel subagents + diversity score gate.
• Zoom-out + explore-first micro-utilities — scout v0.4.0 listens for agent.stuck; ba Step 2.0 HARD-GATE requires tool-call evidence.

Previous (v2.13.0 — Script Contract + Media Pack)

• @rune-pro/media pack v1.0.0 — new Pro pack: raster image generation across 5 providers (Codex CLI, DALL-E, Replicate, Stability AI, local SD), prompt engineering with 4-gate safety check (trademark, public-figure, prompt-injection, uncanny-precondition), batch asset pipeline with multi-resolution variants + WebP/AVIF conversion + EXIF strip.
• sentinel-env v0.3.0 — 9-tier binary detection for hard-dependency checks.
• skill-forge v1.8.0 — new Phase 5.25 "Script Contract" — helper scripts must follow stdout=paths / stderr=diagnostics / --json opt-in / semantic exit codes. HARD-GATE on pre-ship verification.
• OpenClaw adapter — generateManifest now declares artifactConvention.

Previous (v2.12.0 — Auto-Discipline)

• Runtime auto-discipline — rune hooks install wires native hooks on Claude Code, Cursor, Windsurf, Antigravity so preflight, sentinel, completion-gate auto-fire before tool use. No more "remember to invoke the skill."
• Three presets — strict (blocking gates), gentle (warnings, default), off (uninstall). Idempotent install / uninstall with full restore of user hooks.
• Multi-tier hook layering — --tier pro / --tier business stack paid-tier hooks on top of Free using a tier-tagged manifest at $<TIER>_ROOT/hooks/manifest.json. Free compiler stays tier-agnostic (MIT-clean).
• logic-guardian v0.3.0 — rune init now auto-seeds .rune/INVARIANTS.md with project-detected rules (money math, state machines, payment flows). Preflight reads it as a hard gate.
• session-bridge v0.7.0 — emits context.compact.imminent signal; cook/plan/team listen and checkpoint work before compaction.
• autopilot v1.1.0 (Pro) — honors the hooks manifest; runs overnight with the same blocking gates your interactive sessions enforce.
• Security — tier name sanitization (path-traversal-safe), precise statusLine detection (no false-positive uninstall of user commands), overrides migration for legacy hook entries.
• 1,152 tests — +31 from v2.11.0 covering hooks adapter, tier manifest loader, override migration, and review regressions.

Previous (v2.11.0)

• Mesh integrity — 8 dead wires fixed, 5 workflow gaps closed (hotfix chain, API versioning, monorepo mode, feature flags, dependency upgrade campaigns)
• audit v0.4.0 — DX Review Mode: Addy Osmani's 8 developer experience principles with scoring rubric and browser-pilot integration
• cook v2.4.0 — remediation cycle counter + upstream inconsistency protocol
• problem-solver v0.4.0 — Cynefin, SWOT, PESTLE, Porter's Five Forces, ethics framework
• plan v1.5.0 — autopilot suggested_next: autonomous execution path for Pro users after plan approval
• Autopilot routing — skill-router Tier 1 entry for Pro autopilot ("auto", "làm hết", "đi ngủ" → autonomous mode)

Previous (v2.10.0)

• marketing v0.4.0 — anti-AI copy rules (banned phrases, 5 hook types, specificity mandate), expanded SEO audit with schema markup guide (10 types + @graph pattern), programmatic SEO awareness (4 playbooks), optional Pro content-scorer/cro-analyst integration
• Pro growth pack v1.1.0 — 3 new skills (content-scorer, cro-analyst, marketing-psych) + 6 existing skills enriched with SEO Machine patterns

Previous (v2.8.0)

• Anti-Loop Intelligence — 7 core skills enriched with execution loop detection, saturation analysis, error pattern matching, artifact folding, budget-aware progression, and recovery policy routing
• cook v2.1.0 — observation/effect ratio tracking (detects stuck agents reading without writing) + budget-aware phase progression with hard caps on replans, quality retries, and session tool calls
• completion-gate v1.8.0 — execution loop audit: classifies tool calls as observation vs effect, flags imbalanced ratios and repeating sequences in gate reports
• scout v0.3.0 — info saturation detection: tracks entity discovery rate and content similarity to stop scanning when diminishing returns detected
• research v0.4.0 — diminishing returns detection: monitors new-entity ratio and result overlap across searches to skip redundant queries
• context-engine v0.9.0 — artifact folding: large tool outputs (>4000 chars or >120 lines) saved to .rune/artifacts/ with compact preview in context
• debug v1.0.0 — known error pattern catalog: 8 error archetypes (STATELESS_LOSS, MODULE_NOT_FOUND, TYPE_MISMATCH, ASYNC_DEADLOCK, etc.) with recovery hints + error fingerprinting for dedup
• fix v0.8.0 — recovery policy matrix: classifies errors into 8 types (INPUT_REQUIRED→PROMPT_USER, TIMEOUT→RETRY, POLICY_BLOCKED→ABORT, etc.) before attempting fixes
• Source attribution cleanup — removed all enrichment credit lines from skill files to reduce context noise

Previous (v2.7.0)

• Deep Knowledge — 8 core skills enriched with battle-tested patterns: context compaction, structured cumulative memory, milestone analysis, multi-provider adapters, AI-driven interview, prompt-as-API-contract, token budget tracking, incremental stream processing
• 946 Tests — compiler + signals + hooks + scripts + status + visualizer validation

Previous (v2.6.0)

• Mesh Signals — event-driven skill communication via frontmatter. Skills declare emit and listen signals; compiler builds a signal graph in skill-index.json. 23 signals across 15 core skills
• Signal Validation — scripts/validate-signals.js checks orphan listeners (hard error), unlistened emitters (warning), signal naming conventions
• Mesh Contract (v2.5.0) — .rune/contract.md project-level invariants enforced by cook + sentinel as hard gates
• Tier Override — Pro/Business packs override Free packs with skill-level merging
• Scripts Bundling — compiler copies scripts/ directories, resolves {scripts_dir} placeholders

Signal Graph

Skills communicate through declarative signals — no runtime event bus, just metadata for discovery, validation, and routing:

scout ──emit:codebase.scanned──→ plan, brainstorm
fix ────emit:code.changed──────→ test, sentinel, review, preflight, verification
test ───emit:tests.passed──────→ deploy
test ───emit:tests.failed──────→ debug
sentinel─emit:security.passed──→ deploy
debug ──emit:bug.diagnosed─────→ fix
deploy ─emit:deploy.complete───→ watchdog
cook ───emit:phase.complete────→ session-bridge

What Rune Is (and Isn't)

Rune started as a Claude Code plugin and now compiles to every major AI IDE. Same 67 skills, same mesh connections, same workflows — zero knowledge loss across platforms.

OpenAI Codex is now a first-class native runtime too: Rune ships .codex-plugin/plugin.json, synchronous Codex lifecycle hooks, project-scoped .codex/agents/*.toml roles, and .agents/skills/ output. Codex hook trust is still explicit; review newly installed definitions with /hooks.

| | Rune Provides | Agent Runtime Provides | |---|---|---| | Workflows | 8-phase TDD cycle (cook), parallel DAG execution (team), rescue pipelines | Tool calling | | Quality Gates | preflight + sentinel + review + completion-gate (parallel) | None built-in | | Domain Knowledge | 14 extension packs (trading, SaaS, mobile, etc.) | General-purpose | | Cross-Session State | .rune/ directory (decisions, conventions, progress) | Conversation only | | Mesh Resilience | 248 skill connections + 45 mesh signals, fail-loud-route-around | Runtime execution | | Cost Optimization | Model-role hints and task routing | Available models | | | | | | Sandbox & Permissions | — | The runtime handles this | | Agent Spawning | Orchestration policy | Claude Task/Agent, Codex spawn_agent, or runtime equivalent | | MCP Integration | Connector workflows | The runtime's MCP client | | File System Access | — | The runtime's permissions |

Common Misconceptions

| "Rune doesn't have..." | Reality | |---|---| | Task graph / DAG | team skill: DAG decomposition → parallel worktree agents → merge coordination | | CI quality gates | verification skill: lint + typecheck + tests + build (actual commands, not LLM review) | | Memory / state | session-bridge + journal: cross-session decisions, conventions, ADRs, module health | | Multi-model strategy | Every skill has assigned model: haiku (scan), sonnet (code), opus (architecture) | | Agent specialization | 67 specialized skills plus native role definitions; Claude uses Task/Agent and Codex uses spawn_agent collaboration primitives | | Security scanning | sentinel: OWASP patterns, secret scanning, dependency audit. sast: static analysis |

Install

One-Command Setup (recommended)

After installing Rune, run the wizard once to wire native hooks and platform-compiled skills — pick scope, runtime, and tiers:

npx @rune-kit/rune setup

The wizard auto-detects what you have:

Rune Setup Wizard
──────────────────
Free version:    2.18.0 (cached)
Pro detected:    sibling (../Pro) (v1.1.0)
Business:        not detected

Where to install hooks?
  [c] Current project — D:/MyProject/.claude/settings.json
  [g] Global          — ~/.claude/settings.json
       (every Claude Code session, regardless of project)

Scope [c/g] (default c): g
Install Pro tier? [Y/n]: y
Preset [g/s] (default g): g

✓ Wired 5 hooks to ~/.claude/settings.json
  Verify: rune doctor --hooks

What does the wizard do? It installs Rune-managed lifecycle hooks in the selected runtime's native configuration and installs tier skills in that runtime's native skill directory. For Claude this is .claude/settings.json; for Codex it is .codex/hooks.json plus .agents/skills/. With --tier pro, it also wires loop-circuit-breaker (auto-engages only in autopilot sessions).

Non-interactive mode (CI / scripted):

npx @rune-kit/rune setup --here --platform codex --preset gentle --tier pro
npx @rune-kit/rune setup --here --platform all --preset strict --tier pro,business
npx @rune-kit/rune setup --here --no-tier --dry      # preview without writing

Claude Code (Native Plugin)

# Install via Claude Code CLI
claude plugin add rune-kit/rune

Or add manually in ~/.claude/settings.json under installed_plugins.

Full mesh: subagents, hooks, adaptive routing, mesh analytics. Run npx @rune-kit/rune setup afterward to wire hooks (see One-Command Setup above).

OpenAI Codex (Native Plugin)

# From the project that should receive Rune
npx @rune-kit/rune setup --here --platform codex

# Paid tiers are compiled through the Codex adapter too
npx @rune-kit/rune setup --here --platform codex --tier pro,business

Rune emits .agents/skills/, project-scoped .codex/agents/rune-{heavy,standard,fast}.toml, a managed AGENTS.md block, and synchronous .codex/hooks.json definitions. Review and trust newly installed hooks with /hooks.

Cursor / Windsurf / Antigravity / Any IDE

# Compile Rune skills for your platform
npx @rune-kit/rune init

# Or specify platform explicitly
npx @rune-kit/rune init --platform cursor
npx @rune-kit/rune init --platform windsurf
npx @rune-kit/rune init --platform antigravity

This compiles all 67 skills into your IDE's rules format. Same knowledge, same workflows.

Platform Comparison

| Feature | Claude Code | OpenAI Codex | Other compiled targets | |---------|-------------|--------------|------------------------| | Skills available | 67/67 | 67/67 | 67/67 | | Mesh connections | 248 + 46 signals | 248 + 46 signals | 248 + 46 signals as native rules/skills | | Workflows & HARD-GATEs | Full | Full | Full knowledge, runtime-dependent enforcement | | Extension packs | 14 | 14 | 14 | | Subagent parallelism | Native Task/Agent | Native spawn_agent | Sequential fallback unless supported | | Lifecycle hooks | Native executable hooks | Native synchronous hooks | Native where supported; inline constraints otherwise | | Role/model routing | Claude model roles | Project-scoped Codex agent roles | Adapter-specific | | Mesh analytics | Runtime metrics | Runtime metrics | Adapter-dependent |

Same mesh, platform-native delivery. Claude Code and Codex receive native agents and lifecycle hooks; the remaining adapters preserve the workflows and constraints in the best format each runtime supports.

Updating

New releases are announced on Telegram and GitHub Releases; see CHANGELOG.md for what changed.

One-liner alternative: npx @rune-kit/rune@latest update runs the whole flow below for an already-configured project — git-pulls detected Pro/Business repos, re-runs the managed setup rewrite in place (reusing your installed platforms/preset/tiers), and verifies with doctor. The platform-specific commands below remain the canonical path.

Claude Code (plugin)

claude plugin update rune

Restart Claude Code to load the new version, then re-run the wizard once so hooks and tier skills match the new release:

npx @rune-kit/rune@latest setup

Codex / Cursor / Windsurf / other compiled platforms

Re-running setup with @latest fetches the newest compiler and rewrites everything Rune manages in place — it is idempotent, and never touches your own config or the human-authored parts of AGENTS.md:

# same flags you installed with, e.g.:
npx @rune-kit/rune@latest setup --here
npx @rune-kit/rune@latest setup --here --platform codex --tier pro

If you use the build pipeline (rune init route) instead of the wizard: npx @rune-kit/rune@latest init --force regenerates platform files without touching your .rune/ state.

Verify after updating

npx @rune-kit/rune@latest doctor          # compiled output + mesh integrity
npx @rune-kit/rune@latest doctor --hooks  # hook drift vs the canonical preset

On Codex, review and re-trust changed hooks with /hooks.

Quick Start

# Onboard any project (generates CLAUDE.md + .rune/ context)
/rune onboard

# Build a feature (full TDD cycle)
/rune cook "add user authentication with JWT"

# Debug an issue
/rune debug "login returns 401 for valid credentials"

# Security scan before commit
/rune sentinel

# Refactor legacy code safely
/rune rescue

# Full project health audit
/rune audit

# Respond to a production incident
/rune incident "login service returning 503 for 30% of users"

# Generate design system before building UI
/rune design "trading dashboard with real-time data"

# Bootstrap a new project from scratch (v2.1.0)
/rune scaffold "REST API with auth, payments, and Docker"

# Deep requirement analysis before building
/rune ba "integrate Telegram bot with trading signals"

# Auto-generate project documentation
/rune docs init

# Build an MCP server
/rune mcp-builder "weather API with forecast tools"

Auto-Discipline (Claude Code Hooks)

Turn Rune skills into ambient runtime — no more /rune preflight every time. Install once, skills auto-fire on relevant tool calls:

# Wire Rune quality gates into Claude Code (.claude/settings.json)
npx @rune-kit/rune hooks install --preset gentle

# Preset options:
#   gentle  — advisory, never blocks (default)
#   strict  — blocks tool call on BLOCK verdict
#   off     — uninstall

# Inspect current wiring
npx @rune-kit/rune hooks status

# Remove (preserves user-authored hooks)
npx @rune-kit/rune hooks uninstall

What gets wired:

| Event | Skill | When it fires | |---|---|---| | PreToolUse(Edit|Write) | preflight | Before Claude edits source files | | PreToolUse(Bash) | sentinel | Before shell commands (catches git commit, secrets) | | PostToolUse(Edit|Write) | dependency-doctor | After dependency manifest edits | | Stop | completion-gate | End of session — validates claims against evidence |

Rune only manages entries tagged with its command signature. User-authored hooks in the same events are preserved on install/uninstall.

Stacking paid tiers (Pro, Business)

Paid tiers ship their own hooks/manifest.json. Point Rune at the install root and pass --tier:

export RUNE_PRO_ROOT=~/rune-pro
rune hooks install --preset gentle --tier pro

# Stack Free + Pro + Business in one command
export RUNE_BUSINESS_ROOT=~/rune-business
rune hooks install --preset gentle --tier pro --tier business

Multi-platform: tier hooks compile to Claude Code, Cursor, Windsurf, and Antigravity with the same command — no Claude-only lock-in.

Architecture

5-Layer Model

╔══════════════════════════════════════════════════════╗
║  L0: ROUTER (1)                                      ║
║  Meta-enforcement — routes every action               ║
║  skill-router                                         ║
╠══════════════════════════════════════════════════════╣
║  L1: ORCHESTRATORS (5)                                ║
║  Full lifecycle workflows                             ║
║  cook │ team │ launch │ rescue │ scaffold             ║
╠══════════════════════════════════════════════════════╣
║  L2: WORKFLOW HUBS (29)                               ║
║  Cross-hub mesh — the key differentiator              ║
║                                                        ║
║  Creation:    plan │ scout │ brainstorm │ design │     ║
║               skill-forge │ ba │ mcp-builder │ graft   ║
║  Development: debug │ fix │ test │ review │ db         ║
║  Quality:     sentinel │ preflight │ onboard │         ║
║               audit │ perf │ review-intake │           ║
║               logic-guardian                            ║
║  Delivery:    deploy │ marketing │ incident │ docs     ║
║  Rescue:      autopsy │ safeguard │ surgeon            ║
║  Security:    adversary                                ║
║  Velocity:    retro                                    ║
╠══════════════════════════════════════════════════════╣
║  L3: UTILITIES (27)                                   ║
║  Stateless, pure capabilities                         ║
║                                                        ║
║  Knowledge:   research │ docs-seeker │ trend-scout     ║
║  Reasoning:   problem-solver │ sequential-thinking     ║
║  Validation:  verification │ hallucination-guard │     ║
║               completion-gate │ constraint-check │     ║
║               sast │ integrity-check                   ║
║  State:       context-engine │ journal │               ║
║               session-bridge                           ║
║  Monitoring:  watchdog │ scope-guard                   ║
║  Media:       browser-pilot │ asset-creator │          ║
║               video-creator                            ║
║  Deps:        dependency-doctor                        ║
║  Workspace:   worktree                                 ║
║  Git:         git                                      ║
║  Documents:   doc-processor                            ║
║  Security:    sentinel-env                             ║
║  Memory:      neural-memory                            ║
║  Packs:       context-pack                             ║
║  Slides:      slides                                   ║
╠══════════════════════════════════════════════════════╣
║  L4: EXTENSION PACKS (14)                             ║
║  Domain-specific, install what you need                ║
║                                                        ║
║  @rune/ui │ @rune/backend │ @rune/devops │            ║
║  @rune/mobile │ @rune/security │ @rune/trading │      ║
║  @rune/saas │ @rune/ecommerce │ @rune/ai-ml │        ║
║  @rune/gamedev │ @rune/content │ @rune/analytics │    ║
║  @rune/chrome-ext │ @rune/zalo                         ║
╚══════════════════════════════════════════════════════╝

Layer Rules

| Layer | Can Call | Called By | State | |-------|---------|----------|-------| | L0 Router | L1-L3 (routing) | Every message | Stateless | | L1 Orchestrators | L2, L3 | L0, User | Stateful (workflow) | | L2 Workflow Hubs | L2 (cross-hub), L3 | L1, L2 | Stateful (task) | | L3 Utilities | Nothing (pure)* | L1, L2 | Stateless | | L4 Extensions | L3 | L2 (domain match) | Config-based |

*L3→L3 exceptions: context-engine→session-bridge, hallucination-guard→research, session-bridge→integrity-check

Cost Intelligence

Every skill has an auto-selected model for optimal cost:

| Task Type | Model | Cost | |-----------|-------|------| | Scan, search, validate | Haiku | Cheapest | | Write code, fix bugs, review | Sonnet | Default | | Architecture, security audit | Opus | Deep reasoning |

Typical feature: ~$0.05-0.15 (vs ~$0.60 all-opus).

Key Workflows

/rune cook — Build a Feature

Phase 0 RESUME     → detect existing .rune/plan-*.md, load active phase
Phase 1 UNDERSTAND → scout scans codebase, ba elicits requirements
Phase 2 PLAN       → plan creates master plan + phase files
Phase 3 TEST       → test writes failing tests (TDD red)
Phase 4 IMPLEMENT  → fix writes code (TDD green)
Phase 5 QUALITY    → preflight + sentinel + review (parallel)
Phase 6 VERIFY     → verification + hallucination-guard
Phase 7 COMMIT     → git creates semantic commit
Phase 8 BRIDGE     → session-bridge saves state, announce next phase

Multi-session: Phase 0 detects existing plans and resumes from the current phase. One phase per session = small context = better code.

/rune rescue — Refactor Legacy Code

Phase 0 RECON      → autopsy assesses damage (health score)
Phase 1 SAFETY NET → safeguard writes characterization tests
Phase 2-N SURGERY  → surgeon refactors 1 module per session
Phase N+1 CLEANUP  → remove @legacy markers
Phase N+2 VERIFY   → health score comparison (before vs after)

/rune launch — Deploy + Market

Phase 1 PRE-FLIGHT → full test suite
Phase 2 DEPLOY     → push to platform
Phase 3 VERIFY     → live site checks + monitoring
Phase 4 MARKET     → landing copy, social, SEO
Phase 5 ANNOUNCE   → publish content

Mesh Resilience

If a skill fails, the mesh adapts:

| If this fails... | Rune tries... | |---|---| | debug can't find cause | problem-solver (different reasoning) | | docs-seeker can't find docs | research (broader web search) | | scout can't find files | research + docs-seeker | | test can't run | deploy fix env, then test again |

Loop prevention: max 2 visits per skill, max chain depth 8.

Cross-Session Persistence

Rune preserves context across sessions via .rune/:

.rune/
├── decisions.md     — architectural decisions log
├── conventions.md   — established patterns & style
├── progress.md      — task progress tracker
└── session-log.md   — brief session history

Every new session loads .rune/ automatically — zero context loss.

Extension Packs

Domain-specific skills that plug into the core mesh:

| Pack | Skills | For | |------|--------|-----| | @rune/ui | design-system, components, a11y, animation | Frontend | | @rune/backend | api, auth, database, middleware | Backend | | @rune/devops | docker, ci-cd, monitoring, server, ssl | DevOps | | @rune/mobile | react-native, flutter, app-store, native | Mobile | | @rune/security | owasp, pentest, secrets, compliance | Security | | @rune/trading | fintech, realtime, charts, indicators | Fintech | | @rune/saas | multi-tenant, billing, subscription, onboarding | SaaS | | @rune/ecommerce | shopify, payment, cart, inventory | E-commerce | | @rune/ai-ml | llm, rag, embeddings, fine-tuning | AI/ML | | @rune/gamedev | threejs, webgl, game-loops, physics | Games | | @rune/content | blog, cms, mdx, i18n, seo | Content | | @rune/analytics | tracking, a/b testing, funnels, dashboards | Growth |

Rune Pro — $49 lifetime

Free Rune makes the agent disciplined. Pro makes the workflow context-aware.

Context Intelligence — the headline Pro feature. On Claude Code, Pulse runs as an executable native statusline. Codex CLI's built-in [tui].status_line supports its own footer items but does not execute an arbitrary statusline command, so full Rune Pulse runs as the Pro external watcher/HUD while Rune's hooks preserve context before compaction.

◈ Opus 4.8 │ ████████░░░ 73% WARM │ ⬡ cook·L1 │ $0.91 │ 5h ██░░ 22%  7d ███░ 61%

Three things a blind meter can't do: a glitch-proof % (no phantom 0%, no false "100% URGENT" during light work), a burn-rate ETA ("~4m until auto-compaction"), and what's eating your context ("files 61% · mcp 22%" → trim the biggest, don't nuke blind). At 70/80/90% real, context-inject writes pressure into the active agent context → it triggers session-bridge + neural-memory; after compaction, session-start reloads .rune/.

Free ships the blind tool-call counter; the real-% cockpit + predictive intelligence is Pro.

Autopilot — approve a plan, walk away. Autonomous multi-session execution with zero-HIGH-tolerance quality gates, baseline regression checks, cross-phase coherence review, and structured completion reports. cook gets the job done. autopilot gets it done while you sleep.

Pro Packs — 9 domain packs:

| Pack | What it does | |------|-------------| | Product | PRDs from user stories, roadmap prioritization, KPI dashboards, release comms, competitive analysis | | Sales | Account research briefs,