@rune-kit/rune 2.27.0 → 2.29.0

package/compiler/__tests__/setup.test.js

@@ -397,6 +397,65 @@ describe('runSetup — Pro skill installation (regression: rune:autopilot Unknow
 
     assert.deepStrictEqual(result.skillResults, []);
   });
+
+  test('installs Codex tier skills into project .agents/skills', async () => {
+    const projectRoot = path.join(tmpRoot, 'codex-project');
+    await mkdir(path.join(projectRoot, '.codex'), { recursive: true });
+    await seedTier(projectRoot, 'pro', { skills: ['autopilot'] });
+    const runeRoot = await seedFakeRuneRoot(tmpRoot);
+
+    const result = await runSetup({
+      projectRoot,
+      runeRoot,
+      args: { here: true, platform: 'codex', preset: 'gentle', tier: 'pro' },
+    });
+
+    assert.strictEqual(result.skillTarget.source, 'codex-project');
+    assert.deepStrictEqual(result.platforms, ['codex']);
+    assert.ok(existsSync(path.join(projectRoot, '.codex', 'hooks.json')));
+    const installed = path.join(projectRoot, '.agents', 'skills', 'rune-autopilot', 'SKILL.md');
+    assert.ok(existsSync(installed));
+    const content = readFileSync(installed, 'utf-8');
+    assert.match(content, /^name: rune-autopilot$/m);
+    assert.doesNotMatch(content, /^context: fork$/m);
+    assert.doesNotMatch(content, /^agent: general-purpose$/m);
+  });
+
+  test('installs tier skills into every detected non-Claude platform using native adapters', async () => {
+    const projectRoot = path.join(tmpRoot, 'multi-project');
+    await mkdir(path.join(projectRoot, '.cursor'), { recursive: true });
+    await mkdir(path.join(projectRoot, '.windsurf'), { recursive: true });
+    await seedTier(projectRoot, 'business', { skills: ['quarterly-review'] });
+    const runeRoot = await seedFakeRuneRoot(tmpRoot);
+
+    const result = await runSetup({
+      projectRoot,
+      runeRoot,
+      args: { here: true, platform: 'all', preset: 'gentle', tier: 'business' },
+    });
+
+    assert.deepStrictEqual(result.platforms.sort(), ['cursor', 'windsurf']);
+    assert.ok(existsSync(path.join(projectRoot, '.cursor', 'skills', 'rune-quarterly-review', 'SKILL.md')));
+    assert.ok(existsSync(path.join(projectRoot, '.windsurf', 'skills', 'rune-quarterly-review', 'SKILL.md')));
+    assert.deepStrictEqual(result.skillResults.map((entry) => entry.platform).sort(), ['cursor', 'windsurf']);
+  });
+
+  test('Codex dry-run reports tier skills on a fresh project without creating directories', async () => {
+    const projectRoot = path.join(tmpRoot, 'fresh-codex-project');
+    await mkdir(projectRoot, { recursive: true });
+    await seedTier(projectRoot, 'business', { skills: ['launch-product'] });
+    const runeRoot = await seedFakeRuneRoot(tmpRoot);
+
+    const result = await runSetup({
+      projectRoot,
+      runeRoot,
+      args: { here: true, platform: 'codex', preset: 'gentle', tier: 'business', dry: true },
+    });
+
+    assert.deepStrictEqual(result.skillResults[0].installed, ['launch-product']);
+    assert.strictEqual(result.skillResults[0].reason, null);
+    assert.ok(!existsSync(path.join(projectRoot, '.agents')));
+  });
 });
 
 describe('formatSetupResult', () => {

package/compiler/__tests__/status.test.js

@@ -2,6 +2,7 @@ import assert from 'node:assert';
 import path from 'node:path';
 import { describe, test } from 'node:test';
 import { fileURLToPath } from 'node:url';
+import { checkMeshIntegrity } from '../doctor.js';
 import { collectStats, renderStatus, renderStatusJson } from '../status.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -42,6 +43,11 @@ describe('collectStats', () => {
     assert.ok(parseFloat(stats.avgConnections) > 1);
   });
 
+  test('uses the same canonical outbound connection count as doctor', async () => {
+    const [stats, mesh] = await Promise.all([collectStats(RUNE_ROOT), checkMeshIntegrity(RUNE_ROOT)]);
+    assert.strictEqual(stats.totalConnections, mesh.stats.connections);
+  });
+
   test('discovers free packs', async () => {
     const stats = await collectStats(RUNE_ROOT);
     assert.ok(stats.freePacks.length >= 14);
@@ -203,7 +209,7 @@ describe('renderStatus', () => {
     if (stats.bizPacks.length > 0) {
       const output = renderStatus(stats);
       assert.ok(output.includes('Business Packs'));
-      assert.ok(output.includes('@rune-biz/'));
+      assert.ok(output.includes('@rune-pro/'));
     }
   });
 

package/compiler/__tests__/tier-override.test.js

@@ -11,7 +11,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { describe, test } from 'node:test';
-import { discoverTieredPacks } from '../emitter.js';
+import { discoverTieredPacks, discoverTieredSkills } from '../emitter.js';
 
 /**
  * Create a temp directory structure with PACK.md files for testing
@@ -197,3 +197,44 @@ describe('discoverTieredPacks', () => {
     }
   });
 });
+
+describe('discoverTieredSkills', () => {
+  test('includes standalone Pro and Business skills and applies tier priority', async () => {
+    const root = mkdtempSync(path.join(tmpdir(), 'rune-tier-skills-'));
+    try {
+      const freeSkills = path.join(root, 'Free', 'skills');
+      const proExtensions = path.join(root, 'Pro', 'extensions');
+      const businessExtensions = path.join(root, 'Business', 'extensions');
+      for (const [skillsDir, names] of [
+        [freeSkills, ['cook', 'shared']],
+        [path.join(root, 'Pro', 'skills'), ['autopilot', 'shared']],
+        [path.join(root, 'Business', 'skills'), ['launch-product', 'shared']],
+      ]) {
+        for (const name of names) {
+          const dir = path.join(skillsDir, name);
+          mkdirSync(dir, { recursive: true });
+          writeFileSync(path.join(dir, 'SKILL.md'), `---\nname: ${name}\n---\n# ${name}\n`);
+        }
+      }
+      mkdirSync(proExtensions, { recursive: true });
+      mkdirSync(businessExtensions, { recursive: true });
+
+      const skills = await discoverTieredSkills(freeSkills, {
+        pro: proExtensions,
+        business: businessExtensions,
+      });
+
+      assert.deepStrictEqual(
+        skills.map(({ name, tier }) => [name, tier]),
+        [
+          ['autopilot', 'pro'],
+          ['cook', 'free'],
+          ['launch-product', 'business'],
+          ['shared', 'business'],
+        ],
+      );
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

package/compiler/__tests__/transforms.test.js

@@ -2,6 +2,7 @@ import assert from 'node:assert';
 import { describe, test } from 'node:test';
 import { addBranding } from '../transforms/branding.js';
 import { transformCrossReferences } from '../transforms/cross-references.js';
+import { transformSubagents } from '../transforms/subagents.js';
 import { transformToolNames } from '../transforms/tool-names.js';
 
 // --- Mock adapter ---
@@ -75,6 +76,20 @@ describe('transformToolNames', () => {
   });
 });
 
+describe('transformSubagents', () => {
+  const input = 'Launch 3 parallel agents as independent Task agents.';
+
+  test('preserves native Codex subagent instructions', () => {
+    assert.strictEqual(transformSubagents(input, { name: 'codex' }), input);
+  });
+
+  test('keeps sequential fallback for platforms without native subagents', () => {
+    const result = transformSubagents(input, { name: 'generic' });
+    assert.notStrictEqual(result, input);
+    assert.match(result, /sequentially/);
+  });
+});
+
 // --- Branding transform ---
 
 describe('addBranding', () => {

package/compiler/adapters/codex.js

@@ -21,18 +21,21 @@
  * Codex GPT-5.6 tiers (verified against codex-cli 0.144.1 + developers.openai.com/codex/models):
  *   sol  = flagship/complex → opus
  *   terra = balanced everyday → sonnet
- *   luna = fast/affordable → haiku
+ *   terra at low effort = fast/affordable → haiku
  * Codex also exposes `model_reasoning_effort = minimal|low|medium|high|xhigh`
  * (a config.toml key, not per-skill frontmatter) — Rune surfaces the tier→effort
  * suggestion in AGENTS.md rather than emitting a speculative per-skill field.
  */
 
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
 import { BRANDING_FOOTER } from '../transforms/branding.js';
 
 const MODEL_MAP = {
   opus: 'gpt-5.6-sol',
   sonnet: 'gpt-5.6-terra',
-  haiku: 'gpt-5.6-luna',
+  haiku: 'gpt-5.6-terra',
 };
 
 // Suggested config.toml `model_reasoning_effort` per tier (global key, documented in AGENTS.md).
@@ -78,8 +81,6 @@ export default {
   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: ${translatedModel}`);
     lines.push('---', '', '');
     return lines.join('\n');
   },
@@ -102,25 +103,27 @@ export default {
 
   // 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 = [
+  async generateExtraFiles({ stats, outputRoot }) {
+    const runeBlock = [
+      '<!-- rune:codex:start -->',
       '# 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.`,
+      `${stats.coreSkillCount ?? stats.skillCount} core skills${stats.tierSkillCount ? ` + ${stats.tierSkillCount} tier 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**`,
+      `**${stats.coreSkillCount ?? stats.skillCount} core skills**${stats.tierSkillCount ? ` + **${stats.tierSkillCount} tier skills**` : ''} + **${stats.packCount} extension packs**`,
       '',
       '## Usage',
       '',
-      'Reference skills using the `Skill` tool or delegate to subagents using the `Agent` tool.',
+      'Mention a skill as `$rune-<name>` or let Codex activate it from the task description.',
+      'When an applicable Rune skill requests delegation, Codex may run bounded subagents in parallel.',
       '',
       '## Skills Directory',
       '',
@@ -134,12 +137,86 @@ export default {
       `- sonnet → \`${MODEL_MAP.sonnet}\` (\`model_reasoning_effort = "${REASONING_EFFORT_MAP.sonnet}"\`) — code / edit / review`,
       `- haiku → \`${MODEL_MAP.haiku}\` (\`model_reasoning_effort = "${REASONING_EFFORT_MAP.haiku}"\`) — scan / read-only`,
       '',
-      'Set `model` + `model_reasoning_effort` in `~/.codex/config.toml` to match the tier of the task.',
+      'Generated project-scoped roles live in `.codex/agents/` so spawned agents can apply these settings natively.',
       '',
       '---',
       '> Rune Skill Mesh — https://github.com/rune-kit/rune',
+      '<!-- rune:codex:end -->',
       '',
     ].join('\n');
-    return [{ path: 'AGENTS.md', content: agentsMd }];
+
+    const agentsMd = await mergeAgentsMd(outputRoot, runeBlock);
+    return [
+      { path: 'AGENTS.md', content: agentsMd },
+      {
+        path: '.codex/agents/rune-heavy.toml',
+        content: renderAgentRole({
+          name: 'rune_heavy',
+          description: 'Rune worker for architecture, security, planning, and other high-complexity tasks.',
+          model: MODEL_MAP.opus,
+          effort: REASONING_EFFORT_MAP.opus,
+          instructions:
+            'Follow the applicable Rune skill exactly. Prioritize correctness, explicit assumptions, impact analysis, and complete verification.',
+        }),
+      },
+      {
+        path: '.codex/agents/rune-standard.toml',
+        content: renderAgentRole({
+          name: 'rune_standard',
+          description: 'Rune worker for implementation, debugging, review, and everyday engineering tasks.',
+          model: MODEL_MAP.sonnet,
+          effort: REASONING_EFFORT_MAP.sonnet,
+          instructions:
+            'Follow the applicable Rune skill exactly. Keep changes scoped, preserve user work, and verify behavior before reporting completion.',
+        }),
+      },
+      {
+        path: '.codex/agents/rune-fast.toml',
+        content: renderAgentRole({
+          name: 'rune_fast',
+          description: 'Read-heavy Rune worker for scouting, dependency checks, and focused evidence gathering.',
+          model: MODEL_MAP.haiku,
+          effort: REASONING_EFFORT_MAP.haiku,
+          instructions:
+            'Stay read-only unless the parent explicitly requests edits. Return concise evidence with file and line references.',
+        }),
+      },
+    ];
   },
 };
+
+const RUNE_AGENTS_START = '<!-- rune:codex:start -->';
+const RUNE_AGENTS_END = '<!-- rune:codex:end -->';
+
+async function mergeAgentsMd(outputRoot, runeBlock) {
+  if (!outputRoot) return runeBlock;
+
+  const agentsPath = path.join(outputRoot, 'AGENTS.md');
+  if (!existsSync(agentsPath)) return runeBlock;
+
+  const existing = await readFile(agentsPath, 'utf-8');
+  const start = existing.indexOf(RUNE_AGENTS_START);
+  const end = existing.indexOf(RUNE_AGENTS_END);
+  if (start !== -1 && end > start) {
+    const after = end + RUNE_AGENTS_END.length;
+    return `${existing.slice(0, start)}${runeBlock}${existing.slice(after)}`;
+  }
+
+  // Migrate files produced by Rune versions before managed markers existed.
+  if (existing.trimStart().startsWith('# Rune — Project Configuration')) return runeBlock;
+
+  return `${existing.trimEnd()}\n\n${runeBlock}`;
+}
+
+function renderAgentRole({ name, description, model, effort, instructions }) {
+  return [
+    `name = "${name}"`,
+    `description = "${description}"`,
+    `model = "${model}"`,
+    `model_reasoning_effort = "${effort}"`,
+    'developer_instructions = """',
+    instructions,
+    '"""',
+    '',
+  ].join('\n');
+}

package/compiler/adapters/hooks/codex.js

@@ -0,0 +1,178 @@
+/**
+ * OpenAI Codex hooks adapter.
+ *
+ * Target: `.codex/hooks.json` — Codex-native lifecycle hooks. Codex currently
+ * skips handlers marked `async`, so Rune emits every command synchronously and
+ * relies on the preset's `--gentle` flag for warn-only behavior.
+ */
+
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import {
+  appendHookBlock,
+  detectPreset,
+  stripHooksBySkill,
+  stripRuneHooks,
+  summarizeRuneHooks,
+} from '../../commands/hooks/merge.js';
+import { buildPreset, WIRED_SKILLS } from '../../commands/hooks/presets.js';
+
+export const id = 'codex';
+export const HOOKS_REL_PATH = '.codex/hooks.json';
+
+const RUNE_DESCRIPTION = 'Rune lifecycle hooks for OpenAI Codex.';
+
+export function detect(projectRoot) {
+  return existsSync(path.join(projectRoot, '.codex'));
+}
+
+export async function emit({ preset, projectRoot, tierManifests = [] }) {
+  if (preset === 'off' && tierManifests.length === 0) return uninstall({ projectRoot });
+  if (preset !== 'off' && preset !== 'strict' && preset !== 'gentle') {
+    throw new Error(`codex adapter: invalid preset '${preset}'`);
+  }
+
+  const hooksPath = path.join(projectRoot, HOOKS_REL_PATH);
+  const existing = await readJson(hooksPath);
+  let merged = stripRuneHooks(existing);
+  const notes = [
+    'Codex requires review/trust for new or changed project hooks. Open `/hooks` after installation.',
+    'Codex does not execute async command hooks; Rune emitted synchronous handlers with preset-controlled behavior.',
+  ];
+
+  if (!merged.description) merged.description = RUNE_DESCRIPTION;
+  if (preset !== 'off') {
+    merged = appendHookBlock(merged, normalizeBlock(buildPreset(preset)));
+  }
+
+  for (const manifest of tierManifests) {
+    const overrideKeys = Object.keys(manifest.overrides || {});
+    if (overrideKeys.length > 0) merged = stripHooksBySkill(merged, overrideKeys);
+
+    const tierBlock = buildCodexTierBlock(manifest);
+    if (Object.keys(tierBlock.hooks).length > 0) {
+      merged = appendHookBlock(merged, tierBlock);
+    }
+    if (tierBlock.skipped.length > 0) {
+      notes.push(`${manifest.tier}: skipped Codex-unsupported entries (${tierBlock.skipped.join(', ')}).`);
+    }
+  }
+
+  return {
+    files: [{ path: hooksPath, content: `${JSON.stringify(merged, null, 2)}\n` }],
+    notes,
+  };
+}
+
+export async function uninstall({ projectRoot }) {
+  const hooksPath = path.join(projectRoot, HOOKS_REL_PATH);
+  if (!existsSync(hooksPath)) {
+    return { files: [], notes: ['no .codex/hooks.json — nothing to uninstall'] };
+  }
+
+  const existing = await readJson(hooksPath);
+  const stripped = stripRuneHooks(existing);
+  const keys = Object.keys(stripped);
+  const isRuneOnlyShell = keys.length === 1 && keys[0] === 'description' && stripped.description === RUNE_DESCRIPTION;
+
+  return {
+    files: [{ path: hooksPath, content: isRuneOnlyShell ? null : `${JSON.stringify(stripped, null, 2)}\n` }],
+    notes: [],
+  };
+}
+
+export async function status(projectRoot) {
+  const hooksPath = path.join(projectRoot, HOOKS_REL_PATH);
+  if (!existsSync(hooksPath)) {
+    return {
+      installed: false,
+      preset: null,
+      wired: [],
+      missing: [...WIRED_SKILLS],
+      notes: ['no .codex/hooks.json'],
+    };
+  }
+
+  const settings = await readJson(hooksPath);
+  const summary = summarizeRuneHooks(settings);
+  const preset = detectPreset(settings);
+  const wired = Array.from(new Set(Object.values(summary.events).flat()));
+  return {
+    installed: summary.total > 0,
+    preset: preset === 'none' ? null : preset,
+    wired,
+    missing: WIRED_SKILLS.filter((skill) => !wired.includes(skill)),
+    events: summary.events,
+    notes: ['Use `/hooks` in Codex to inspect the current trust state.'],
+  };
+}
+
+function normalizeBlock(block) {
+  const hooks = {};
+  for (const [event, groups] of Object.entries(block.hooks || {})) {
+    hooks[event] = groups.map((group) => {
+      const normalized = {
+        ...group,
+        hooks: group.hooks.map(normalizeCommand),
+      };
+      if (event === 'UserPromptSubmit' || event === 'Stop') delete normalized.matcher;
+      return normalized;
+    });
+  }
+  return { hooks };
+}
+
+function normalizeCommand(entry) {
+  const { async: _unsupported, ...normalized } = entry;
+  const commandWindows = toWindowsCommand(normalized.command);
+  if (commandWindows !== normalized.command) normalized.commandWindows = commandWindows;
+  return normalized;
+}
+
+function buildCodexTierBlock(manifest) {
+  const hooks = {};
+  const skipped = [];
+
+  for (const entry of manifest.entries) {
+    if (entry.event === 'statusLine' || entry.claudeOnly || entry.platforms?.codex === 'unsupported') {
+      skipped.push(entry.id || entry.skill);
+      continue;
+    }
+
+    const event = entry.event;
+    const matcher = entry.matcher || '.*';
+    if (!hooks[event]) hooks[event] = [];
+    let group = hooks[event].find((candidate) => candidate.matcher === matcher);
+    if (!group) {
+      group = { matcher, hooks: [] };
+      hooks[event].push(group);
+    }
+    group.hooks.push(
+      normalizeCommand({
+        type: 'command',
+        command: entry.command,
+      }),
+    );
+  }
+
+  return { ...normalizeBlock({ hooks }), skipped };
+}
+
+function toWindowsCommand(command) {
+  if (typeof command !== 'string') return command;
+  return command.replace(/\$\{([A-Z][A-Z0-9_]*)\}/g, '%$1%');
+}
+
+async function readJson(hooksPath) {
+  if (!existsSync(hooksPath)) return {};
+  const raw = await readFile(hooksPath, 'utf-8');
+  if (!raw.trim()) return {};
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `${hooksPath} is not valid JSON — fix it manually or delete the file and re-run \`rune hooks install --platform codex\`. (${err.message})`,
+    );
+  }
+}

package/compiler/adapters/hooks/index.js

@@ -15,11 +15,13 @@
 
 import * as antigravity from './antigravity.js';
 import * as claude from './claude.js';
+import * as codex from './codex.js';
 import * as cursor from './cursor.js';
 import * as windsurf from './windsurf.js';
 
 export const ADAPTERS = Object.freeze({
   claude,
+  codex,
   cursor,
   windsurf,
   antigravity,
@@ -55,6 +57,14 @@ export const CAPABILITIES = Object.freeze({
     stop: true,
     notes: 'Full hook parity — PreToolUse/PostToolUse/Stop all supported.',
   },
+  codex: {
+    maturity: 'stable',
+    preToolEdit: true,
+    preToolBash: true,
+    postToolEdit: true,
+    stop: true,
+    notes: 'Native hooks via `.codex/hooks.json`; operator trust is required before first execution.',
+  },
   cursor: {
     maturity: 'beta',
     preToolEdit: 'rule-injection',

package/compiler/adapters/openclaw.js

@@ -105,7 +105,7 @@ export default {
       id: 'rune',
       name: 'Rune',
       kind: 'skills',
-      description: `${skills.length}-skill mesh for AI coding assistants. Routes all code tasks through specialized skills. 203 sync connections + 40 async signals, 14 extension packs.`,
+      description: `${skills.length}-skill mesh for AI coding assistants. Routes all code tasks through specialized skills. 248 sync connections + 45 async signals, 14 extension packs.`,
       version: pluginJson.version || '0.0.0',
       skills: ['./skills'],
       artifactConvention: {
@@ -170,7 +170,7 @@ export default {
 
 > Less skills. Deeper connections.
 
-**${skills.length}-skill mesh** for AI coding assistants — 5-layer architecture, 215+ connections, 14 extension packs.
+**${skills.length}-skill mesh** for AI coding assistants — 5-layer architecture, 248 connections + 45 signals, 14 extension packs.
 
 ## Install
 

package/compiler/bin/rune.js

@@ -63,9 +63,10 @@ function detectPlatform(projectRoot) {
   if (existsSync(path.join(projectRoot, '.claude-plugin'))) return 'claude';
   if (existsSync(path.join(projectRoot, '.cursor'))) return 'cursor';
   if (existsSync(path.join(projectRoot, '.windsurf'))) return 'windsurf';
-  if (existsSync(path.join(projectRoot, '.agents'))) return 'antigravity';
-  if (existsSync(path.join(projectRoot, '.openclaw'))) return 'openclaw';
   if (existsSync(path.join(projectRoot, '.codex'))) return 'codex';
+  if (existsSync(path.join(projectRoot, '.agents', 'skills'))) return 'codex';
+  if (existsSync(path.join(projectRoot, '.antigravity'))) return 'antigravity';
+  if (existsSync(path.join(projectRoot, '.openclaw'))) return 'openclaw';
   if (existsSync(path.join(projectRoot, '.opencode'))) return 'opencode';
   return null;
 }
@@ -655,7 +656,7 @@ async function cmdHooks(projectRoot, args, subcommand) {
       '    status [--platform <name>|all] [--tier pro|business]          Show active preset, wired skills, tier coverage',
     );
     log('');
-    log('  Platforms: claude, cursor, windsurf, antigravity (auto-detected if omitted)');
+    log('  Platforms: claude, codex, cursor, windsurf, antigravity (auto-detected if omitted)');
     log('  Tiers: pro, business — requires $RUNE_PRO_ROOT / $RUNE_BUSINESS_ROOT env var or monorepo sibling.');
     log('  Options:');
     log('    --dry    Preview changes without writing');
@@ -899,7 +900,7 @@ async function main() {
       log('               [--days <n>]  Lookback window for gate counts (default: 30)');
       log('    hooks      Install/uninstall/status for multi-platform auto-discipline');
       log(
-        '               hooks install [--preset gentle|strict|off] [--platform claude|cursor|windsurf|antigravity|all] [--global]',
+        '               hooks install [--preset gentle|strict|off] [--platform claude|codex|cursor|windsurf|antigravity|all] [--global]',
       );
       log('               hooks uninstall [--platform <name>|all]');
       log('               hooks status [--platform <name>|all]');

package/compiler/commands/hooks/install.js

@@ -1,5 +1,5 @@
 /**
- * `rune hooks install [--preset strict|gentle|off] [--platform claude|cursor|windsurf|antigravity|all]`
+ * `rune hooks install [--preset strict|gentle|off] [--platform claude|codex|cursor|windsurf|antigravity|all]`
  *
  * Writes Rune-managed hook/rule/workflow entries for one or more platforms.
  * Idempotent: re-running replaces existing Rune entries, preserves user entries.
@@ -41,7 +41,7 @@ export async function installHooks(projectRoot, args = {}) {
       results: [],
       written: false,
       notes: [
-        'No target platform detected. Create `.claude/`, `.cursor/`, `.windsurf/`, or `.antigravity/` first, or pass `--platform <name>`.',
+        'No target platform detected. Create `.claude/`, `.codex/`, `.cursor/`, `.windsurf/`, or `.antigravity/` first, or pass `--platform <name>`.',
         ...tierNotes,
       ],
     };

package/compiler/commands/hooks/status.js

@@ -34,7 +34,7 @@ export async function hookStatus(projectRoot, runeRoot, args = {}) {
       tiers,
       missingInRepo,
       notes: [
-        'No target platform detected. Create `.claude/`, `.cursor/`, `.windsurf/`, or `.antigravity/` first, or pass `--platform <name>`.',
+        'No target platform detected. Create `.claude/`, `.codex/`, `.cursor/`, `.windsurf/`, or `.antigravity/` first, or pass `--platform <name>`.',
       ],
     };
   }