@rune-kit/rune 2.28.0 → 2.29.0

package/compiler/commands/setup.js

@@ -21,10 +21,14 @@
  */
 
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { cp, readdir, readFile, rm } from 'node:fs/promises';
+import { cp, mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
+import { getAdapter as getCompilerAdapter } from '../adapters/index.js';
+import { parseSkill } from '../parser.js';
+import { transformSkill } from '../transformer.js';
+import { resolveScriptsPath } from '../transforms/scripts-path.js';
 import { installHooks } from './hooks/install.js';
 import { resolveTier, TIER_ENV_VARS } from './hooks/tiers.js';
 
@@ -103,9 +107,10 @@ export async function runSetup({ projectRoot, runeRoot, args = {}, skillTarget:
   // Determine target root
   const targetRoot = scope === 'global' ? os.homedir() : projectRoot;
 
-  // For global scope, claude is the only meaningful platform (cursor/windsurf
-  // configs typically live per-project). Force claude.
-  const platform = scope === 'global' ? 'claude' : args.platform;
+  // Global defaults to Claude for backward compatibility, but an explicit
+  // Codex target installs user-wide hooks under ~/.codex and skills under
+  // ~/.agents/skills.
+  const platform = args.platform || (scope === 'global' ? 'claude' : undefined);
 
   // Set tier env vars from detection so installer can resolve
   for (const tier of tiers) {
@@ -130,23 +135,44 @@ export async function runSetup({ projectRoot, runeRoot, args = {}, skillTarget:
   // Claude Code plugin cache when present, runeRoot otherwise. Without this
   // step, paid tiers ship hooks only — `rune:autopilot` returns "Unknown skill"
   // because Pro/skills/autopilot/ is invisible to the plugin runtime.
-  const skillTarget =
-    typeof skillTargetOverride === 'string'
-      ? { root: skillTargetOverride, source: 'override' }
-      : (skillTargetOverride ?? resolveSkillInstallRoot(runeRoot));
+  const skillPlatforms = result.platforms || [];
+  const skillTargets = skillPlatforms.map((skillPlatform) => {
+    if (skillPlatform === 'claude') {
+      if (typeof skillTargetOverride === 'string') {
+        return { platform: skillPlatform, root: skillTargetOverride, source: 'override' };
+      }
+      if (skillTargetOverride) return { platform: skillPlatform, ...skillTargetOverride };
+      return { platform: skillPlatform, ...resolveSkillInstallRoot(runeRoot) };
+    }
+    return {
+      platform: skillPlatform,
+      root: targetRoot,
+      source: scope === 'global' ? `${skillPlatform}-user` : `${skillPlatform}-project`,
+    };
+  });
+  const skillTarget = skillTargets[0] || null;
   const skillResults = [];
-  for (const tier of tiers) {
-    try {
-      const tierManifest = await resolveTier(tier, projectRoot);
-      const skillResult = await installTierSkills({
-        tier,
-        tierManifest,
-        runeRoot: skillTarget.root,
-        dry: args.dry,
-      });
-      skillResults.push(skillResult);
-    } catch (err) {
-      skillResults.push({ tier, installed: [], skipped: [], reason: err.message });
+  for (const skillTargetEntry of skillTargets) {
+    for (const tier of tiers) {
+      try {
+        const tierManifest = await resolveTier(tier, projectRoot);
+        const skillResult = await installTierSkills({
+          tier,
+          tierManifest,
+          runeRoot: skillTargetEntry.root,
+          platform: skillTargetEntry.platform,
+          dry: args.dry,
+        });
+        skillResults.push({ platform: skillTargetEntry.platform, ...skillResult });
+      } catch (err) {
+        skillResults.push({
+          platform: skillTargetEntry.platform,
+          tier,
+          installed: [],
+          skipped: [],
+          reason: err.message,
+        });
+      }
     }
   }
 
@@ -158,6 +184,7 @@ export async function runSetup({ projectRoot, runeRoot, args = {}, skillTarget:
     detected,
     skillResults,
     skillTarget,
+    skillTargets,
     ...result,
   };
 }
@@ -177,11 +204,12 @@ export async function runSetup({ projectRoot, runeRoot, args = {}, skillTarget:
  * @param {object} opts
  * @param {string} opts.tier
  * @param {import('./hooks/tiers.js').TierManifest} opts.tierManifest
- * @param {string} opts.runeRoot — target is `<runeRoot>/skills/`
+ * @param {string} opts.runeRoot — Claude plugin root, or project/user root for other platforms
+ * @param {string} [opts.platform='claude']
  * @param {boolean} [opts.dry]
  * @returns {Promise<{tier: string, installed: string[], skipped: Array<{skill: string, reason: string}>, reason: string|null}>}
  */
-export async function installTierSkills({ tier, tierManifest, runeRoot, dry }) {
+export async function installTierSkills({ tier, tierManifest, runeRoot, platform = 'claude', dry }) {
   if (!tierManifest?.source) {
     return { tier, installed: [], skipped: [], reason: 'tier manifest source missing' };
   }
@@ -203,9 +231,24 @@ export async function installTierSkills({ tier, tierManifest, runeRoot, dry }) {
   if (!runeRoot) {
     return { tier, installed: [], skipped: [], reason: 'runeRoot not provided' };
   }
-  const targetDir = path.join(runeRoot, 'skills');
+  const adapter = platform === 'claude' ? null : getCompilerAdapter(platform);
+  if (adapter && !adapter.useSkillDirectories) {
+    return {
+      tier,
+      installed: [],
+      skipped: [],
+      reason: `platform '${platform}' does not use directory-based Agent Skills`,
+    };
+  }
+  const targetDir = adapter ? path.join(runeRoot, adapter.outputDir) : path.join(runeRoot, 'skills');
   if (!existsSync(targetDir)) {
-    return { tier, installed: [], skipped: [], reason: `target skills/ missing at ${targetDir}` };
+    if (dry) {
+      // Dry-run should describe what would be installed even on a fresh target.
+    } else if (adapter) {
+      await mkdir(targetDir, { recursive: true });
+    } else {
+      return { tier, installed: [], skipped: [], reason: `target skills/ missing at ${targetDir}` };
+    }
   }
   const installed = [];
   const skipped = [];
@@ -230,7 +273,33 @@ export async function installTierSkills({ tier, tierManifest, runeRoot, dry }) {
       continue;
     }
     const src = path.join(sourceDir, skillName);
-    const dst = path.join(targetDir, skillName);
+    let parsed = null;
+    let compiledOutput = null;
+    let targetSkillName = skillName;
+    if (adapter) {
+      try {
+        const skillPath = path.join(src, 'SKILL.md');
+        const content = await readFile(skillPath, 'utf-8');
+        parsed = parseSkill(content, skillPath);
+        targetSkillName = `${adapter.skillPrefix || ''}${parsed.name}${adapter.skillSuffix || ''}`;
+        if (path.basename(targetSkillName) !== targetSkillName) {
+          skipped.push({ skill: skillName, reason: 'rejected: compiled skill name is unsafe' });
+          continue;
+        }
+        const { header, body: rawBody, footer } = transformSkill(parsed, adapter);
+        const scriptsSource = path.join(src, 'scripts');
+        const scriptsPath =
+          existsSync(scriptsSource) && typeof adapter.scriptsDir === 'function'
+            ? path.join(adapter.outputDir, adapter.scriptsDir(parsed.name)).replaceAll('\\', '/')
+            : null;
+        const body = scriptsPath ? resolveScriptsPath(rawBody, scriptsPath) : rawBody;
+        compiledOutput = [header, body, footer].filter(Boolean).join('\n');
+      } catch (err) {
+        skipped.push({ skill: skillName, reason: `compile failed for ${platform}: ${err.message}` });
+        continue;
+      }
+    }
+    const dst = path.join(targetDir, targetSkillName);
     if (existsSync(dst)) {
       const drift = await detectVersionDrift(src, dst);
       skipped.push({ skill: skillName, reason: drift || 'already present' });
@@ -242,6 +311,9 @@ export async function installTierSkills({ tier, tierManifest, runeRoot, dry }) {
         // symlinks at dst. Belt-and-suspenders alongside the isSymbolicLink reject above
         // (nested symlinks inside a skill dir would otherwise still recreate).
         await cp(src, dst, { recursive: true, dereference: true });
+        if (compiledOutput !== null) {
+          await writeFile(path.join(dst, adapter.skillFileName || 'SKILL.md'), compiledOutput, 'utf-8');
+        }
       } catch (err) {
         // Clean partial-copy residue so next run isn't silently locked-out by
         // existsSync(dst) on a corrupt half-written directory.
@@ -436,10 +508,11 @@ export function formatSetupResult(result) {
   lines.push(`  Preset:    ${result.preset}`);
   lines.push(`  Platforms: ${(result.platforms || []).join(', ') || '—'}`);
   for (const sr of result.skillResults || []) {
+    const platformLabel = sr.platform ? `/${sr.platform}` : '';
     if (sr.installed.length > 0) {
       const preview = sr.installed.slice(0, 3).join(', ');
       const more = sr.installed.length > 3 ? `, +${sr.installed.length - 3}` : '';
-      lines.push(`  Skills:    ${sr.tier}: ${sr.installed.length} installed (${preview}${more})`);
+      lines.push(`  Skills:    ${sr.tier}${platformLabel}: ${sr.installed.length} installed (${preview}${more})`);
     }
     if (sr.skipped.length > 0) {
       const rejected = sr.skipped.filter((s) => s.reason.startsWith('rejected:'));
@@ -447,14 +520,14 @@ export function formatSetupResult(result) {
       const parts = [];
       if (benign > 0) parts.push(`${benign} already present`);
       if (rejected.length > 0) parts.push(`${rejected.length} rejected`);
-      lines.push(`  Skipped:   ${sr.tier}: ${parts.join(', ')}`);
+      lines.push(`  Skipped:   ${sr.tier}${platformLabel}: ${parts.join(', ')}`);
       // Surface rejection details so the operator can investigate a compromised tier repo.
       for (const r of rejected) {
         lines.push(`    ⚠ ${r.skill}: ${r.reason}`);
       }
     }
     if (sr.reason) {
-      lines.push(`  Skill warn:${sr.tier}: ${sr.reason}`);
+      lines.push(`  Skill warn:${sr.tier}${platformLabel}: ${sr.reason}`);
     }
   }
   if (result.notes?.length) {

package/compiler/doctor.js

@@ -742,7 +742,7 @@ export async function checkMeshIntegrity(runeRoot) {
 /**
  * Parse skill connections from SKILL.md content
  */
-function parseSkillConnections(content, skillName) {
+export function parseSkillConnections(content, skillName) {
   const result = {
     name: skillName,
     calls: [],
@@ -777,13 +777,15 @@ function parseSkillConnections(content, skillName) {
   }
 
   // Extract Calls section
-  const callsMatch = content.match(/## Calls \(outbound\)\s*\n([\s\S]*?)(?=\n## |\n---|Z)/);
+  const callsMatch = content.match(/## Calls \(outbound(?: connections)?\)\s*\r?\n([\s\S]*?)(?=\r?\n## |\r?\n---|$)/);
   if (callsMatch) {
     const lines = callsMatch[1].split('\n');
     for (const line of lines) {
       // Match patterns like: - `scout` (L2): scan codebase
-      // Or: - scout (L2): scan codebase
-      const match = line.match(/^-\s*`?([a-z][\w-]*)`?\s*\(L\d\)/i);
+      // Or table rows like: | 1 | `scout` | L2 | scan codebase |
+      const match =
+        line.match(/^-\s*`?([a-z][\w-]*)`?\s*\((?:L[0-4]|ext)\)/i) ||
+        line.match(/^\|(?:[^|]*\|)*?\s*`?([a-z][\w-]*)`?\s*\|\s*(?:L[0-4]|ext)\s*\|/i);
       if (match) {
         const skillRef = match[1].toLowerCase();
         const reason = line
@@ -796,11 +798,15 @@ function parseSkillConnections(content, skillName) {
   }
 
   // Extract Called By section
-  const calledByMatch = content.match(/## Called By \(inbound\)\s*\n([\s\S]*?)(?=\n## |\n---|Z)/);
+  const calledByMatch = content.match(
+    /## Called By \(inbound(?: connections)?\)\s*\r?\n([\s\S]*?)(?=\r?\n## |\r?\n---|$)/,
+  );
   if (calledByMatch) {
     const lines = calledByMatch[1].split('\n');
     for (const line of lines) {
-      const match = line.match(/^-\s*`?([a-z][\w-]*)`?\s*\(L\d\)/i);
+      const match =
+        line.match(/^-\s*`?([a-z][\w-]*)`?\s*\((?:L[0-4]|ext)\)/i) ||
+        line.match(/^\|(?:[^|]*\|)*?\s*`?([a-z][\w-]*)`?\s*\|\s*(?:L[0-4]|ext)\s*\|/i);
       if (match) {
         const skillRef = match[1].toLowerCase();
         result.calledBy.push({ skill: skillRef });

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.