@rune-kit/rune 2.4.0 → 2.6.0

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>
-  59 skills · 200+ mesh connections · 8 platforms · MIT
+  61 skills · 200+ mesh connections · 8 platforms · MIT
 </p>
 
 <p align="center">
@@ -22,7 +22,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** — 59 skills with 200+ connections across a 5-layer architecture. Skills call each other bidirectionally, forming resilient workflows that adapt when things go wrong.
+Rune is a **mesh** — 61 skills with 200+ connections 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)
@@ -82,19 +82,34 @@ _Methodology: Claude Code CLI headless mode (`claude -p --output-format json`),
 
 ---
 
-## What's New (v2.4.0)
+## What's New (v2.6.0)
 
-- **UI/UX Pro Max Integration** — 161 palettes, 84 styles, 73 font pairings, 161 reasoning rules from [UI/UX Pro Max](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill) (MIT, 42.8k★) meshed into `design` skill + `@rune/ui` pack
-- **11 Core Skill Enrichments** — deviation rules, repair operators, evidence quality gate, decision classification, debug knowledge base, CSO discipline, YAGNI pushback, formal pause/resume
-- **Enforcement Upgrade** — Antigravity-level IDE compliance: 5-type Request Classifier, File Ownership Matrix, Self-Verification HARD-GATE, Routing Proof, Clarification Gate, Phase Transition Protocol
-- **All 14 Free Packs Deep** — every L4 extension pack now exceeds 500 lines of production-ready patterns and code examples
-- **8 Platform Adapters** — Claude Code, Cursor, Windsurf, Google Antigravity, OpenAI Codex, OpenCode, OpenClaw, Generic
-- **59 Core Skills** — +4 since v2.1.0: adversary, sentinel-env, chrome-ext pack, context-pack
-- **Rune Pro** — 4 premium packs (product, sales, data-science, support) in private repo. $49 lifetime
+- **Mesh Signals** — event-driven skill communication via frontmatter. Skills declare `emit` and `listen` signals; compiler builds a signal graph in `skill-index.json`. 17 signals across 15 core skills. Completes the spec-kit trilogy: Tier Override → Mesh Contract → Mesh Signals
+- **Signal Validation** — `scripts/validate-signals.js` checks orphan listeners (hard error), unlistened emitters (warning), signal naming conventions
+- **Mesh Contract** (v2.5.0) — `.rune/contract.md` project-level invariants enforced by cook + sentinel as hard gates
+- **Compiled Intent Mesh** (v2.5.0) — compile-time `skill-index.json` with intent keywords, mesh graph, chain predictions
+- **Tier Override** — Pro/Business packs override Free packs with skill-level merging
+- **Scripts Bundling** — compiler copies `scripts/` directories, resolves `{scripts_dir}` placeholders
+- **566 Tests** — compiler + signals + hooks + scripts validation
+
+### Signal Graph
+
+Skills communicate through declarative signals — no runtime event bus, just metadata for discovery, validation, and routing:
+
+```
+scout ──emit:codebase.scanned──→ plan, brainstorm
+fix ────emit:code.changed──────→ test, sentinel, review, preflight, verification
+test ───emit:tests.passed──────→ deploy
+test ───emit:tests.failed──────→ debug
+sentinel─emit:security.passed──→ deploy
+debug ──emit:bug.diagnosed─────→ fix
+deploy ─emit:deploy.complete───→ watchdog
+cook ───emit:phase.complete────→ session-bridge
+```
 
 ## What Rune Is (and Isn't)
 
-Rune started as a **Claude Code plugin** and now compiles to **every major AI IDE**. Same 59 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 61 skills, same mesh connections, same workflows — zero knowledge loss across platforms.
 
 | | Rune Provides | Claude Code Provides |
 |---|---|---|
@@ -118,7 +133,7 @@ Rune started as a **Claude Code plugin** and now compiles to **every major AI ID
 | CI quality gates | `verification` skill: lint + typecheck + tests + build (actual commands, not LLM review) |
 | Memory / state | `session-bridge` + `journal`: cross-session decisions, conventions, ADRs, module health |
 | Multi-model strategy | Every skill has assigned model: haiku (scan), sonnet (code), opus (architecture) |
-| Agent specialization | 58 specialized skills with dedicated roles (architect, coder, reviewer, scanner, researcher, BA, scaffolder) — each runs as a Task agent via Claude Code |
+| Agent specialization | 61 specialized skills with dedicated roles (architect, coder, reviewer, scanner, researcher, BA, scaffolder) — each runs as a Task agent via Claude Code |
 | Security scanning | `sentinel`: OWASP patterns, secret scanning, dependency audit. `sast`: static analysis |
 
 ## Install
@@ -146,13 +161,13 @@ npx @rune-kit/rune init --platform windsurf
 npx @rune-kit/rune init --platform antigravity
 ```
 
-This compiles all 59 skills into your IDE's rules format. Same knowledge, same workflows.
+This compiles all 61 skills into your IDE's rules format. Same knowledge, same workflows.
 
 ### Platform Comparison
 
 | Feature | Claude Code | Cursor / Windsurf / Others |
 |---------|-------------|---------------------------|
-| Skills available | 59/59 | 59/59 |
+| Skills available | 61/61 | 61/61 |
 | Mesh connections | 200+ (programmatic) | 200+ (rule references) |
 | Workflows & HARD-GATEs | Full | Full |
 | Extension packs | 14 | 14 |
@@ -229,8 +244,9 @@ This compiles all 59 skills into your IDE's rules format. Same knowledge, same w
 ║  Delivery:    deploy │ marketing │ incident │ docs     ║
 ║  Rescue:      autopsy │ safeguard │ surgeon            ║
 ║  Security:    adversary                                ║
+║  Velocity:    retro                                    ║
 ╠══════════════════════════════════════════════════════╣
-║  L3: UTILITIES (26)                                   ║
+║  L3: UTILITIES (27)                                   ║
 ║  Stateless, pure capabilities                         ║
 ║                                                        ║
 ║  Knowledge:   research │ docs-seeker │ trend-scout     ║
@@ -249,6 +265,8 @@ This compiles all 59 skills into your IDE's rules format. Same knowledge, same w
 ║  Documents:   doc-processor                            ║
 ║  Security:    sentinel-env                             ║
 ║  Memory:      neural-memory                            ║
+║  Packs:       context-pack                             ║
+║  Slides:      slides                                   ║
 ╠══════════════════════════════════════════════════════╣
 ║  L4: EXTENSION PACKS (14)                             ║
 ║  Domain-specific, install what you need                ║
@@ -426,13 +444,14 @@ See [docs/MULTI-PLATFORM.md](docs/MULTI-PLATFORM.md) for the full architecture.
 ## Numbers
 
 ```
-Core Skills:       59 (L0: 1 │ L1: 5 │ L2: 28 │ L3: 26)
+Core Skills:       61 (L0: 1 │ L1: 5 │ L2: 28 │ L3: 27)
 Extension Packs:   14 free + 4 pro + 4 business
 Mesh Connections:  200+ cross-references
+Mesh Signals:      17 signals across 15 skills (emit/listen graph)
 Connections/Skill: 3.4 avg
 Platforms:         8 (Claude Code, Cursor, Windsurf, Antigravity, Codex, OpenCode, OpenClaw, Generic)
 Compiler:          ~1400 LOC (parser + 8 transforms + 8 adapters + CLI)
-Quality:           59/59 skills with Output Format, Sharp Edges, Done When, Cost Profile
+Tests:             566 (compiler + signals + hooks + scripts)
 Pack Depth:        22 packs total (14 free + 4 pro + 4 business, all free packs rated Deep)
 ```
 

package/compiler/__tests__/pack-split.test.js

@@ -1,8 +1,12 @@
 import assert from 'node:assert';
 import { existsSync, readFileSync } from 'node:fs';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { test } from 'node:test';
+import { describe, test } from 'node:test';
 import { fileURLToPath } from 'node:url';
+import { getAdapter } from '../adapters/index.js';
+import { buildAll } from '../emitter.js';
 import { parsePack } from '../parser.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -143,3 +147,139 @@ test('parsePack: real backend PACK.md parses as split (post-split)', () => {
   assert.strictEqual(parsed.layer, 'L4');
   assert.ok(parsed.sections.size > 0);
 });
+
+// --- Integration: buildAll auto-discovers split pack skill files ---
+
+describe('buildAll split pack auto-discovery', () => {
+  async function createTempWithSplitPack() {
+    const tmp = path.join(tmpdir(), `rune-split-test-${Date.now()}`);
+    const skillsDir = path.join(tmp, 'skills', 'test-skill');
+    const extDir = path.join(tmp, 'extensions', 'test-pack');
+    const extSkillsDir = path.join(extDir, 'skills');
+
+    await mkdir(skillsDir, { recursive: true });
+    await mkdir(extSkillsDir, { recursive: true });
+
+    // Minimal core skill (required for build)
+    await writeFile(
+      path.join(skillsDir, 'SKILL.md'),
+      [
+        '---',
+        'name: test-skill',
+        'description: "A test skill"',
+        'layer: L3',
+        'group: utility',
+        'connections: []',
+        'tags: [test]',
+        '---',
+        '',
+        '# test-skill',
+        '',
+        'Hello.',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Split pack WITHOUT skills: array in frontmatter
+    await writeFile(
+      path.join(extDir, 'PACK.md'),
+      [
+        '---',
+        'name: "@rune/test-pack"',
+        'description: "Test pack"',
+        'metadata:',
+        '  version: "0.1.0"',
+        '  format: split',
+        '---',
+        '',
+        '# @rune/test-pack',
+        '',
+        'Pack index body.',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Two skill files in skills/ subdir
+    await writeFile(
+      path.join(extSkillsDir, 'alpha.md'),
+      [
+        '---',
+        'name: "alpha"',
+        'description: "Alpha skill"',
+        'model: sonnet',
+        '---',
+        '',
+        '# alpha',
+        '',
+        'Alpha body content here.',
+      ].join('\n'),
+      'utf-8',
+    );
+    await writeFile(
+      path.join(extSkillsDir, 'beta.md'),
+      [
+        '---',
+        'name: "beta"',
+        'description: "Beta skill"',
+        'model: sonnet',
+        '---',
+        '',
+        '# beta',
+        '',
+        'Beta body content here.',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    return tmp;
+  }
+
+  test('auto-discovers skill files from skills/ subdir when manifest is empty', async () => {
+    const tmp = await createTempWithSplitPack();
+    try {
+      const outputRoot = path.join(tmp, 'out');
+      const adapter = getAdapter('cursor');
+      const stats = await buildAll({ runeRoot: tmp, outputRoot, adapter });
+
+      assert.strictEqual(stats.packCount, 1, 'should build 1 pack');
+
+      // Read the compiled pack output
+      const packOutput = await readFile(path.join(outputRoot, adapter.outputDir, 'rune-ext-test-pack.mdc'), 'utf-8');
+
+      // Should contain the pack index body
+      assert.ok(packOutput.includes('Pack index body'), 'missing pack index body');
+
+      // Should contain BOTH auto-discovered skill bodies
+      assert.ok(packOutput.includes('Alpha body content here'), 'missing alpha skill body');
+      assert.ok(packOutput.includes('Beta body content here'), 'missing beta skill body');
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test('real ai-ml pack includes skill content after build', async () => {
+    const aimlPath = path.join(EXTENSIONS_DIR, 'ai-ml', 'PACK.md');
+    if (!existsSync(aimlPath)) {
+      console.log('  skip: ai-ml PACK.md not found');
+      return;
+    }
+
+    const tmp = path.join(tmpdir(), `rune-aiml-test-${Date.now()}`);
+    const runeRoot = path.resolve(__dirname, '../..');
+    const adapter = getAdapter('cursor');
+    await buildAll({ runeRoot, outputRoot: tmp, adapter });
+
+    try {
+      const packOutput = await readFile(path.join(tmp, adapter.outputDir, 'rune-ext-ai-ml.mdc'), 'utf-8');
+
+      // Should be significantly longer than just the index body (~99 lines without skills)
+      const lineCount = packOutput.split('\n').length;
+      assert.ok(lineCount > 200, `ai-ml pack output too short (${lineCount} lines) — skills likely not included`);
+
+      // Should contain content from individual skill files
+      assert.ok(packOutput.includes('ai-agents') || packOutput.includes('AI agent'), 'missing ai-agents skill content');
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+});

package/compiler/__tests__/parser.test.js

@@ -1,55 +1,147 @@
-import assert from 'node:assert';
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-import { parseSkill } from '../parser.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SKILLS_DIR = path.resolve(__dirname, '../../skills');
-
-test('parse cook SKILL.md', () => {
-  const content = readFileSync(path.join(SKILLS_DIR, 'cook/SKILL.md'), 'utf-8');
-  const parsed = parseSkill(content, 'cook/SKILL.md');
-
-  console.log('name:', JSON.stringify(parsed.name));
-  console.log('description:', JSON.stringify(parsed.description?.substring(0, 50)));
-  console.log('layer:', parsed.layer);
-  console.log('model:', parsed.model);
-  console.log('group:', parsed.group);
-  console.log('contextFork:', parsed.contextFork);
-  console.log('agentType:', parsed.agentType);
-  console.log('crossRefs:', parsed.crossRefs.length);
-  console.log('toolRefs:', parsed.toolRefs.length);
-  console.log('hardGates:', parsed.hardGates.length);
-  console.log('sections:', [...parsed.sections.keys()]);
-  console.log('frontmatter keys:', Object.keys(parsed.frontmatter));
-
-  assert.strictEqual(parsed.name, 'cook');
-  assert.strictEqual(parsed.layer, 'L1');
-  assert.ok(parsed.crossRefs.length > 0);
-  assert.ok(parsed.hardGates.length > 0);
-});
-
-test('parse fix SKILL.md', () => {
-  const content = readFileSync(path.join(SKILLS_DIR, 'fix/SKILL.md'), 'utf-8');
-  const parsed = parseSkill(content, 'fix/SKILL.md');
-
-  console.log('fix name:', JSON.stringify(parsed.name));
-  console.log('fix layer:', parsed.layer);
-
-  assert.strictEqual(parsed.name, 'fix');
-  assert.strictEqual(parsed.layer, 'L2');
-});
-
-test('parse verification SKILL.md', () => {
-  const content = readFileSync(path.join(SKILLS_DIR, 'verification/SKILL.md'), 'utf-8');
-  const parsed = parseSkill(content, 'verification/SKILL.md');
-
-  console.log('verification name:', JSON.stringify(parsed.name));
-  console.log('verification layer:', parsed.layer);
-  console.log('verification toolRefs:', parsed.toolRefs.length);
-
-  assert.strictEqual(parsed.name, 'verification');
-  assert.strictEqual(parsed.layer, 'L3');
-});
+import assert from 'node:assert';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { describe, test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { parseSkill } from '../parser.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SKILLS_DIR = path.resolve(__dirname, '../../skills');
+
+test('parse cook SKILL.md', () => {
+  const content = readFileSync(path.join(SKILLS_DIR, 'cook/SKILL.md'), 'utf-8');
+  const parsed = parseSkill(content, 'cook/SKILL.md');
+
+  console.log('name:', JSON.stringify(parsed.name));
+  console.log('description:', JSON.stringify(parsed.description?.substring(0, 50)));
+  console.log('layer:', parsed.layer);
+  console.log('model:', parsed.model);
+  console.log('group:', parsed.group);
+  console.log('contextFork:', parsed.contextFork);
+  console.log('agentType:', parsed.agentType);
+  console.log('crossRefs:', parsed.crossRefs.length);
+  console.log('toolRefs:', parsed.toolRefs.length);
+  console.log('hardGates:', parsed.hardGates.length);
+  console.log('sections:', [...parsed.sections.keys()]);
+  console.log('frontmatter keys:', Object.keys(parsed.frontmatter));
+
+  assert.strictEqual(parsed.name, 'cook');
+  assert.strictEqual(parsed.layer, 'L1');
+  assert.ok(parsed.crossRefs.length > 0);
+  assert.ok(parsed.hardGates.length > 0);
+});
+
+test('parse fix SKILL.md', () => {
+  const content = readFileSync(path.join(SKILLS_DIR, 'fix/SKILL.md'), 'utf-8');
+  const parsed = parseSkill(content, 'fix/SKILL.md');
+
+  console.log('fix name:', JSON.stringify(parsed.name));
+  console.log('fix layer:', parsed.layer);
+
+  assert.strictEqual(parsed.name, 'fix');
+  assert.strictEqual(parsed.layer, 'L2');
+});
+
+test('parse verification SKILL.md', () => {
+  const content = readFileSync(path.join(SKILLS_DIR, 'verification/SKILL.md'), 'utf-8');
+  const parsed = parseSkill(content, 'verification/SKILL.md');
+
+  console.log('verification name:', JSON.stringify(parsed.name));
+  console.log('verification layer:', parsed.layer);
+  console.log('verification toolRefs:', parsed.toolRefs.length);
+
+  assert.strictEqual(parsed.name, 'verification');
+  assert.strictEqual(parsed.layer, 'L3');
+});
+
+describe('signals parsing', () => {
+  test('parses emit and listen from metadata', () => {
+    const content = [
+      '---',
+      'name: alpha',
+      'description: "Test skill"',
+      'metadata:',
+      '  layer: L2',
+      '  emit: code.changed, tests.passed',
+      '  listen: plan.ready',
+      '---',
+      '',
+      '# alpha',
+    ].join('\n');
+
+    const parsed = parseSkill(content);
+    assert.ok(parsed.signals, 'signals should not be null');
+    assert.deepStrictEqual(parsed.signals.emit, ['code.changed', 'tests.passed']);
+    assert.deepStrictEqual(parsed.signals.listen, ['plan.ready']);
+  });
+
+  test('emit only — no listen', () => {
+    const content = [
+      '---',
+      'name: beta',
+      'description: "Emitter only"',
+      'metadata:',
+      '  layer: L3',
+      '  emit: deploy.complete',
+      '---',
+      '',
+      '# beta',
+    ].join('\n');
+
+    const parsed = parseSkill(content);
+    assert.ok(parsed.signals);
+    assert.deepStrictEqual(parsed.signals.emit, ['deploy.complete']);
+    assert.deepStrictEqual(parsed.signals.listen, []);
+  });
+
+  test('listen only — no emit', () => {
+    const content = [
+      '---',
+      'name: gamma',
+      'description: "Listener only"',
+      'metadata:',
+      '  layer: L3',
+      '  listen: code.changed',
+      '---',
+      '',
+      '# gamma',
+    ].join('\n');
+
+    const parsed = parseSkill(content);
+    assert.ok(parsed.signals);
+    assert.deepStrictEqual(parsed.signals.emit, []);
+    assert.deepStrictEqual(parsed.signals.listen, ['code.changed']);
+  });
+
+  test('no signals — returns null', () => {
+    const content = [
+      '---',
+      'name: delta',
+      'description: "No signals"',
+      'metadata:',
+      '  layer: L3',
+      '---',
+      '',
+      '# delta',
+    ].join('\n');
+
+    const parsed = parseSkill(content);
+    assert.strictEqual(parsed.signals, null);
+  });
+
+  test('real cook skill has signals', () => {
+    const content = readFileSync(path.join(SKILLS_DIR, 'cook/SKILL.md'), 'utf-8');
+    const parsed = parseSkill(content, 'cook/SKILL.md');
+    assert.ok(parsed.signals, 'cook should have signals');
+    assert.ok(parsed.signals.emit.includes('phase.complete'));
+  });
+
+  test('real test skill has emit and listen', () => {
+    const content = readFileSync(path.join(SKILLS_DIR, 'test/SKILL.md'), 'utf-8');
+    const parsed = parseSkill(content, 'test/SKILL.md');
+    assert.ok(parsed.signals, 'test should have signals');
+    assert.ok(parsed.signals.emit.includes('tests.passed'));
+    assert.ok(parsed.signals.emit.includes('tests.failed'));
+    assert.ok(parsed.signals.listen.includes('code.changed'));
+  });
+});

package/compiler/__tests__/scripts-bundling.test.js

@@ -138,11 +138,7 @@ describe('buildAll with scripts', () => {
 
     // Minimal .claude-plugin for openclaw
     await mkdir(path.join(tmp, '.claude-plugin'), { recursive: true });
-    await writeFile(
-      path.join(tmp, '.claude-plugin', 'plugin.json'),
-      JSON.stringify({ version: '0.0.1' }),
-      'utf-8',
-    );
+    await writeFile(path.join(tmp, '.claude-plugin', 'plugin.json'), JSON.stringify({ version: '0.0.1' }), 'utf-8');
 
     return tmp;
   }
@@ -168,7 +164,10 @@ describe('buildAll with scripts', () => {
       assert.ok(mdc.includes('.cursor/rules/rune-test-slide-scripts/build-deck.js'), 'resolved path missing');
 
       // Plain skill: no scripts dir created
-      assert.ok(!existsSync(path.join(outputRoot, adapter.outputDir, 'rune-test-plain-scripts')), 'plain skill should not have scripts dir');
+      assert.ok(
+        !existsSync(path.join(outputRoot, adapter.outputDir, 'rune-test-plain-scripts')),
+        'plain skill should not have scripts dir',
+      );
     } finally {
       await rm(tmp, { recursive: true, force: true });
     }
@@ -189,10 +188,7 @@ describe('buildAll with scripts', () => {
       assert.ok(existsSync(path.join(scriptsOut, 'helper.py')), 'helper.py missing');
 
       // Placeholder resolved
-      const md = await readFile(
-        path.join(outputRoot, adapter.outputDir, 'rune-test-slide', 'SKILL.md'),
-        'utf-8',
-      );
+      const md = await readFile(path.join(outputRoot, adapter.outputDir, 'rune-test-slide', 'SKILL.md'), 'utf-8');
       assert.ok(!md.includes('{scripts_dir}'), 'placeholder should be resolved');
       assert.ok(md.includes('.codex/skills/rune-test-slide/scripts/build-deck.js'), 'resolved path missing');
     } finally {
@@ -254,7 +250,10 @@ describe('buildAll with scripts', () => {
       await buildAll({ runeRoot: tmp, outputRoot, adapter });
 
       const original = await readFile(path.join(tmp, 'skills', 'test-slide', 'scripts', 'build-deck.js'), 'utf-8');
-      const copied = await readFile(path.join(outputRoot, adapter.outputDir, 'rune-test-slide-scripts', 'build-deck.js'), 'utf-8');
+      const copied = await readFile(
+        path.join(outputRoot, adapter.outputDir, 'rune-test-slide-scripts', 'build-deck.js'),
+        'utf-8',
+      );
       assert.strictEqual(copied, original, 'script content should be identical');
     } finally {
       await rm(tmp, { recursive: true, force: true });