@rune-kit/rune 2.2.0 → 2.2.1

package/README.md

@@ -2,15 +2,15 @@
 
 **Less skills. Deeper connections.**
 
-A lean, interconnected skill ecosystem for AI coding assistants. 55 skills, 200+ mesh connections, full project lifecycle — from idea to production.
+A lean, interconnected skill ecosystem for AI coding assistants. 58 skills, 200+ mesh connections, full project lifecycle — from idea to production.
 
-Works on **Claude Code** (native plugin) · **Cursor** · **Windsurf** · **Google Antigravity** · any AI IDE
+Works on **Claude Code** (native plugin) · **Cursor** · **Windsurf** · **Google Antigravity** · **OpenAI Codex** · **OpenCode** · any AI IDE
 
 ## Why Rune?
 
 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** — 55 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** — 58 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)
@@ -20,24 +20,23 @@ Mesh:      A ↔ B ↔ C             (B fails = A reaches C via D→E)
            D ↔ E ↔ F
 ```
 
-## What's New (v2.1.0)
+## What's New (v2.2.1)
 
-- **Phase-Aware Execution** — cook v0.5.0 resumes multi-session plans automatically. Master plan + phase files = one phase per session, any model executes accurately
-- **Amateur-Proof Plans** — plan v0.4.0 generates self-contained phase files with data flow diagrams, code contracts, failure scenarios, and rejection criteria. Designed so even the weakest model succeeds
-- **Cognitive Bias Detection** — problem-solver v0.3.0 runs mandatory bias checks (12 biases) before every analysis. Reversibility Filter, Pre-Mortem, Weighted Matrix, MECE decomposition
-- **Second-Order Thinking** — sequential-thinking v0.3.0 classifies decision reversibility, traces cascading effects, and cross-checks for anchoring/status-quo/overconfidence biases
-- **6 New Skills** — ba (business analyst), scaffold (project bootstrap), docs (documentation lifecycle), git (semantic commits), mcp-builder (MCP server generator), doc-processor (PDF/DOCX/XLSX)
-- **Multi-Platform Compiler** — all 55 skills compile to Cursor, Windsurf, Antigravity, and generic formats with zero knowledge loss
+- **Enforcement Upgrade** — Antigravity-level IDE compliance: 5-type Request Classifier, File Ownership Matrix, Self-Verification HARD-GATE, Routing Proof, Clarification Gate, Phase Transition Protocol. Distributed via compiler — every skill file gets compliance preamble on non-Claude platforms
+- **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
+- **58 Core Skills** — +3 since v2.1.0: adversary (red team), sentinel-env (env validation), chrome-ext pack
+- **Rune Pro** — 4 premium packs (product, sales, data-science, support) in private repo. $49 lifetime
 
 ## What Rune Is (and Isn't)
 
-Rune started as a **Claude Code plugin** and now compiles to **every major AI IDE**. Same 55 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 58 skills, same mesh connections, same workflows — zero knowledge loss across platforms.
 
 | | Rune Provides | Claude Code Provides |
 |---|---|---|
 | **Workflows** | 8-phase TDD cycle (cook), parallel DAG execution (team), rescue pipelines | Basic tool calling |
 | **Quality Gates** | preflight + sentinel + review + completion-gate (parallel) | None built-in |
-| **Domain Knowledge** | 12 extension packs (trading, SaaS, mobile, etc.) | General-purpose |
+| **Domain Knowledge** | 14 extension packs (trading, SaaS, mobile, etc.) | General-purpose |
 | **Cross-Session State** | .rune/ directory (decisions, conventions, progress) | Conversation only |
 | **Mesh Resilience** | 200+ skill connections, fail-loud-route-around | Linear execution |
 | **Cost Optimization** | Auto model selection (haiku/sonnet/opus per task) | Single model |
@@ -55,7 +54,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 | 55 specialized skills with dedicated roles (architect, coder, reviewer, scanner, researcher, BA, scaffolder) — each runs as a Task agent via Claude Code |
+| Agent specialization | 58 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
@@ -82,16 +81,16 @@ npx @rune-kit/rune init --platform windsurf
 npx @rune-kit/rune init --platform antigravity
 ```
 
-This compiles all 55 skills into your IDE's rules format. Same knowledge, same workflows.
+This compiles all 58 skills into your IDE's rules format. Same knowledge, same workflows.
 
 ### Platform Comparison
 
 | Feature | Claude Code | Cursor / Windsurf / Others |
 |---------|-------------|---------------------------|
-| Skills available | 55/55 | 55/55 |
+| Skills available | 58/58 | 58/58 |
 | Mesh connections | 200+ (programmatic) | 200+ (rule references) |
 | Workflows & HARD-GATEs | Full | Full |
-| Extension packs | 12 | 12 |
+| Extension packs | 14 | 14 |
 | Subagent parallelism | Native | Sequential fallback |
 | Lifecycle hooks | 8 hooks (JS runtime) | Inline MUST/NEVER constraints |
 | Adaptive model routing | haiku/sonnet/opus | Single model |
@@ -153,7 +152,7 @@ This compiles all 55 skills into your IDE's rules format. Same knowledge, same w
 ║  Full lifecycle workflows                             ║
 ║  cook │ team │ launch │ rescue │ scaffold             ║
 ╠══════════════════════════════════════════════════════╣
-║  L2: WORKFLOW HUBS (26)                               ║
+║  L2: WORKFLOW HUBS (27)                               ║
 ║  Cross-hub mesh — the key differentiator              ║
 ║                                                        ║
 ║  Creation:    plan │ scout │ brainstorm │ design │     ║
@@ -164,8 +163,9 @@ This compiles all 55 skills into your IDE's rules format. Same knowledge, same w
 ║               logic-guardian                            ║
 ║  Delivery:    deploy │ marketing │ incident │ docs     ║
 ║  Rescue:      autopsy │ safeguard │ surgeon            ║
+║  Security:    adversary                                ║
 ╠══════════════════════════════════════════════════════╣
-║  L3: UTILITIES (23)                                   ║
+║  L3: UTILITIES (25)                                   ║
 ║  Stateless, pure capabilities                         ║
 ║                                                        ║
 ║  Knowledge:   research │ docs-seeker │ trend-scout     ║
@@ -182,14 +182,17 @@ This compiles all 55 skills into your IDE's rules format. Same knowledge, same w
 ║  Workspace:   worktree                                 ║
 ║  Git:         git                                      ║
 ║  Documents:   doc-processor                            ║
+║  Security:    sentinel-env                             ║
+║  Memory:      neural-memory                            ║
 ╠══════════════════════════════════════════════════════╣
-║  L4: EXTENSION PACKS (12)                             ║
+║  L4: EXTENSION PACKS (14)                             ║
 ║  Domain-specific, install what you need                ║
 ║                                                        ║
 ║  @rune/ui │ @rune/backend │ @rune/devops │            ║
 ║  @rune/mobile │ @rune/security │ @rune/trading │      ║
 ║  @rune/saas │ @rune/ecommerce │ @rune/ai-ml │        ║
-║  @rune/gamedev │ @rune/content │ @rune/analytics      ║
+║  @rune/gamedev │ @rune/content │ @rune/analytics │    ║
+║  @rune/chrome-ext │ @rune/zalo                         ║
 ╚══════════════════════════════════════════════════════╝
 ```
 
@@ -310,8 +313,9 @@ Business department packs for product, sales, and data teams. Same PACK.md forma
 | @rune-pro/product | feature-spec, roadmap, metrics, release-comms, user-research, competitive | Product Management |
 | @rune-pro/sales | account-research, call-prep, outreach, pipeline-review, competitive-intel | Sales Enablement |
 | @rune-pro/data-science | data-exploration, sql-advanced, visualization, statistical-testing, dashboards | Data Science |
+| @rune-pro/support | ticket-triage, response-drafting, knowledge-base, escalation, faq, metrics | Customer Support |
 
-Coming soon. See [docs/plans/RUNE-PRO-PLAN.md](docs/plans/RUNE-PRO-PLAN.md) for the full roadmap.
+**$49 lifetime** (Pro) · **$149 lifetime** (Business). See [docs/plans/RUNE-PRO-PLAN.md](docs/plans/RUNE-PRO-PLAN.md).
 
 ## Multi-Platform Compiler
 
@@ -321,13 +325,14 @@ Rune includes a 3-stage compiler that transforms SKILL.md files into platform-na
 skills/*.md → PARSE → TRANSFORM → EMIT → platform rules
 ```
 
-**6 transforms applied per platform:**
-1. Cross-references: `rune:cook` → `@rune-cook.mdc` (Cursor) / prose ref (Windsurf)
-2. Tool names: `Read`, `Edit`, `Bash` → generic language
-3. Frontmatter: strip Claude Code-specific directives
+**8 transforms applied per platform:**
+1. Frontmatter: strip Claude Code-specific directives
+2. Cross-references: `rune:cook` → `@rune-cook.mdc` (Cursor) / prose ref (Windsurf)
+3. Tool names: `Read`, `Edit`, `Bash` → generic language
 4. Subagents: parallel → sequential workflow
-5. Hooks: runtime hooks → inline MUST/NEVER constraints
-6. Branding: Rune attribution footer
+5. Compliance: inject enforcement preamble (non-Claude platforms)
+6. Hooks: runtime hooks → inline MUST/NEVER constraints
+7. Branding: Rune attribution footer
 
 ```bash
 # Build for any platform
@@ -343,13 +348,14 @@ See [docs/MULTI-PLATFORM.md](docs/MULTI-PLATFORM.md) for the full architecture.
 ## Numbers
 
 ```
-Core Skills:       55 (L0: 1 │ L1: 5 │ L2: 26 │ L3: 23)
-Extension Packs:   12 free + 3 pro (coming soon)
-Mesh Connections:  206 cross-references + 151 tool references
-Connections/Skill: 3.7 avg
-Platforms:         5 (Claude Code, Cursor, Windsurf, Antigravity, Generic)
-Compiler:          ~1200 LOC (parser + transforms + adapters + CLI)
-Quality:           55/55 skills with Output Format, Sharp Edges, Done When, Cost Profile
+Core Skills:       58 (L0: 1 │ L1: 5 │ L2: 27 │ L3: 25)
+Extension Packs:   14 free + 4 pro + 2 business
+Mesh Connections:  200+ cross-references
+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:           58/58 skills with Output Format, Sharp Edges, Done When, Cost Profile
+Pack Depth:        20 packs total (14 free + 4 pro + 2 business, all free packs rated Deep)
 ```
 
 ## License

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

@@ -0,0 +1,145 @@
+import { parsePack, parseSkill } from '../parser.js';
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { readFileSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const EXTENSIONS_DIR = path.resolve(__dirname, '../../extensions');
+
+// --- Monolith format (regression) ---
+
+test('parsePack: monolith format has isSplit=false', () => {
+  const content = `---
+name: "@rune/trading"
+description: "Trading patterns"
+metadata:
+  version: "0.2.0"
+  layer: L4
+  price: free
+  target: Traders
+---
+
+# @rune/trading
+
+## Purpose
+Trading pack.
+
+## Skills Included
+
+### risk-management
+Risk management workflow.
+`;
+
+  const parsed = parsePack(content, 'extensions/trading/PACK.md');
+
+  assert.strictEqual(parsed.isSplit, false);
+  assert.deepStrictEqual(parsed.skillManifest, []);
+  assert.strictEqual(parsed.name, '@rune/trading');
+  assert.strictEqual(parsed.version, '0.2.0');
+  assert.strictEqual(parsed.layer, 'L4');
+  assert.ok(parsed.body.includes('risk-management'));
+});
+
+test('parsePack: monolith without metadata block defaults correctly', () => {
+  const content = `---
+name: "@rune/test"
+description: "Test pack"
+---
+
+# @rune/test
+Body here.
+`;
+
+  const parsed = parsePack(content, 'test/PACK.md');
+
+  assert.strictEqual(parsed.isSplit, false);
+  assert.strictEqual(parsed.version, '1.0.0');
+});
+
+// --- Split format detection ---
+
+test('parsePack: split format detected via metadata.format', () => {
+  const content = `---
+name: "@rune/backend"
+description: "Backend patterns"
+metadata:
+  version: "0.3.0"
+  layer: L4
+  price: free
+  target: Backend developers
+  format: split
+---
+
+# @rune/backend
+
+## Purpose
+Backend pack index.
+
+## Skills Included
+| Skill | Model | Description |
+|-------|-------|-------------|
+| api-design | sonnet | API patterns |
+| auth | sonnet | Auth patterns |
+`;
+
+  const parsed = parsePack(content, 'extensions/backend/PACK.md');
+
+  assert.strictEqual(parsed.isSplit, true);
+  assert.strictEqual(parsed.version, '0.3.0');
+  assert.strictEqual(parsed.name, '@rune/backend');
+});
+
+test('parsePack: skill manifest parsed from string array', () => {
+  // Note: our YAML parser is simple — it handles nested objects but not arrays.
+  // This test validates the parseSkillManifest function directly with object skills.
+  const content = `---
+name: "@rune/test"
+description: "Test"
+metadata:
+  format: split
+---
+
+Body.
+`;
+
+  const parsed = parsePack(content, 'test/PACK.md');
+  assert.strictEqual(parsed.isSplit, true);
+  // With simple YAML parser, skills array won't parse — manifest will be empty
+  // Real usage will use the skills/ directory detection as fallback
+  assert.ok(Array.isArray(parsed.skillManifest));
+});
+
+// --- Real pack regression: existing monolith packs parse correctly ---
+
+test('parsePack: real trading PACK.md parses as split', () => {
+  const tradingPath = path.join(EXTENSIONS_DIR, 'trading', 'PACK.md');
+  if (!existsSync(tradingPath)) {
+    console.log('  skip: trading PACK.md not found');
+    return;
+  }
+
+  const content = readFileSync(tradingPath, 'utf-8');
+  const parsed = parsePack(content, tradingPath);
+
+  assert.strictEqual(parsed.isSplit, true);
+  assert.strictEqual(parsed.layer, 'L4');
+  assert.strictEqual(parsed.group, 'extension');
+  assert.ok(parsed.body.length > 50);
+});
+
+test('parsePack: real backend PACK.md parses as split (post-split)', () => {
+  const backendPath = path.join(EXTENSIONS_DIR, 'backend', 'PACK.md');
+  if (!existsSync(backendPath)) {
+    console.log('  skip: backend PACK.md not found');
+    return;
+  }
+
+  const content = readFileSync(backendPath, 'utf-8');
+  const parsed = parsePack(content, backendPath);
+
+  assert.strictEqual(parsed.isSplit, true);
+  assert.strictEqual(parsed.layer, 'L4');
+  assert.ok(parsed.sections.size > 0);
+});

package/compiler/bin/rune.js

@@ -51,11 +51,6 @@ function detectPlatform(projectRoot) {
   return null;
 }
 
-function discoverExtensions() {
-  const extDir = path.join(RUNE_ROOT, 'extensions');
-  if (!existsSync(extDir)) return [];
-  return [];
-}
 
 async function prompt(question) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });

package/compiler/doctor.js

@@ -7,6 +7,7 @@
 import { readdir, readFile, stat } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
+import { parsePack } from './parser.js';
 
 /**
  * Run doctor checks on compiled output
@@ -89,6 +90,18 @@ export async function runDoctor({ outputRoot, adapter, config, runeRoot }) {
     results.warnings.push(`${disabled.length} skills disabled: ${disabled.join(', ')}`);
   }
 
+  // Check 7: Split pack integrity (validate skill manifest files exist)
+  const extensionsDir = path.join(runeRoot, 'extensions');
+  if (existsSync(extensionsDir)) {
+    const splitPackErrors = await checkSplitPacks(extensionsDir);
+    if (splitPackErrors.length === 0) {
+      results.checks.push({ name: 'Split packs', status: 'pass' });
+    } else {
+      results.checks.push({ name: 'Split packs', status: 'fail', detail: `${splitPackErrors.length} missing skill files` });
+      results.errors.push(...splitPackErrors);
+    }
+  }
+
   if (results.errors.length > 0) results.healthy = false;
 
   return results;
@@ -119,6 +132,35 @@ async function checkCrossRefs(outputDir, files, adapter) {
   return [...new Set(errors)]; // deduplicate
 }
 
+/**
+ * Check that all split packs have their declared skill files present
+ */
+async function checkSplitPacks(extensionsDir) {
+  const errors = [];
+  const entries = await readdir(extensionsDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const packFile = path.join(extensionsDir, entry.name, 'PACK.md');
+    if (!existsSync(packFile)) continue;
+
+    const content = await readFile(packFile, 'utf-8');
+    const parsed = parsePack(content, packFile);
+
+    if (!parsed.isSplit) continue;
+
+    const packDir = path.dirname(packFile);
+    for (const skill of parsed.skillManifest) {
+      const skillPath = path.join(packDir, skill.file);
+      if (!existsSync(skillPath)) {
+        errors.push(`@rune/${entry.name}: skill file "${skill.file}" declared in manifest but not found`);
+      }
+    }
+  }
+
+  return errors;
+}
+
 /**
  * Format doctor results for console output
  */

package/compiler/emitter.js

@@ -8,7 +8,7 @@
 import { readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
-import { parseSkill, parsePack } from './parser.js';
+import { parseSkill, parsePack, extractCrossRefs, extractToolRefs } from './parser.js';
 import { transformSkill } from './transformer.js';
 
 /**
@@ -158,6 +158,29 @@ export async function buildAll({ runeRoot, outputRoot, adapter, disabledSkills =
       const content = await readFile(packPath, 'utf-8');
       const parsed = parsePack(content, packPath);
       const packName = path.basename(path.dirname(packPath));
+      const packDir = path.dirname(packPath);
+
+      // For split packs, load individual skill files and concatenate into body
+      if (parsed.isSplit && parsed.skillManifest.length > 0) {
+        const skillBodies = [];
+        for (const skill of parsed.skillManifest) {
+          const skillPath = path.join(packDir, skill.file);
+          if (existsSync(skillPath)) {
+            const skillContent = await readFile(skillPath, 'utf-8');
+            // Strip frontmatter from skill file — we only need the body
+            const skillBodyMatch = skillContent.replace(/\r\n/g, '\n').match(/^---\n[\s\S]*?\n---\n?([\s\S]*)$/);
+            const skillBody = skillBodyMatch ? skillBodyMatch[1].trim() : skillContent.trim();
+            skillBodies.push(skillBody);
+          } else {
+            stats.errors.push({ file: skillPath, error: `Skill file not found (listed in ${packPath} manifest)` });
+          }
+        }
+        // Concatenate: index body + all skill bodies
+        parsed.body = parsed.body + '\n\n' + skillBodies.join('\n\n---\n\n');
+        // Re-extract refs from the full concatenated body
+        parsed.crossRefs = extractCrossRefs(parsed.body);
+        parsed.toolRefs = extractToolRefs(parsed.body);
+      }
 
       // Normalize pack name for headers (ext-trading instead of @rune/trading)
       parsed.name = `ext-${packName}`;
@@ -170,9 +193,9 @@ export async function buildAll({ runeRoot, outputRoot, adapter, disabledSkills =
 
       if (adapter.useSkillDirectories) {
         const dirName = `${adapter.skillPrefix}ext-${packName}`;
-        const packDir = path.join(outputDir, dirName);
-        await mkdir(packDir, { recursive: true });
-        outputPath = path.join(packDir, adapter.skillFileName || 'SKILL.md');
+        const outPackDir = path.join(outputDir, dirName);
+        await mkdir(outPackDir, { recursive: true });
+        outputPath = path.join(outPackDir, adapter.skillFileName || 'SKILL.md');
         displayName = `${dirName}/${adapter.skillFileName || 'SKILL.md'}`;
       } else {
         const fileName = outputFileName(`ext-${packName}`, adapter);

package/compiler/parser.js

@@ -65,7 +65,7 @@ function parseFrontmatter(content) {
 /**
  * Extract all rune:<name> cross-references from body
  */
-function extractCrossRefs(body) {
+export function extractCrossRefs(body) {
   const refs = [];
   const lines = body.split('\n');
 
@@ -90,7 +90,7 @@ function extractCrossRefs(body) {
 /**
  * Extract all Claude Code tool references from body
  */
-function extractToolRefs(body) {
+export function extractToolRefs(body) {
   const refs = [];
   const lines = body.split('\n');
 
@@ -188,16 +188,25 @@ export function parseSkill(content, filePath = '') {
 
 /**
  * Parse a PACK.md extension file (same format, slightly different metadata)
+ * Supports both monolith format (all skills inline) and split format (skills in separate files)
+ *
+ * Split format detection: metadata.format === "split" OR metadata.skills array present
  */
 export function parsePack(content, filePath = '') {
   const { frontmatter, body } = parseFrontmatter(content);
+  const metadata = frontmatter.metadata || {};
+
+  // Detect split format
+  const isSplit = metadata.format === 'split' || Array.isArray(metadata.skills);
 
   return {
     name: frontmatter.name || '',
     description: frontmatter.description || '',
-    version: frontmatter.version || '1.0.0',
+    version: metadata.version || frontmatter.version || '1.0.0',
     layer: 'L4',
     group: 'extension',
+    isSplit,
+    skillManifest: isSplit ? parseSkillManifest(metadata.skills || []) : [],
     body,
     crossRefs: extractCrossRefs(body),
     toolRefs: extractToolRefs(body),
@@ -207,3 +216,32 @@ export function parsePack(content, filePath = '') {
     frontmatter,
   };
 }
+
+/**
+ * Parse the skills manifest from split PACK.md frontmatter
+ *
+ * @param {Array} skills - array of skill entries from frontmatter metadata.skills
+ * @returns {Array<{name: string, file: string, model: string, description: string}>}
+ */
+function parseSkillManifest(skills) {
+  if (!Array.isArray(skills)) return [];
+
+  return skills.map(skill => {
+    // Handle both string format ("skill-name") and object format ({name, file, model, description})
+    if (typeof skill === 'string') {
+      return {
+        name: skill,
+        file: `skills/${skill}.md`,
+        model: 'sonnet',
+        description: '',
+      };
+    }
+
+    return {
+      name: skill.name || '',
+      file: skill.file || `skills/${skill.name}.md`,
+      model: skill.model || 'sonnet',
+      description: skill.description || '',
+    };
+  });
+}

package/compiler/transformer.js

@@ -2,7 +2,7 @@
  * Transform Pipeline
  *
  * Applies all transforms in order to convert a parsed skill into platform-specific output.
- * Pipeline: frontmatter → cross-refs → tool-names → subagents → hooks → branding
+ * Pipeline: frontmatter → cross-refs → tool-names → subagents → compliance → hooks → branding
  */
 
 import { transformCrossReferences } from './transforms/cross-references.js';
@@ -10,6 +10,7 @@ import { transformToolNames } from './transforms/tool-names.js';
 import { transformFrontmatter } from './transforms/frontmatter.js';
 import { transformSubagents } from './transforms/subagents.js';
 import { generateHookConstraints } from './transforms/hooks.js';
+import { transformCompliance } from './transforms/compliance.js';
 import { addBranding } from './transforms/branding.js';
 
 /**
@@ -40,16 +41,19 @@ export function transformSkill(parsedSkill, adapter) {
   // 3. Convert subagent/parallel instructions to sequential
   body = transformSubagents(body, adapter);
 
-  // 4. Platform-specific post-processing
+  // 4. Inject compliance preamble (enforcement for non-Claude platforms)
+  body = transformCompliance(body, adapter);
+
+  // 5. Platform-specific post-processing
   body = adapter.postProcess(body);
 
-  // 5. Generate header (platform-specific frontmatter/preamble)
+  // 6. Generate header (platform-specific frontmatter/preamble)
   const header = adapter.generateHeader(parsedSkill);
 
-  // 6. Generate hook constraints section
+  // 7. Generate hook constraints section
   const hookConstraints = generateHookConstraints(parsedSkill, adapter);
 
-  // 7. Inject hook constraints after the first heading
+  // 8. Inject hook constraints after the first heading
   if (hookConstraints) {
     const firstHeadingEnd = body.indexOf('\n## ');
     if (firstHeadingEnd !== -1) {
@@ -62,7 +66,7 @@ export function transformSkill(parsedSkill, adapter) {
     }
   }
 
-  // 8. Generate footer (branding + CTA)
+  // 9. Generate footer (branding + CTA)
   const footer = adapter.generateFooter();
 
   return { header, body, footer };

package/compiler/transforms/compliance.js

@@ -0,0 +1,40 @@
+/**
+ * Compliance Transform
+ *
+ * Injects a compliance preamble into every compiled skill file.
+ * This distributes enforcement to ALL platforms (Cursor, Windsurf, etc.)
+ * so the AI is reminded of routing discipline even if skill-router
+ * itself is not loaded in context.
+ *
+ * Only applies to non-Claude platforms (Claude has native plugin enforcement).
+ */
+
+const COMPLIANCE_PREAMBLE = [
+  '',
+  '> **RUNE COMPLIANCE**: Before ANY code response, you MUST:',
+  '> 1. Classify this request (CODE_CHANGE | QUESTION | DEBUG | REVIEW | EXPLORE)',
+  '> 2. Route through the correct Rune skill (see skill-router routing table)',
+  "> 3. Follow the skill's workflow — do NOT freelance or skip steps",
+  '> Violation: writing code without skill routing = incorrect behavior.',
+  '',
+].join('\n');
+
+/**
+ * Inject compliance preamble after the first heading in a skill body.
+ *
+ * @param {string} body - skill body text
+ * @param {object} adapter - platform adapter
+ * @returns {string} body with compliance preamble injected
+ */
+export function transformCompliance(body, adapter) {
+  if (adapter.name === 'claude') return body;
+
+  // Insert after first heading (# skill-name), before first ## section
+  const firstH2 = body.indexOf('\n## ');
+  if (firstH2 !== -1) {
+    return body.slice(0, firstH2) + COMPLIANCE_PREAMBLE + body.slice(firstH2);
+  }
+
+  // Fallback: append at end if no ## sections found
+  return body + COMPLIANCE_PREAMBLE;
+}