@rune-kit/rune 2.17.1 → 2.18.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>
-  64 skills · 203 connections · 40 signals · 8 platforms · MIT
+  64 skills · 203 connections · 40 signals · 13 platforms · MIT
 </p>
 
 <p align="center">
@@ -16,7 +16,7 @@
 </p>
 
 <p align="center">
-  <strong>Claude Code</strong> (native plugin) · <strong>Cursor</strong> · <strong>Windsurf</strong> · <strong>Google Antigravity</strong> · <strong>OpenAI Codex</strong> · <strong>OpenCode</strong> · any AI IDE
+  <strong>Claude Code</strong> (native plugin) · <strong>Cursor</strong> · <strong>Windsurf</strong> · <strong>Google Antigravity</strong> · <strong>OpenAI Codex</strong> · <strong>OpenCode</strong> · <strong>Aider</strong> · <strong>GitHub Copilot CLI</strong> · <strong>Gemini CLI</strong> · <strong>Qoder</strong> · <strong>Qwen Coder</strong> · any AI IDE
 </p>
 
 ## Why Rune?
@@ -83,7 +83,11 @@ _Methodology: Claude Code CLI headless mode (`claude -p --output-format json`),
 
 ---
 
-## What's New (v2.17.1 — One-Command Setup Wizard)
+## What's New (v2.18.0 — Cross-Platform Reach + Discipline Tightening)
+
+> **v2.18.0 (2026-05-15):** Compiler grew from 8 → 13 platforms with five new adapters: **Aider** (per-skill `aider/rules/` + auto-generated `.aider.conf.yml` `read:` array), **GitHub Copilot CLI** (`.github/instructions/*.instructions.md` w/ documented `applyTo` YAML), **Gemini CLI** (bundled `GEMINI.md` for single-file context), **Qoder** (`.qoder/rules/` + AGENTS.md), **Qwen Coder** (`qwen/skills/` + `QWEN.md` with `@import`). New `adapter.generateExtraFiles()` hook with path-traversal guard + frozen stats snapshot — replaces ad-hoc adapter special-cases (codex AGENTS.md migrated). Discipline tightening: `design` v0.6.0 adds Step 2.9 Rules 4/5/6 (measurable constraints, no #000/#fff/lorem ipsum, CJK-first font stack); `skill-forge` v1.9.0 adds soft `examples/` convention for output-format skills; `sentinel-env` v0.4.0 expands Tier 8 binary detection (Bun, Cargo, Deno, Volta, asdf, proto). New `CONTRIBUTING.md` "What we don't accept" non-goals section. Source: graft from `nexu-io/html-anything` (Apache-2.0). CI 1435/1435.
+
+### Previous (v2.17.1 — One-Command Setup Wizard)
 
 > **v2.17.1 (2026-05-06):** New `rune setup` interactive wizard collapses the multi-step `cd <project> && export RUNE_PRO_ROOT && rune hooks install --preset gentle --tier pro` workflow into one command — auto-detects Pro/Business tiers across env var / sibling / well-known paths, asks for scope (current project / global) + preset, installs hooks. New `--global` flag on `rune hooks install` writes to `~/.claude/settings.json` (every Claude Code session, regardless of project). Non-interactive mode via `--here` / `--global` / `--tier` / `--preset` / `--dry` flags. Anti-paywall — wizard ships in Free, NOT Pro/Business (tier-agnostic infrastructure UX). Doc sweep: README "One-Command Setup", HOOKS.md restructure, agent skill-routing row for "set up rune". CI 1376/1376.
 
@@ -243,7 +247,7 @@ The wizard auto-detects what you have:
 ```
 Rune Setup Wizard
 ──────────────────
-Free version:    2.17.1 (cached)
+Free version:    2.18.0 (cached)
 Pro detected:    sibling (../Pro) (v1.1.0)
 Business:        not detected
 

package/compiler/__tests__/adapter-model-mapping.test.js

@@ -131,6 +131,86 @@ describe('Anthropic-native adapters are no-op for model field', () => {
   });
 });
 
+describe('qoder adapter model mapping (provider-agnostic)', () => {
+  const qoder = getAdapter('qoder');
+
+  test('opus translates to tier:heavy', () => {
+    const header = qoder.generateHeader({ ...baseSkill, model: 'opus' });
+    assert.match(header, /model: tier:heavy/);
+  });
+
+  test('omitted model produces no model line', () => {
+    const header = qoder.generateHeader({ ...baseSkill });
+    assert.doesNotMatch(header, /model:/);
+  });
+});
+
+describe('copilot adapter model mapping (tier-hint comment)', () => {
+  const copilot = getAdapter('copilot');
+
+  test('opus emits tier-hint:tier:heavy as comment (Copilot ignores model field)', () => {
+    const header = copilot.generateHeader({ ...baseSkill, model: 'opus' });
+    assert.match(header, /tier-hint: tier:heavy/);
+  });
+
+  test('omitted model produces no tier-hint line', () => {
+    const header = copilot.generateHeader({ ...baseSkill });
+    assert.doesNotMatch(header, /tier-hint/);
+  });
+});
+
+describe('aider adapter model mapping (inline header)', () => {
+  const aider = getAdapter('aider');
+
+  test('opus appears as tier:heavy inline', () => {
+    const header = aider.generateHeader({ ...baseSkill, model: 'opus' });
+    assert.match(header, /tier:heavy/);
+  });
+
+  test('omitted model produces no tier line', () => {
+    const header = aider.generateHeader({ ...baseSkill });
+    assert.doesNotMatch(header, /tier:/);
+  });
+});
+
+describe('qwen adapter model mapping (Qwen family)', () => {
+  const qwen = getAdapter('qwen');
+
+  test('opus translates to qwen3-coder-plus', () => {
+    const header = qwen.generateHeader({ ...baseSkill, model: 'opus' });
+    assert.match(header, /qwen3-coder-plus/);
+  });
+
+  test('sonnet translates to qwen3-coder', () => {
+    const header = qwen.generateHeader({ ...baseSkill, model: 'sonnet' });
+    assert.match(header, /qwen3-coder(?!-)/);
+  });
+
+  test('haiku translates to qwen3-coder-flash', () => {
+    const header = qwen.generateHeader({ ...baseSkill, model: 'haiku' });
+    assert.match(header, /qwen3-coder-flash/);
+  });
+});
+
+describe('gemini adapter model mapping (Gemini family)', () => {
+  const gemini = getAdapter('gemini');
+
+  test('opus translates to gemini-2.5-pro', () => {
+    const header = gemini.generateHeader({ ...baseSkill, model: 'opus' });
+    assert.match(header, /gemini-2\.5-pro/);
+  });
+
+  test('sonnet translates to gemini-2.5-flash', () => {
+    const header = gemini.generateHeader({ ...baseSkill, model: 'sonnet' });
+    assert.match(header, /gemini-2\.5-flash/);
+  });
+
+  test('haiku translates to gemini-2.0-flash-lite', () => {
+    const header = gemini.generateHeader({ ...baseSkill, model: 'haiku' });
+    assert.match(header, /gemini-2\.0-flash-lite/);
+  });
+});
+
 describe('cross-adapter consistency', () => {
   test('all 5 non-Anthropic adapters emit a model line for opus skills', () => {
     const adapterNames = ['codex', 'antigravity', 'opencode', 'openclaw', 'generic'];

package/compiler/__tests__/adapters.test.js

@@ -4,9 +4,23 @@ import { getAdapter, listPlatforms } from '../adapters/index.js';
 
 // --- Adapter registry ---
 
-test('listPlatforms returns all 8 platform adapters', () => {
+test('listPlatforms returns all 13 platform adapters', () => {
   const adapters = listPlatforms();
-  const expected = ['claude', 'cursor', 'windsurf', 'antigravity', 'codex', 'opencode', 'openclaw', 'generic'];
+  const expected = [
+    'claude',
+    'cursor',
+    'windsurf',
+    'antigravity',
+    'codex',
+    'opencode',
+    'openclaw',
+    'generic',
+    'aider',
+    'copilot',
+    'gemini',
+    'qoder',
+    'qwen',
+  ];
   for (const name of expected) {
     assert.ok(adapters.includes(name), `missing adapter: ${name}`);
   }
@@ -35,7 +49,19 @@ const REQUIRED_METHODS = [
 
 const REQUIRED_PROPS = ['name', 'outputDir', 'fileExtension', 'skillPrefix', 'skillSuffix'];
 
-const ADAPTER_NAMES = ['cursor', 'windsurf', 'antigravity', 'codex', 'opencode', 'generic'];
+const ADAPTER_NAMES = [
+  'cursor',
+  'windsurf',
+  'antigravity',
+  'codex',
+  'opencode',
+  'generic',
+  'aider',
+  'copilot',
+  'gemini',
+  'qoder',
+  'qwen',
+];
 
 for (const adapterName of ADAPTER_NAMES) {
   describe(`${adapterName} adapter contract`, () => {
@@ -107,3 +133,89 @@ test('codex adapter uses skill directories', () => {
   assert.strictEqual(codex.useSkillDirectories, true);
   assert.strictEqual(codex.skillFileName, 'SKILL.md');
 });
+
+// --- New v2.18 adapters: shape + generateExtraFiles contract ---
+
+test('qoder adapter targets .qoder/rules and emits AGENTS.md', async () => {
+  const qoder = getAdapter('qoder');
+  assert.strictEqual(qoder.outputDir, '.qoder/rules');
+  assert.strictEqual(qoder.useSkillDirectories, false);
+  assert.strictEqual(typeof qoder.generateExtraFiles, 'function');
+  const extras = await qoder.generateExtraFiles({ stats: { skillCount: 5, packCount: 1, files: [] } });
+  assert.ok(extras.some((e) => e.path === 'AGENTS.md' && e.content.includes('Rune')));
+});
+
+test('copilot adapter targets .github/instructions with .instructions.md ext', async () => {
+  const copilot = getAdapter('copilot');
+  assert.strictEqual(copilot.outputDir, '.github/instructions');
+  assert.strictEqual(copilot.fileExtension, '.instructions.md');
+  const header = copilot.generateHeader({ name: 'cook', layer: 'L1', group: 'orchestrator', description: 'Test' });
+  // Per docs.github.com Copilot CLI custom-instructions spec, only `applyTo` is a
+  // documented frontmatter field. Description and tier-hint must live in the body.
+  assert.ok(header.includes('applyTo: "**"'));
+  assert.ok(!/^description:/m.test(header.split('---')[1] || ''), 'description must NOT appear in frontmatter');
+  const extras = await copilot.generateExtraFiles({ stats: { skillCount: 5, packCount: 1, files: [] } });
+  assert.ok(extras.some((e) => e.path === '.github/copilot-instructions.md'));
+  assert.ok(extras.some((e) => e.path === 'AGENTS.md'));
+});
+
+test('codex adapter migrated to generateExtraFiles for AGENTS.md (no longer special-cased in emitter)', async () => {
+  const codex = getAdapter('codex');
+  assert.strictEqual(typeof codex.generateExtraFiles, 'function');
+  const extras = await codex.generateExtraFiles({
+    stats: { skillCount: 64, packCount: 14, crossRefsResolved: 287, files: [] },
+  });
+  const agentsMd = extras.find((e) => e.path === 'AGENTS.md');
+  assert.ok(agentsMd, 'codex must emit AGENTS.md via generateExtraFiles');
+  assert.ok(agentsMd.content.includes('Rune'));
+  assert.ok(agentsMd.content.includes('64 core skills'));
+});
+
+test('emitter rejects absolute paths from generateExtraFiles (path-traversal guard)', async () => {
+  // Smoke: verify both qoder and gemini return relative paths only (no absolute).
+  for (const name of ['qoder', 'copilot', 'aider', 'qwen', 'gemini', 'codex']) {
+    const adapter = getAdapter(name);
+    const extras = await adapter.generateExtraFiles({
+      stats: { skillCount: 1, packCount: 0, crossRefsResolved: 0, files: ['rune-cook.md'] },
+      outputDir: '/tmp/test',
+    });
+    for (const extra of extras || []) {
+      assert.ok(!extra.path.startsWith('/'), `${name} returned absolute path: ${extra.path}`);
+      assert.ok(!/^[A-Z]:[\\/]/.test(extra.path), `${name} returned Windows absolute path: ${extra.path}`);
+    }
+  }
+});
+
+test('aider adapter emits .aider.conf.yml with read array', async () => {
+  const aider = getAdapter('aider');
+  assert.strictEqual(aider.outputDir, 'aider/rules');
+  const extras = await aider.generateExtraFiles({
+    stats: { skillCount: 2, packCount: 0, files: ['rune-cook.md', 'rune-fix.md', 'index.md'] },
+  });
+  const conf = extras.find((e) => e.path === '.aider.conf.yml');
+  assert.ok(conf);
+  assert.ok(conf.content.includes('read:'));
+  assert.ok(conf.content.includes('aider/rules/rune-cook.md'));
+  assert.ok(conf.content.includes('aider/rules/rune-fix.md'));
+  // index.md must NOT be in the read array
+  assert.ok(!conf.content.includes('aider/rules/index.md'));
+});
+
+test('qwen adapter emits QWEN.md with @import lines', async () => {
+  const qwen = getAdapter('qwen');
+  assert.strictEqual(qwen.outputDir, 'qwen/skills');
+  const extras = await qwen.generateExtraFiles({
+    stats: { skillCount: 2, packCount: 0, files: ['rune-cook.md', 'rune-fix.md'] },
+  });
+  const qwenMd = extras.find((e) => e.path === 'QWEN.md');
+  assert.ok(qwenMd);
+  assert.ok(qwenMd.content.includes('@qwen/skills/rune-cook.md'));
+  assert.ok(qwenMd.content.includes('@qwen/skills/rune-fix.md'));
+});
+
+test('gemini adapter declares generateExtraFiles for bundled GEMINI.md', () => {
+  const gemini = getAdapter('gemini');
+  assert.strictEqual(gemini.outputDir, 'gemini/skills');
+  assert.strictEqual(typeof gemini.generateExtraFiles, 'function');
+  // Full bundle test happens in pipeline test (needs filesystem) — contract checked here.
+});

package/compiler/adapters/aider.js

@@ -0,0 +1,120 @@
+/**
+ * Aider Adapter
+ *
+ * Emits per-skill convention files into aider/rules/ and a `.aider.conf.yml`
+ * at the project root with a `read:` array pointing to every rule file. Aider
+ * loads everything in `read:` automatically on each session.
+ *
+ * Aider rules dir: aider/rules/
+ * Aider rule file: aider/rules/rune-{name}.md
+ * Aider config: .aider.conf.yml (auto-discovered: home dir → repo root → cwd)
+ *
+ * @see https://aider.chat/docs/usage/conventions.html
+ * @see https://aider.chat/docs/config/aider_conf.html
+ *
+ * MODEL TIER MAPPING (v2.18+):
+ * Aider supports any provider via env vars / CLI flags. Tier hint is emitted
+ * as a comment — aider does not parse model directives from rule files.
+ */
+
+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',
+  Edit: 'edit the file',
+  Glob: 'find files by pattern',
+  Grep: 'search file contents',
+  Bash: 'run a shell command',
+  TodoWrite: 'track task progress',
+  Skill: 'follow the referenced rune-{name} convention',
+  Agent: 'execute the workflow',
+};
+
+export default {
+  name: 'aider',
+  outputDir: 'aider/rules',
+  fileExtension: '.md',
+  skillPrefix: 'rune-',
+  skillSuffix: '',
+
+  // Aider conventions are flat per-skill markdown files.
+  useSkillDirectories: false,
+
+  transformReference(skillName, raw) {
+    const isBackticked = raw.startsWith('`') && raw.endsWith('`');
+    const ref = `the rune-${skillName} convention`;
+    return isBackticked ? `\`${ref}\`` : ref;
+  },
+
+  transformToolName(toolName) {
+    return TOOL_MAP[toolName] || toolName;
+  },
+
+  generateHeader(skill) {
+    const tierHint = skill.model ? MODEL_MAP[skill.model] || skill.model : null;
+    const tierLine = tierHint ? ` | ${tierHint}` : '';
+    return `# rune-${skill.name}\n\n> Rune ${skill.layer} ${skill.group}${tierLine}\n> ${(skill.description || '').replace(/\n/g, ' ')}\n\n`;
+  },
+
+  generateFooter() {
+    return BRANDING_FOOTER;
+  },
+
+  transformSubagentInstruction(text) {
+    return text;
+  },
+
+  scriptsDir(skillName) {
+    return `rune-${skillName}-scripts`;
+  },
+
+  postProcess(content) {
+    return content.replace(/^context: fork\n/gm, '').replace(/^agent: general-purpose\n/gm, '');
+  },
+
+  // Emit `.aider.conf.yml` with `read:` array referencing every rule file +
+  // a CONVENTIONS.md as the high-level entry point.
+  generateExtraFiles({ stats }) {
+    // stats.files holds entries like 'rune-cook.md' (per-skill) and 'index.md' (autogen).
+    // Filter to per-skill rule files; aider loads everything in read[] on every session.
+    const ruleFiles = stats.files
+      .filter((f) => f.startsWith('rune-') && f.endsWith('.md') && !f.includes('/') && !f.includes('\\'))
+      .sort();
+
+    const conf = [
+      '# Auto-generated by Rune — do not edit manually.',
+      '# Aider auto-loads every file listed under `read:` on each session.',
+      'read:',
+      ...ruleFiles.map((f) => `  - aider/rules/${f}`),
+      '',
+    ].join('\n');
+
+    const conventions = [
+      '# Rune Conventions for Aider',
+      '',
+      `Rune compiles ${stats.skillCount} skills + ${stats.packCount} packs into per-skill convention files under \`aider/rules/\`. Aider auto-loads them via \`.aider.conf.yml\`.`,
+      '',
+      'When a request matches a skill (e.g. "implement", "refactor", "review"), follow the matching rune-<name> convention.',
+      '',
+      '## Loaded Conventions',
+      '',
+      ...ruleFiles.map((f) => `- \`aider/rules/${f}\``),
+      '',
+      '---',
+      '> Rune Skill Mesh — https://github.com/rune-kit/rune',
+      '',
+    ].join('\n');
+
+    return [
+      { path: '.aider.conf.yml', content: conf },
+      { path: 'CONVENTIONS.md', content: conventions },
+    ];
+  },
+};

package/compiler/adapters/codex.js

@@ -80,4 +80,37 @@ export default {
   postProcess(content) {
     return content.replace(/^context: fork\n/gm, '').replace(/^agent: general-purpose\n/gm, '');
   },
+
+  // Codex (and OpenAI's AGENTS.md convention generally) reads AGENTS.md at the
+  // project root for high-level context. Migrated from emitter.js v2.18.
+  generateExtraFiles({ stats }) {
+    const agentsMd = [
+      '# Rune — Project Configuration',
+      '',
+      '## Overview',
+      '',
+      'Rune is an interconnected skill ecosystem for AI coding assistants.',
+      `${stats.skillCount} core skills | 5-layer mesh architecture | ${stats.crossRefsResolved} connections | Multi-platform.`,
+      'Philosophy: "Less skills. Deeper connections."',
+      '',
+      'Platform: codex',
+      '',
+      '## Skills',
+      '',
+      `**${stats.skillCount} core skills** + **${stats.packCount} extension packs**`,
+      '',
+      '## Usage',
+      '',
+      'Reference skills using the `Skill` tool or delegate to subagents using the `Agent` tool.',
+      '',
+      '## Skills Directory',
+      '',
+      'Skills are located in: .codex/skills/',
+      '',
+      '---',
+      '> Rune Skill Mesh — https://github.com/rune-kit/rune',
+      '',
+    ].join('\n');
+    return [{ path: 'AGENTS.md', content: agentsMd }];
+  },
 };

package/compiler/adapters/copilot.js

@@ -0,0 +1,126 @@
+/**
+ * GitHub Copilot CLI Adapter
+ *
+ * Emits per-skill instruction files into .github/instructions/ — the documented
+ * convention for GitHub Copilot custom instructions (read by both the CLI and
+ * the GitHub Copilot IDE plugin family).
+ *
+ * Copilot instructions dir: .github/instructions/
+ * Copilot instruction file: .github/instructions/rune-{name}.instructions.md
+ * Copilot project context: AGENTS.md (Copilot Spaces / Coding Agent convention)
+ *
+ * Each .instructions.md uses YAML frontmatter with `applyTo` for path scoping.
+ * Default applyTo: "**" means "apply to all files."
+ *
+ * @see https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-custom-instructions
+ * @see https://docs.github.com/en/copilot/concepts/response-customization
+ *
+ * MODEL TIER MAPPING (v2.18+):
+ * Copilot multi-model support exposes Anthropic/OpenAI/Google providers. Tier
+ * names are emitted as a hint comment in the body — Copilot does not parse a
+ * model field, so we don't fight the platform.
+ */
+
+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',
+  Edit: 'edit the file',
+  Glob: 'find files by pattern',
+  Grep: 'search file contents',
+  Bash: 'run a shell command',
+  TodoWrite: 'track task progress',
+  Skill: 'follow the referenced instructions',
+  Agent: 'execute the workflow',
+};
+
+export default {
+  name: 'copilot',
+  outputDir: '.github/instructions',
+  fileExtension: '.instructions.md',
+  skillPrefix: 'rune-',
+  skillSuffix: '',
+
+  // Copilot instructions are flat per-skill files, not directories.
+  useSkillDirectories: false,
+
+  transformReference(skillName, raw) {
+    const isBackticked = raw.startsWith('`') && raw.endsWith('`');
+    const ref = `the rune-${skillName} instructions`;
+    return isBackticked ? `\`${ref}\`` : ref;
+  },
+
+  transformToolName(toolName) {
+    return TOOL_MAP[toolName] || toolName;
+  },
+
+  generateHeader(skill) {
+    // Per docs.github.com Copilot CLI custom-instructions spec, the only
+    // documented frontmatter key for `.instructions.md` is `applyTo`. Other
+    // metadata (description, tier hint) belongs in the markdown body so it
+    // survives parsing across CLI/IDE/extensions consistently.
+    const desc = (skill.description || '').replace(/\n/g, ' ');
+    const tierHint = skill.model ? MODEL_MAP[skill.model] || skill.model : null;
+    const lines = ['---', 'applyTo: "**"', '---', '', `# rune-${skill.name}`, '', `> ${desc}`];
+    if (tierHint) lines.push('', `<!-- tier-hint: ${tierHint} -->`);
+    lines.push('', '');
+    return lines.join('\n');
+  },
+
+  generateFooter() {
+    return BRANDING_FOOTER;
+  },
+
+  transformSubagentInstruction(text) {
+    return text;
+  },
+
+  scriptsDir(skillName) {
+    return `rune-${skillName}-scripts`;
+  },
+
+  postProcess(content) {
+    return content.replace(/^context: fork\n/gm, '').replace(/^agent: general-purpose\n/gm, '');
+  },
+
+  // Emit a top-level .github/copilot-instructions.md as the entry point + an
+  // AGENTS.md so Copilot Spaces / Coding Agent can find the project context.
+  generateExtraFiles({ stats }) {
+    const copilotIndex = [
+      '# Rune — Copilot Custom Instructions',
+      '',
+      `Per-skill instructions live under \`.github/instructions/rune-<name>.instructions.md\` (${stats.skillCount} skills + ${stats.packCount} packs). Copilot loads them based on each file's \`applyTo\` glob.`,
+      '',
+      'When a user request matches a skill\'s domain (e.g. "fix the failing test", "review this PR"), prefer following the corresponding rune-<name>.instructions.md over freestyling.',
+      '',
+      '---',
+      '> Rune Skill Mesh — https://github.com/rune-kit/rune',
+      '',
+    ].join('\n');
+
+    const agentsMd = [
+      '# Rune — Project Configuration',
+      '',
+      'Rune is an interconnected skill ecosystem for AI coding assistants.',
+      `${stats.skillCount} core skills + ${stats.packCount} extension packs.`,
+      '',
+      'Per-skill custom instructions: `.github/instructions/rune-<name>.instructions.md`',
+      '',
+      '---',
+      '> Rune Skill Mesh — https://github.com/rune-kit/rune',
+      '',
+    ].join('\n');
+
+    return [
+      { path: '.github/copilot-instructions.md', content: copilotIndex },
+      { path: 'AGENTS.md', content: agentsMd },
+    ];
+  },
+};

package/compiler/adapters/gemini.js

@@ -0,0 +1,131 @@
+/**
+ * Gemini CLI Adapter
+ *
+ * Gemini CLI loads a single GEMINI.md at project root for context. It does NOT
+ * support per-skill imports as of writing — so the canonical output is a
+ * bundled GEMINI.md with every skill concatenated under `## rune-<name>` H2
+ * sections. Per-skill files are still emitted under gemini/skills/ for human
+ * inspection and forward-compatibility if Gemini adds @import support later.
+ *
+ * Gemini context file: GEMINI.md (project root)
+ * Gemini per-skill files: gemini/skills/rune-{name}.md (forward-compat staging)
+ *
+ * @see https://github.com/google-gemini/gemini-cli
+ * @see https://geminicli.com/docs/reference/configuration/
+ *
+ * MODEL TIER MAPPING (v2.18+):
+ * Gemini CLI exposes 1.5 Pro / 1.5 Flash / 2.0 Flash etc. Anthropic tier names
+ * translate to Gemini families: opus→1.5-pro, sonnet→1.5-flash, haiku→
+ * 2.0-flash-lite. Hint only — Gemini CLI reads model from --model flag /
+ * config, not from rule body.
+ */
+
+import { readFile } from 'node:fs/promises';
+import nodePath from 'node:path';
+import { BRANDING_FOOTER } from '../transforms/branding.js';
+
+const MODEL_MAP = {
+  opus: 'gemini-2.5-pro',
+  sonnet: 'gemini-2.5-flash',
+  haiku: 'gemini-2.0-flash-lite',
+};
+
+const TOOL_MAP = {
+  Read: 'read the file',
+  Write: 'write/create the file',
+  Edit: 'edit the file',
+  Glob: 'find files by pattern',
+  Grep: 'search file contents',
+  Bash: 'run a shell command',
+  TodoWrite: 'track task progress',
+  Skill: 'follow the referenced rune-{name} section in GEMINI.md',
+  Agent: 'execute the workflow',
+};
+
+export default {
+  name: 'gemini',
+  outputDir: 'gemini/skills',
+  fileExtension: '.md',
+  skillPrefix: 'rune-',
+  skillSuffix: '',
+
+  // Per-skill files staged for forward compat; canonical entry is bundled GEMINI.md.
+  useSkillDirectories: false,
+
+  transformReference(skillName, raw) {
+    const isBackticked = raw.startsWith('`') && raw.endsWith('`');
+    const ref = `the rune-${skillName} section in GEMINI.md`;
+    return isBackticked ? `\`${ref}\`` : ref;
+  },
+
+  transformToolName(toolName) {
+    return TOOL_MAP[toolName] || toolName;
+  },
+
+  generateHeader(skill) {
+    const desc = (skill.description || '').replace(/"/g, '\\"');
+    const lines = ['---', `name: rune-${skill.name}`, `description: "${desc}"`];
+    const translatedModel = skill.model ? MODEL_MAP[skill.model] || skill.model : null;
+    if (translatedModel) lines.push(`# model-hint: ${translatedModel}`);
+    lines.push('---', '', '');
+    return lines.join('\n');
+  },
+
+  generateFooter() {
+    return BRANDING_FOOTER;
+  },
+
+  transformSubagentInstruction(text) {
+    return text;
+  },
+
+  scriptsDir(skillName) {
+    return `rune-${skillName}-scripts`;
+  },
+
+  postProcess(content) {
+    return content.replace(/^context: fork\n/gm, '').replace(/^agent: general-purpose\n/gm, '');
+  },
+
+  // Bundle every per-skill file into a single GEMINI.md with H2 section per skill.
+  // Gemini CLI loads GEMINI.md from project root as its context file. Hook contract
+  // requires relative paths (resolved against outputRoot by the emitter).
+  async generateExtraFiles({ stats, outputDir }) {
+    const skillFiles = [...stats.files]
+      .filter((f) => f.startsWith('rune-') && f.endsWith('.md') && !f.includes('/') && !f.includes('\\'))
+      .sort();
+
+    const sections = [];
+    for (const fname of skillFiles) {
+      const sourcePath = nodePath.join(outputDir, fname);
+      try {
+        const raw = await readFile(sourcePath, 'utf-8');
+        // Strip frontmatter — Gemini reads plain markdown.
+        const stripped = raw.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+        const skillName = fname.replace(/^rune-/, '').replace(/\.md$/, '');
+        sections.push(`\n\n## rune-${skillName}\n\n${stripped}`);
+      } catch {
+        // Skip unreadable per-skill file — sections array still produces valid bundle.
+      }
+    }
+
+    const geminiMd = [
+      '# Rune — Project Configuration',
+      '',
+      'Rune is an interconnected skill ecosystem for AI coding assistants.',
+      `${stats.skillCount} core skills + ${stats.packCount} extension packs, bundled below.`,
+      '',
+      'When a user request matches a skill\'s domain (e.g. "implement", "review", "debug"), follow the matching `## rune-<name>` section.',
+      '',
+      '> Per-skill files are staged in `gemini/skills/` for forward-compat if Gemini CLI adds @import support.',
+      '',
+      ...sections,
+      '',
+      '---',
+      '> Rune Skill Mesh — https://github.com/rune-kit/rune',
+      '',
+    ].join('\n');
+
+    return [{ path: 'GEMINI.md', content: geminiMd }];
+  },
+};