@rune-kit/rune 2.1.1 → 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/adapters/antigravity.js

@@ -41,7 +41,7 @@ export default {
     return [
       '',
       '---',
-      '> **Rune Skill Mesh** — 49 skills, 170+ connections',
+      '> **Rune Skill Mesh** — 58 skills, 200+ connections',
       '> Source: https://github.com/rune-kit/rune',
       '> Full experience with subagents, hooks, adaptive routing → use Rune on Claude Code.',
     ].join('\n');

package/compiler/adapters/codex.js

@@ -0,0 +1,77 @@
+/**
+ * OpenAI Codex Adapter
+ *
+ * Emits SKILL.md files into .codex/skills/{name}/ directories.
+ * Codex uses the same SKILL.md frontmatter format (name, description)
+ * with markdown body — very close to Rune's native format.
+ *
+ * Codex project context: AGENTS.md (equivalent to CLAUDE.md)
+ * Codex skills dir: .codex/skills/
+ * Codex skill format: .codex/skills/{name}/SKILL.md
+ */
+
+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 skill',
+  Agent: 'execute the workflow',
+};
+
+export default {
+  name: 'codex',
+  outputDir: '.codex/skills',
+  fileExtension: '.md',
+  skillPrefix: 'rune-',
+  skillSuffix: '',
+
+  // Codex uses directory-per-skill: .codex/skills/{name}/SKILL.md
+  useSkillDirectories: true,
+  skillFileName: 'SKILL.md',
+
+  transformReference(skillName, raw) {
+    const isBackticked = raw.startsWith('`') && raw.endsWith('`');
+    const ref = `the rune-${skillName} skill`;
+    return isBackticked ? `\`${ref}\`` : ref;
+  },
+
+  transformToolName(toolName) {
+    return TOOL_MAP[toolName] || toolName;
+  },
+
+  generateHeader(skill) {
+    const desc = (skill.description || '').replace(/"/g, '\\"');
+    return [
+      '---',
+      `name: rune-${skill.name}`,
+      `description: "${desc}"`,
+      '---',
+      '',
+      '',
+    ].join('\n');
+  },
+
+  generateFooter() {
+    return [
+      '',
+      '---',
+      '> **Rune Skill Mesh** — 58 skills, 200+ connections',
+      '> Source: https://github.com/rune-kit/rune',
+      '> Full experience with subagents, hooks, adaptive routing → use Rune on Claude Code.',
+    ].join('\n');
+  },
+
+  transformSubagentInstruction(text) {
+    return text;
+  },
+
+  postProcess(content) {
+    return content
+      .replace(/^context: fork\n/gm, '')
+      .replace(/^agent: general-purpose\n/gm, '');
+  },
+};

package/compiler/adapters/cursor.js

@@ -49,7 +49,7 @@ export default {
     return [
       '',
       '---',
-      '> **Rune Skill Mesh** — 49 skills, 170+ connections',
+      '> **Rune Skill Mesh** — 58 skills, 200+ connections',
       '> Source: https://github.com/rune-kit/rune',
       '> Full experience with subagents, hooks, adaptive routing → use Rune on Claude Code.',
     ].join('\n');

package/compiler/adapters/generic.js

@@ -42,7 +42,7 @@ export default {
     return [
       '',
       '---',
-      '> **Rune Skill Mesh** — 49 skills, 170+ connections',
+      '> **Rune Skill Mesh** — 58 skills, 200+ connections',
       '> Source: https://github.com/rune-kit/rune',
       '> Full experience with subagents, hooks, adaptive routing → use Rune on Claude Code.',
     ].join('\n');

package/compiler/adapters/index.js

@@ -10,6 +10,8 @@ import windsurf from './windsurf.js';
 import antigravity from './antigravity.js';
 import generic from './generic.js';
 import openclaw from './openclaw.js';
+import codex from './codex.js';
+import opencode from './opencode.js';
 
 const adapters = {
   claude,
@@ -18,6 +20,8 @@ const adapters = {
   antigravity,
   generic,
   openclaw,
+  codex,
+  opencode,
 };
 
 /**

package/compiler/adapters/opencode.js

@@ -0,0 +1,86 @@
+/**
+ * OpenCode Adapter
+ *
+ * Emits SKILL.md files into .opencode/skills/{name}/ directories.
+ * OpenCode uses the same SKILL.md frontmatter format (name, description)
+ * with markdown body — identical to Codex pattern.
+ *
+ * OpenCode project context: AGENTS.md (+ CLAUDE.md fallback)
+ * OpenCode skills dir: .opencode/skills/
+ * OpenCode skill format: .opencode/skills/{name}/SKILL.md
+ * OpenCode agents dir: .opencode/agents/
+ *
+ * OpenCode also searches:
+ *   .claude/skills/{name}/SKILL.md (Claude-compatible)
+ *   .agents/skills/{name}/SKILL.md (agent-compatible)
+ *
+ * @see https://opencode.ai/docs/skills/
+ * @see https://opencode.ai/docs/agents/
+ */
+
+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: 'invoke the named skill',
+  Agent: 'delegate to a subagent',
+};
+
+export default {
+  name: 'opencode',
+  outputDir: '.opencode/skills',
+  fileExtension: '.md',
+  skillPrefix: 'rune-',
+  skillSuffix: '',
+
+  // OpenCode uses directory-per-skill: .opencode/skills/{name}/SKILL.md
+  useSkillDirectories: true,
+  skillFileName: 'SKILL.md',
+
+  transformReference(skillName, raw) {
+    const isBackticked = raw.startsWith('`') && raw.endsWith('`');
+    const ref = `the rune-${skillName} skill`;
+    return isBackticked ? `\`${ref}\`` : ref;
+  },
+
+  transformToolName(toolName) {
+    return TOOL_MAP[toolName] || toolName;
+  },
+
+  generateHeader(skill) {
+    const desc = (skill.description || '').replace(/"/g, '\\"');
+    return [
+      '---',
+      `name: rune-${skill.name}`,
+      `description: "${desc}"`,
+      '---',
+      '',
+      '',
+    ].join('\n');
+  },
+
+  generateFooter() {
+    return [
+      '',
+      '---',
+      '> **Rune Skill Mesh** — 58 skills, 200+ connections',
+      '> Source: https://github.com/rune-kit/rune',
+      '> Full experience with subagents, hooks, adaptive routing → use Rune on Claude Code.',
+    ].join('\n');
+  },
+
+  transformSubagentInstruction(text) {
+    // OpenCode has native subagent support — preserve parallel agent instructions
+    return text;
+  },
+
+  postProcess(content) {
+    return content
+      .replace(/^context: fork\n/gm, '')
+      .replace(/^agent: general-purpose\n/gm, '');
+  },
+};

package/compiler/adapters/windsurf.js

@@ -42,7 +42,7 @@ export default {
     return [
       '',
       '---',
-      '> **Rune Skill Mesh** — 49 skills, 170+ connections',
+      '> **Rune Skill Mesh** — 58 skills, 200+ connections',
       '> Source: https://github.com/rune-kit/rune',
       '> Full experience with subagents, hooks, adaptive routing → use Rune on Claude Code.',
     ].join('\n');

package/compiler/bin/rune.js

@@ -46,14 +46,11 @@ function detectPlatform(projectRoot) {
   if (existsSync(path.join(projectRoot, '.windsurf'))) return 'windsurf';
   if (existsSync(path.join(projectRoot, '.agent'))) return 'antigravity';
   if (existsSync(path.join(projectRoot, '.openclaw'))) return 'openclaw';
+  if (existsSync(path.join(projectRoot, '.codex'))) return 'codex';
+  if (existsSync(path.join(projectRoot, '.opencode'))) return 'opencode';
   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 });
@@ -159,7 +156,7 @@ async function cmdBuild(projectRoot, args) {
 
   const adapter = getAdapter(platform);
   const runeRoot = config?.source || RUNE_ROOT;
-  const outputRoot = args.output || projectRoot;
+  const outputRoot = typeof args.output === 'string' ? args.output : projectRoot;
   const disabledSkills = config?.skills?.disabled || [];
   const enabledPacks = config?.extensions?.enabled || null;
 
@@ -220,6 +217,9 @@ async function cmdDoctor(projectRoot, args) {
 
 // ─── Arg Parsing ───
 
+// Flags that require a string value (not boolean)
+const VALUE_REQUIRED_FLAGS = new Set(['platform', 'output', 'disable', 'extensions']);
+
 function parseArgs(argv) {
   const args = {};
   const positional = [];
@@ -232,6 +232,9 @@ function parseArgs(argv) {
       if (next && !next.startsWith('--')) {
         args[key] = next;
         i++;
+      } else if (VALUE_REQUIRED_FLAGS.has(key)) {
+        log(`  ✗ Flag --${key} requires a value. Example: --${key} <value>`);
+        process.exit(1);
       } else {
         args[key] = true;
       }
@@ -271,7 +274,7 @@ async function main() {
       log('    doctor   Validate compiled output');
       log('');
       log('  Options:');
-      log('    --platform <name>   Override platform (cursor, windsurf, antigravity, openclaw, generic)');
+      log('    --platform <name>   Override platform (cursor, windsurf, antigravity, codex, openclaw, opencode, generic)');
       log('    --output <dir>      Override output directory');
       log('    --disable <skills>  Comma-separated skills to disable');
       log('');

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
  */