@rune-kit/rune 2.28.0 → 2.29.1

package/compiler/emitter.js

@@ -19,6 +19,7 @@ import { resolveScriptsPath } from './transforms/scripts-path.js';
  * @returns {Promise<string[]>} array of SKILL.md file paths
  */
 async function discoverSkills(skillsDir) {
+  if (!existsSync(skillsDir)) return [];
   const entries = await readdir(skillsDir, { withFileTypes: true });
   const paths = [];
 
@@ -33,6 +34,38 @@ async function discoverSkills(skillsDir) {
   return paths.sort();
 }
 
+/**
+ * Discover standalone skills across Free and paid tiers.
+ * Business > Pro > Free when the same skill directory name exists.
+ *
+ * Tier sources point at `<tier>/extensions`; standalone tier skills live in
+ * the sibling `<tier>/skills` directory.
+ *
+ * @param {string} freeSkillsDir
+ * @param {Object<string, string>} [tierSources]
+ * @returns {Promise<Array<{path: string, tier: string, name: string}>>}
+ */
+export async function discoverTieredSkills(freeSkillsDir, tierSources = {}) {
+  const skillMap = new Map();
+
+  async function scanDir(skillsDir, tier) {
+    for (const skillPath of await discoverSkills(skillsDir)) {
+      const name = path.basename(path.dirname(skillPath));
+      const priority = TIER_PRIORITY[tier] ?? 0;
+      const existing = skillMap.get(name);
+      if (!existing || priority > existing.priority) {
+        skillMap.set(name, { path: skillPath, tier, name, priority });
+      }
+    }
+  }
+
+  await scanDir(freeSkillsDir, 'free');
+  if (tierSources.pro) await scanDir(path.join(path.dirname(tierSources.pro), 'skills'), 'pro');
+  if (tierSources.business) await scanDir(path.join(path.dirname(tierSources.business), 'skills'), 'business');
+
+  return [...skillMap.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
 /**
  * Discover all PACK.md files in the extensions directory
  *
@@ -435,10 +468,15 @@ export async function buildAll({
   // Ensure output directory exists
   await mkdir(outputDir, { recursive: true });
 
-  const skillPaths = await discoverSkills(skillsDir);
-
   // Tier-aware pack discovery: if tierSources provided, resolve overrides
   const hasTiers = tierSources && (tierSources.pro || tierSources.business);
+  const skillEntries = hasTiers
+    ? await discoverTieredSkills(skillsDir, tierSources)
+    : (await discoverSkills(skillsDir)).map((skillPath) => ({
+        path: skillPath,
+        tier: 'free',
+        name: path.basename(path.dirname(skillPath)),
+      }));
   const packEntries = hasTiers
     ? await discoverTieredPacks(extensionsDir, tierSources, enabledPacks)
     : (await discoverPacks(extensionsDir, enabledPacks)).map((p) => ({
@@ -450,6 +488,8 @@ export async function buildAll({
   const stats = {
     platform: adapter.name,
     skillCount: 0,
+    coreSkillCount: 0,
+    tierSkillCount: 0,
     packCount: 0,
     crossRefsResolved: 0,
     toolRefsResolved: 0,
@@ -471,7 +511,8 @@ export async function buildAll({
   // Build skills — collect parsed data for skill-index + openclaw reuse
   const parsedSkills = [];
 
-  for (const skillPath of skillPaths) {
+  for (const skillEntry of skillEntries) {
+    const skillPath = skillEntry.path;
     try {
       const content = await readFile(skillPath, 'utf-8');
       const parsed = parseSkill(content, skillPath);
@@ -553,6 +594,8 @@ export async function buildAll({
 
       parsedSkills.push(parsed);
       stats.skillCount++;
+      if (skillEntry.tier === 'free') stats.coreSkillCount++;
+      else stats.tierSkillCount++;
       stats.crossRefsResolved += parsed.crossRefs.length;
       stats.toolRefsResolved += parsed.toolRefs.length;
       stats.files.push(displayName);

package/compiler/governance-collector.js

@@ -312,8 +312,9 @@ async function assembleCompliance(runeRoot) {
       continue; // skip unreadable pack
     }
 
-    // Derive a human-readable pack name from the directory name.
-    const packName = packDir.replace(/^pro-/, '@rune-business/');
+    // Business is the entitlement tier; paid pack manifests retain the
+    // canonical @rune-pro/* namespace for mesh compatibility.
+    const packName = packDir.replace(/^pro-/, '@rune-pro/');
 
     // Extract obligations from ## Constraints. Real Business PACK.md files use
     // numbered ("1. MUST …") OR bulleted ("- MUST …") lists, so accept both.

package/compiler/status.js

@@ -8,6 +8,7 @@
 import { existsSync } from 'node:fs';
 import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
+import { parseSkillConnections } from './doctor.js';
 import { parseSkill } from './parser.js';
 
 // ─── Constants ───
@@ -73,6 +74,7 @@ export async function collectStats(runeRoot, tierSources = {}) {
   const layers = { L0: 0, L1: 0, L2: 0, L3: 0 };
   const skillNames = [];
   let signalCount = 0;
+  let totalConnections = 0;
   const signalMap = { emitters: {}, listeners: {} };
   const parsedSkills = [];
 
@@ -85,6 +87,7 @@ export async function collectStats(runeRoot, tierSources = {}) {
 
       const content = await readFile(skillFile, 'utf-8');
       const parsed = parseSkill(content, skillFile);
+      totalConnections += parseSkillConnections(content, entry.name).calls.length;
       parsedSkills.push(parsed);
       skillNames.push(parsed.name);
 
@@ -106,11 +109,6 @@ export async function collectStats(runeRoot, tierSources = {}) {
     signalCount = allSignals.size;
   }
 
-  // Count connections
-  let totalConnections = 0;
-  for (const skill of parsedSkills) {
-    totalConnections += new Set((skill.crossRefs ?? []).map((r) => r.skillName)).size;
-  }
   const avgConnections = parsedSkills.length > 0 ? (totalConnections / parsedSkills.length).toFixed(1) : '0';
 
   // Count free packs
@@ -302,8 +300,7 @@ export function renderStatusJson(stats, { version = '', platform = '', projectNa
 
 function formatPackName(dirName, tier = 'free') {
   const baseName = dirName.replace(/^(pro|business)-/, '');
-  if (tier === 'business') return `@rune-biz/${baseName}`.padEnd(26);
-  if (tier === 'pro') return `@rune-pro/${baseName}`.padEnd(26);
+  if (tier === 'business' || tier === 'pro') return `@rune-pro/${baseName}`.padEnd(26);
   return `@rune/${baseName}`.padEnd(26);
 }
 

package/compiler/transforms/branding.js

@@ -12,9 +12,9 @@
 export const BRANDING_FOOTER = [
   '',
   '---',
-  '> **Rune Skill Mesh** — 64 skills, 204 connections + 40 signals, 14 extension packs',
+  '> **Rune Skill Mesh** — 66 skills, 248 connections + 45 signals, 14 extension packs',
   '> [Landing Page](https://rune-kit.github.io/rune) · [Source](https://github.com/rune-kit/rune) (MIT)',
-  '> **Rune Pro** ($49 lifetime) — product, sales, data-science, support packs → [rune-kit/rune-pro](https://github.com/rune-kit/rune-pro)',
+  '> **Rune Pro** ($49 lifetime) — 9 domain packs + context intelligence → [rune-kit/rune-pro](https://github.com/rune-kit/rune-pro)',
   '> **Rune Business** ($149 lifetime) — finance, legal, HR, enterprise-search packs → [rune-kit/rune-business](https://github.com/rune-kit/rune-business)',
 ].join('\n');
 

package/compiler/transforms/subagents.js

@@ -1,8 +1,8 @@
 /**
  * Subagent Transform
  *
- * Converts parallel agent/subagent execution instructions to sequential workflow.
- * On non-Claude platforms, there is no multi-agent support.
+ * Converts parallel agent/subagent execution instructions to sequential workflow
+ * only on platforms without native multi-agent support.
  */
 
 const PARALLEL_PATTERNS = [
@@ -23,7 +23,7 @@ const PARALLEL_PATTERNS = [
  * @returns {string} transformed body
  */
 export function transformSubagents(body, adapter) {
-  if (adapter.name === 'claude') return body;
+  if (adapter.name === 'claude' || adapter.name === 'codex') return body;
 
   let result = body;
   for (const { pattern, replace } of PARALLEL_PATTERNS) {

package/hooks/codex-hooks.json

@@ -0,0 +1,96 @@
+{
+  "description": "Rune lifecycle hooks optimized for OpenAI Codex.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" session-start"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" intent-router"
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Read|Write|Edit|apply_patch|view_image",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" pre-tool-guard"
+          }
+        ]
+      },
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" context-watch"
+          }
+        ]
+      },
+      {
+        "matcher": "Bash|shell_command",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" secrets-scan"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Skill|Task|Agent|spawn_agent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" metrics-collector"
+          }
+        ]
+      },
+      {
+        "matcher": "mcp__.*|WebFetch|Read|web_search",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" quarantine"
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" pre-compact"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" post-session-reflect"
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/context-watch/index.cjs

@@ -13,6 +13,9 @@
 
 const fs = require('fs');
 const { stateFile } = require('../lib/context-key.cjs');
+const { captureConsole } = require('../lib/hook-output.cjs');
+
+captureConsole('PreToolUse');
 
 // The counter file is keyed by Claude Code session_id (parsed from stdin in the
 // handler below) so it resets per session and never bleeds across sessions or
@@ -53,7 +56,9 @@ process.stdin.on('end', () => {
     // Ensure fields exist (upgrade from old format)
     if (!state.toolCounts) state.toolCounts = {};
     if (!state.sessionStart) state.sessionStart = new Date().toISOString();
-    if (!state.sessionId) {
+    if (sessionId) {
+      state.sessionId = sessionId;
+    } else if (!state.sessionId) {
       const s = state.sessionStart;
       state.sessionId = `s-${s.slice(0, 10).replace(/-/g, '')}-${s.slice(11, 19).replace(/:/g, '')}`;
     }
@@ -61,7 +66,8 @@ process.stdin.on('end', () => {
     // First run or corrupted — start fresh
     const now = new Date().toISOString();
     state.sessionStart = now;
-    state.sessionId = `s-${now.slice(0, 10).replace(/-/g, '')}-${now.slice(11, 19).replace(/:/g, '')}`;
+    state.sessionId = sessionId
+      || `s-${now.slice(0, 10).replace(/-/g, '')}-${now.slice(11, 19).replace(/:/g, '')}`;
   }
 
   // Increment total (drives context-pressure warnings) and per-tool distribution.
@@ -88,9 +94,6 @@ process.stdin.on('end', () => {
     state.lastWarning = count;
   }
 
-  // Pass through stdin to stdout (required for PreToolUse hooks)
-  if (stdinData) process.stdout.write(stdinData);
-
   // Persist
   try {
     fs.writeFileSync(counterFile, JSON.stringify(state));

package/hooks/intent-router/index.cjs

@@ -9,6 +9,9 @@
 
 const fs = require('fs');
 const path = require('path');
+const { captureConsole } = require('../lib/hook-output.cjs');
+
+captureConsole('UserPromptSubmit');
 
 // Read user prompt from Claude Code hook stdin
 let input = '';

package/hooks/lib/hook-output.cjs

@@ -79,16 +79,24 @@ function emit(hookEventName, text) {
  * `console.error` is untouched — stderr is not parsed as the output contract.
  *
  * @param {string} hookEventName
+ * @param {{captureError?: boolean}} [options]
  * @returns {{buffer: ReturnType<typeof outputBuffer>, restore: () => void}}
  */
-function captureConsole(hookEventName) {
+function captureConsole(hookEventName, options = {}) {
   const buffer = outputBuffer(hookEventName);
-  const original = console.log;
+  const originalLog = console.log;
+  const originalError = console.error;
   console.log = (...args) => {
     buffer.line(args.map((a) => (typeof a === 'string' ? a : String(a))).join(' '));
   };
+  if (options.captureError) {
+    console.error = (...args) => {
+      buffer.line(args.map((a) => (typeof a === 'string' ? a : String(a))).join(' '));
+    };
+  }
   const restore = () => {
-    console.log = original;
+    console.log = originalLog;
+    console.error = originalError;
   };
   // Fires for a natural end AND for process.exit(), which is how the BLOCK
   // paths leave — those messages must survive too.

package/hooks/post-session-reflect/index.cjs

@@ -4,7 +4,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
+const { stateFile } = require('../lib/context-key.cjs');
 const { captureConsole } = require('../lib/hook-output.cjs');
 // Hook stdout is a JSON contract, not free text (Codex rejects bare lines and
 // discards the output). Capture the prints below and emit one envelope on exit.
@@ -12,12 +12,17 @@ captureConsole('Stop');
 
 
 const cwd = process.cwd();
-const hash = Buffer.from(cwd).toString('base64url').slice(0, 16);
+let sessionId;
+try {
+  sessionId = JSON.parse(fs.readFileSync(0, 'utf-8')).session_id;
+} catch {
+  // Older runtimes may not provide hook input.
+}
 
 // === H3: Flush Session Metrics ===
 
-const metricsJsonl = path.join(os.tmpdir(), `rune-metrics-${hash}.jsonl`);
-const counterFile = path.join(os.tmpdir(), `rune-context-watch-${hash}.json`);
+const metricsJsonl = stateFile('rune-metrics', sessionId, cwd).replace(/\.json$/, '.jsonl');
+const counterFile = stateFile('rune-context-watch', sessionId, cwd);
 const runeMetricsDir = path.join(cwd, '.rune', 'metrics');
 
 // Resolve skill names → expected model from agent frontmatter
@@ -101,33 +106,69 @@ function flushMetrics() {
   const modelsUsed = resolveSkillModels(skillCounts);
 
   // Use session ID from context-watch (shared) or generate new
-  const sessionId = watchState.sessionId
+  const metricSessionId = sessionId
+    || watchState.sessionId
     || `s-${now.slice(0, 10).replace(/-/g, '')}-${now.slice(11, 19).replace(/:/g, '')}`;
 
-  // 1. Append to sessions.jsonl
+  // 1. Upsert sessions.jsonl. Stop can fire more than once in one session;
+  // appending every time inflated session counts and duration metrics.
+  let previousSession = null;
+  const sessionsFile = path.join(runeMetricsDir, 'sessions.jsonl');
+  let sessionEntries = [];
+  if (fs.existsSync(sessionsFile)) {
+    sessionEntries = fs
+      .readFileSync(sessionsFile, 'utf-8')
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .flatMap((line) => {
+        try {
+          return [JSON.parse(line)];
+        } catch {
+          return [];
+        }
+      });
+    previousSession = [...sessionEntries].reverse().find((entry) => entry.id === metricSessionId) || null;
+  }
+
+  const mergedSkillCounts = { ...(previousSession?.skill_counts || {}) };
+  for (const [skill, count] of Object.entries(skillCounts)) {
+    mergedSkillCounts[skill] = (mergedSkillCounts[skill] || 0) + count;
+  }
+  const mergedSkillDurations = { ...(previousSession?.skill_durations || {}) };
+  for (const [skill, duration] of Object.entries(skillDurations)) {
+    mergedSkillDurations[skill] = (mergedSkillDurations[skill] || 0) + duration;
+  }
+  const mergedModels = { ...(previousSession?.models_used || {}) };
+  for (const [model, count] of Object.entries(modelsUsed)) {
+    mergedModels[model] = (mergedModels[model] || 0) + count;
+  }
+  const mergedSkills = Object.keys(mergedSkillCounts);
+  const mergedPrimarySkill = Object.entries(mergedSkillCounts)
+    .sort((a, b) => b[1] - a[1])[0]?.[0]
+    || previousSession?.primary_skill
+    || primarySkill;
+
   const sessionEntry = {
-    id: sessionId,
+    id: metricSessionId,
     date: now.slice(0, 10),
     duration_min: durationMin,
     tool_calls: watchState.count,
     tool_distribution: watchState.toolCounts,
-    skill_invocations: skillEvents.length,
-    skills_used: Object.keys(skillCounts),
-    primary_skill: primarySkill,
-    models_used: modelsUsed,
-    skill_durations: Object.keys(skillDurations).length > 0 ? skillDurations : undefined
+    skill_invocations: Object.values(mergedSkillCounts).reduce((sum, count) => sum + count, 0),
+    skills_used: mergedSkills,
+    primary_skill: mergedPrimarySkill,
+    models_used: mergedModels,
+    skill_counts: Object.keys(mergedSkillCounts).length > 0 ? mergedSkillCounts : undefined,
+    skill_durations: Object.keys(mergedSkillDurations).length > 0 ? mergedSkillDurations : undefined
   };
 
-  const sessionsFile = path.join(runeMetricsDir, 'sessions.jsonl');
-  fs.appendFileSync(sessionsFile, JSON.stringify(sessionEntry) + '\n');
-
-  // Cap at 100 sessions (rotate oldest)
-  try {
-    const allLines = fs.readFileSync(sessionsFile, 'utf-8').trim().split('\n').filter(Boolean);
-    if (allLines.length > 100) {
-      fs.writeFileSync(sessionsFile, allLines.slice(-100).join('\n') + '\n');
-    }
-  } catch { /* cap is best-effort */ }
+  sessionEntries = sessionEntries.filter((entry) => entry.id !== metricSessionId);
+  sessionEntries.push(sessionEntry);
+  fs.writeFileSync(
+    sessionsFile,
+    `${sessionEntries.slice(-100).map((entry) => JSON.stringify(entry)).join('\n')}\n`,
+  );
 
   // 2. Merge into skills.json (running totals)
   const skillsFile = path.join(runeMetricsDir, 'skills.json');
@@ -153,7 +194,7 @@ function flushMetrics() {
   if (skillChain.length > 0) {
     const chainsFile = path.join(runeMetricsDir, 'chains.jsonl');
     const chainEntry = {
-      session: sessionId,
+      session: metricSessionId,
       chain: skillChain,
       depth: skillChain.length
     };
@@ -170,7 +211,7 @@ function flushMetrics() {
     .map(([s, c]) => `${s}(${c})`)
     .join(', ');
 
-  console.log(`\n📊 [Rune metrics] Session ${sessionId} — ${durationMin}min, ${watchState.count} tool calls, ${skillEvents.length} skill invocations`);
+  console.log(`\n📊 [Rune metrics] Session ${metricSessionId} — ${durationMin}min, ${watchState.count} tool calls, ${skillEvents.length} new skill invocations`);
   if (skillList) console.log(`   Skills: ${skillList}`);
   console.log(`   Saved to .rune/metrics/\n`);
 }

package/hooks/pre-compact/index.cjs

@@ -7,20 +7,26 @@
 
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
+const { stateFile } = require('../lib/context-key.cjs');
 
 const { captureConsole } = require('../lib/hook-output.cjs');
 // Hook stdout is a JSON contract, not free text (Codex rejects bare lines and
 // discards the output). Capture the prints below and emit one envelope on exit.
-captureConsole('PreCompact');
+captureConsole('PreCompact', { captureError: true });
 
 
 const cwd = process.cwd();
 const runeDir = path.join(cwd, '.rune');
 
+let sessionId;
+try {
+  sessionId = JSON.parse(fs.readFileSync(0, 'utf-8')).session_id;
+} catch {
+  // Older runtimes may not provide hook input.
+}
+
 // Read context-watch state (tool counts, session timing)
-const hash = Buffer.from(cwd).toString('base64url').slice(0, 16);
-const counterFile = path.join(os.tmpdir(), `rune-context-watch-${hash}.json`);
+const counterFile = stateFile('rune-context-watch', sessionId, cwd);
 
 let watchState = null;
 try {

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

@@ -66,14 +66,14 @@ function appendGateOutcome(gate, outcome, detail) {
  *
  * @param {string} toolName
  * @param {object} toolInput
- * @returns {string} target path, or '' when this is not a patch we understand
+ * @returns {string[]} target paths
  */
-function patchTargetPath(toolName, toolInput) {
-  if (toolName !== 'apply_patch') return '';
-  const patch = typeof toolInput === 'string' ? toolInput : toolInput.input || toolInput.patch || '';
-  if (typeof patch !== 'string') return '';
-  const match = patch.match(/^\*\*\* (?:Update|Add|Delete) File:\s*(.+)$/m);
-  return match ? match[1].trim() : '';
+function patchTargetPaths(toolName, toolInput) {
+  if (toolName !== 'apply_patch') return [];
+  const patch =
+    typeof toolInput === 'string' ? toolInput : toolInput.command || toolInput.input || toolInput.patch || '';
+  if (typeof patch !== 'string') return [];
+  return Array.from(patch.matchAll(/^\*\*\* (?:Update|Add|Delete) File:\s*(.+)$/gm), (match) => match[1].trim());
 }
 
 // Read tool_input from Claude Code hook stdin
@@ -92,11 +92,9 @@ process.stdin.on('end', () => {
     process.exit(0);
   }
 
-  const filePath = toolInput.file_path || toolInput.path || patchTargetPath(toolName, toolInput);
-  if (!filePath) process.exit(0);
-
-  const basename = path.basename(filePath);
-  const normalized = filePath.replace(/\\/g, '/');
+  const directPath = toolInput.file_path || toolInput.path;
+  const filePaths = directPath ? [directPath] : patchTargetPaths(toolName, toolInput);
+  if (filePaths.length === 0) process.exit(0);
 
   // Load project-specific privacy config
   const privacyConfig = loadPrivacyConfig();
@@ -147,33 +145,37 @@ process.stdin.on('end', () => {
   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) {
-    // Append block outcome BEFORE printing/exiting — fail-safe, never affects exit code.
-    // Only "blocked" is captured here; "passed" and "bypassed" are not observable
-    // at this layer and intentionally remain uncaptured (see GAP-1 in governance-collector.js).
-    appendGateOutcome('privacy-mesh', 'blocked', `file matched BLOCK-tier pattern: ${basename}`);
-
-    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
-  }
+  for (const filePath of filePaths) {
+    const basename = path.basename(filePath);
+    const normalized = filePath.replace(/\\/g, '/');
+    const isSafe = safeExceptions.some((p) => p.test(basename) || p.test(normalized));
+    if (isSafe) continue;
+
+    const isBlocked = blockPatterns.some((p) => p.test(basename) || p.test(normalized));
+    if (isBlocked) {
+      // Append block outcome BEFORE printing/exiting — fail-safe, never affects exit code.
+      // Only "blocked" is captured here; "passed" and "bypassed" are not observable
+      // at this layer and intentionally remain uncaptured (see GAP-1 in governance-collector.js).
+      appendGateOutcome('privacy-mesh', 'blocked', `file matched BLOCK-tier pattern: ${basename}`);
+
+      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);
+    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(`\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');
     }
-    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);

package/hooks/run-hook

@@ -8,7 +8,7 @@ if (!hookName) {
   process.exit(1);
 }
 
-const hookPath = path.join(__dirname, hookName, 'index.js');
+const hookPath = path.join(__dirname, hookName, 'index.cjs');
 try {
   require(hookPath);
 } catch (e) {

package/hooks/run-hook.cmd

@@ -1 +1 @@
-@node "%~dp0run-hook.js" %*
+@node "%~dp0run-hook.cjs" %*