@rune-kit/rune 2.11.0 → 2.12.0

package/README.md

@@ -83,7 +83,18 @@ _Methodology: Claude Code CLI headless mode (`claude -p --output-format json`),
 
 ---
 
-## What's New (v2.11.0)
+## What's New (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
@@ -248,6 +259,52 @@ This compiles all 62 skills into your IDE's rules format. Same knowledge, same w
 /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:
+
+```bash
+# 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`:
+
+```bash
+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

package/compiler/__tests__/detect-invariants.test.js

@@ -0,0 +1,136 @@
+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 { after, before, describe, test } from 'node:test';
+import { detectInvariants, renderInvariants } from '../../skills/onboard/scripts/detect-invariants.js';
+
+async function scaffold(files) {
+  const root = await mkdtemp(path.join(tmpdir(), 'rune-invariants-'));
+  for (const [rel, content] of Object.entries(files)) {
+    const abs = path.join(root, rel);
+    await mkdir(path.dirname(abs), { recursive: true });
+    await writeFile(abs, content, 'utf8');
+  }
+  return root;
+}
+
+describe('detectInvariants — danger zones', () => {
+  test('scores deeply-nested source directories as danger zones', async () => {
+    const files = {};
+    for (let i = 0; i < 12; i++) {
+      files[`src/auth/sub/file${i}.ts`] = `export const x${i} = ${i};\n`;
+    }
+    files['src/auth/session.ts'] = 'export const SESSION_TTL = 900;\n';
+    const root = await scaffold(files);
+    try {
+      const result = await detectInvariants({ root });
+      const danger = result.danger.map((r) => r.where[0]);
+      assert.ok(
+        danger.some((d) => d.startsWith('src/auth')),
+        `expected src/auth in danger, got: ${JSON.stringify(danger)}`,
+      );
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test('ignores node_modules and .git', async () => {
+    const files = {};
+    for (let i = 0; i < 20; i++) {
+      files[`node_modules/pkg/file${i}.js`] = '// noise\n';
+    }
+    files['src/app.ts'] = 'export const A = 1;\n';
+    const root = await scaffold(files);
+    try {
+      const result = await detectInvariants({ root });
+      const danger = result.danger.map((r) => r.where[0]);
+      assert.ok(!danger.some((d) => d.includes('node_modules')), 'node_modules must not appear');
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('detectInvariants — critical constants', () => {
+  test('flags SCREAMING_SNAKE constants used in 3+ files', async () => {
+    const files = {
+      'src/config.ts': 'export const MAX_RETRIES = 3;\n',
+      'src/a.ts': 'import { MAX_RETRIES } from "./config";\nconsole.log(MAX_RETRIES);\n',
+      'src/b.ts': 'import { MAX_RETRIES } from "./config";\nif (MAX_RETRIES > 0) {}\n',
+      'src/c.ts': 'import { MAX_RETRIES } from "./config";\nconst x = MAX_RETRIES;\n',
+    };
+    const root = await scaffold(files);
+    try {
+      const result = await detectInvariants({ root });
+      const found = result.critical.some(
+        (r) => (r.title ?? '').includes('MAX_RETRIES') || (r.what ?? '').includes('MAX_RETRIES'),
+      );
+      assert.ok(
+        found,
+        `expected MAX_RETRIES in critical, got titles: ${JSON.stringify(result.critical.map((r) => r.title))}`,
+      );
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test('does NOT flag constants used in fewer than 3 places', async () => {
+    const files = {
+      'src/config.ts': 'export const LONELY = 1;\n',
+      'src/a.ts': 'import { LONELY } from "./config";\n',
+    };
+    const root = await scaffold(files);
+    try {
+      const result = await detectInvariants({ root });
+      const found = result.critical.some((r) => (r.title ?? '').includes('LONELY'));
+      assert.strictEqual(found, false, 'LONELY should not be flagged with only 2 usages');
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('renderInvariants', () => {
+  test('produces markdown headings per non-empty bucket', () => {
+    const result = {
+      danger: [{ title: 'src/auth', what: '12 files', where: ['src/auth/**'], why: 'high churn' }],
+      critical: [],
+      state: [],
+      cross: [],
+      stats: { filesScanned: 10 },
+    };
+    const md = renderInvariants(result);
+    assert.ok(md.includes('### Danger Zones'));
+    assert.ok(md.includes('#### src/auth'));
+    assert.ok(md.includes('- **WHAT**: 12 files'));
+    assert.ok(!md.includes('### Critical Invariants'));
+  });
+
+  test('falls back to placeholder when empty', () => {
+    const md = renderInvariants({ danger: [], critical: [], state: [], cross: [] });
+    assert.match(md, /No invariants detected/);
+  });
+});
+
+describe('detectInvariants — performance', () => {
+  let root;
+  before(async () => {
+    const files = {};
+    for (let i = 0; i < 120; i++) {
+      files[`src/mod${i % 12}/file${i}.ts`] = `export const FOO_${i} = ${i};\n`;
+    }
+    root = await scaffold(files);
+  });
+  after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  test('completes under 5 seconds for a 120-file project', async () => {
+    const start = Date.now();
+    const result = await detectInvariants({ root });
+    const elapsed = Date.now() - start;
+    assert.ok(elapsed < 5000, `took ${elapsed}ms, expected <5000ms`);
+    assert.ok(result.stats.filesScanned >= 100, `scanned ${result.stats.filesScanned} files`);
+  });
+});

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

@@ -0,0 +1,229 @@
+/**
+ * Tests for doctor mesh integrity checks
+ */
+
+import assert from 'node:assert';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { checkMeshIntegrity, formatMeshResults } from '../doctor.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEST_ROOT = path.join(__dirname, '.test-mesh-skills');
+
+describe('checkMeshIntegrity', () => {
+  beforeEach(async () => {
+    await mkdir(path.join(TEST_ROOT, 'skills', 'skill-a'), { recursive: true });
+    await mkdir(path.join(TEST_ROOT, 'skills', 'skill-b'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(TEST_ROOT, { recursive: true, force: true });
+  });
+
+  test('detects missing reciprocal connections', async () => {
+    // skill-a calls skill-b, but skill-b doesn't acknowledge
+    await writeFile(
+      path.join(TEST_ROOT, 'skills', 'skill-a', 'SKILL.md'),
+      `---
+name: skill-a
+metadata:
+  version: "1.0.0"
+---
+# skill-a
+## Calls (outbound)
+- \`skill-b\` (L2): some reason
+## Called By (inbound)
+None
+## Sharp Edges
+| Mode | Sev | Mit |
+## Done When
+- done
+## Cost Profile
+~100 tokens
+`,
+    );
+
+    await writeFile(
+      path.join(TEST_ROOT, 'skills', 'skill-b', 'SKILL.md'),
+      `---
+name: skill-b
+metadata:
+  version: "1.0.0"
+---
+# skill-b
+## Calls (outbound)
+None
+## Called By (inbound)
+None
+## Sharp Edges
+| Mode | Sev | Mit |
+## Done When
+- done
+## Cost Profile
+~100 tokens
+`,
+    );
+
+    const results = await checkMeshIntegrity(TEST_ROOT);
+
+    assert.strictEqual(results.stats.skills, 2, 'Should find 2 skills');
+    assert.strictEqual(results.stats.missingReciprocals, 1, 'Should detect 1 missing reciprocal');
+    assert.ok(
+      results.warnings.some((w) => w.includes('skill-b') && w.includes('skill-a')),
+      'Should warn that skill-b is missing skill-a in Called By',
+    );
+  });
+
+  test('passes when reciprocals are correct', async () => {
+    await writeFile(
+      path.join(TEST_ROOT, 'skills', 'skill-a', 'SKILL.md'),
+      `---
+name: skill-a
+metadata:
+  version: "1.0.0"
+---
+# skill-a
+## Calls (outbound)
+- \`skill-b\` (L2): some reason
+## Called By (inbound)
+None
+## Sharp Edges
+| Mode | Sev | Mit |
+## Done When
+- done
+## Cost Profile
+~100 tokens
+`,
+    );
+
+    await writeFile(
+      path.join(TEST_ROOT, 'skills', 'skill-b', 'SKILL.md'),
+      `---
+name: skill-b
+metadata:
+  version: "1.0.0"
+---
+# skill-b
+## Calls (outbound)
+None
+## Called By (inbound)
+- \`skill-a\` (L2): caller
+## Sharp Edges
+| Mode | Sev | Mit |
+## Done When
+- done
+## Cost Profile
+~100 tokens
+`,
+    );
+
+    const results = await checkMeshIntegrity(TEST_ROOT);
+
+    assert.strictEqual(results.stats.missingReciprocals, 0, 'Should have no missing reciprocals');
+    assert.strictEqual(
+      results.checks.find((c) => c.name === 'Reciprocal connections')?.status,
+      'pass',
+      'Reciprocal check should pass',
+    );
+  });
+
+  test('suggests version bump for mature skills', async () => {
+    await writeFile(
+      path.join(TEST_ROOT, 'skills', 'skill-a', 'SKILL.md'),
+      `---
+name: skill-a
+metadata:
+  version: "0.9.0"
+---
+# skill-a
+## Calls (outbound)
+None
+## Called By (inbound)
+None
+## Sharp Edges
+| Mode | Sev | Mit |
+## Done When
+- done
+## Cost Profile
+~100 tokens
+## Returns
+| Artifact | Format | Location |
+`,
+    );
+
+    const results = await checkMeshIntegrity(TEST_ROOT);
+
+    assert.ok(
+      results.warnings.some((w) => w.includes('skill-a') && w.includes('1.0')),
+      'Should suggest promoting to 1.0',
+    );
+  });
+
+  test('detects missing required sections', async () => {
+    await writeFile(
+      path.join(TEST_ROOT, 'skills', 'skill-a', 'SKILL.md'),
+      `---
+name: skill-a
+metadata:
+  version: "1.0.0"
+---
+# skill-a
+## Calls (outbound)
+None
+## Called By (inbound)
+None
+`,
+    );
+
+    const results = await checkMeshIntegrity(TEST_ROOT);
+
+    assert.ok(
+      results.warnings.some((w) => w.includes('skill-a') && w.includes('Sharp Edges')),
+      'Should warn about missing Sharp Edges',
+    );
+    assert.ok(
+      results.warnings.some((w) => w.includes('skill-a') && w.includes('Done When')),
+      'Should warn about missing Done When',
+    );
+  });
+});
+
+describe('formatMeshResults', () => {
+  test('formats results for console output', () => {
+    const results = {
+      checks: [
+        { name: 'Reciprocal connections', status: 'pass' },
+        { name: 'Version maturity', status: 'warn', detail: '2 skills ready for 1.0' },
+      ],
+      warnings: ['skill-a v0.9.0: consider promoting to 1.0'],
+      errors: [],
+      stats: { skills: 10, connections: 50, missingReciprocals: 0 },
+    };
+
+    const output = formatMeshResults(results);
+
+    assert.ok(output.includes('Skills: 10'), 'Should show skill count');
+    assert.ok(output.includes('Connections: 50'), 'Should show connection count');
+    assert.ok(output.includes('[✓] Reciprocal'), 'Should show pass icon');
+    assert.ok(output.includes('[!] Version'), 'Should show warn icon');
+    assert.ok(output.includes('skill-a v0.9.0'), 'Should include warnings');
+  });
+});
+
+describe('integration: real skills', () => {
+  test('runs mesh check on actual Rune skills directory', async () => {
+    const runeRoot = path.resolve(__dirname, '../..');
+    const results = await checkMeshIntegrity(runeRoot);
+
+    // Should find skills
+    assert.ok(results.stats.skills > 50, `Should find 50+ skills, got ${results.stats.skills}`);
+
+    // Should find connections
+    assert.ok(results.stats.connections > 100, `Should find 100+ connections, got ${results.stats.connections}`);
+
+    // Should not have errors
+    assert.strictEqual(results.errors.length, 0, `Should have no errors: ${results.errors.join(', ')}`);
+  });
+});

package/compiler/__tests__/hook-dispatch.test.js

@@ -0,0 +1,91 @@
+import assert from 'node:assert';
+import { PassThrough } from 'node:stream';
+import { describe, test } from 'node:test';
+import { dispatchHook } from '../commands/hook-dispatch.js';
+
+function makeIO({ stdinData = '' } = {}) {
+  const stdin = new PassThrough();
+  stdin.setEncoding = () => {};
+  stdin.isTTY = false;
+  if (stdinData) {
+    stdin.write(stdinData);
+  }
+  stdin.end();
+
+  const stdout = new PassThrough();
+  const stderr = new PassThrough();
+  let out = '';
+  let err = '';
+  stdout.on('data', (chunk) => {
+    out += chunk.toString();
+  });
+  stderr.on('data', (chunk) => {
+    err += chunk.toString();
+  });
+  return { stdin, stdout, stderr, getOut: () => out, getErr: () => err };
+}
+
+describe('dispatchHook', () => {
+  test('unknown skill exits 1 in strict mode', async () => {
+    const io = makeIO();
+    const code = await dispatchHook(['evil-skill'], io);
+    assert.strictEqual(code, 1);
+    assert.match(io.getErr(), /unknown skill/);
+  });
+
+  test('unknown skill exits 0 in gentle mode', async () => {
+    const io = makeIO();
+    const code = await dispatchHook(['evil-skill', '--gentle'], io);
+    assert.strictEqual(code, 0);
+    assert.match(io.getErr(), /unknown skill/);
+  });
+
+  test('missing skill name errors', async () => {
+    const io = makeIO();
+    const code = await dispatchHook([], io);
+    assert.strictEqual(code, 1);
+    assert.match(io.getErr(), /missing skill/);
+  });
+
+  test('known skill succeeds and emits advisory line', async () => {
+    const io = makeIO({ stdinData: JSON.stringify({ tool_name: 'Edit' }) });
+    const code = await dispatchHook(['preflight', '--gentle'], io);
+    assert.strictEqual(code, 0);
+    assert.match(io.getOut(), /rune-hook: preflight/);
+    assert.match(io.getOut(), /advisory/);
+    assert.match(io.getOut(), /Edit/);
+  });
+
+  test('strict mode prints enforcing label', async () => {
+    const io = makeIO({ stdinData: '{}' });
+    const code = await dispatchHook(['sentinel'], io);
+    assert.strictEqual(code, 0);
+    assert.match(io.getOut(), /enforcing/);
+  });
+
+  test('malformed stdin does not crash', async () => {
+    const io = makeIO({ stdinData: 'not json at all' });
+    const code = await dispatchHook(['completion-gate', '--gentle'], io);
+    assert.strictEqual(code, 0);
+  });
+
+  // T5: invalid skill name (not in allowlist) → exits non-zero, stderr contains rejected name
+  test('T5: skill not in allowlist exits 1 in strict mode with name in stderr', async () => {
+    const io = makeIO();
+    const code = await dispatchHook(['totally-fake-skill'], io);
+    assert.strictEqual(code, 1);
+    assert.ok(io.getErr().includes('totally-fake-skill'), 'stderr must contain the rejected skill name');
+  });
+
+  // T6: stdin larger than 1MB → truncates or errors gracefully (no OOM)
+  test('T6: stdin larger than 1MB is rejected gracefully', async () => {
+    // Build a payload just over the 1MB limit
+    const big = 'x'.repeat(1_100_000);
+    const io = makeIO({ stdinData: big });
+    // Should not throw — must return an exit code (0 or 1, gentle or strict)
+    const code = await dispatchHook(['preflight', '--gentle'], io);
+    assert.ok(typeof code === 'number', 'must return a numeric exit code');
+    // gentle mode: still exits 0 even if stdin was discarded
+    assert.strictEqual(code, 0);
+  });
+});

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

@@ -0,0 +1,118 @@
+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 antigravity from '../adapters/hooks/antigravity.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 = '.antigravity/rules';
+
+let tmpRoot;
+
+async function seedAntigravity(root) {
+  await mkdir(path.join(root, '.antigravity'), { recursive: true });
+}
+
+beforeEach(async () => {
+  tmpRoot = await mkdtemp(path.join(tmpdir(), 'rune-antigravity-'));
+});
+
+afterEach(async () => {
+  if (tmpRoot) await rm(tmpRoot, { recursive: true, force: true });
+});
+
+describe('antigravity adapter', () => {
+  test('detect() true when .antigravity exists', async () => {
+    await seedAntigravity(tmpRoot);
+    assert.strictEqual(antigravity.detect(tmpRoot), true);
+  });
+
+  test('emit(gentle) returns 3 rule markdowns with WARN mode', async () => {
+    const plan = await antigravity.emit({ preset: 'gentle', projectRoot: tmpRoot });
+    assert.strictEqual(plan.files.length, 3);
+    for (const file of plan.files) {
+      assert.ok(file.content.includes('rune-managed: true'));
+      assert.ok(file.content.includes('mode: WARN'));
+    }
+  });
+
+  test('emit(strict) renders BLOCK mode', async () => {
+    const plan = await antigravity.emit({ preset: 'strict', projectRoot: tmpRoot });
+    for (const file of plan.files) {
+      assert.ok(file.content.includes('mode: BLOCK'));
+    }
+  });
+
+  test('emit() rejects invalid preset', async () => {
+    await assert.rejects(antigravity.emit({ preset: 'weird', projectRoot: tmpRoot }), /invalid preset/);
+  });
+
+  test('emit() notes call out experimental status', async () => {
+    const plan = await antigravity.emit({ preset: 'gentle', projectRoot: tmpRoot });
+    assert.ok(plan.notes.some((n) => n.toLowerCase().includes('experimental')));
+  });
+
+  test('install writes rule files under .antigravity/rules/', async () => {
+    await seedAntigravity(tmpRoot);
+    const result = await installHooks(tmpRoot, { preset: 'gentle', platform: 'antigravity' });
+    assert.strictEqual(result.written, true);
+    const files = await readdir(path.join(tmpRoot, RULES_DIR));
+    assert.ok(files.includes('rune-preflight.md'));
+    assert.ok(files.includes('rune-sentinel.md'));
+    assert.ok(files.includes('rune-dependency-doctor.md'));
+  });
+
+  test('idempotent re-install', async () => {
+    await seedAntigravity(tmpRoot);
+    await installHooks(tmpRoot, { preset: 'gentle', platform: 'antigravity' });
+    const first = await readFile(path.join(tmpRoot, RULES_DIR, 'rune-preflight.md'), 'utf-8');
+    await installHooks(tmpRoot, { preset: 'gentle', platform: 'antigravity' });
+    const second = await readFile(path.join(tmpRoot, RULES_DIR, 'rune-preflight.md'), 'utf-8');
+    assert.strictEqual(first, second);
+  });
+
+  test('uninstall removes Rune rules, preserves user rules', async () => {
+    await seedAntigravity(tmpRoot);
+    const rulesDir = path.join(tmpRoot, RULES_DIR);
+    await mkdir(rulesDir, { recursive: true });
+    await writeFile(path.join(rulesDir, 'user-rule.md'), '# User rule\n', 'utf-8');
+
+    await installHooks(tmpRoot, { preset: 'gentle', platform: 'antigravity' });
+    await uninstallHooks(tmpRoot, { platform: 'antigravity' });
+
+    const remaining = await readdir(rulesDir);
+    assert.ok(remaining.includes('user-rule.md'), 'user rule must survive');
+    assert.ok(!remaining.some((f) => f.startsWith('rune-')), 'no rune-* files should remain');
+  });
+
+  test('uninstall leaves non-managed rune-* files alone', async () => {
+    await seedAntigravity(tmpRoot);
+    const rulesDir = path.join(tmpRoot, RULES_DIR);
+    await mkdir(rulesDir, { recursive: true });
+    await writeFile(path.join(rulesDir, 'rune-fake.md'), '---\ndescription: imposter\n---\n\nnot ours\n', 'utf-8');
+
+    await uninstallHooks(tmpRoot, { platform: 'antigravity' });
+    assert.ok(existsSync(path.join(rulesDir, 'rune-fake.md')));
+  });
+
+  test('status after install reports wired skills', async () => {
+    await seedAntigravity(tmpRoot);
+    await installHooks(tmpRoot, { preset: 'strict', platform: 'antigravity' });
+    const result = await hookStatus(tmpRoot, RUNE_ROOT, { platform: 'antigravity' });
+    const r = result.results.find((x) => x.platform === 'antigravity');
+    assert.strictEqual(r.installed, true);
+    assert.strictEqual(r.preset, 'strict');
+    assert.ok(r.wired.includes('preflight'));
+  });
+
+  test('status reports not installed when .antigravity missing', async () => {
+    const result = await hookStatus(tmpRoot, RUNE_ROOT, { platform: 'antigravity' });
+    const r = result.results.find((x) => x.platform === 'antigravity');
+    assert.strictEqual(r.installed, false);
+  });
+});