@rune-kit/rune 2.16.1 → 2.17.1

package/README.md

@@ -5,7 +5,7 @@
 <p align="center">
   <strong>Less skills. Deeper connections.</strong><br>
   A lean, interconnected skill ecosystem for AI coding assistants.<br>
-  63 skills · 215+ mesh connections · 8 platforms · MIT
+  64 skills · 203 connections · 40 signals · 8 platforms · MIT
 </p>
 
 <p align="center">
@@ -23,7 +23,7 @@
 
 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** — 63 skills with 215+ connections across a 5-layer architecture. Skills call each other bidirectionally, forming resilient workflows that adapt when things go wrong.
+Rune is a **mesh** — 64 skills with 203 connections + 40 signals across a 5-layer architecture. Skills call each other bidirectionally, forming resilient workflows that adapt when things go wrong.
 
 ```
 Pipeline:  A → B → C → D         (B fails = stuck)
@@ -83,7 +83,15 @@ _Methodology: Claude Code CLI headless mode (`claude -p --output-format json`),
 
 ---
 
-## What's New (v2.16.1 — Skill Enrichment + Triage Workflow + Output Modes)
+## What's New (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.
 
@@ -193,7 +201,7 @@ 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 63 skills, same mesh connections, same workflows — zero knowledge loss across platforms.
+Rune started as a **Claude Code plugin** and now compiles to **every major AI IDE**. Same 64 skills, same mesh connections, same workflows — zero knowledge loss across platforms.
 
 | | Rune Provides | Claude Code Provides |
 |---|---|---|
@@ -201,7 +209,7 @@ Rune started as a **Claude Code plugin** and now compiles to **every major AI ID
 | **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** | 215+ skill connections, fail-loud-route-around | Linear execution |
+| **Mesh Resilience** | 203 skill connections + 40 mesh signals, fail-loud-route-around | Linear execution |
 | **Cost Optimization** | Auto model selection (haiku/sonnet/opus per task) | Single model |
 | | | |
 | **Sandbox & Permissions** | — | Claude Code handles this |
@@ -222,6 +230,46 @@ Rune started as a **Claude Code plugin** and now compiles to **every major AI ID
 
 ## Install
 
+### One-Command Setup (recommended)
+
+After installing the plugin, run the wizard once to wire hooks the way you want them — pick scope, pick tiers, done:
+
+```bash
+npx @rune-kit/rune setup
+```
+
+The wizard auto-detects what you have:
+
+```
+Rune Setup Wizard
+──────────────────
+Free version:    2.17.1 (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 writes Rune-managed entries to `.claude/settings.json` (project-local OR global) so Claude Code auto-fires `preflight`, `sentinel`, `dependency-doctor`, `completion-gate`, and `quarantine` at the right moments. With `--tier pro`, it also wires `loop-circuit-breaker` (auto-engages only in autopilot sessions).
+
+**Non-interactive mode** (CI / scripted):
+
+```bash
+npx @rune-kit/rune setup --here --preset gentle --tier pro
+npx @rune-kit/rune setup --global --preset strict --tier pro,business
+npx @rune-kit/rune setup --here --no-tier --dry      # preview without writing
+```
+
 ### Claude Code (Native Plugin)
 
 ```bash
@@ -231,7 +279,7 @@ claude plugin add rune-kit/rune
 
 Or add manually in `~/.claude/settings.json` under `installed_plugins`.
 
-Full mesh: subagents, hooks, adaptive routing, mesh analytics.
+Full mesh: subagents, hooks, adaptive routing, mesh analytics. **Run `npx @rune-kit/rune setup` afterward to wire hooks** (see One-Command Setup above).
 
 ### Cursor / Windsurf / Antigravity / Any IDE
 
@@ -245,14 +293,14 @@ npx @rune-kit/rune init --platform windsurf
 npx @rune-kit/rune init --platform antigravity
 ```
 
-This compiles all 63 skills into your IDE's rules format. Same knowledge, same workflows.
+This compiles all 64 skills into your IDE's rules format. Same knowledge, same workflows.
 
 ### Platform Comparison
 
 | Feature | Claude Code | Cursor / Windsurf / Others |
 |---------|-------------|---------------------------|
-| Skills available | 61/61 | 61/61 |
-| Mesh connections | 215+ (programmatic) | 215+ (rule references) |
+| Skills available | 64/64 | 64/64 |
+| Mesh connections | 203 sync + 40 signals (programmatic) | 203 sync + 40 signals (rule references) |
 | Workflows & HARD-GATEs | Full | Full |
 | Extension packs | 14 | 14 |
 | Subagent parallelism | Native | Sequential fallback |
@@ -596,7 +644,7 @@ See [docs/MULTI-PLATFORM.md](docs/MULTI-PLATFORM.md) for the full architecture.
 | Doc | What's inside |
 |-----|---------------|
 | [`docs/GETTING_STARTED.md`](docs/GETTING_STARTED.md) | Your first 5 minutes with Rune — install to first `/rune cook` |
-| [`docs/SKILLS.md`](docs/SKILLS.md) | All 63 skills, searchable by intent and layer |
+| [`docs/SKILLS.md`](docs/SKILLS.md) | All 64 skills, searchable by intent and layer |
 | [`docs/SIGNALS.md`](docs/SIGNALS.md) | Canonical signal inventory — 25 events, emit/listen graph |
 | [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) | 5-layer mesh architecture reference |
 | [`docs/VISION.md`](docs/VISION.md) | Philosophy — what Rune is and isn't |
@@ -609,11 +657,11 @@ See [docs/MULTI-PLATFORM.md](docs/MULTI-PLATFORM.md) for the full architecture.
 ## Numbers
 
 ```
-Core Skills:       62 (L0: 1 │ L1: 5 │ L2: 29 │ L3: 27)
-Extension Packs:   14 free + 5 pro + 4 business
-Mesh Connections:  215+ cross-references
-Mesh Signals:      25 signals across 63 skills (emit/listen graph)
-Connections/Skill: 3.4 avg
+Core Skills:       64 (L0: 1 │ L1: 5 │ L2: 30 │ L3: 28)
+Extension Packs:   14 free + 6 pro + 4 business
+Mesh Connections:  203 sync calls (rune doctor)
+Mesh Signals:      40 signals · 50 emit/listen edges (rune doctor)
+Connections/Skill: 3.2 avg
 Platforms:         8 (Claude Code, Cursor, Windsurf, Antigravity, Codex, OpenCode, OpenClaw, Generic)
 Compiler:          ~1400 LOC (parser + 8 transforms + 8 adapters + CLI)
 Tests:             1,152+ (compiler + signals + status + visualizer + hooks + scripts + tier-hooks)

package/compiler/__tests__/doctor-mesh.test.js

@@ -223,6 +223,11 @@ describe('integration: real skills', () => {
     // Should find connections
     assert.ok(results.stats.connections > 100, `Should find 100+ connections, got ${results.stats.connections}`);
 
+    // Should find signals (emit/listen mesh — separate from sync calls)
+    // Free core scan only — Pro/Business packs scanned separately by validate-signals.js
+    assert.ok(results.stats.signals > 20, `Should find 20+ signals, got ${results.stats.signals}`);
+    assert.ok(results.stats.signalEdges > 0, `Should find signal edges, got ${results.stats.signalEdges}`);
+
     // Should not have errors
     assert.strictEqual(results.errors.length, 0, `Should have no errors: ${results.errors.join(', ')}`);
   });

package/compiler/__tests__/hooks-drift.test.js

@@ -0,0 +1,156 @@
+import assert from 'node:assert';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, test } from 'node:test';
+import { checkHookDrift, formatHookDriftResult } from '../commands/hooks/drift.js';
+import { buildPreset, SETTINGS_REL_PATH } from '../commands/hooks/presets.js';
+
+let tmpRoot;
+
+async function seedClaude(root, settings) {
+  await mkdir(path.join(root, '.claude'), { recursive: true });
+  if (settings) {
+    await writeFile(path.join(root, SETTINGS_REL_PATH), `${JSON.stringify(settings, null, 2)}\n`);
+  }
+}
+
+beforeEach(async () => {
+  tmpRoot = await mkdtemp(path.join(tmpdir(), 'rune-drift-'));
+});
+
+afterEach(async () => {
+  if (tmpRoot) await rm(tmpRoot, { recursive: true, force: true });
+});
+
+describe('checkHookDrift', () => {
+  test('returns empty findings when settings.json matches canonical gentle preset', async () => {
+    await seedClaude(tmpRoot, buildPreset('gentle'));
+    const result = await checkHookDrift(tmpRoot);
+    assert.strictEqual(result.findings.length, 0);
+    assert.strictEqual(result.summary.drifted, 0);
+    assert.strictEqual(result.summary.missing, 0);
+    assert.strictEqual(result.platforms.length, 1);
+    assert.strictEqual(result.platforms[0].preset, 'gentle');
+  });
+
+  test('returns empty findings for canonical strict preset', async () => {
+    await seedClaude(tmpRoot, buildPreset('strict'));
+    const result = await checkHookDrift(tmpRoot);
+    assert.strictEqual(result.findings.length, 0);
+    assert.strictEqual(result.platforms[0].preset, 'strict');
+  });
+
+  test('flags drifted entry when installed command differs from canonical', async () => {
+    const baseline = buildPreset('gentle');
+    // Mutate one command to simulate operator hand-edit
+    baseline.hooks.PreToolUse[0].hooks[0].command = 'npx --yes @rune-kit/rune hook-dispatch preflight --custom-flag';
+    await seedClaude(tmpRoot, baseline);
+    const result = await checkHookDrift(tmpRoot);
+    const drift = result.findings.filter((f) => f.status === 'drift');
+    const missing = result.findings.filter((f) => f.status === 'missing');
+    assert.ok(drift.length >= 1, 'should flag the modified entry as drifted');
+    assert.ok(missing.length >= 1, 'canonical entry no longer present → missing');
+    assert.match(drift[0].actual, /--custom-flag/);
+  });
+
+  test('flags missing entry when canonical has more than installed', async () => {
+    const partial = buildPreset('gentle');
+    // Remove one Stop entry to simulate partial install
+    partial.hooks.Stop = [];
+    await seedClaude(tmpRoot, partial);
+    const result = await checkHookDrift(tmpRoot);
+    const missing = result.findings.filter((f) => f.status === 'missing' && f.event === 'Stop');
+    assert.strictEqual(missing.length, 1);
+    assert.match(missing[0].expected, /completion-gate/);
+  });
+
+  test('ignores tier-emitted entries (${RUNE_PRO_ROOT})', async () => {
+    const settings = buildPreset('gentle');
+    // Inject a Pro-tier entry alongside Free preset entries
+    settings.hooks.PostToolUse.push({
+      matcher: 'Edit|Write',
+      hooks: [
+        {
+          type: 'command',
+          command: 'node "${RUNE_PRO_ROOT}/hooks/run-hook.cjs" context-sense',
+          async: false,
+        },
+      ],
+    });
+    await seedClaude(tmpRoot, settings);
+    const result = await checkHookDrift(tmpRoot);
+    // Tier entry should NOT be flagged as drift — it's tier-managed, not Free-preset
+    const tierDrift = result.findings.find(
+      (f) => f.status === 'drift' && typeof f.actual === 'string' && f.actual.includes('RUNE_PRO_ROOT'),
+    );
+    assert.strictEqual(tierDrift, undefined);
+  });
+
+  test('returns empty when settings.json absent', async () => {
+    await mkdir(path.join(tmpRoot, '.claude'), { recursive: true });
+    const result = await checkHookDrift(tmpRoot);
+    assert.strictEqual(result.findings.length, 0);
+    assert.strictEqual(result.platforms.length, 0);
+  });
+
+  test('returns empty when no Rune hooks installed (preset = none)', async () => {
+    await seedClaude(tmpRoot, { env: { FOO: 'bar' } }); // user settings, no Rune hooks
+    const result = await checkHookDrift(tmpRoot);
+    assert.strictEqual(result.findings.length, 0);
+    assert.strictEqual(result.platforms.length, 0);
+  });
+
+  test('reports parse error when settings.json is malformed', async () => {
+    await mkdir(path.join(tmpRoot, '.claude'), { recursive: true });
+    await writeFile(path.join(tmpRoot, SETTINGS_REL_PATH), '{ not valid json');
+    const result = await checkHookDrift(tmpRoot);
+    const errors = result.findings.filter((f) => f.status === 'error');
+    assert.strictEqual(errors.length, 1);
+    assert.match(errors[0].message, /Cannot parse/);
+  });
+
+  test('flags mixed preset (both gentle and strict installed)', async () => {
+    // Mix gentle PreToolUse with strict Stop
+    const gentle = buildPreset('gentle');
+    const strict = buildPreset('strict');
+    const mixed = {
+      hooks: {
+        PreToolUse: gentle.hooks.PreToolUse,
+        Stop: strict.hooks.Stop,
+      },
+    };
+    await seedClaude(tmpRoot, mixed);
+    const result = await checkHookDrift(tmpRoot);
+    const mixedFinding = result.findings.find((f) => f.status === 'mixed-preset');
+    assert.ok(mixedFinding, 'should flag mixed-preset');
+    assert.match(mixedFinding.message, /gentle and strict/);
+  });
+});
+
+describe('formatHookDriftResult', () => {
+  test('clean preset → all-match line', () => {
+    const out = formatHookDriftResult({
+      findings: [],
+      summary: { drifted: 0, missing: 0, errors: 0 },
+      platforms: [{ platform: 'claude', preset: 'gentle' }],
+    });
+    assert.match(out, /All Rune-managed entries match canonical preset/);
+  });
+
+  test('no platforms → install hint', () => {
+    const out = formatHookDriftResult({ findings: [], summary: { drifted: 0, missing: 0, errors: 0 }, platforms: [] });
+    assert.match(out, /No installed Rune hooks detected/);
+  });
+
+  test('drift finding renders actual command', () => {
+    const out = formatHookDriftResult({
+      findings: [{ platform: 'claude', event: 'PreToolUse', status: 'drift', actual: 'custom-cmd' }],
+      summary: { drifted: 1, missing: 0, errors: 0 },
+      platforms: [{ platform: 'claude', preset: 'gentle' }],
+    });
+    assert.match(out, /drift/);
+    assert.match(out, /custom-cmd/);
+    assert.match(out, /Summary: 1 drifted/);
+  });
+});

package/compiler/__tests__/hooks-merge.test.js

@@ -169,10 +169,11 @@ describe('summarizeRuneHooks', () => {
   test('extracts skill names per event', () => {
     const merged = mergePreset({}, buildPreset('gentle'));
     const summary = summarizeRuneHooks(merged);
-    assert.strictEqual(summary.total, 4);
+    assert.strictEqual(summary.total, 5);
     assert.ok(summary.events.PreToolUse.includes('preflight'));
     assert.ok(summary.events.PreToolUse.includes('sentinel'));
     assert.ok(summary.events.PostToolUse.includes('dependency-doctor'));
+    assert.ok(summary.events.PostToolUse.includes('quarantine'));
     assert.ok(summary.events.Stop.includes('completion-gate'));
   });
 

package/compiler/__tests__/setup.test.js

@@ -0,0 +1,152 @@
+import assert from 'node:assert';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, test } from 'node:test';
+import { detectTiers, formatSetupResult, runSetup } from '../commands/setup.js';
+
+let tmpRoot;
+
+async function seedClaude(root) {
+  await mkdir(path.join(root, '.claude'), { recursive: true });
+}
+
+async function seedTier(root, tier) {
+  const dir = path.join(root, '..', tier === 'pro' ? 'Pro' : 'Business', 'hooks');
+  await mkdir(dir, { recursive: true });
+  await writeFile(
+    path.join(dir, 'manifest.json'),
+    JSON.stringify({
+      tier,
+      version: '1.0.0',
+      minFreeVersion: '2.0.0',
+      requires: [tier === 'pro' ? 'RUNE_PRO_ROOT' : 'RUNE_BUSINESS_ROOT'],
+      entries: [],
+    }),
+  );
+}
+
+beforeEach(async () => {
+  tmpRoot = await mkdtemp(path.join(tmpdir(), 'rune-setup-'));
+  await mkdir(path.join(tmpRoot, 'project'), { recursive: true });
+});
+
+afterEach(async () => {
+  if (tmpRoot) await rm(tmpRoot, { recursive: true, force: true });
+  delete process.env.RUNE_PRO_ROOT;
+  delete process.env.RUNE_BUSINESS_ROOT;
+});
+
+describe('detectTiers', () => {
+  test('returns null for both when no tier present', () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    const result = detectTiers(projectRoot, { wellKnownPaths: { pro: [], business: [] } });
+    assert.strictEqual(result.pro, null);
+    assert.strictEqual(result.business, null);
+  });
+
+  test('detects Pro via sibling path', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedTier(projectRoot, 'pro');
+    const result = detectTiers(projectRoot, { wellKnownPaths: { pro: [], business: [] } });
+    assert.ok(result.pro);
+    assert.match(result.pro.source, /sibling/);
+    assert.strictEqual(result.pro.version, '1.0.0');
+    assert.strictEqual(result.business, null);
+  });
+
+  test('detects Business via sibling path', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedTier(projectRoot, 'business');
+    const result = detectTiers(projectRoot, { wellKnownPaths: { pro: [], business: [] } });
+    assert.ok(result.business);
+    assert.match(result.business.source, /sibling/);
+    assert.strictEqual(result.pro, null);
+  });
+
+  test('env var takes precedence over sibling', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedTier(projectRoot, 'pro');
+    // Env var pointing at a different location
+    const envRoot = path.join(tmpRoot, 'env-pro');
+    await mkdir(path.join(envRoot, 'hooks'), { recursive: true });
+    await writeFile(
+      path.join(envRoot, 'hooks', 'manifest.json'),
+      JSON.stringify({ tier: 'pro', version: '2.0.0', minFreeVersion: '2.0.0', requires: [], entries: [] }),
+    );
+    process.env.RUNE_PRO_ROOT = envRoot;
+    const result = detectTiers(projectRoot, { wellKnownPaths: { pro: [], business: [] } });
+    assert.match(result.pro.source, /\$RUNE_PRO_ROOT/);
+    assert.strictEqual(result.pro.version, '2.0.0');
+  });
+});
+
+describe('runSetup (non-interactive)', () => {
+  test('--here installs to current project, no tiers when none detected', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedClaude(projectRoot);
+    const result = await runSetup({
+      projectRoot,
+      runeRoot: path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', '..'),
+      args: { here: true, preset: 'gentle', 'no-tier': true },
+    });
+    assert.strictEqual(result.scope, 'current');
+    assert.strictEqual(result.preset, 'gentle');
+    assert.deepStrictEqual(result.tiers, []);
+    assert.strictEqual(result.targetRoot, projectRoot);
+  });
+
+  test('--tier flag bypasses prompt', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedClaude(projectRoot);
+    await seedTier(projectRoot, 'pro');
+    const result = await runSetup({
+      projectRoot,
+      runeRoot: path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', '..'),
+      args: { here: true, preset: 'gentle', tier: 'pro' },
+    });
+    assert.deepStrictEqual(result.tiers, ['pro']);
+  });
+
+  test('--dry does not write files', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedClaude(projectRoot);
+    const result = await runSetup({
+      projectRoot,
+      runeRoot: path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', '..'),
+      args: { here: true, preset: 'gentle', 'no-tier': true, dry: true },
+    });
+    assert.strictEqual(result.written, false);
+  });
+});
+
+describe('formatSetupResult', () => {
+  test('renders summary with scope and tiers', () => {
+    const out = formatSetupResult({
+      scope: 'current',
+      targetRoot: '/path/to/project',
+      tiers: ['pro'],
+      preset: 'gentle',
+      platforms: ['claude'],
+      written: true,
+      notes: [],
+    });
+    assert.match(out, /Setup Complete/);
+    assert.match(out, /Tiers:.*Free.*pro/);
+    assert.match(out, /current project/);
+    assert.match(out, /rune doctor --hooks/);
+  });
+
+  test('renders global scope label when scope=global', () => {
+    const out = formatSetupResult({
+      scope: 'global',
+      targetRoot: '/home/user',
+      tiers: [],
+      preset: 'gentle',
+      platforms: ['claude'],
+      written: true,
+      notes: [],
+    });
+    assert.match(out, /GLOBAL/);
+  });
+});

package/compiler/adapters/openclaw.js

@@ -105,7 +105,7 @@ export default {
       id: 'rune',
       name: 'Rune',
       kind: 'skills',
-      description: `${skills.length}-skill mesh for AI coding assistants. Routes all code tasks through specialized skills. 215+ connections, 14 extension packs.`,
+      description: `${skills.length}-skill mesh for AI coding assistants. Routes all code tasks through specialized skills. 203 sync connections + 40 async signals, 14 extension packs.`,
       version: pluginJson.version || '0.0.0',
       skills: ['./skills'],
       artifactConvention: {

package/compiler/bin/rune.js

@@ -13,6 +13,7 @@
 
 import { existsSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
 import { fileURLToPath } from 'node:url';
@@ -24,6 +25,8 @@ import { hookStatus } from '../commands/hooks/status.js';
 import { uninstallHooks } from '../commands/hooks/uninstall.js';
 import { generateDashboardHTML } from '../dashboard.js';
 import { checkMeshIntegrity, formatDoctorResults, formatMeshResults, runDoctor } from '../doctor.js';
+import { checkHookDrift, formatHookDriftResult } from '../commands/hooks/drift.js';
+import { runSetup, formatSetupResult } from '../commands/setup.js';
 import { buildAll } from '../emitter.js';
 import { collectStats, renderStatus, renderStatusJson } from '../status.js';
 import { collectGraphData, generateMeshHTML } from '../visualizer.js';
@@ -241,6 +244,14 @@ async function cmdBuild(projectRoot, args) {
 async function cmdDoctor(projectRoot, args) {
   const config = await readConfig(projectRoot);
 
+  // --hooks flag: run hook drift report only (reporter, exit 0 always)
+  if (args.hooks) {
+    log('');
+    const driftResult = await checkHookDrift(projectRoot);
+    log(formatHookDriftResult(driftResult));
+    return;
+  }
+
   // --mesh flag: run mesh integrity check only
   if (args.mesh) {
     log('');
@@ -294,6 +305,45 @@ async function cmdDoctor(projectRoot, args) {
   if (!results.healthy) process.exit(1);
 }
 
+async function cmdSetup(projectRoot, args) {
+  log('');
+  log('  Rune Setup Wizard');
+  log('  ──────────────────');
+  log(`  Free version:    ${await readVersion()} (cached)`);
+
+  // Print detected tiers banner
+  const { detectTiers } = await import('../commands/setup.js');
+  const detected = detectTiers(projectRoot);
+  if (detected.pro) {
+    log(`  Pro detected:    ${detected.pro.source} (v${detected.pro.version})`);
+  } else {
+    log('  Pro:             not detected');
+  }
+  if (detected.business) {
+    log(`  Business:        ${detected.business.source} (v${detected.business.version})`);
+  } else {
+    log('  Business:        not detected');
+  }
+
+  try {
+    const result = await runSetup({ projectRoot, runeRoot: RUNE_ROOT, args });
+    log(formatSetupResult(result));
+  } catch (err) {
+    log('');
+    log(`  ✗ Setup failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function readVersion() {
+  try {
+    const pkg = JSON.parse(await readFile(path.join(RUNE_ROOT, 'package.json'), 'utf-8'));
+    return pkg.version;
+  } catch {
+    return 'unknown';
+  }
+}
+
 async function cmdStatus(projectRoot, args) {
   const config = await readConfig(projectRoot);
   const tierSources = resolveTierSources(config?.tiers, projectRoot);
@@ -458,10 +508,13 @@ async function cmdHooks(projectRoot, args, subcommand) {
   switch (subcommand) {
     case 'install': {
       const tierArg = parseTierFlag(args.tier);
-      const result = await installHooks(projectRoot, {
+      // --global writes to ~/.claude/settings.json (covers every Claude Code session)
+      const targetRoot = args.global ? os.homedir() : projectRoot;
+      const platform = args.global ? 'claude' : args.platform;
+      const result = await installHooks(targetRoot, {
         preset: args.preset,
         dry: args.dry,
-        platform: args.platform,
+        platform,
         tier: tierArg,
       });
       log('');
@@ -636,6 +689,9 @@ async function main() {
     case 'doctor':
       await cmdDoctor(projectRoot, args);
       break;
+    case 'setup':
+      await cmdSetup(projectRoot, args);
+      break;
     case 'status':
       await cmdStatus(projectRoot, args);
       break;
@@ -664,17 +720,20 @@ async function main() {
       log('  Rune CLI — Skill mesh for AI coding assistants');
       log('');
       log('  Commands:');
-      log('    init     Interactive setup (auto-detects platform)');
+      log('    setup    Interactive wizard — auto-detect tiers, pick scope, install hooks (recommended for first-time)');
+      log('             [--here|--global] [--tier pro,business] [--preset gentle|strict] [--dry]');
+      log('    init     Interactive setup for build pipeline (auto-detects platform)');
       log('    build    Compile skills for configured platform');
       log('    doctor   Validate compiled output + mesh integrity');
       log('             --mesh   Mesh integrity only (reciprocals, versions, sections)');
+      log('             --hooks  Hook drift report — compare installed vs canonical preset (reporter, exit 0)');
       log('             --strict Fail on warnings (for CI)');
       log('    status   Project dashboard (skills, signals, packs, health)');
       log('    visualize  Interactive mesh graph (opens in browser)');
       log('    analytics  Usage analytics dashboard (Business tier)');
       log('    hooks      Install/uninstall/status for multi-platform auto-discipline');
       log(
-        '               hooks install [--preset gentle|strict|off] [--platform claude|cursor|windsurf|antigravity|all]',
+        '               hooks install [--preset gentle|strict|off] [--platform claude|cursor|windsurf|antigravity|all] [--global]',
       );
       log('               hooks uninstall [--platform <name>|all]');
       log('               hooks status [--platform <name>|all]');