@rune-kit/rune 2.4.0 → 2.7.0

package/README.md

@@ -5,13 +5,14 @@
 <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">
   <a href="https://rune-kit.github.io/rune"><img src="https://img.shields.io/badge/Landing_Page-rune--kit.github.io-blue?style=for-the-badge" alt="Landing Page"></a>
   <a href="https://rune-kit.github.io/rune#pricing"><img src="https://img.shields.io/badge/Pro_%2449-lifetime-blueviolet?style=for-the-badge" alt="Rune Pro $49"></a>
   <a href="https://rune-kit.github.io/rune#pricing"><img src="https://img.shields.io/badge/Business_%24149-lifetime-orange?style=for-the-badge" alt="Rune Business $149"></a>
+  <a href="https://t.me/xlabs_updates"><img src="https://img.shields.io/badge/Telegram-Updates-26A5E4?style=for-the-badge&logo=telegram&logoColor=white" alt="Telegram Updates"></a>
 </p>
 
 <p align="center">
@@ -22,7 +23,7 @@
 
 Most skill ecosystems are either **too many isolated skills** (540+ that don't talk to each other) or **rigid pipelines** (A → B → C, if B fails everything stops).
 
-Rune is a **mesh** — 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 +83,44 @@ _Methodology: Claude Code CLI headless mode (`claude -p --output-format json`),
 
 ---
 
-## What's New (v2.4.0)
+## What's New (v2.7.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
+- **Deep Knowledge** — 8 core skills enriched with battle-tested patterns: context compaction, structured cumulative memory, milestone analysis, multi-provider adapters, AI-driven interview, prompt-as-API-contract, token budget tracking, incremental stream processing
+- **context-engine v0.8.0** — structured compaction summaries with continuation point anchoring + sentence-level stream processing pattern
+- **session-bridge v0.5.0** — cumulative project notes (`.rune/cumulative-notes.md`) for living institutional memory across sessions
+- **retro v0.3.0** — milestone progressive analysis at project thresholds (4/12/24/50 retros) with focal-point depth scaling
+- **mcp-builder v0.4.0** — multi-provider adapter pattern reference with discriminated StreamChunk union + dual-model cost config
+- **onboard v0.4.0** — AI-driven conversational interview mode (`--interview`) for ambiguous or complex projects
+- **perf v0.3.0** — token budget tracking for AI-powered apps (loop detection, model mismatch, unbounded tokens, duplicate calls)
+- **cook v2.0.0** — prompt-as-API-contract pattern for structured sub-skill output
+- **946 Tests** — compiler + signals + hooks + scripts + status + visualizer validation
+
+### Previous (v2.6.0)
+
+- **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
+- **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
+- **Tier Override** — Pro/Business packs override Free packs with skill-level merging
+- **Scripts Bundling** — compiler copies `scripts/` directories, resolves `{scripts_dir}` placeholders
+
+### 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 +144,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 +172,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 +255,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 +276,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 +455,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:      57 signals across 66 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:             946 (compiler + signals + status + visualizer + hooks + scripts)
 Pack Depth:        22 packs total (14 free + 4 pro + 4 business, all free packs rated Deep)
 ```
 

package/compiler/__tests__/executive-dashboards.test.js

@@ -0,0 +1,285 @@
+import assert from 'node:assert';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { describe, test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const BUSINESS_DIR = path.resolve(__dirname, '../../../Business');
+const REPORT_TEMPLATES_DIR = path.join(BUSINESS_DIR, 'report-templates');
+const SKILLS_DIR = path.resolve(__dirname, '../../skills');
+
+// ─── HTML report template validation ──────────────────────────────
+
+// Skip Business tier tests when Business repo is not available (CI)
+const HAS_BUSINESS = existsSync(BUSINESS_DIR);
+
+(HAS_BUSINESS ? describe : describe.skip)('Business report-templates directory', () => {
+  test('report-templates directory exists', () => {
+    assert.ok(existsSync(REPORT_TEMPLATES_DIR), 'Expected Business/report-templates/ to exist');
+  });
+
+  test('retro-business.html exists', () => {
+    assert.ok(
+      existsSync(path.join(REPORT_TEMPLATES_DIR, 'retro-business.html')),
+      'Expected retro-business.html template',
+    );
+  });
+
+  test('autopsy-executive.html exists', () => {
+    assert.ok(
+      existsSync(path.join(REPORT_TEMPLATES_DIR, 'autopsy-executive.html')),
+      'Expected autopsy-executive.html template',
+    );
+  });
+});
+
+describe('retro-business.html template', () => {
+  const filePath = path.join(REPORT_TEMPLATES_DIR, 'retro-business.html');
+  if (!existsSync(filePath)) return;
+  const content = readFileSync(filePath, 'utf-8');
+
+  test('is valid HTML with doctype', () => {
+    assert.ok(content.startsWith('<!DOCTYPE html>'), 'Must start with DOCTYPE');
+    assert.ok(content.includes('<html'), 'Must have html tag');
+    assert.ok(content.includes('</html>'), 'Must close html tag');
+  });
+
+  test('is self-contained (no external CSS/JS)', () => {
+    assert.ok(!content.includes('href="http'), 'No external CSS links');
+    assert.ok(!content.includes('src="http'), 'No external JS scripts');
+    assert.ok(!content.includes('cdn.'), 'No CDN references');
+  });
+
+  test('has inline styles', () => {
+    assert.ok(content.includes('<style>'), 'Must have inline style block');
+  });
+
+  test('has print-friendly styles', () => {
+    assert.ok(content.includes('@media print'), 'Must have print media query');
+    assert.ok(content.includes('@page'), 'Must have @page rule for PDF export');
+  });
+
+  test('has KPI card placeholders', () => {
+    assert.ok(content.includes('{{sprint_velocity}}'), 'Missing sprint_velocity placeholder');
+    assert.ok(content.includes('{{mrr}}'), 'Missing MRR placeholder');
+    assert.ok(content.includes('{{sla_pct}}'), 'Missing SLA placeholder');
+    assert.ok(content.includes('{{compliance_score}}'), 'Missing compliance_score placeholder');
+  });
+
+  test('has domain performance sections', () => {
+    assert.ok(content.includes('Engineering'), 'Missing Engineering domain');
+    assert.ok(content.includes('Revenue'), 'Missing Revenue domain');
+    assert.ok(content.includes('Support'), 'Missing Support domain');
+    assert.ok(content.includes('Finance'), 'Missing Finance domain');
+  });
+
+  test('has team health table', () => {
+    assert.ok(content.includes('Team Health'), 'Missing Team Health section');
+    assert.ok(content.includes('{{team_name}}'), 'Missing team_name placeholder');
+    assert.ok(content.includes('{{team_lead}}'), 'Missing team_lead placeholder');
+  });
+
+  test('has compliance status section', () => {
+    assert.ok(content.includes('Compliance Status'), 'Missing Compliance Status section');
+    assert.ok(content.includes('{{framework}}'), 'Missing framework placeholder');
+  });
+
+  test('has key insights section (wins + risks)', () => {
+    assert.ok(content.includes('Key Insights'), 'Missing Key Insights section');
+    assert.ok(content.includes('Wins'), 'Missing Wins subsection');
+    assert.ok(content.includes('Risks'), 'Missing Risks subsection');
+  });
+
+  test('has Rune Business footer', () => {
+    assert.ok(content.includes('Rune Business'), 'Missing Rune Business branding');
+    assert.ok(content.includes('retro --business'), 'Missing retro --business reference');
+  });
+
+  test('has trend delta placeholders for KPIs', () => {
+    assert.ok(content.includes('{{velocity_delta}}'), 'Missing velocity trend');
+    assert.ok(content.includes('{{mrr_delta}}'), 'Missing MRR trend');
+  });
+
+  test('uses CSS custom properties for theming', () => {
+    assert.ok(content.includes(':root'), 'Must use CSS custom properties');
+    assert.ok(content.includes('--bg'), 'Missing --bg variable');
+    assert.ok(content.includes('--accent'), 'Missing --accent variable');
+  });
+});
+
+describe('autopsy-executive.html template', () => {
+  const filePath = path.join(REPORT_TEMPLATES_DIR, 'autopsy-executive.html');
+  if (!existsSync(filePath)) return;
+  const content = readFileSync(filePath, 'utf-8');
+
+  test('is valid HTML with doctype', () => {
+    assert.ok(content.startsWith('<!DOCTYPE html>'), 'Must start with DOCTYPE');
+    assert.ok(content.includes('<html'), 'Must have html tag');
+    assert.ok(content.includes('</html>'), 'Must close html tag');
+  });
+
+  test('is self-contained (no external CSS/JS)', () => {
+    assert.ok(!content.includes('href="http'), 'No external CSS links');
+    assert.ok(!content.includes('src="http'), 'No external JS scripts');
+    assert.ok(!content.includes('cdn.'), 'No CDN references');
+  });
+
+  test('has print-friendly styles', () => {
+    assert.ok(content.includes('@media print'), 'Must have print media query');
+    assert.ok(content.includes('@page'), 'Must have @page rule');
+  });
+
+  test('has SVG health ring', () => {
+    assert.ok(content.includes('<svg'), 'Must have inline SVG');
+    assert.ok(content.includes('<circle'), 'Must have SVG circle for health ring');
+    assert.ok(content.includes('stroke-dasharray'), 'Must use dasharray for progress ring');
+  });
+
+  test('has health score placeholder', () => {
+    assert.ok(content.includes('{{health_score}}'), 'Missing health_score placeholder');
+    assert.ok(content.includes('{{risk_tier}}'), 'Missing risk_tier placeholder');
+    assert.ok(content.includes('{{score_color}}'), 'Missing score_color placeholder');
+  });
+
+  test('has six health dimensions', () => {
+    assert.ok(content.includes('Complexity'), 'Missing Complexity dimension');
+    assert.ok(content.includes('Test Coverage'), 'Missing Test Coverage dimension');
+    assert.ok(content.includes('Documentation'), 'Missing Documentation dimension');
+    assert.ok(content.includes('Dependencies'), 'Missing Dependencies dimension');
+    assert.ok(content.includes('Code Smells'), 'Missing Code Smells dimension');
+    assert.ok(content.includes('Maintenance'), 'Missing Maintenance dimension');
+  });
+
+  test('has module health table', () => {
+    assert.ok(content.includes('Module Health'), 'Missing Module Health section');
+    assert.ok(content.includes('{{module_name}}'), 'Missing module_name placeholder');
+    assert.ok(content.includes('{{module_score}}'), 'Missing module_score placeholder');
+  });
+
+  test('has surgery queue section', () => {
+    assert.ok(content.includes('Surgery Queue'), 'Missing Surgery Queue section');
+    assert.ok(content.includes('{{surgery_module}}'), 'Missing surgery_module placeholder');
+    assert.ok(content.includes('{{surgery_pattern}}'), 'Missing surgery_pattern placeholder');
+  });
+
+  test('has risk assessment section', () => {
+    assert.ok(content.includes('Risk Assessment'), 'Missing Risk Assessment section');
+    assert.ok(content.includes('Git Archaeology'), 'Missing Git Archaeology section');
+  });
+
+  test('has cross-domain impact table', () => {
+    assert.ok(content.includes('Cross-Domain Impact'), 'Missing Cross-Domain Impact section');
+    assert.ok(content.includes('{{domain_name}}'), 'Missing domain_name placeholder');
+  });
+
+  test('has recommended actions', () => {
+    assert.ok(content.includes('Recommended Actions'), 'Missing Recommended Actions section');
+  });
+
+  test('has Rune Business footer', () => {
+    assert.ok(content.includes('Rune Business'), 'Missing Rune Business branding');
+    assert.ok(content.includes('autopsy --executive'), 'Missing autopsy --executive reference');
+  });
+
+  test('has board-ready label', () => {
+    assert.ok(content.includes('Board-ready'), 'Should mention board-ready format');
+  });
+});
+
+// ─── Skill integration validation ─────────────────────────────────
+
+describe('retro skill --business integration', () => {
+  const retroPath = path.join(SKILLS_DIR, 'retro', 'SKILL.md');
+  const content = readFileSync(retroPath, 'utf-8');
+
+  test('retro has --business trigger', () => {
+    assert.ok(content.includes('retro --business'), 'retro should document --business mode');
+  });
+
+  test('retro --business references HTML report', () => {
+    assert.ok(content.includes('.html'), 'retro --business should reference HTML output');
+  });
+
+  test('retro --business references cross-domain data', () => {
+    assert.ok(
+      content.includes('Revenue') || content.includes('revenue'),
+      'retro --business should reference revenue domain',
+    );
+    assert.ok(
+      content.includes('Support') || content.includes('support'),
+      'retro --business should reference support domain',
+    );
+    assert.ok(
+      content.includes('Finance') || content.includes('finance'),
+      'retro --business should reference finance domain',
+    );
+  });
+
+  test('retro --business references org config', () => {
+    assert.ok(content.includes('.rune/org/org.md'), 'retro --business should reference org config');
+  });
+
+  test('retro --business has graceful degradation', () => {
+    assert.ok(
+      content.includes('Graceful Degradation') || content.includes('graceful'),
+      'retro --business should handle missing Business pack gracefully',
+    );
+  });
+
+  test('retro --business references report template', () => {
+    assert.ok(content.includes('retro-business.html'), 'retro should reference the HTML template file');
+  });
+});
+
+describe('autopsy skill --executive integration', () => {
+  const autopsyPath = path.join(SKILLS_DIR, 'autopsy', 'SKILL.md');
+  const content = readFileSync(autopsyPath, 'utf-8');
+
+  test('autopsy has --executive mode', () => {
+    assert.ok(content.includes('--executive'), 'autopsy should document --executive mode');
+  });
+
+  test('autopsy --executive references HTML report', () => {
+    assert.ok(
+      content.includes('EXECUTIVE-HEALTH.html'),
+      'autopsy --executive should reference EXECUTIVE-HEALTH.html output',
+    );
+  });
+
+  test('autopsy --executive references SVG health ring', () => {
+    assert.ok(
+      content.includes('SVG') || content.includes('svg'),
+      'autopsy --executive should reference SVG health ring',
+    );
+  });
+
+  test('autopsy --executive has color coding table', () => {
+    assert.ok(
+      content.includes('Color Coding') || content.includes('color'),
+      'autopsy --executive should define color coding',
+    );
+  });
+
+  test('autopsy --executive references org config', () => {
+    assert.ok(content.includes('.rune/org/org.md'), 'autopsy --executive should reference org config for team mapping');
+  });
+
+  test('autopsy --executive references report template', () => {
+    assert.ok(content.includes('autopsy-executive.html'), 'autopsy should reference the HTML template file');
+  });
+
+  test('autopsy --executive has cross-domain impact', () => {
+    assert.ok(
+      content.includes('Cross-Domain') || content.includes('cross-domain'),
+      'autopsy --executive should map to business domains',
+    );
+  });
+
+  test('autopsy --executive has graceful degradation', () => {
+    assert.ok(
+      content.includes('Graceful Degradation') || content.includes('graceful'),
+      'autopsy --executive should handle missing Business pack',
+    );
+  });
+});

package/compiler/__tests__/inject.test.js

@@ -0,0 +1,128 @@
+import assert from 'node:assert';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { describe, test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SKILLS_DIR = path.resolve(__dirname, '../../skills');
+const PRO_DIR = path.resolve(__dirname, '../../../Pro/extensions');
+const BUSINESS_DIR = path.resolve(__dirname, '../../../Business/extensions');
+
+// Skip Pro/Business tier tests when repos are not available (CI)
+const HAS_PRO = existsSync(PRO_DIR);
+
+// Collect known Free core skill names
+const knownSkills = new Set();
+if (existsSync(SKILLS_DIR)) {
+  for (const entry of readdirSync(SKILLS_DIR, { withFileTypes: true })) {
+    if (entry.isDirectory() && existsSync(path.join(SKILLS_DIR, entry.name, 'SKILL.md'))) {
+      knownSkills.add(entry.name);
+    }
+  }
+}
+
+(HAS_PRO ? describe : describe.skip)('inject.json format validation', () => {
+  const packDirs = [];
+
+  // Collect all extension dirs that might have inject.json
+  for (const extDir of [PRO_DIR, BUSINESS_DIR]) {
+    if (!existsSync(extDir)) continue;
+    for (const entry of readdirSync(extDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const injectPath = path.join(extDir, entry.name, 'inject.json');
+      if (existsSync(injectPath)) {
+        packDirs.push({ name: entry.name, dir: path.join(extDir, entry.name), injectPath });
+      }
+    }
+  }
+
+  test('at least one inject.json exists in Pro packs', () => {
+    assert.ok(packDirs.length > 0, 'Expected at least one pack with inject.json');
+  });
+
+  for (const pack of packDirs) {
+    describe(`${pack.name}/inject.json`, () => {
+      let config;
+
+      test('is valid JSON', () => {
+        const raw = readFileSync(pack.injectPath, 'utf-8');
+        config = JSON.parse(raw);
+        assert.ok(config, 'inject.json should parse as valid JSON');
+      });
+
+      test('has injections array', () => {
+        if (!config) return;
+        assert.ok(Array.isArray(config.injections), 'must have injections array');
+        assert.ok(config.injections.length > 0, 'must have at least one injection rule');
+      });
+
+      test('has description field', () => {
+        if (!config) return;
+        assert.ok(config.description, 'should have a description field');
+      });
+
+      test('each rule has required fields', () => {
+        if (!config) return;
+        for (const rule of config.injections) {
+          assert.ok(rule.skill, `rule must have "skill" field: ${JSON.stringify(rule)}`);
+          assert.ok(rule.ref, `rule must have "ref" field: ${JSON.stringify(rule)}`);
+          assert.ok(rule.context, `rule must have "context" field: ${JSON.stringify(rule)}`);
+        }
+      });
+
+      test('target skills exist in Free core', () => {
+        if (!config) return;
+        for (const rule of config.injections) {
+          assert.ok(knownSkills.has(rule.skill), `target skill "${rule.skill}" not found in Free core skills`);
+        }
+      });
+
+      test('reference files exist', () => {
+        if (!config) return;
+        for (const rule of config.injections) {
+          const refPath = path.join(pack.dir, rule.ref);
+          assert.ok(existsSync(refPath), `reference file "${rule.ref}" not found at ${refPath}`);
+        }
+      });
+
+      test('reference files are .md', () => {
+        if (!config) return;
+        for (const rule of config.injections) {
+          assert.ok(rule.ref.endsWith('.md'), `reference "${rule.ref}" should be a .md file`);
+        }
+      });
+
+      test('no duplicate skill targets within same pack', () => {
+        if (!config) return;
+        const seen = new Set();
+        for (const rule of config.injections) {
+          assert.ok(!seen.has(rule.skill), `duplicate injection target "${rule.skill}" in ${pack.name}`);
+          seen.add(rule.skill);
+        }
+      });
+    });
+  }
+});
+
+(HAS_PRO ? describe : describe.skip)('injection rule coverage', () => {
+  const expectedPacks = ['pro-product', 'pro-data-science', 'pro-sales', 'pro-support'];
+
+  for (const packName of expectedPacks) {
+    test(`${packName} has inject.json`, () => {
+      const injectPath = path.join(PRO_DIR, packName, 'inject.json');
+      assert.ok(existsSync(injectPath), `${packName} should have inject.json`);
+    });
+  }
+
+  test('total injection rules across all packs', () => {
+    let totalRules = 0;
+    for (const packName of expectedPacks) {
+      const injectPath = path.join(PRO_DIR, packName, 'inject.json');
+      if (!existsSync(injectPath)) continue;
+      const config = JSON.parse(readFileSync(injectPath, 'utf-8'));
+      totalRules += (config.injections || []).length;
+    }
+    assert.ok(totalRules >= 8, `should have at least 8 injection rules total, got ${totalRules}`);
+  });
+});