@rune-kit/rune 2.11.0 → 2.12.0

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

@@ -0,0 +1,139 @@
+import assert from 'node:assert';
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, readdir, readFile, 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 * as cursor from '../adapters/hooks/cursor.js';
+import { installHooks } from '../commands/hooks/install.js';
+import { hookStatus } from '../commands/hooks/status.js';
+import { uninstallHooks } from '../commands/hooks/uninstall.js';
+
+const RUNE_ROOT = path.resolve(import.meta.dirname, '..', '..');
+const RULES_DIR = '.cursor/rules';
+
+let tmpRoot;
+
+async function seedCursor(root) {
+  await mkdir(path.join(root, '.cursor'), { recursive: true });
+}
+
+beforeEach(async () => {
+  tmpRoot = await mkdtemp(path.join(tmpdir(), 'rune-cursor-'));
+});
+
+afterEach(async () => {
+  if (tmpRoot) await rm(tmpRoot, { recursive: true, force: true });
+});
+
+describe('cursor adapter', () => {
+  test('detect() true when .cursor exists', async () => {
+    await seedCursor(tmpRoot);
+    assert.strictEqual(cursor.detect(tmpRoot), true);
+  });
+
+  test('detect() false when .cursor missing', () => {
+    assert.strictEqual(cursor.detect(tmpRoot), false);
+  });
+
+  test('emit(gentle) returns 3 .mdc rule files', async () => {
+    const plan = await cursor.emit({ preset: 'gentle', projectRoot: tmpRoot });
+    assert.strictEqual(plan.files.length, 3);
+    const names = plan.files.map((f) => path.basename(f.path)).sort();
+    assert.deepStrictEqual(names, ['rune-dependency-doctor.mdc', 'rune-preflight.mdc', 'rune-sentinel.mdc']);
+    for (const file of plan.files) {
+      assert.ok(file.content.includes('rune-managed: true'));
+      assert.ok(file.content.includes('@rune-kit/rune hook-dispatch'));
+    }
+  });
+
+  test('emit(strict) renders WARN → BLOCK guidance', async () => {
+    const gentle = await cursor.emit({ preset: 'gentle', projectRoot: tmpRoot });
+    const strict = await cursor.emit({ preset: 'strict', projectRoot: tmpRoot });
+    const gentlePreflight = gentle.files.find((f) => f.path.endsWith('rune-preflight.mdc')).content;
+    const strictPreflight = strict.files.find((f) => f.path.endsWith('rune-preflight.mdc')).content;
+    assert.ok(gentlePreflight.includes('WARN'));
+    assert.ok(strictPreflight.includes('BLOCK'));
+  });
+
+  test('emit(off) delegates to uninstall', async () => {
+    await seedCursor(tmpRoot);
+    await installHooks(tmpRoot, { preset: 'gentle', platform: 'cursor' });
+    const plan = await cursor.emit({ preset: 'off', projectRoot: tmpRoot });
+    assert.ok(plan.files.every((f) => f.content === null));
+    assert.ok(plan.files.length >= 1);
+  });
+
+  test('emit() rejects invalid preset', async () => {
+    await assert.rejects(cursor.emit({ preset: 'loose', projectRoot: tmpRoot }), /invalid preset/);
+  });
+
+  test('install writes .mdc files to .cursor/rules/', async () => {
+    await seedCursor(tmpRoot);
+    const result = await installHooks(tmpRoot, { preset: 'gentle', platform: 'cursor' });
+    assert.strictEqual(result.written, true);
+    const rulesDir = path.join(tmpRoot, RULES_DIR);
+    const files = await readdir(rulesDir);
+    assert.ok(files.includes('rune-preflight.mdc'));
+    assert.ok(files.includes('rune-sentinel.mdc'));
+    assert.ok(files.includes('rune-dependency-doctor.mdc'));
+  });
+
+  test('idempotent re-install produces identical content', async () => {
+    await seedCursor(tmpRoot);
+    await installHooks(tmpRoot, { preset: 'gentle', platform: 'cursor' });
+    const rulesDir = path.join(tmpRoot, RULES_DIR);
+    const first = await readFile(path.join(rulesDir, 'rune-preflight.mdc'), 'utf-8');
+    await installHooks(tmpRoot, { preset: 'gentle', platform: 'cursor' });
+    const second = await readFile(path.join(rulesDir, 'rune-preflight.mdc'), 'utf-8');
+    assert.strictEqual(first, second);
+  });
+
+  test('uninstall removes only Rune-managed .mdc files', async () => {
+    await seedCursor(tmpRoot);
+    const rulesDir = path.join(tmpRoot, RULES_DIR);
+    await mkdir(rulesDir, { recursive: true });
+    await writeFile(path.join(rulesDir, 'user-custom.mdc'), '---\ndescription: user\n---\n\n# User rule\n', 'utf-8');
+
+    await installHooks(tmpRoot, { preset: 'gentle', platform: 'cursor' });
+    await uninstallHooks(tmpRoot, { platform: 'cursor' });
+
+    const remaining = await readdir(rulesDir);
+    assert.ok(remaining.includes('user-custom.mdc'), 'user rule must survive');
+    assert.ok(!remaining.some((f) => f.startsWith('rune-')), 'no rune-* files should remain');
+  });
+
+  test('uninstall skips files without rune-managed signature', async () => {
+    await seedCursor(tmpRoot);
+    const rulesDir = path.join(tmpRoot, RULES_DIR);
+    await mkdir(rulesDir, { recursive: true });
+    // A file that happens to start with "rune-" but is NOT managed by Rune
+    await writeFile(
+      path.join(rulesDir, 'rune-fake.mdc'),
+      '---\ndescription: user imposter\n---\n\nnot ours\n',
+      'utf-8',
+    );
+
+    await uninstallHooks(tmpRoot, { platform: 'cursor' });
+    assert.ok(existsSync(path.join(rulesDir, 'rune-fake.mdc')), 'non-managed rune-* file must survive');
+  });
+
+  test('status reports installed preset after install', async () => {
+    await seedCursor(tmpRoot);
+    await installHooks(tmpRoot, { preset: 'strict', platform: 'cursor' });
+    const result = await hookStatus(tmpRoot, RUNE_ROOT, { platform: 'cursor' });
+    const r = result.results.find((x) => x.platform === 'cursor');
+    assert.strictEqual(r.installed, true);
+    assert.strictEqual(r.preset, 'strict');
+    assert.ok(r.wired.includes('preflight'));
+    assert.ok(r.wired.includes('sentinel'));
+    assert.ok(r.wired.includes('dependency-doctor'));
+  });
+
+  test('status reports not installed when .cursor missing', async () => {
+    const result = await hookStatus(tmpRoot, RUNE_ROOT, { platform: 'cursor' });
+    const r = result.results.find((x) => x.platform === 'cursor');
+    assert.strictEqual(r.installed, false);
+    assert.ok(r.missing.includes('preflight'));
+  });
+});

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

@@ -0,0 +1,305 @@
+import assert from 'node:assert';
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, readFile, 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 { installHooks } from '../commands/hooks/install.js';
+import { SETTINGS_REL_PATH } from '../commands/hooks/presets.js';
+import { hookStatus } from '../commands/hooks/status.js';
+import { uninstallHooks } from '../commands/hooks/uninstall.js';
+
+const RUNE_ROOT = path.resolve(import.meta.dirname, '..', '..');
+
+let tmpRoot;
+
+async function seedClaude(root) {
+  await mkdir(path.join(root, '.claude'), { recursive: true });
+}
+
+beforeEach(async () => {
+  tmpRoot = await mkdtemp(path.join(tmpdir(), 'rune-hooks-'));
+});
+
+afterEach(async () => {
+  if (tmpRoot) await rm(tmpRoot, { recursive: true, force: true });
+});
+
+describe('installHooks (claude adapter)', () => {
+  test('fresh install writes .claude/settings.json with gentle preset', async () => {
+    await seedClaude(tmpRoot);
+    const result = await installHooks(tmpRoot, { preset: 'gentle' });
+    assert.strictEqual(result.preset, 'gentle');
+    assert.strictEqual(result.written, true);
+    assert.deepStrictEqual(result.platforms, ['claude']);
+
+    const settingsPath = path.join(tmpRoot, SETTINGS_REL_PATH);
+    assert.ok(existsSync(settingsPath));
+
+    const settings = JSON.parse(await readFile(settingsPath, 'utf-8'));
+    assert.ok(settings.hooks?.PreToolUse);
+    assert.ok(settings.hooks?.Stop);
+  });
+
+  test('defaults to gentle when preset omitted', async () => {
+    await seedClaude(tmpRoot);
+    const result = await installHooks(tmpRoot, {});
+    assert.strictEqual(result.preset, 'gentle');
+    const settings = JSON.parse(await readFile(path.join(tmpRoot, SETTINGS_REL_PATH), 'utf-8'));
+    const stopCmd = settings.hooks.Stop[0].hooks[0].command;
+    assert.ok(stopCmd.includes('--gentle'));
+  });
+
+  test('re-install with same preset is idempotent', async () => {
+    await seedClaude(tmpRoot);
+    await installHooks(tmpRoot, { preset: 'gentle' });
+    const first = await readFile(path.join(tmpRoot, SETTINGS_REL_PATH), 'utf-8');
+    await installHooks(tmpRoot, { preset: 'gentle' });
+    const second = await readFile(path.join(tmpRoot, SETTINGS_REL_PATH), 'utf-8');
+    assert.strictEqual(first, second);
+  });
+
+  test('upgrade gentle → strict replaces Rune entries', async () => {
+    await seedClaude(tmpRoot);
+    await installHooks(tmpRoot, { preset: 'gentle' });
+    await installHooks(tmpRoot, { preset: 'strict' });
+    const settings = JSON.parse(await readFile(path.join(tmpRoot, SETTINGS_REL_PATH), 'utf-8'));
+    const preflightCmd = settings.hooks.PreToolUse[0].hooks[0].command;
+    assert.ok(!preflightCmd.includes('--gentle'), 'strict should not have --gentle');
+  });
+
+  test('preserves user hooks when installing', async () => {
+    const settingsDir = path.join(tmpRoot, '.claude');
+    await mkdir(settingsDir, { recursive: true });
+    await writeFile(
+      path.join(settingsDir, 'settings.json'),
+      JSON.stringify(
+        {
+          env: { MY_VAR: 'keep-me' },
+          hooks: {
+            PreToolUse: [{ matcher: 'Read', hooks: [{ type: 'command', command: 'user-read-hook.sh' }] }],
+          },
+        },
+        null,
+        2,
+      ),
+    );
+
+    await installHooks(tmpRoot, { preset: 'gentle' });
+    const settings = JSON.parse(await readFile(path.join(settingsDir, 'settings.json'), 'utf-8'));
+    assert.deepStrictEqual(settings.env, { MY_VAR: 'keep-me' }, 'env preserved');
+    const readGroup = settings.hooks.PreToolUse.find((g) => g.matcher === 'Read');
+    assert.ok(readGroup, 'user Read matcher preserved');
+    assert.strictEqual(readGroup.hooks[0].command, 'user-read-hook.sh');
+  });
+
+  test('rejects invalid preset', async () => {
+    await seedClaude(tmpRoot);
+    await assert.rejects(installHooks(tmpRoot, { preset: 'loose' }), /Invalid preset/);
+  });
+
+  test('dry-run does not write', async () => {
+    await seedClaude(tmpRoot);
+    const result = await installHooks(tmpRoot, { preset: 'gentle', dry: true });
+    assert.strictEqual(result.written, false);
+    assert.ok(!existsSync(path.join(tmpRoot, SETTINGS_REL_PATH)));
+  });
+
+  test('preset=off uninstalls rune hooks only', async () => {
+    await seedClaude(tmpRoot);
+    await installHooks(tmpRoot, { preset: 'gentle' });
+    const result = await installHooks(tmpRoot, { preset: 'off' });
+    assert.strictEqual(result.preset, 'off');
+    const settings = JSON.parse(await readFile(path.join(tmpRoot, SETTINGS_REL_PATH), 'utf-8'));
+    assert.strictEqual(settings.hooks, undefined);
+  });
+
+  test('T1: preset=off with no settings.json does not create the file', async () => {
+    await seedClaude(tmpRoot);
+    const settingsPath = path.join(tmpRoot, SETTINGS_REL_PATH);
+    assert.ok(!existsSync(settingsPath), 'precondition: file must not exist');
+    const result = await installHooks(tmpRoot, { preset: 'off' });
+    // H1 fix: written reflects actual byte writes, not just !dry
+    assert.strictEqual(result.written, false);
+    assert.ok(result.notes.some((n) => n.includes('no changes')));
+    const claudeResult = result.results.find((r) => r.platform === 'claude');
+    assert.strictEqual(claudeResult.files.length, 0, 'no files should be written for off+missing');
+    assert.strictEqual(claudeResult.writes, 0);
+    assert.ok(!existsSync(settingsPath), 'settings.json must NOT have been created');
+  });
+
+  test('T2: malformed settings.json causes actionable error, file unchanged', async () => {
+    const settingsDir = path.join(tmpRoot, '.claude');
+    await mkdir(settingsDir, { recursive: true });
+    const settingsPath = path.join(settingsDir, 'settings.json');
+    const malformed = '{ not valid json }';
+    await writeFile(settingsPath, malformed, 'utf-8');
+    await assert.rejects(installHooks(tmpRoot, { preset: 'gentle' }), (err) => {
+      assert.ok(err.message.includes('settings.json'), 'error must mention settings.json');
+      return true;
+    });
+    assert.strictEqual(await readFile(settingsPath, 'utf-8'), malformed);
+  });
+
+  test('auto-detects no platforms → returns empty results with note', async () => {
+    const result = await installHooks(tmpRoot, { preset: 'gentle' });
+    assert.deepStrictEqual(result.platforms, []);
+    assert.strictEqual(result.written, false);
+    assert.ok(result.notes.some((n) => n.includes('No target platform')));
+  });
+
+  test('--platform claude forces install even without .claude/', async () => {
+    const result = await installHooks(tmpRoot, { preset: 'gentle', platform: 'claude' });
+    assert.deepStrictEqual(result.platforms, ['claude']);
+    assert.strictEqual(result.written, true);
+    assert.ok(existsSync(path.join(tmpRoot, SETTINGS_REL_PATH)));
+  });
+
+  test('--platform all targets only detected platforms (no silent dir creation)', async () => {
+    // Bare dir → no platforms detected → all expands to nothing
+    const bare = await installHooks(tmpRoot, { preset: 'gentle', platform: 'all' });
+    assert.deepStrictEqual(bare.platforms, []);
+    assert.strictEqual(bare.written, false);
+
+    // Seed .claude/ + .cursor/ only → all picks up those two, NOT windsurf/antigravity
+    await seedClaude(tmpRoot);
+    await mkdir(path.join(tmpRoot, '.cursor'), { recursive: true });
+    const result = await installHooks(tmpRoot, { preset: 'gentle', platform: 'all' });
+    assert.ok(result.platforms.includes('claude'));
+    assert.ok(result.platforms.includes('cursor'));
+    assert.ok(!result.platforms.includes('windsurf'), 'must not force-create windsurf dir');
+    assert.ok(!result.platforms.includes('antigravity'), 'must not force-create antigravity dir');
+    assert.ok(!existsSync(path.join(tmpRoot, '.windsurf')));
+    assert.ok(!existsSync(path.join(tmpRoot, '.antigravity')));
+  });
+
+  test('--platform <name> still force-creates the platform dir (explicit opt-in)', async () => {
+    const result = await installHooks(tmpRoot, { preset: 'gentle', platform: 'cursor' });
+    assert.deepStrictEqual(result.platforms, ['cursor']);
+    assert.ok(existsSync(path.join(tmpRoot, '.cursor', 'rules')));
+  });
+
+  test('unknown --platform rejected', async () => {
+    await assert.rejects(installHooks(tmpRoot, { preset: 'gentle', platform: 'bogus' }), /Unknown platform/);
+  });
+});
+
+describe('uninstallHooks (claude adapter)', () => {
+  test('no-op when no platforms detected', async () => {
+    const result = await uninstallHooks(tmpRoot);
+    assert.deepStrictEqual(result.platforms, []);
+    assert.strictEqual(result.written, false);
+  });
+
+  test('no-op when .claude/ exists but no settings.json', async () => {
+    await seedClaude(tmpRoot);
+    const result = await uninstallHooks(tmpRoot);
+    assert.deepStrictEqual(result.platforms, ['claude']);
+    // H1 fix: written=false when no actual writes happened
+    assert.strictEqual(result.written, false);
+    const claudeResult = result.results.find((r) => r.platform === 'claude');
+    assert.strictEqual(claudeResult.files.length, 0);
+    assert.strictEqual(claudeResult.writes, 0);
+  });
+
+  test('removes Rune hooks, preserves user hooks', async () => {
+    const settingsDir = path.join(tmpRoot, '.claude');
+    await mkdir(settingsDir, { recursive: true });
+    await writeFile(
+      path.join(settingsDir, 'settings.json'),
+      JSON.stringify(
+        {
+          hooks: {
+            PreToolUse: [
+              {
+                matcher: 'Edit|Write',
+                hooks: [
+                  { type: 'command', command: 'npx --yes @rune-kit/rune hook-dispatch preflight' },
+                  { type: 'command', command: 'user-lint.sh' },
+                ],
+              },
+            ],
+          },
+        },
+        null,
+        2,
+      ),
+    );
+
+    const result = await uninstallHooks(tmpRoot);
+    assert.strictEqual(result.written, true);
+    const settings = JSON.parse(await readFile(path.join(settingsDir, 'settings.json'), 'utf-8'));
+    const editGroup = settings.hooks.PreToolUse.find((g) => g.matcher === 'Edit|Write');
+    assert.strictEqual(editGroup.hooks.length, 1);
+    assert.strictEqual(editGroup.hooks[0].command, 'user-lint.sh');
+  });
+
+  test('T4: user hook preserved exactly through install/uninstall round-trip', async () => {
+    const settingsDir = path.join(tmpRoot, '.claude');
+    await mkdir(settingsDir, { recursive: true });
+    const userCommand = 'my-rune hook-dispatch-notes.sh';
+    const initialSettings = {
+      hooks: {
+        PreToolUse: [{ matcher: 'Edit|Write', hooks: [{ type: 'command', command: userCommand }] }],
+      },
+    };
+    await writeFile(path.join(settingsDir, 'settings.json'), JSON.stringify(initialSettings, null, 2));
+
+    await installHooks(tmpRoot, { preset: 'gentle' });
+    await uninstallHooks(tmpRoot);
+
+    const settings = JSON.parse(await readFile(path.join(settingsDir, 'settings.json'), 'utf-8'));
+    const editGroup = settings.hooks?.PreToolUse?.find((g) => g.matcher === 'Edit|Write');
+    assert.ok(editGroup, 'user Edit|Write group must survive');
+    assert.ok(
+      editGroup.hooks.some((h) => h.command === userCommand),
+      `user command "${userCommand}" must be preserved exactly`,
+    );
+  });
+
+  test('malformed settings.json causes actionable error on uninstall', async () => {
+    const settingsDir = path.join(tmpRoot, '.claude');
+    await mkdir(settingsDir, { recursive: true });
+    await writeFile(path.join(settingsDir, 'settings.json'), '{ broken json', 'utf-8');
+    await assert.rejects(uninstallHooks(tmpRoot), (err) => {
+      assert.ok(err.message.includes('settings.json') || err.message.includes('JSON'));
+      return true;
+    });
+  });
+});
+
+describe('hookStatus (claude adapter)', () => {
+  test('reports empty platforms when nothing detected', async () => {
+    const result = await hookStatus(tmpRoot, RUNE_ROOT);
+    assert.deepStrictEqual(result.platforms, []);
+  });
+
+  test('reports none for .claude/ without settings', async () => {
+    await seedClaude(tmpRoot);
+    const result = await hookStatus(tmpRoot, RUNE_ROOT);
+    const claude = result.results.find((r) => r.platform === 'claude');
+    assert.strictEqual(claude.installed, false);
+    assert.strictEqual(claude.preset, null);
+  });
+
+  test('reports gentle preset after install', async () => {
+    await seedClaude(tmpRoot);
+    await installHooks(tmpRoot, { preset: 'gentle' });
+    const result = await hookStatus(tmpRoot, RUNE_ROOT);
+    const claude = result.results.find((r) => r.platform === 'claude');
+    assert.strictEqual(claude.installed, true);
+    assert.strictEqual(claude.preset, 'gentle');
+    assert.ok(claude.events.PreToolUse.includes('preflight'));
+    assert.ok(claude.events.Stop.includes('completion-gate'));
+  });
+
+  test('--platform all surfaces every adapter', async () => {
+    const result = await hookStatus(tmpRoot, RUNE_ROOT, { platform: 'all' });
+    assert.strictEqual(result.results.length, 4);
+    for (const id of ['claude', 'cursor', 'windsurf', 'antigravity']) {
+      const r = result.results.find((x) => x.platform === id);
+      assert.ok(r, `result for ${id} must be present`);
+      assert.ok(r.capability, `capability matrix for ${id} must be present`);
+    }
+  });
+});

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

@@ -0,0 +1,204 @@
+import assert from 'node:assert';
+import { describe, test } from 'node:test';
+import { detectPreset, mergePreset, stripRuneHooks, summarizeRuneHooks } from '../commands/hooks/merge.js';
+import { buildPreset, isRuneManaged } from '../commands/hooks/presets.js';
+
+describe('isRuneManaged', () => {
+  // T3: must reject strings that merely contain "rune" or "hook-dispatch"
+  test('T3: rejects commands that contain "rune hook-dispatch" as substring only', () => {
+    const falsePositives = [
+      'my-rune hook-dispatch-notes.sh',
+      '/usr/local/bin/rune hook-dispatch-runner',
+      'echo "rune hook-dispatch done"',
+      'log-rune hook-dispatch.log',
+    ];
+    for (const cmd of falsePositives) {
+      assert.strictEqual(isRuneManaged({ command: cmd }), false, `should NOT match: ${cmd}`);
+    }
+  });
+
+  test('T3: matches the exact @rune-kit/rune hook-dispatch invocation', () => {
+    const truePositives = [
+      'npx --yes @rune-kit/rune hook-dispatch preflight',
+      'npx @rune-kit/rune hook-dispatch sentinel',
+      'npx --yes @rune-kit/rune hook-dispatch completion-gate --gentle',
+    ];
+    for (const cmd of truePositives) {
+      assert.strictEqual(isRuneManaged({ command: cmd }), true, `should match: ${cmd}`);
+    }
+  });
+});
+
+describe('buildPreset', () => {
+  test('produces valid gentle preset with expected events', () => {
+    const preset = buildPreset('gentle');
+    assert.ok(preset.hooks.PreToolUse);
+    assert.ok(preset.hooks.PostToolUse);
+    assert.ok(preset.hooks.Stop);
+    const editGroup = preset.hooks.PreToolUse.find((g) => g.matcher === 'Edit|Write');
+    assert.ok(editGroup.hooks[0].command.includes('preflight'));
+    assert.ok(editGroup.hooks[0].command.includes('--gentle'));
+  });
+
+  test('strict preset omits --gentle flag', () => {
+    const preset = buildPreset('strict');
+    const editGroup = preset.hooks.PreToolUse.find((g) => g.matcher === 'Edit|Write');
+    assert.ok(!editGroup.hooks[0].command.includes('--gentle'));
+  });
+
+  test('rejects unknown preset', () => {
+    assert.throws(() => buildPreset('loose'), /Unknown preset/);
+  });
+
+  test('all commands carry Rune-managed signature', () => {
+    for (const name of ['gentle', 'strict']) {
+      const preset = buildPreset(name);
+      for (const groups of Object.values(preset.hooks)) {
+        for (const group of groups) {
+          for (const entry of group.hooks) {
+            assert.ok(isRuneManaged(entry), `entry missing signature: ${JSON.stringify(entry)}`);
+          }
+        }
+      }
+    }
+  });
+});
+
+describe('stripRuneHooks', () => {
+  test('removes Rune entries, preserves user entries', () => {
+    const settings = {
+      hooks: {
+        PreToolUse: [
+          {
+            matcher: 'Edit|Write',
+            hooks: [
+              { type: 'command', command: 'npx --yes @rune-kit/rune hook-dispatch preflight --gentle' },
+              { type: 'command', command: 'my-custom-hook.sh' },
+            ],
+          },
+        ],
+      },
+    };
+    const result = stripRuneHooks(settings);
+    const group = result.hooks.PreToolUse.find((g) => g.matcher === 'Edit|Write');
+    assert.strictEqual(group.hooks.length, 1);
+    assert.strictEqual(group.hooks[0].command, 'my-custom-hook.sh');
+  });
+
+  test('drops event if all entries were Rune-managed', () => {
+    const settings = {
+      hooks: {
+        Stop: [
+          {
+            matcher: '.*',
+            hooks: [{ type: 'command', command: 'npx --yes @rune-kit/rune hook-dispatch completion-gate' }],
+          },
+        ],
+      },
+    };
+    const result = stripRuneHooks(settings);
+    assert.strictEqual(result.hooks, undefined);
+  });
+
+  test('handles missing hooks field', () => {
+    assert.deepStrictEqual(stripRuneHooks({ other: 'data' }), { other: 'data' });
+  });
+
+  test('returns {} for null input', () => {
+    assert.deepStrictEqual(stripRuneHooks(null), {});
+  });
+
+  test('preserves top-level non-hook fields', () => {
+    const settings = {
+      $schema: 'https://example.com/schema.json',
+      env: { FOO: 'bar' },
+      hooks: {
+        Stop: [{ matcher: '.*', hooks: [{ command: 'npx --yes @rune-kit/rune hook-dispatch completion-gate' }] }],
+      },
+    };
+    const result = stripRuneHooks(settings);
+    assert.strictEqual(result.$schema, 'https://example.com/schema.json');
+    assert.deepStrictEqual(result.env, { FOO: 'bar' });
+  });
+});
+
+describe('mergePreset', () => {
+  test('fresh install writes full preset', () => {
+    const merged = mergePreset({}, buildPreset('gentle'));
+    assert.ok(merged.hooks.PreToolUse);
+    assert.ok(merged.hooks.Stop);
+  });
+
+  test('re-install replaces Rune entries, keeps user entries', () => {
+    const initial = mergePreset({}, buildPreset('gentle'));
+    // user adds their own hook to the same matcher
+    initial.hooks.PreToolUse[0].hooks.push({ type: 'command', command: 'user-lint.sh' });
+
+    const reinstalled = mergePreset(initial, buildPreset('strict'));
+    const editGroup = reinstalled.hooks.PreToolUse.find((g) => g.matcher === 'Edit|Write');
+    const commands = editGroup.hooks.map((h) => h.command);
+    assert.ok(commands.includes('user-lint.sh'), 'user hook preserved');
+    assert.ok(
+      commands.some((c) => c.includes('preflight') && !c.includes('--gentle')),
+      'strict preflight installed',
+    );
+    assert.ok(!commands.some((c) => c.includes('--gentle')), 'no gentle entries remain');
+  });
+
+  test('idempotent — same preset twice = same result', () => {
+    const once = mergePreset({}, buildPreset('gentle'));
+    const twice = mergePreset(once, buildPreset('gentle'));
+    assert.deepStrictEqual(once, twice);
+  });
+
+  test('merges into existing user matcher without duplicate groups', () => {
+    const userSettings = {
+      hooks: {
+        PreToolUse: [{ matcher: 'Edit|Write', hooks: [{ command: 'user-guard.sh' }] }],
+      },
+    };
+    const merged = mergePreset(userSettings, buildPreset('gentle'));
+    const groups = merged.hooks.PreToolUse.filter((g) => g.matcher === 'Edit|Write');
+    assert.strictEqual(groups.length, 1, 'no duplicate matcher group');
+    assert.ok(groups[0].hooks.some((h) => h.command === 'user-guard.sh'));
+    assert.ok(groups[0].hooks.some((h) => h.command.includes('preflight')));
+  });
+});
+
+describe('summarizeRuneHooks', () => {
+  test('extracts skill names per event', () => {
+    const merged = mergePreset({}, buildPreset('gentle'));
+    const summary = summarizeRuneHooks(merged);
+    assert.strictEqual(summary.total, 4);
+    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.Stop.includes('completion-gate'));
+  });
+
+  test('empty settings → zero total', () => {
+    const summary = summarizeRuneHooks({});
+    assert.strictEqual(summary.total, 0);
+  });
+});
+
+describe('detectPreset', () => {
+  test('detects gentle', () => {
+    assert.strictEqual(detectPreset(mergePreset({}, buildPreset('gentle'))), 'gentle');
+  });
+  test('detects strict', () => {
+    assert.strictEqual(detectPreset(mergePreset({}, buildPreset('strict'))), 'strict');
+  });
+  test('detects mixed', () => {
+    const mixed = mergePreset({}, buildPreset('gentle'));
+    // manually inject a strict entry
+    mixed.hooks.Stop[0].hooks.push({
+      type: 'command',
+      command: 'npx --yes @rune-kit/rune hook-dispatch sentinel',
+    });
+    assert.strictEqual(detectPreset(mixed), 'mixed');
+  });
+  test('returns none for empty settings', () => {
+    assert.strictEqual(detectPreset({}), 'none');
+  });
+});