@rune-kit/rune 2.13.0 → 2.15.0

package/compiler/__tests__/out-of-scope-format.test.js

@@ -0,0 +1,303 @@
+/**
+ * .out-of-scope/ KB format validation.
+ *
+ * Validates:
+ *   - Frontmatter parses as YAML
+ *   - Required fields present (concept, aliases, decision, rejected_at, rejected_by, prior_requests)
+ *   - decision == "rejected" (deferrals don't belong here)
+ *   - concept matches filename (slug rule)
+ *   - prior_requests has >=1 entry
+ *   - Slug rules: kebab-case, lowercase, max 40 chars
+ *
+ * Operates on test fixtures (no real .out-of-scope/ in this repo yet).
+ */
+
+import assert from 'node:assert';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, test } from 'node:test';
+
+// Minimal YAML frontmatter parser — we only need flat key:value + simple lists/objects.
+// Mirrors what ba and review-intake expect at runtime.
+function parseFrontmatter(text) {
+  const match = text.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const block = match[1];
+  const lines = block.split('\n');
+  const out = {};
+  let currentKey = null;
+  let currentList = null;
+  let currentObj = null;
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    if (line.startsWith('  - ')) {
+      // List item, or object-list item starting with `- key: value`
+      const inner = line.slice(4);
+      if (inner.includes(': ')) {
+        // First field of a new object in the list
+        currentObj = {};
+        const [k, v] = inner.split(/:\s+/);
+        currentObj[k.trim()] = stripQuotes(v.trim());
+        currentList.push(currentObj);
+      } else {
+        currentList.push(stripQuotes(inner.trim()));
+        currentObj = null;
+      }
+    } else if (line.startsWith('    ')) {
+      // Continuation field of the current object
+      if (currentObj && line.includes(': ')) {
+        const [k, v] = line.trim().split(/:\s+/);
+        currentObj[k.trim()] = stripQuotes(v.trim());
+      }
+    } else if (line.match(/^[a-z_]+:/)) {
+      const [key, ...rest] = line.split(':');
+      const value = rest.join(':').trim();
+      currentKey = key.trim();
+      currentObj = null;
+      if (value === '' || value === '[]') {
+        out[currentKey] = [];
+        currentList = out[currentKey];
+      } else if (value.startsWith('[') && value.endsWith(']')) {
+        out[currentKey] = value
+          .slice(1, -1)
+          .split(',')
+          .map((s) => stripQuotes(s.trim()))
+          .filter(Boolean);
+        currentList = null;
+      } else {
+        out[currentKey] = stripQuotes(value);
+        currentList = null;
+      }
+    }
+  }
+  return out;
+}
+
+function stripQuotes(s) {
+  if (!s) return s;
+  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+
+const REQUIRED_FIELDS = ['concept', 'aliases', 'decision', 'rejected_at', 'rejected_by', 'prior_requests'];
+const SLUG_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+
+function validateOutOfScope(filename, content) {
+  const issues = [];
+  const fm = parseFrontmatter(content);
+  if (!fm) return ['frontmatter missing or unparseable'];
+
+  for (const f of REQUIRED_FIELDS) {
+    if (!(f in fm) || fm[f] === undefined) issues.push(`missing field: ${f}`);
+  }
+
+  if (fm.decision && fm.decision !== 'rejected') {
+    issues.push(`decision must be "rejected" (got "${fm.decision}") — deferrals don't belong in .out-of-scope/`);
+  }
+
+  if (fm.concept) {
+    if (!SLUG_RE.test(fm.concept)) issues.push(`concept slug malformed: ${fm.concept}`);
+    if (fm.concept.length > 40) issues.push(`concept slug too long (>40 chars): ${fm.concept}`);
+    const expected = path.basename(filename, '.md');
+    if (fm.concept !== expected) {
+      issues.push(`concept "${fm.concept}" does not match filename "${expected}"`);
+    }
+  }
+
+  if (fm.rejected_at && !ISO_DATE_RE.test(fm.rejected_at)) {
+    issues.push(`rejected_at must be ISO date YYYY-MM-DD (got "${fm.rejected_at}")`);
+  }
+
+  if (Array.isArray(fm.prior_requests) && fm.prior_requests.length === 0) {
+    issues.push('prior_requests must have >=1 entry');
+  }
+
+  return issues;
+}
+
+// --- Tests ---
+
+describe('out-of-scope/ KB format', () => {
+  let tmpDir;
+
+  test('valid file passes', () => {
+    tmpDir = mkdtempSync(path.join(os.tmpdir(), 'rune-oos-'));
+    const file = path.join(tmpDir, 'dark-mode.md');
+    const content = `---
+concept: dark-mode
+aliases: [night-theme, dark-theme]
+decision: rejected
+rejected_at: 2026-04-27
+rejected_by: review-intake
+priority_to_revisit: low
+prior_requests:
+  - id: gh-issue-42
+    summary: Add dark mode support
+    closed_at: 2025-08-01
+revisit_if:
+  - "team adds front-end engineer"
+---
+
+# Dark Mode
+
+Body content.
+`;
+    writeFileSync(file, content);
+    const issues = validateOutOfScope(file, content);
+    assert.deepStrictEqual(issues, []);
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('rejects file with decision=deferred', () => {
+    const content = `---
+concept: dark-mode
+aliases: [night-theme]
+decision: deferred
+rejected_at: 2026-04-27
+rejected_by: ba
+prior_requests:
+  - id: gh-issue-42
+    summary: x
+    closed_at: 2025-08-01
+---
+
+body
+`;
+    const issues = validateOutOfScope('dark-mode.md', content);
+    assert.ok(
+      issues.some((i) => i.includes('decision must be "rejected"')),
+      'should reject decision=deferred',
+    );
+  });
+
+  test('rejects mismatched filename and concept', () => {
+    const content = `---
+concept: foo-bar
+aliases: []
+decision: rejected
+rejected_at: 2026-04-27
+rejected_by: ba
+prior_requests:
+  - id: i
+    summary: s
+    closed_at: 2025-08-01
+---
+
+body
+`;
+    const issues = validateOutOfScope('different-name.md', content);
+    assert.ok(
+      issues.some((i) => i.includes('does not match filename')),
+      'should flag filename/concept mismatch',
+    );
+  });
+
+  test('rejects empty prior_requests', () => {
+    const content = `---
+concept: dark-mode
+aliases: []
+decision: rejected
+rejected_at: 2026-04-27
+rejected_by: ba
+prior_requests: []
+---
+
+body
+`;
+    const issues = validateOutOfScope('dark-mode.md', content);
+    assert.ok(
+      issues.some((i) => i.includes('prior_requests must have >=1 entry')),
+      'should require prior_requests',
+    );
+  });
+
+  test('rejects malformed slug', () => {
+    const content = `---
+concept: Dark_Mode
+aliases: []
+decision: rejected
+rejected_at: 2026-04-27
+rejected_by: ba
+prior_requests:
+  - id: i
+    summary: s
+    closed_at: 2025-08-01
+---
+
+body
+`;
+    const issues = validateOutOfScope('Dark_Mode.md', content);
+    assert.ok(
+      issues.some((i) => i.includes('concept slug malformed')),
+      'should reject non-kebab-case slug',
+    );
+  });
+
+  test('rejects slug longer than 40 chars', () => {
+    const longSlug = 'a-very-long-concept-name-that-exceeds-the-forty-char-cap';
+    const content = `---
+concept: ${longSlug}
+aliases: []
+decision: rejected
+rejected_at: 2026-04-27
+rejected_by: ba
+prior_requests:
+  - id: i
+    summary: s
+    closed_at: 2025-08-01
+---
+
+body
+`;
+    const issues = validateOutOfScope(`${longSlug}.md`, content);
+    assert.ok(
+      issues.some((i) => i.includes('too long')),
+      'should reject overlong slug',
+    );
+  });
+
+  test('rejects malformed rejected_at date', () => {
+    const content = `---
+concept: dark-mode
+aliases: []
+decision: rejected
+rejected_at: yesterday
+rejected_by: ba
+prior_requests:
+  - id: i
+    summary: s
+    closed_at: 2025-08-01
+---
+
+body
+`;
+    const issues = validateOutOfScope('dark-mode.md', content);
+    assert.ok(
+      issues.some((i) => i.includes('ISO date')),
+      'should reject non-ISO date',
+    );
+  });
+
+  test('rejects file missing required fields', () => {
+    const content = `---
+concept: dark-mode
+---
+
+body
+`;
+    const issues = validateOutOfScope('dark-mode.md', content);
+    assert.ok(issues.length >= 4, `expected multiple missing-field errors, got ${issues.length}`);
+  });
+});
+
+describe('signal name validity', () => {
+  test('outofscope.match conforms to signal naming pattern', () => {
+    const SIGNAL_PATTERN = /^[a-z][a-z0-9]*(\.[a-z][a-z0-9]*)+$/;
+    assert.ok(SIGNAL_PATTERN.test('outofscope.match'));
+  });
+});

package/compiler/__tests__/skill-description-quality.test.js

@@ -0,0 +1,147 @@
+/**
+ * Skill description quality (v2.15+) — lint validation that every SKILL.md
+ * description is YAML-safe, well-formed, and ambiguous-name skills carry an
+ * explicit "Use when…" routing hint.
+ *
+ * Validates:
+ *   - All descriptions are double-quoted (YAML safety)
+ *   - All descriptions end with `.` or `?`
+ *   - All descriptions are 30-500 chars
+ *   - Specific ambiguous-name skills include "Use when…" clause
+ */
+
+import assert from 'node:assert';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { describe, test } from 'node:test';
+
+const SKILLS_DIR = resolve(import.meta.dirname, '../..', 'skills');
+
+function listSkills() {
+  return readdirSync(SKILLS_DIR).filter((name) => {
+    const p = join(SKILLS_DIR, name);
+    return statSync(p).isDirectory() && readdirSync(p).includes('SKILL.md');
+  });
+}
+
+function readDescriptionLine(name) {
+  const text = readFileSync(join(SKILLS_DIR, name, 'SKILL.md'), 'utf8');
+  const lines = text.split(/\r?\n/);
+  for (const line of lines.slice(0, 20)) {
+    if (line.startsWith('description:')) return line;
+  }
+  return null;
+}
+
+function extractDescriptionValue(line) {
+  const m = line.match(/^description:\s+"(.+)"\s*$/);
+  if (m) return m[1].replace(/\\"/g, '"');
+  return null;
+}
+
+const AMBIGUOUS_SKILLS_REQUIRING_USE_WHEN = [
+  'ba',
+  'completion-gate',
+  'constraint-check',
+  'doc-processor',
+  'integrity-check',
+  'logic-guardian',
+  'onboard',
+  'preflight',
+  'sentinel-env',
+  'watchdog',
+  'worktree',
+  'hallucination-guard',
+  'mcp-builder',
+];
+
+describe('Skill description format', () => {
+  test('every description is double-quoted (YAML-safe)', () => {
+    const skills = listSkills();
+    const violations = [];
+    for (const name of skills) {
+      const line = readDescriptionLine(name);
+      if (!line) {
+        violations.push(`${name}: no description line found`);
+        continue;
+      }
+      if (!line.match(/^description:\s+"/)) {
+        violations.push(`${name}: description is not double-quoted`);
+      }
+    }
+    assert.strictEqual(violations.length, 0, `Unquoted descriptions:\n${violations.join('\n')}`);
+  });
+
+  test('every description ends with terminal punctuation', () => {
+    const skills = listSkills();
+    const violations = [];
+    for (const name of skills) {
+      const line = readDescriptionLine(name);
+      const val = extractDescriptionValue(line);
+      if (!val) continue;
+      if (!val.match(/[.?]$/)) {
+        violations.push(`${name}: description does not end with . or ?`);
+      }
+    }
+    assert.strictEqual(violations.length, 0, `Bad endings:\n${violations.join('\n')}`);
+  });
+
+  test('every description is 30-500 chars', () => {
+    const skills = listSkills();
+    const violations = [];
+    for (const name of skills) {
+      const line = readDescriptionLine(name);
+      const val = extractDescriptionValue(line);
+      if (!val) continue;
+      if (val.length < 30) violations.push(`${name}: description too short (${val.length} chars)`);
+      if (val.length > 500) violations.push(`${name}: description too long (${val.length} chars)`);
+    }
+    assert.strictEqual(violations.length, 0, `Length violations:\n${violations.join('\n')}`);
+  });
+});
+
+describe('Ambiguous-name skills include "Use when…" routing hint', () => {
+  test('all 13 ambiguous-name skills explicitly state "Use when…"', () => {
+    const violations = [];
+    for (const name of AMBIGUOUS_SKILLS_REQUIRING_USE_WHEN) {
+      const line = readDescriptionLine(name);
+      const val = extractDescriptionValue(line);
+      if (!val) {
+        violations.push(`${name}: description not parseable`);
+        continue;
+      }
+      if (!/Use when/i.test(val)) {
+        violations.push(`${name}: missing "Use when…" clause`);
+      }
+    }
+    assert.strictEqual(violations.length, 0, `Ambiguous-name skills missing "Use when…":\n${violations.join('\n')}`);
+  });
+});
+
+describe('Description integrity', () => {
+  test('YAML escape sequences are well-formed (no orphan \\")', () => {
+    const skills = listSkills();
+    const violations = [];
+    for (const name of skills) {
+      const line = readDescriptionLine(name);
+      if (!line) continue;
+      // Parse the quoted value: count unescaped quotes inside the value
+      const inner = line.replace(/^description:\s+"/, '').replace(/"\s*$/, '');
+      // Every \" should be escaping a quote; bare " inside is invalid
+      let i = 0;
+      let bareQuotes = 0;
+      while (i < inner.length) {
+        if (inner[i] === '\\' && inner[i + 1] === '"') {
+          i += 2;
+          continue;
+        }
+        if (inner[i] === '"') bareQuotes++;
+        i++;
+      }
+      if (bareQuotes > 0) {
+        violations.push(`${name}: ${bareQuotes} unescaped " inside description value`);
+      }
+    }
+    assert.strictEqual(violations.length, 0, `Bare quotes:\n${violations.join('\n')}`);
+  });
+});

package/compiler/__tests__/zoom-out-output.test.js

@@ -0,0 +1,112 @@
+/**
+ * Zoom-out output validation — scout v0.4 zoom-out mode produces a 3-layer Mermaid map.
+ *
+ * Validates:
+ *   - Output is parseable Mermaid (graph LR ... or graph TB)
+ *   - L0 (target) node is present and styled as "stuck"
+ *   - L1 cap: max 8 sibling files
+ *   - L2 cap: max 8 caller modules
+ *   - Total nodes never exceed L0 + 16
+ *   - Edge collapse note appears when caps hit
+ */
+
+import assert from 'node:assert';
+import { describe, test } from 'node:test';
+
+function parseMermaid(text) {
+  // Minimal validator — just need to confirm structure
+  const lines = text
+    .split('\n')
+    .map((l) => l.trim())
+    .filter(Boolean);
+  const directive = lines.find((l) => /^graph (LR|TB|RL|BT)/.test(l));
+  if (!directive) return { valid: false, error: 'missing graph directive' };
+
+  const nodes = new Set();
+  const edges = [];
+  for (const line of lines) {
+    if (line.startsWith('graph ') || line.startsWith('classDef ') || line.startsWith('%%')) continue;
+    // Extract node names from edges like "A --> B" or "A -.text.- B"
+    const edgeMatch = line.match(/^(\S+?)(?:\[[^\]]*\])?\s*(?:-->|-\.[^.]*\.-)\s*(\S+?)(?:\[[^\]]*\])?$/);
+    if (edgeMatch) {
+      nodes.add(edgeMatch[1]);
+      nodes.add(edgeMatch[2]);
+      edges.push({ from: edgeMatch[1], to: edgeMatch[2] });
+    }
+  }
+  return { valid: true, nodes: [...nodes], edges };
+}
+
+function buildZoomOutFixture({ targetName, l1Files, l2Modules, edgeCollapseNote = false }) {
+  const lines = ['graph LR', `  ${targetName}[src/auth/login.ts]:::stuck`];
+  for (let i = 0; i < l1Files; i++) {
+    lines.push(`  sibling${i}[siblingFile${i}] -.same-dir.- ${targetName}`);
+  }
+  for (let i = 0; i < l2Modules; i++) {
+    lines.push(`  caller${i}[callerModule${i}] --> ${targetName}`);
+  }
+  if (edgeCollapseNote) {
+    lines.push('  %% showing top 8 by import-frequency (>8 collapsed)');
+  }
+  lines.push('  classDef stuck fill:#ff6b6b');
+  return lines.join('\n');
+}
+
+describe('zoom-out Mermaid output', () => {
+  test('valid output parses', () => {
+    const fixture = buildZoomOutFixture({ targetName: 'target', l1Files: 3, l2Modules: 4 });
+    const parsed = parseMermaid(fixture);
+    assert.strictEqual(parsed.valid, true);
+    assert.ok(parsed.nodes.includes('target'));
+  });
+
+  test('target has classDef stuck', () => {
+    const fixture = buildZoomOutFixture({ targetName: 'target', l1Files: 1, l2Modules: 1 });
+    assert.ok(fixture.includes(':::stuck'));
+    assert.ok(fixture.includes('classDef stuck'));
+  });
+
+  test('respects L1 cap (8 max)', () => {
+    const fixture = buildZoomOutFixture({ targetName: 'target', l1Files: 8, l2Modules: 0 });
+    const parsed = parseMermaid(fixture);
+    const siblingCount = parsed.nodes.filter((n) => n.startsWith('sibling')).length;
+    assert.ok(siblingCount <= 8, `expected <=8 siblings, got ${siblingCount}`);
+  });
+
+  test('respects L2 cap (8 max)', () => {
+    const fixture = buildZoomOutFixture({ targetName: 'target', l1Files: 0, l2Modules: 8 });
+    const parsed = parseMermaid(fixture);
+    const callerCount = parsed.nodes.filter((n) => n.startsWith('caller')).length;
+    assert.ok(callerCount <= 8, `expected <=8 callers, got ${callerCount}`);
+  });
+
+  test('total node cap: target + L1 (8) + L2 (8) = 17 max', () => {
+    const fixture = buildZoomOutFixture({ targetName: 'target', l1Files: 8, l2Modules: 8 });
+    const parsed = parseMermaid(fixture);
+    assert.ok(parsed.nodes.length <= 17, `expected <=17 nodes, got ${parsed.nodes.length}`);
+  });
+
+  test('edge-collapse note included when caps hit', () => {
+    const fixture = buildZoomOutFixture({
+      targetName: 'target',
+      l1Files: 8,
+      l2Modules: 8,
+      edgeCollapseNote: true,
+    });
+    assert.ok(fixture.includes('showing top 8'));
+  });
+
+  test('rejects output without graph directive', () => {
+    const fixture = `target[src/auth/login.ts]
+  caller --> target`;
+    const parsed = parseMermaid(fixture);
+    assert.strictEqual(parsed.valid, false);
+  });
+});
+
+describe('agent.stuck signal name validity', () => {
+  test('agent.stuck conforms to signal naming pattern', () => {
+    const SIGNAL_PATTERN = /^[a-z][a-z0-9]*(\.[a-z][a-z0-9]*)+$/;
+    assert.ok(SIGNAL_PATTERN.test('agent.stuck'));
+  });
+});

package/compiler/adapters/antigravity.js

@@ -8,10 +8,22 @@
  * Antigravity project context: AGENTS.md (+ CLAUDE.md fallback)
  * Antigravity skills dir: .agents/skills/
  * Antigravity skill format: .agents/skills/{name}/SKILL.md
+ *
+ * MODEL TIER MAPPING (v2.15+):
+ * Skill frontmatter `model: opus|sonnet|haiku` (Anthropic naming) is
+ * translated to Gemini provider-correct model names. Antigravity supports
+ * both Gemini and Claude — defaulting to Gemini family since it is the
+ * native model. Unknown tier values pass through.
  */
 
 import { BRANDING_FOOTER } from '../transforms/branding.js';
 
+const MODEL_MAP = {
+  opus: 'gemini-3-pro',
+  sonnet: 'gemini-3-flash',
+  haiku: 'gemini-3-flash-lite',
+};
+
 const TOOL_MAP = {
   Read: 'read the file',
   Write: 'write/create the file',
@@ -46,7 +58,11 @@ export default {
 
   generateHeader(skill) {
     const desc = (skill.description || '').replace(/"/g, '\\"');
-    return ['---', `name: rune-${skill.name}`, `description: "${desc}"`, '---', '', ''].join('\n');
+    const lines = ['---', `name: rune-${skill.name}`, `description: "${desc}"`];
+    const translatedModel = skill.model ? MODEL_MAP[skill.model] || skill.model : null;
+    if (translatedModel) lines.push(`model: ${translatedModel}`);
+    lines.push('---', '', '');
+    return lines.join('\n');
   },
 
   generateFooter() {

package/compiler/adapters/claude.js

@@ -2,6 +2,10 @@
  * Claude Code Adapter (Passthrough)
  *
  * No transformation needed — source IS the output.
+ *
+ * MODEL TIER MAPPING (v2.15+):
+ * No-op. Claude Code's Anthropic backend understands `model: opus|sonnet|haiku`
+ * natively, so no translation is required (unlike codex/antigravity/opencode).
  */
 
 export default {

package/compiler/adapters/codex.js

@@ -8,10 +8,21 @@
  * Codex project context: AGENTS.md (equivalent to CLAUDE.md)
  * Codex skills dir: .codex/skills/
  * Codex skill format: .codex/skills/{name}/SKILL.md
+ *
+ * MODEL TIER MAPPING (v2.15+):
+ * Skill frontmatter `model: opus|sonnet|haiku` (Anthropic naming) is
+ * translated to Codex/OpenAI provider-correct model names so the field
+ * is meaningful in the compiled output. Unknown tier values pass through.
  */
 
 import { BRANDING_FOOTER } from '../transforms/branding.js';
 
+const MODEL_MAP = {
+  opus: 'gpt-5-pro',
+  sonnet: 'gpt-5',
+  haiku: 'gpt-5-mini',
+};
+
 const TOOL_MAP = {
   Read: 'read the file',
   Write: 'write/create the file',
@@ -47,7 +58,11 @@ export default {
 
   generateHeader(skill) {
     const desc = (skill.description || '').replace(/"/g, '\\"');
-    return ['---', `name: rune-${skill.name}`, `description: "${desc}"`, '---', '', ''].join('\n');
+    const lines = ['---', `name: rune-${skill.name}`, `description: "${desc}"`];
+    const translatedModel = skill.model ? MODEL_MAP[skill.model] || skill.model : null;
+    if (translatedModel) lines.push(`model: ${translatedModel}`);
+    lines.push('---', '', '');
+    return lines.join('\n');
   },
 
   generateFooter() {

package/compiler/adapters/cursor.js

@@ -3,6 +3,10 @@
  *
  * Emits .mdc rule files for .cursor/rules/ directory.
  * Uses @file references for cross-skill mesh.
+ *
+ * MODEL TIER MAPPING (v2.15+):
+ * No-op. Cursor's Anthropic API integration understands `model: opus|sonnet|haiku`
+ * natively. No translation required.
  */
 
 import { BRANDING_FOOTER } from '../transforms/branding.js';

package/compiler/adapters/generic.js

@@ -3,10 +3,21 @@
  *
  * For unknown or future platforms. Emits to .ai/rules/ directory.
  * Uses the most portable format possible.
+ *
+ * MODEL TIER MAPPING (v2.15+):
+ * Provider-agnostic — emits semantic tier hints in the markdown header.
+ * Skill frontmatter `model: opus|sonnet|haiku` is translated to
+ * `tier:heavy|mid|light`. The consuming platform resolves the tier.
  */
 
 import { BRANDING_FOOTER } from '../transforms/branding.js';
 
+const MODEL_MAP = {
+  opus: 'tier:heavy',
+  sonnet: 'tier:mid',
+  haiku: 'tier:light',
+};
+
 const TOOL_MAP = {
   Read: 'read the file',
   Write: 'write/create the file',
@@ -37,7 +48,9 @@ export default {
   },
 
   generateHeader(skill) {
-    return `# rune-${skill.name}\n\n> Rune ${skill.layer} Skill | ${skill.group}\n\n`;
+    const translatedModel = skill.model ? MODEL_MAP[skill.model] || skill.model : null;
+    const modelSuffix = translatedModel ? ` | model: ${translatedModel}` : '';
+    return `# rune-${skill.name}\n\n> Rune ${skill.layer} Skill | ${skill.group}${modelSuffix}\n\n`;
   },
 
   generateFooter() {