@rune-kit/rune 2.4.0 → 2.7.0

package/hooks/intent-router/index.cjs

@@ -0,0 +1,108 @@
+// Rune Intent Router Hook — Compiled Intent Mesh (CIM)
+// Auto-suggests skill routing based on user prompt analysis
+// Runs as UserPromptSubmit hook — scores prompt against compiled skill-index.json
+//
+// Key difference from runtime scoring approaches:
+// - Compile-time generated index (zero runtime deps)
+// - Mesh-aware chain prediction (uses actual connection graph)
+// - Works on all platforms (index ships with every build)
+
+const fs = require('fs');
+const path = require('path');
+
+// Read user prompt from Claude Code hook stdin
+let input = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  let userPrompt = '';
+  try {
+    const parsed = JSON.parse(input);
+    userPrompt = parsed.user_prompt || parsed.prompt || parsed.content || '';
+  } catch {
+    // Raw text input
+    userPrompt = input.trim();
+  }
+
+  if (!userPrompt || userPrompt.length < 3) {
+    process.exit(0);
+  }
+
+  // Find skill-index.json — check multiple locations
+  const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT || path.resolve(__dirname, '../..');
+  const candidates = [
+    path.join(pluginRoot, '.cursor', 'rules', 'skill-index.json'),
+    path.join(pluginRoot, '.windsurf', 'rules', 'skill-index.json'),
+    path.join(pluginRoot, 'dist', 'cursor', 'skill-index.json'),
+    path.join(pluginRoot, 'dist', 'generic', 'skill-index.json'),
+    // Also check .rune/ for locally cached index
+    path.join(process.cwd(), '.rune', 'skill-index.json'),
+  ];
+
+  let index = null;
+  for (const candidate of candidates) {
+    try {
+      if (fs.existsSync(candidate)) {
+        index = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
+        break;
+      }
+    } catch {
+      // Try next candidate
+    }
+  }
+
+  if (!index || !index.intents) {
+    // No index available — exit silently (not an error, just not built yet)
+    process.exit(0);
+  }
+
+  // Score prompt against intent patterns
+  const promptLower = userPrompt.toLowerCase();
+  const scores = [];
+
+  for (const [skillName, intent] of Object.entries(index.intents)) {
+    let score = 0;
+
+    for (const keyword of intent.keywords) {
+      if (promptLower.includes(keyword)) {
+        // Exact word boundary match scores higher
+        const wordBoundary = new RegExp(`\\b${keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
+        score += wordBoundary.test(userPrompt) ? 3 : 1;
+      }
+    }
+
+    // Layer priority boost: L1 orchestrators get a small bonus (they're entry points)
+    if (intent.layer === 'L1') score += 1;
+
+    if (score > 0) {
+      scores.push({ skill: skillName, score, chain: intent.chain, model: intent.model, layer: intent.layer });
+    }
+  }
+
+  if (scores.length === 0) {
+    process.exit(0);
+  }
+
+  // Sort by score descending, take top match
+  scores.sort((a, b) => b.score - a.score);
+  const top = scores[0];
+
+  // Only suggest if confidence is reasonable (score >= 3 = at least one strong keyword match)
+  if (top.score < 3) {
+    process.exit(0);
+  }
+
+  // Format chain for display
+  const chainDisplay = top.chain.slice(0, 4).join(' → ');
+  const alternates = scores.slice(1, 3).map((s) => s.skill).join(', ');
+
+  // Output routing suggestion
+  console.log(`\n🧭 [Rune intent-router] Suggested: rune:${top.skill} (${top.layer}, ${top.model})`);
+  console.log(`   Chain: ${chainDisplay}`);
+  if (alternates) {
+    console.log(`   Also consider: ${alternates}`);
+  }
+  console.log('');
+
+  process.exit(0);
+});

package/hooks/pre-tool-guard/index.cjs

@@ -1,68 +1,177 @@
-// Rune Pre-Tool Guard Hook
-// Preventive security gate — warns before AI reads/edits sensitive files
-// Runs as PreToolUse hook for Read, Write, Edit tools
-
-const path = require('path');
-
-// Read tool_input from Claude Code hook stdin
-let input = '';
-process.stdin.setEncoding('utf-8');
-process.stdin.on('data', (chunk) => { input += chunk; });
-process.stdin.on('end', () => {
-  let toolInput = {};
-  try {
-    const parsed = JSON.parse(input);
-    toolInput = parsed.tool_input || parsed;
-  } catch {
-    // If no stdin or parse fails, exit cleanly (non-blocking)
-    process.exit(0);
-  }
-
-  const filePath = toolInput.file_path || toolInput.path || '';
-  if (!filePath) process.exit(0);
-
-  const basename = path.basename(filePath);
-  const normalized = filePath.replace(/\\/g, '/');
-
-  // Sensitive file patterns
-  const sensitivePatterns = [
-    /^\.env$/,                         // .env exactly
-    /^\.env\.[^e]/,                    // .env.* but NOT .env.example
-    /\.pem$/,
-    /\.key$/,
-    /\.p12$/,
-    /\.pfx$/,
-    /^credentials\.json$/,
-    /\.secret$/,
-    /^\.netrc$/,
-    /^id_rsa$/,
-    /^id_ed25519$/,
-    /^id_ecdsa$/,
-    /^\.ssh\//,
-    /private.*key/i,
-    /secret.*key/i,
-  ];
-
-  // Exclude safe exceptions
-  const safeExceptions = [
-    /\.env\.example$/,
-    /\.env\.sample$/,
-    /\.env\.template$/,
-    /\.env\.test$/,
-    /test.*credential/i,
-    /fixture/i,
-    /mock/i,
-  ];
-
-  const isSensitive = sensitivePatterns.some((p) => p.test(basename) || p.test(normalized));
-  const isSafe = safeExceptions.some((p) => p.test(basename) || p.test(normalized));
-
-  if (isSensitive && !isSafe) {
-    // Output warning to user — does NOT hard-block (developer may legitimately need access)
-    console.log(`\n⚠ [Rune pre-tool-guard] Sensitive file detected: ${filePath}`);
-    console.log('  This file may contain secrets. Confirm this access is intentional.');
-    console.log('  If scanning for secrets, use /rune sentinel instead.\n');
-  }
-
-  process.exit(0);
-});
+// Rune Pre-Tool Guard Hook — Privacy Mesh
+// Three-tier security gate: ALLOW / WARN / BLOCK
+// Configurable via .rune/privacy.json per project
+// Skill-aware: sentinel/review can access files other skills cannot
+//
+// Upgrades over basic path matching:
+// - Per-project .rune/privacy.json config (custom patterns + overrides)
+// - Three tiers: ALLOW (silent), WARN (log), BLOCK (exit code 2)
+// - Content-aware: scans first bytes for secret patterns on WARN files
+
+const fs = require('fs');
+const path = require('path');
+
+// Read tool_input from Claude Code hook stdin
+let input = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  let toolInput = {};
+  let toolName = '';
+  try {
+    const parsed = JSON.parse(input);
+    toolInput = parsed.tool_input || parsed;
+    toolName = parsed.tool_name || '';
+  } catch {
+    // If no stdin or parse fails, exit cleanly (non-blocking)
+    process.exit(0);
+  }
+
+  const filePath = toolInput.file_path || toolInput.path || '';
+  if (!filePath) process.exit(0);
+
+  const basename = path.basename(filePath);
+  const normalized = filePath.replace(/\\/g, '/');
+
+  // Load project-specific privacy config
+  const privacyConfig = loadPrivacyConfig();
+
+  // Default sensitive file patterns — BLOCK tier (hard block)
+  const blockPatterns = [
+    /^id_rsa$/,
+    /^id_ed25519$/,
+    /^id_ecdsa$/,
+    /\.p12$/,
+    /\.pfx$/,
+    /\.pem$/,
+    /^\.netrc$/,
+    /private[-_.]?key/i,
+    ...privacyConfig.block.map((p) => new RegExp(p)),
+  ];
+
+  // WARN tier (log warning, allow through)
+  const warnPatterns = [
+    /^\.env$/,
+    /^\.env\.[^e]/,                  // .env.* but NOT .env.example
+    /\.key$/,
+    /^credentials\.json$/,
+    /\.secret$/,
+    /secret[-_.]?key/i,
+    ...privacyConfig.warn.map((p) => new RegExp(p)),
+  ];
+
+  // Safe exceptions (always allow)
+  const safeExceptions = [
+    /\.env\.example$/,
+    /\.env\.sample$/,
+    /\.env\.template$/,
+    /\.env\.test$/,
+    /test.*credential/i,
+    /fixture/i,
+    /mock/i,
+    ...privacyConfig.allow.map((p) => new RegExp(p)),
+  ];
+
+  // Skills with elevated access (can read WARN-tier files without warning)
+  const elevatedSkills = new Set([
+    'sentinel', 'review', 'audit', 'secrets-scan', 'onboard',
+    ...privacyConfig.elevatedSkills,
+  ]);
+
+  // Detect active skill from environment (set by metrics-collector or skill invocation)
+  const activeSkill = process.env.RUNE_ACTIVE_SKILL || '';
+  const isElevated = elevatedSkills.has(activeSkill);
+
+  const isSafe = safeExceptions.some((p) => p.test(basename) || p.test(normalized));
+  if (isSafe) process.exit(0);
+
+  const isBlocked = blockPatterns.some((p) => p.test(basename) || p.test(normalized));
+  if (isBlocked) {
+    console.log(`\n🚫 [Rune privacy-mesh] BLOCKED: ${filePath}`);
+    console.log('  This file matches a BLOCK-tier pattern (private keys, certificates).');
+    console.log('  Override: add path to .rune/privacy.json "allow" list if intentional.\n');
+    process.exit(2); // Exit code 2 = BLOCK
+  }
+
+  const isWarned = warnPatterns.some((p) => p.test(basename) || p.test(normalized));
+  if (isWarned && !isElevated) {
+    // Content-aware check: scan first 4KB for secret patterns
+    const contentWarning = scanContentForSecrets(filePath);
+
+    console.log(`\n⚠ [Rune privacy-mesh] Sensitive file: ${filePath}`);
+    if (contentWarning) {
+      console.log(`  Content scan: ${contentWarning}`);
+    }
+    console.log('  This file may contain secrets. Confirm access is intentional.');
+    console.log('  Elevated skills (sentinel, review, audit) bypass this warning.\n');
+  }
+
+  process.exit(0);
+});
+
+/**
+ * Load .rune/privacy.json from project root
+ * Returns merged config with defaults
+ */
+function loadPrivacyConfig() {
+  const defaults = { block: [], warn: [], allow: [], elevatedSkills: [] };
+
+  const candidates = [
+    path.join(process.cwd(), '.rune', 'privacy.json'),
+    path.join(process.cwd(), 'privacy.json'),
+  ];
+
+  for (const configPath of candidates) {
+    try {
+      if (fs.existsSync(configPath)) {
+        const raw = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        return {
+          block: Array.isArray(raw.block) ? raw.block : defaults.block,
+          warn: Array.isArray(raw.warn) ? raw.warn : defaults.warn,
+          allow: Array.isArray(raw.allow) ? raw.allow : defaults.allow,
+          elevatedSkills: Array.isArray(raw.elevatedSkills) ? raw.elevatedSkills : defaults.elevatedSkills,
+        };
+      }
+    } catch {
+      // Invalid config — use defaults
+    }
+  }
+
+  return defaults;
+}
+
+/**
+ * Scan first 4KB of a file for common secret patterns
+ * Returns a warning string if secrets detected, null otherwise
+ */
+function scanContentForSecrets(filePath) {
+  try {
+    const fd = fs.openSync(filePath, 'r');
+    const buffer = Buffer.alloc(4096);
+    const bytesRead = fs.readSync(fd, buffer, 0, 4096, 0);
+    fs.closeSync(fd);
+
+    if (bytesRead === 0) return null;
+
+    const content = buffer.toString('utf-8', 0, bytesRead);
+
+    const secretPatterns = [
+      { pattern: /AKIA[0-9A-Z]{16}/, label: 'AWS access key' },
+      { pattern: /gh[ps]_[A-Za-z0-9_]{36,}/, label: 'GitHub token' },
+      { pattern: /sk_(live|test)_[0-9a-zA-Z]{24,}/, label: 'Stripe key' },
+      { pattern: /-----BEGIN .* PRIVATE KEY-----/, label: 'Private key' },
+      { pattern: /xox[bpors]-[0-9a-zA-Z-]{10,}/, label: 'Slack token' },
+      { pattern: /sk-[a-zA-Z0-9]{32,}/, label: 'OpenAI/API key' },
+    ];
+
+    for (const { pattern, label } of secretPatterns) {
+      if (pattern.test(content)) {
+        return `Found ${label} pattern in file content`;
+      }
+    }
+  } catch {
+    // Can't read file (doesn't exist yet, permissions, etc.) — skip silently
+  }
+
+  return null;
+}

package/package.json

@@ -1,63 +1,63 @@
-{
-  "name": "@rune-kit/rune",
-  "version": "2.4.0",
-  "description": "60-skill mesh for AI coding assistants — 5-layer architecture, 200+ connections, 8 platforms (Claude Code, Cursor, Windsurf, Antigravity, Codex, OpenCode, OpenClaw, Generic)",
-  "type": "module",
-  "bin": {
-    "rune": "./compiler/bin/rune.js"
-  },
-  "scripts": {
-    "build": "node compiler/bin/rune.js build",
-    "doctor": "node compiler/bin/rune.js doctor && node scripts/version-sync-check.js",
-    "test": "node --test compiler/__tests__/*.test.js scripts/__tests__/*.test.js",
-    "test:coverage": "c8 --reporter=text --reporter=lcov node --test compiler/__tests__/*.test.js scripts/__tests__/*.test.js",
-    "lint": "biome check .",
-    "lint:fix": "biome check --fix .",
-    "format": "biome format --write .",
-    "ci": "biome check . && node --test compiler/__tests__/*.test.js scripts/__tests__/*.test.js && node compiler/bin/rune.js doctor",
-    "version-check": "node scripts/version-sync-check.js",
-    "prepublishOnly": "node scripts/version-sync-check.js"
-  },
-  "keywords": [
-    "claude-code",
-    "cursor",
-    "windsurf",
-    "antigravity",
-    "codex",
-    "opencode",
-    "openclaw",
-    "ai-assistant",
-    "ai-coding",
-    "skills",
-    "coding-agent",
-    "tdd",
-    "multi-platform"
-  ],
-  "author": "runedev",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/rune-kit/rune"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "files": [
-    "compiler/",
-    "skills/",
-    "extensions/",
-    "contexts/",
-    "commands/",
-    "agents/",
-    "hooks/",
-    "references/"
-  ],
-  "homepage": "https://rune-kit.github.io/rune",
-  "bugs": {
-    "url": "https://github.com/rune-kit/rune/issues"
-  },
-  "devDependencies": {
-    "@biomejs/biome": "^2.4.7",
-    "c8": "^10.1.3"
-  }
-}
+{
+  "name": "@rune-kit/rune",
+  "version": "2.7.0",
+  "description": "61-skill mesh for AI coding assistants — 5-layer architecture, 200+ connections, 8 platforms (Claude Code, Cursor, Windsurf, Antigravity, Codex, OpenCode, OpenClaw, Generic)",
+  "type": "module",
+  "bin": {
+    "rune": "./compiler/bin/rune.js"
+  },
+  "scripts": {
+    "build": "node compiler/bin/rune.js build",
+    "doctor": "node compiler/bin/rune.js doctor && node scripts/version-sync-check.js",
+    "test": "node --test compiler/__tests__/*.test.js scripts/__tests__/*.test.js",
+    "test:coverage": "c8 --reporter=text --reporter=lcov node --test compiler/__tests__/*.test.js scripts/__tests__/*.test.js",
+    "lint": "biome check .",
+    "lint:fix": "biome check --fix .",
+    "format": "biome format --write .",
+    "ci": "biome check . && node --test compiler/__tests__/*.test.js scripts/__tests__/*.test.js && node compiler/bin/rune.js doctor",
+    "version-check": "node scripts/version-sync-check.js",
+    "prepublishOnly": "node scripts/version-sync-check.js"
+  },
+  "keywords": [
+    "claude-code",
+    "cursor",
+    "windsurf",
+    "antigravity",
+    "codex",
+    "opencode",
+    "openclaw",
+    "ai-assistant",
+    "ai-coding",
+    "skills",
+    "coding-agent",
+    "tdd",
+    "multi-platform"
+  ],
+  "author": "runedev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rune-kit/rune"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "compiler/",
+    "skills/",
+    "extensions/",
+    "contexts/",
+    "commands/",
+    "agents/",
+    "hooks/",
+    "references/"
+  ],
+  "homepage": "https://rune-kit.github.io/rune",
+  "bugs": {
+    "url": "https://github.com/rune-kit/rune/issues"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.7",
+    "c8": "^10.1.3"
+  }
+}

package/skills/autopsy/SKILL.md

@@ -3,7 +3,7 @@ name: autopsy
 description: Full codebase health assessment. Analyzes complexity, dependencies, dead code, tech debt, and git hotspots. Produces a health score and rescue plan.
 metadata:
   author: runedev
-  version: "0.2.0"
+  version: "0.3.0"
   layer: L2
   model: opus
   group: rescue
@@ -210,3 +210,50 @@ Known failure modes for this skill. Check these before declaring done.
 ~5000-10000 tokens input, ~2000-4000 tokens output. Opus for deep analysis. Most expensive L2 skill but runs once per rescue.
 
 **Scope guardrail:** autopsy assesses — it does not refactor. All surgery is delegated to `surgeon` after the report is complete.
+
+## Executive Mode (--executive)
+
+When invoked as `/rune autopsy --executive`, generate a board-ready HTML health assessment. Requires Business tier.
+
+### Executive Execution Steps
+
+1. **Standard Autopsy**: Run Steps 1-5 (structure scan, module analysis, health scoring, risk assessment, RESCUE-REPORT.md)
+2. **Org Context**: Read `.rune/org/org.md` for team structure and governance level
+3. **Cross-Domain Impact**: Map module health to business domains (which team owns which modules)
+4. **Business Risk Translation**: Convert technical health scores to business risk language:
+   - Critical modules in revenue path → "Revenue infrastructure at risk"
+   - Low test coverage on auth → "Security compliance gap"
+   - High churn in customer-facing code → "Customer experience degradation risk"
+5. **HTML Render**: Load `report-templates/autopsy-executive.html` from Business pack and populate all `{{placeholder}}` fields:
+   - SVG health ring (score → stroke-dasharray calculation: `score / 100 * 440`)
+   - Dimension bars (6 dimensions with color coding)
+   - Module table (sorted by priority)
+   - Surgery queue (top 5 modules)
+   - Risk matrix (6 categories)
+   - Git archaeology summary
+   - Cross-domain impact table
+   - Recommended actions (numbered, prioritized)
+6. **Save**: Write HTML to `EXECUTIVE-HEALTH.html` at project root
+
+### Executive Output
+
+```
+EXECUTIVE-HEALTH.html          — Board-ready HTML report
+RESCUE-REPORT.md               — Detailed technical report (standard autopsy)
+.rune/retros/{date}.json       — Health metrics for trend tracking
+```
+
+### Color Coding
+
+| Score Range | Color | Tier |
+|-------------|-------|------|
+| 80-100 | var(--success) #10b981 | Healthy |
+| 60-79 | var(--warning) #f59e0b | Watch |
+| 40-59 | #f97316 (orange) | At-risk |
+| 0-39 | var(--danger) #ef4444 | Critical |
+
+### Graceful Degradation
+
+- If no Business pack installed: skip executive mode, produce standard RESCUE-REPORT.md only
+- If `.rune/org/org.md` missing: skip team mapping, show modules without domain ownership
+- If org teams don't map to code modules: show "Unmapped" in cross-domain table

package/skills/brainstorm/SKILL.md

@@ -8,6 +8,8 @@ metadata:
   model: opus
   group: creation
   tools: "Read, Glob, Grep"
+  emit: ideas.ready
+  listen: codebase.scanned
 ---
 
 # brainstorm

package/skills/completion-gate/SKILL.md

@@ -4,7 +4,7 @@ description: "Validates agent claims against evidence trail. Catches 'done' with
 user-invocable: false
 metadata:
   author: runedev
-  version: "1.6.0"
+  version: "1.7.0"
   layer: L3
   model: haiku
   group: validation
@@ -210,6 +210,29 @@ Before emitting verdict, verify evidence quality:
 | Quote matches claim exactly | CONFIRMED |
 | Quote contradicts claim | CONTRADICTED |
 
+### Step 5.5 — Plan Diff Check
+
+When validating a phase within a master plan, diff actual changes against the phase plan file:
+
+1. **Read the active phase plan** — `Glob` for `.rune/plan-*-phase*.md` matching the current phase
+2. **Extract `## Files Touched`** — build a list of expected files (new/modify/delete)
+3. **Extract `## Tasks`** — build a list of all `- [ ]` and `- [x]` items
+4. **Compare against actual changes** — `git diff --name-only` (or file system scan)
+5. **Report**:
+
+| Check | Status |
+|-------|--------|
+| Unchecked task in phase plan (`- [ ]` still exists) | **INCOMPLETE** — task was not done |
+| File in plan's "Files Touched" but not in actual diff | **MISSING** — planned file was never touched |
+| File in actual diff but NOT in plan's "Files Touched" | **UNPLANNED** — scope creep (warn, not block) |
+| All tasks `[x]` AND all planned files touched | **PLAN-ALIGNED** |
+
+```
+Plan Diff: PLAN-ALIGNED | INCOMPLETE (2 unchecked tasks) | MISSING (1 file never touched)
+```
+
+**Skip if**: No active phase plan found (single-task, no master plan). **MANDATORY** for multi-phase master plans.
+
 ## Verdict Rules
 
 ```
@@ -245,6 +268,7 @@ Completion Gate Report with status (CONFIRMED/UNCONFIRMED/CONTRADICTED), claim v
 | Rubber-stamping — all CONFIRMED without scrutiny | HIGH | Default-FAIL mindset: actively seek 3-5 issues. Zero issues = red flag, apply skeptic sweep on weakest 2 claims |
 | Partial completion claimed as full — 80% done but "implemented" | HIGH | Adversarial checklist: check for partial completion, scope mismatch, evidence-claim alignment |
 | Self-Validation skipped — skill has checks but gate ignores them | HIGH | Step 1c: extract Self-Validation from skill's SKILL.md, treat each as implicit claim. Missing = UNCONFIRMED |
+| Plan says done but phase file has unchecked tasks | HIGH | Step 5.5: diff changed files vs phase plan's Files Touched + Tasks sections |
 
 ## Done When
 
@@ -252,6 +276,7 @@ Completion Gate Report with status (CONFIRMED/UNCONFIRMED/CONTRADICTED), claim v
 - Each claim matched against tool output evidence
 - Verdict table emitted with claim/evidence/verdict for each item
 - All 3 verification axes (Completeness/Correctness/Coherence) have at least one claim checked
+- Plan diff check passed (if multi-phase): all tasks checked, all planned files touched
 - Overall verdict: CONFIRMED / UNCONFIRMED / CONTRADICTED
 - If not CONFIRMED: specific gaps listed with remediation steps