@rune-kit/rune 2.11.0 → 2.12.2

package/compiler/bin/rune.js

@@ -6,7 +6,7 @@
  * Commands:
  *   rune init    — Interactive setup for a new project
  *   rune build   — Compile skills for the configured platform
- *   rune doctor  — Validate compiled output
+ *   rune doctor  — Validate compiled output + mesh integrity (--mesh for mesh only)
  *   rune status  — Project dashboard (neofetch-style)
  *   rune visualize — Interactive mesh graph
  */
@@ -18,8 +18,12 @@ import { createInterface } from 'node:readline';
 import { fileURLToPath } from 'node:url';
 import { getAdapter, listPlatforms } from '../adapters/index.js';
 import { getAllAnalytics } from '../analytics.js';
+import { dispatchHook } from '../commands/hook-dispatch.js';
+import { installHooks } from '../commands/hooks/install.js';
+import { hookStatus } from '../commands/hooks/status.js';
+import { uninstallHooks } from '../commands/hooks/uninstall.js';
 import { generateDashboardHTML } from '../dashboard.js';
-import { formatDoctorResults, runDoctor } from '../doctor.js';
+import { checkMeshIntegrity, formatDoctorResults, formatMeshResults, runDoctor } from '../doctor.js';
 import { buildAll } from '../emitter.js';
 import { collectStats, renderStatus, renderStatusJson } from '../status.js';
 import { collectGraphData, generateMeshHTML } from '../visualizer.js';
@@ -237,6 +241,17 @@ async function cmdBuild(projectRoot, args) {
 async function cmdDoctor(projectRoot, args) {
   const config = await readConfig(projectRoot);
 
+  // --mesh flag: run mesh integrity check only
+  if (args.mesh) {
+    log('');
+    const meshResults = await checkMeshIntegrity(RUNE_ROOT);
+    log(formatMeshResults(meshResults));
+    if (meshResults.errors.length > 0) process.exit(1);
+    // Exit with warning code if there are warnings (for CI awareness)
+    if (args.strict && meshResults.warnings.length > 0) process.exit(1);
+    return;
+  }
+
   if (!config) {
     // No config = CI or fresh clone. Run source-only checks (split packs).
     log('');
@@ -248,6 +263,12 @@ async function cmdDoctor(projectRoot, args) {
       runeRoot: RUNE_ROOT,
     });
     log(formatDoctorResults(results));
+
+    // Also run mesh check in source-only mode
+    log('');
+    const meshResults = await checkMeshIntegrity(RUNE_ROOT);
+    log(formatMeshResults(meshResults));
+
     if (!results.healthy) process.exit(1);
     return;
   }
@@ -265,6 +286,11 @@ async function cmdDoctor(projectRoot, args) {
 
   log(formatDoctorResults(results));
 
+  // Also run mesh check
+  log('');
+  const meshResults = await checkMeshIntegrity(runeRoot);
+  log(formatMeshResults(meshResults));
+
   if (!results.healthy) process.exit(1);
 }
 
@@ -403,10 +429,155 @@ async function cmdAnalytics(projectRoot, args) {
   }
 }
 
+// ─── Hook Commands ───
+
+async function cmdHooks(projectRoot, args, subcommand) {
+  if (!subcommand) {
+    log('');
+    log('  rune hooks — Auto-discipline entry point for AI IDEs');
+    log('');
+    log('  Subcommands:');
+    log('    install [--preset strict|gentle|off] [--platform <name>|all] [--tier pro|business]');
+    log('                                                                   Wire Rune hooks / rules / workflows');
+    log(
+      '    uninstall [--platform <name>|all]                              Remove Rune-managed entries (keeps user entries)',
+    );
+    log(
+      '    status [--platform <name>|all] [--tier pro|business]          Show active preset, wired skills, tier coverage',
+    );
+    log('');
+    log('  Platforms: claude, cursor, windsurf, antigravity (auto-detected if omitted)');
+    log('  Tiers: pro, business — requires $RUNE_PRO_ROOT / $RUNE_BUSINESS_ROOT env var or monorepo sibling.');
+    log('  Options:');
+    log('    --dry    Preview changes without writing');
+    log('    --tier <name>[,<name>]  Overlay tier manifest(s) — pass multiple tiers comma-separated.');
+    log('');
+    return;
+  }
+
+  switch (subcommand) {
+    case 'install': {
+      const tierArg = parseTierFlag(args.tier);
+      const result = await installHooks(projectRoot, {
+        preset: args.preset,
+        dry: args.dry,
+        platform: args.platform,
+        tier: tierArg,
+      });
+      log('');
+      if (result.platforms.length === 0) {
+        for (const note of result.notes) logStep('·', note);
+        log('');
+        break;
+      }
+      const tierSuffix = result.tiers?.length ? ` + tier(s): ${result.tiers.join(', ')}` : '';
+      if (result.written) {
+        logStep('✓', `Installed preset "${result.preset}"${tierSuffix} across: ${result.platforms.join(', ')}`);
+      } else if (args.dry) {
+        logStep('◎', `Dry-run — no changes written (platforms: ${result.platforms.join(', ')}${tierSuffix})`);
+      }
+      for (const r of result.results) {
+        log('');
+        log(`  [${r.platform}]`);
+        for (const file of r.files) {
+          const rel = path.relative(projectRoot, file.path);
+          logStep(file.deleted ? '−' : '→', rel);
+        }
+        for (const note of r.notes) logStep('·', note);
+      }
+      log('');
+      break;
+    }
+    case 'uninstall': {
+      const result = await uninstallHooks(projectRoot, { dry: args.dry, platform: args.platform });
+      log('');
+      if (result.platforms.length === 0) {
+        for (const note of result.notes) logStep('·', note);
+        log('');
+        break;
+      }
+      if (result.written) {
+        logStep('✓', `Uninstalled Rune entries across: ${result.platforms.join(', ')}`);
+      } else if (args.dry) {
+        logStep('◎', `Dry-run — would uninstall across: ${result.platforms.join(', ')}`);
+      }
+      for (const r of result.results) {
+        log('');
+        log(`  [${r.platform}]`);
+        for (const file of r.files) {
+          const rel = path.relative(projectRoot, file.path);
+          logStep(file.deleted ? '−' : '→', rel);
+        }
+        for (const note of r.notes) logStep('·', note);
+      }
+      log('');
+      break;
+    }
+    case 'status': {
+      const tierArg = parseTierFlag(args.tier);
+      const result = await hookStatus(projectRoot, RUNE_ROOT, { platform: args.platform, tier: tierArg });
+      log('');
+      if (result.platforms.length === 0) {
+        for (const note of result.notes) logStep('·', note);
+        log('');
+        break;
+      }
+      for (const r of result.results) {
+        log(`  [${r.platform}]${r.capability ? ` (${r.capability.maturity})` : ''}`);
+        log(`    installed: ${r.installed ? 'yes' : 'no'}`);
+        log(`    preset:    ${r.preset ?? 'none'}`);
+        if (r.wired.length > 0) log(`    wired:     ${r.wired.join(', ')}`);
+        if (r.missing.length > 0) logStep('⚠', `missing: ${r.missing.join(', ')}`);
+        if (r.events) {
+          for (const [event, skills] of Object.entries(r.events)) {
+            log(`    ${event}: ${skills.join(', ')}`);
+          }
+        }
+        for (const note of r.notes) logStep('·', note);
+        log('');
+      }
+      if (result.tiers && result.tiers.length > 0) {
+        log('  Tiers:');
+        for (const t of result.tiers) {
+          if (!t.found) {
+            logStep('⚠', `${t.tier}: manifest not found${t.error ? ` (${t.error})` : ''}`);
+          } else {
+            const req = t.requiresOk ? 'env OK' : `missing env: ${t.requiresMissing.join(', ')}`;
+            logStep('·', `${t.tier} v${t.version} — ${t.entries} entries — ${req}`);
+          }
+        }
+        log('');
+      }
+      if (result.missingInRepo.length > 0) {
+        logStep('⚠', `Skills referenced by presets but not found in repo: ${result.missingInRepo.join(', ')}`);
+        log('');
+      }
+      break;
+    }
+    default:
+      log(`  ✗ Unknown hooks subcommand: ${subcommand}. Run \`rune hooks\` for help.`);
+      process.exit(1);
+  }
+}
+
 // ─── Arg Parsing ───
 
 // Flags that require a string value (not boolean)
-const VALUE_REQUIRED_FLAGS = new Set(['platform', 'output', 'disable', 'extensions', 'days']);
+const VALUE_REQUIRED_FLAGS = new Set(['platform', 'output', 'disable', 'extensions', 'days', 'preset', 'tier']);
+
+function parseTierFlag(raw) {
+  if (!raw) return undefined;
+  if (Array.isArray(raw)) {
+    return raw
+      .flatMap((v) => String(v).split(','))
+      .map((s) => s.trim())
+      .filter(Boolean);
+  }
+  return String(raw)
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
 
 function parseArgs(argv) {
   const args = {};
@@ -431,13 +602,21 @@ function parseArgs(argv) {
     }
   }
 
-  return { command: positional[0], args };
+  return { command: positional[0], subcommand: positional[1], args, positional };
 }
 
 // ─── Main ───
 
 async function main() {
-  const { command, args } = parseArgs(process.argv.slice(2));
+  const rawArgv = process.argv.slice(2);
+
+  // hook-dispatch bypasses parseArgs so flags like --gentle reach the dispatcher verbatim
+  if (rawArgv[0] === 'hook-dispatch') {
+    const exitCode = await dispatchHook(rawArgv.slice(1));
+    process.exit(exitCode);
+  }
+
+  const { command, subcommand, args } = parseArgs(rawArgv);
   const projectRoot = process.cwd();
 
   // Handle --version / -v as flag (not positional command)
@@ -468,6 +647,9 @@ async function main() {
     case 'dash':
       await cmdAnalytics(projectRoot, args);
       break;
+    case 'hooks':
+      await cmdHooks(projectRoot, args, subcommand);
+      break;
     case 'version':
     case '--version':
     case '-v': {
@@ -484,10 +666,18 @@ async function main() {
       log('  Commands:');
       log('    init     Interactive setup (auto-detects platform)');
       log('    build    Compile skills for configured platform');
-      log('    doctor   Validate compiled output');
+      log('    doctor   Validate compiled output + mesh integrity');
+      log('             --mesh   Mesh integrity only (reciprocals, versions, sections)');
+      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]',
+      );
+      log('               hooks uninstall [--platform <name>|all]');
+      log('               hooks status [--platform <name>|all]');
       log('');
       log('  Options:');
       log(

package/compiler/commands/hook-dispatch.js

@@ -0,0 +1,87 @@
+/**
+ * `rune hook-dispatch <skill> [--gentle]`
+ *
+ * Runtime dispatcher invoked by Claude Code hooks. Reads event JSON from stdin,
+ * validates the skill name against an allowlist, then forwards to the skill's
+ * execution (currently a no-op placeholder that emits a verdict line — skill
+ * invocation wiring happens when skills gain a headless mode).
+ *
+ * In gentle mode: always exits 0, prints advisory line.
+ * In strict mode: exits 2 on BLOCK verdict (Claude Code blocks the tool call).
+ *
+ * Security:
+ *   - Skill name MUST match the allowlist (no arbitrary shell injection)
+ *   - Event payload is parsed but never passed to shell commands
+ *   - Unknown skills fail closed (error in strict, warn in gentle)
+ */
+
+import { WIRED_SKILLS } from './hooks/presets.js';
+
+const ALLOWLIST = new Set(WIRED_SKILLS);
+
+/**
+ * @param {string[]} argv — positional args after `hook-dispatch`
+ * @param {{stdin?: NodeJS.ReadableStream, stdout?: NodeJS.WritableStream, stderr?: NodeJS.WritableStream}} io
+ * @returns {Promise<number>} exit code
+ */
+export async function dispatchHook(argv, io = {}) {
+  const stdout = io.stdout || process.stdout;
+  const stderr = io.stderr || process.stderr;
+  const stdin = io.stdin || process.stdin;
+
+  const positional = argv.filter((a) => !a.startsWith('--'));
+  const flags = new Set(argv.filter((a) => a.startsWith('--')));
+  const skill = positional[0];
+  const gentle = flags.has('--gentle');
+
+  if (!skill) {
+    stderr.write('rune hook-dispatch: missing skill name\n');
+    return gentle ? 0 : 1;
+  }
+
+  if (!ALLOWLIST.has(skill)) {
+    stderr.write(`rune hook-dispatch: unknown skill "${skill}"\n`);
+    return gentle ? 0 : 1;
+  }
+
+  // Read event JSON from stdin (best-effort; hooks may pass empty stdin)
+  let eventJson = {};
+  try {
+    const raw = await readStdin(stdin);
+    if (raw.trim()) eventJson = JSON.parse(raw);
+  } catch {
+    // Non-JSON stdin is tolerable — skills may not need the payload
+  }
+
+  // Skill invocation placeholder — skills don't yet expose a headless API.
+  // For v1: emit advisory line, pass through. This unblocks hook installation
+  // while skill-forge adds `--hook-mode` to preflight/sentinel/etc.
+  const mode = gentle ? 'advisory' : 'enforcing';
+  stdout.write(`rune-hook: ${skill} [${mode}] — tool=${eventJson?.tool_name || 'unknown'}\n`);
+
+  // Until skills expose headless verdicts, dispatcher returns neutral success.
+  // When skills add `--hook-mode`, extend this to run them and propagate exit codes.
+  return 0;
+}
+
+function readStdin(stream) {
+  return new Promise((resolve, reject) => {
+    if (stream.isTTY) {
+      resolve('');
+      return;
+    }
+    let buf = '';
+    stream.setEncoding('utf-8');
+    stream.on('data', (chunk) => {
+      buf += chunk;
+      if (buf.length > 1_000_000) {
+        stream.destroy();
+        reject(new Error('stdin too large'));
+      }
+    });
+    stream.on('end', () => resolve(buf));
+    stream.on('error', reject);
+    // Safety timeout — don't block Claude Code indefinitely
+    setTimeout(() => resolve(buf), 500);
+  });
+}

package/compiler/commands/hooks/install.js

@@ -0,0 +1,120 @@
+/**
+ * `rune hooks install [--preset strict|gentle|off] [--platform claude|cursor|windsurf|antigravity|all]`
+ *
+ * Writes Rune-managed hook/rule/workflow entries for one or more platforms.
+ * Idempotent: re-running replaces existing Rune entries, preserves user entries.
+ */
+
+import { existsSync } from 'node:fs';
+import { mkdir, unlink, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { ADAPTERS, detectPlatforms, getAdapter, PLATFORM_KEYS } from '../../adapters/hooks/index.js';
+import { checkManifestRequires, resolveTier } from './tiers.js';
+
+/**
+ * @param {string} projectRoot
+ * @param {{preset?: string, dry?: boolean, platform?: string|string[], tier?: string|string[]}} args
+ */
+export async function installHooks(projectRoot, args = {}) {
+  const preset = args.preset || 'gentle';
+  if (preset !== 'strict' && preset !== 'gentle' && preset !== 'off') {
+    throw new Error(`Invalid preset: ${preset}. Choose from: strict | gentle | off`);
+  }
+
+  const tierManifests = await resolveTierManifests(projectRoot, args.tier);
+  const tierNotes = [];
+  for (const manifest of tierManifests) {
+    const { ok, missing } = checkManifestRequires(manifest);
+    if (!ok) {
+      tierNotes.push(
+        `${manifest.tier}: missing env var${missing.length === 1 ? '' : 's'} (${missing.join(', ')}) — hooks are written with literal \${${missing[0]}} and will FAIL at runtime until you \`export ${missing.join('=… && export ')}=…\` in your shell.`,
+      );
+    }
+  }
+
+  const platforms = resolvePlatforms(projectRoot, args.platform);
+  if (platforms.length === 0) {
+    return {
+      preset,
+      tiers: tierManifests.map((m) => m.tier),
+      platforms: [],
+      results: [],
+      written: false,
+      notes: [
+        'No target platform detected. Create `.claude/`, `.cursor/`, `.windsurf/`, or `.antigravity/` first, or pass `--platform <name>`.',
+        ...tierNotes,
+      ],
+    };
+  }
+
+  const results = [];
+  let totalWrites = 0;
+  for (const id of platforms) {
+    const adapter = getAdapter(id);
+    const plan = await adapter.emit({ preset, projectRoot, tierManifests });
+    let platformWrites = 0;
+    if (!args.dry) {
+      for (const file of plan.files) {
+        if (file.content === null) {
+          if (existsSync(file.path)) {
+            await unlink(file.path);
+            platformWrites += 1;
+          }
+        } else {
+          await mkdir(path.dirname(file.path), { recursive: true });
+          await writeFile(file.path, file.content, 'utf-8');
+          platformWrites += 1;
+        }
+      }
+    }
+    totalWrites += platformWrites;
+    results.push({
+      platform: id,
+      files: plan.files.map((f) => ({ path: f.path, deleted: f.content === null })),
+      notes: plan.notes,
+      writes: platformWrites,
+    });
+  }
+
+  return {
+    preset,
+    tiers: tierManifests.map((m) => m.tier),
+    platforms,
+    results,
+    written: !args.dry && totalWrites > 0,
+    notes: [...(totalWrites === 0 && !args.dry ? ['no changes to apply (already clean)'] : []), ...tierNotes],
+  };
+}
+
+/**
+ * Resolve requested tiers to loaded manifests.
+ * @returns {Promise<import('./tiers.js').TierManifest[]>}
+ */
+async function resolveTierManifests(projectRoot, requested) {
+  if (!requested) return [];
+  const list = Array.isArray(requested) ? requested : [requested];
+  const unique = Array.from(new Set(list.filter((t) => typeof t === 'string' && t.length > 0)));
+  const manifests = [];
+  for (const tier of unique) {
+    manifests.push(await resolveTier(tier, projectRoot));
+  }
+  return manifests;
+}
+
+function resolvePlatforms(projectRoot, requested) {
+  if (!requested) return detectPlatforms(projectRoot);
+  const list = Array.isArray(requested) ? requested : [requested];
+  const expanded = [];
+  for (const item of list) {
+    if (item === 'all') {
+      // `all` = every *detected* platform, never force-creates unrelated platform dirs.
+      // To install into a platform with no existing directory, pass `--platform <name>` explicitly.
+      expanded.push(...detectPlatforms(projectRoot));
+    } else if (ADAPTERS[item]) {
+      expanded.push(item);
+    } else {
+      throw new Error(`Unknown platform: ${item}. Choose from: ${PLATFORM_KEYS.join(', ')}, all`);
+    }
+  }
+  return Array.from(new Set(expanded));
+}

package/compiler/commands/hooks/merge.js

@@ -0,0 +1,211 @@
+/**
+ * settings.json merger for `rune hooks install/uninstall`.
+ *
+ * Strategy: detect Rune-managed hook entries by command signature (not JSON
+ * comments — settings.json is strict JSON). Remove all Rune entries, then
+ * inject new ones from the preset. User-authored hooks in the same event
+ * arrays are preserved.
+ */
+
+import { isRuneManaged } from './presets.js';
+
+/**
+ * Strip all Rune-managed entries from a settings.json object.
+ * Returns a new settings object (no mutation).
+ *
+ * @param {Object} settings — parsed .claude/settings.json content
+ * @returns {Object} settings with Rune hooks removed
+ */
+export function stripRuneHooks(settings) {
+  if (!settings || typeof settings !== 'object') return {};
+  if (!settings.hooks || typeof settings.hooks !== 'object') return settings;
+
+  const cleanedHooks = {};
+  for (const [eventName, matcherGroups] of Object.entries(settings.hooks)) {
+    if (!Array.isArray(matcherGroups)) {
+      cleanedHooks[eventName] = matcherGroups;
+      continue;
+    }
+
+    const cleanedGroups = matcherGroups
+      .map((group) => {
+        if (!group || !Array.isArray(group.hooks)) return group;
+        const cleanedEntries = group.hooks.filter((entry) => !isRuneManaged(entry));
+        return { ...group, hooks: cleanedEntries };
+      })
+      .filter((group) => {
+        // Drop groups that became empty after stripping Rune entries
+        if (!group || !Array.isArray(group.hooks)) return true;
+        return group.hooks.length > 0;
+      });
+
+    if (cleanedGroups.length > 0) {
+      cleanedHooks[eventName] = cleanedGroups;
+    }
+  }
+
+  const result = { ...settings };
+  if (Object.keys(cleanedHooks).length > 0) {
+    result.hooks = cleanedHooks;
+  } else {
+    delete result.hooks;
+  }
+  return result;
+}
+
+/**
+ * Merge a preset hook block into existing settings. Existing Rune entries are
+ * replaced; user entries in the same events are preserved.
+ *
+ * @param {Object} settings — existing .claude/settings.json content (or {})
+ * @param {Object} preset — output of buildPreset()
+ * @returns {Object} merged settings
+ */
+export function mergePreset(settings, preset) {
+  const stripped = stripRuneHooks(settings || {});
+  return appendHookBlock(stripped, preset);
+}
+
+/**
+ * Append a hook block to pre-stripped settings — does NOT strip Rune entries
+ * first. Use this when layering multiple Rune blocks (e.g. preset + tier)
+ * after a single upstream `stripRuneHooks` call, to avoid each additional
+ * layer wiping the previous one.
+ *
+ * @param {Object} settings — already-stripped settings (or {})
+ * @param {Object} block — { hooks: {...}, ... }
+ * @returns {Object} merged settings
+ */
+export function appendHookBlock(settings, block) {
+  const base = settings && typeof settings === 'object' ? settings : {};
+  const existingHooks = base.hooks && typeof base.hooks === 'object' ? base.hooks : {};
+  const merged = { ...existingHooks };
+
+  for (const [eventName, matcherGroups] of Object.entries(block?.hooks || {})) {
+    const existing = Array.isArray(merged[eventName]) ? merged[eventName] : [];
+    merged[eventName] = mergeEventGroups(existing, matcherGroups);
+  }
+
+  return { ...base, hooks: merged };
+}
+
+/**
+ * Merge preset matcher groups into existing groups for a single event.
+ * If a matcher string already has a user group, append Rune entries into it
+ * rather than duplicating the group.
+ */
+function mergeEventGroups(existingGroups, presetGroups) {
+  const result = existingGroups.map((g) => ({ ...g, hooks: [...(g.hooks || [])] }));
+
+  for (const presetGroup of presetGroups) {
+    const existingIdx = result.findIndex((g) => g.matcher === presetGroup.matcher);
+    if (existingIdx >= 0) {
+      result[existingIdx].hooks.push(...presetGroup.hooks);
+    } else {
+      result.push({ ...presetGroup, hooks: [...presetGroup.hooks] });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Summarize Rune hook entries currently in settings — for `rune hooks status`.
+ *
+ * @param {Object} settings
+ * @returns {{events: Record<string, string[]>, total: number}}
+ */
+export function summarizeRuneHooks(settings) {
+  const events = {};
+  let total = 0;
+  if (!settings?.hooks) return { events, total };
+
+  for (const [eventName, matcherGroups] of Object.entries(settings.hooks)) {
+    if (!Array.isArray(matcherGroups)) continue;
+    for (const group of matcherGroups) {
+      if (!Array.isArray(group?.hooks)) continue;
+      for (const entry of group.hooks) {
+        if (!isRuneManaged(entry)) continue;
+        total += 1;
+        const skill = extractSkillFromCommand(entry.command);
+        if (!events[eventName]) events[eventName] = [];
+        events[eventName].push(skill);
+      }
+    }
+  }
+  return { events, total };
+}
+
+function extractSkillFromCommand(command) {
+  // Expected shapes:
+  //   "npx --yes @rune-kit/rune hook-dispatch <skill> [--gentle]"  (Free preset / dispatch)
+  //   "node \"${RUNE_*_ROOT}/hooks/run-hook.cjs\" <skill>"            (tier entry)
+  const dispatch = command.match(/hook-dispatch\s+(\S+)/);
+  if (dispatch) return dispatch[1];
+  const tier = command.match(/run-hook\.cjs(?:"|')?\s+(\S+)/);
+  if (tier) return tier[1];
+  return 'unknown';
+}
+
+/**
+ * Strip entries whose extracted skill name appears in `skillIds` from an
+ * already-parsed settings object. Used to honor manifest `overrides`:
+ * e.g., Pro's `context-sense` replaces an older `context-watch` entry.
+ *
+ * @param {Object} settings
+ * @param {Iterable<string>} skillIds — skill names to remove
+ * @returns {Object} new settings
+ */
+export function stripHooksBySkill(settings, skillIds) {
+  const targets = new Set(skillIds);
+  if (!settings?.hooks || targets.size === 0) return settings;
+
+  const cleanedHooks = {};
+  for (const [eventName, matcherGroups] of Object.entries(settings.hooks)) {
+    if (!Array.isArray(matcherGroups)) {
+      cleanedHooks[eventName] = matcherGroups;
+      continue;
+    }
+    const cleanedGroups = matcherGroups
+      .map((group) => {
+        if (!group || !Array.isArray(group.hooks)) return group;
+        const filtered = group.hooks.filter((entry) => {
+          if (!entry || typeof entry.command !== 'string') return true;
+          return !targets.has(extractSkillFromCommand(entry.command));
+        });
+        return { ...group, hooks: filtered };
+      })
+      .filter((group) => !group || !Array.isArray(group.hooks) || group.hooks.length > 0);
+    if (cleanedGroups.length > 0) cleanedHooks[eventName] = cleanedGroups;
+  }
+
+  const result = { ...settings };
+  if (Object.keys(cleanedHooks).length > 0) result.hooks = cleanedHooks;
+  else delete result.hooks;
+  return result;
+}
+
+/**
+ * Detect active preset by examining Rune commands in settings.
+ * Returns 'gentle' | 'strict' | 'mixed' | 'none'.
+ */
+export function detectPreset(settings) {
+  if (!settings?.hooks) return 'none';
+  let hasGentle = false;
+  let hasStrict = false;
+  for (const matcherGroups of Object.values(settings.hooks)) {
+    if (!Array.isArray(matcherGroups)) continue;
+    for (const group of matcherGroups) {
+      if (!Array.isArray(group?.hooks)) continue;
+      for (const entry of group.hooks) {
+        if (!isRuneManaged(entry)) continue;
+        if (entry.command.includes('--gentle')) hasGentle = true;
+        else hasStrict = true;
+      }
+    }
+  }
+  if (hasGentle && hasStrict) return 'mixed';
+  if (hasGentle) return 'gentle';
+  if (hasStrict) return 'strict';
+  return 'none';
+}