@hanzlaa/rcode 4.1.2 → 4.3.0

package/cli/install.js

@@ -59,6 +59,11 @@ const os = require('os');
 // Ctrl+C mid-write and malicious symlink-traversal during dedup/cleanup.
 const { writeFileAtomic, safeRmSync } = require('./lib/fsutil.cjs');
 
+// HOME-aware home resolution (#889) — os.homedir() ignores a stubbed HOME on
+// Windows (it reads USERPROFILE), so HOME-isolated tests and CI leaked global
+// installs (~/.rcode, ~/.codex, ~/.gemini) into the real profile dir there.
+const { homedir } = require('./lib/homedir.cjs');
+
 // Bundled packages — devDeps inlined by esbuild, loaded from node_modules in dev.
 const pc = require('picocolors');
 const { createSpinner } = require('nanospinner');
@@ -89,7 +94,7 @@ const SOURCE_ROOT = path.join(PACKAGE_ROOT, 'rcode');
  * detectIdeSignals, plus a row to runInstallWizard's multiselect — three
  * sites instead of ten.
  */
-const SUPPORTED_IDES = Object.freeze(['claude', 'cursor', 'gemini', 'vscode', 'antigravity', 'windsurf', 'codex']);
+const SUPPORTED_IDES = Object.freeze(['claude', 'cursor', 'gemini', 'vscode', 'antigravity', 'windsurf', 'codex', 'grok']);
 
 /**
  * Resolve the stable on-disk location of this package so config.yaml
@@ -247,7 +252,7 @@ function parseArgs(argv) {
   // project directory wrote rcode artifacts to that project, not to the user's
   // home where Claude Code reads global commands from.
   if (opts.global && !opts.targetProvided) {
-    opts.target = os.homedir();
+    opts.target = homedir();
   }
   // Issue #821/#832: pnpm workspace anchor.
   // When `pnpm add -D @hanzlaa/rcode` runs inside a workspace member,
@@ -386,7 +391,7 @@ function detectIdeSignals(target) {
   if (fs.existsSync(path.join(target, '.antigravity'))) signals.antigravity = true;
   if (fs.existsSync(path.join(target, '.windsurf'))) signals.windsurf = true;
   // 2. User-level config dirs
-  const home = os.homedir();
+  const home = homedir();
   if (fs.existsSync(path.join(home, '.claude'))) signals.claude = true;
   if (fs.existsSync(path.join(home, '.cursor'))) signals.cursor = true;
   if (fs.existsSync(path.join(home, '.config', 'Cursor'))) signals.cursor = true;
@@ -615,6 +620,21 @@ function getPathsForIde(ide, target) {
       // claude/vscode install paths). We install agent + command files to .claude/
       // so multi-IDE installs share files, and the rcode workflow bridge gives
       // Codex access to lifecycle workflows via `rcode workflow show <name>` (#883).
+      // NOTE: Codex surfaces native /slash commands ONLY from ~/.codex/prompts/*.md
+      // (home, startup-loaded) — installed separately by installNativeHomeSlashCommands()
+      // under the opt-in --global flag, since .claude/commands is invisible to Codex.
+      return {
+        agentsDir: path.join(target, '.claude', 'agents'),
+        commandsDir: path.join(target, '.claude', 'commands'),
+        workflowsDir: path.join(target, '.rcode', 'workflows'),
+        referencesDir: path.join(target, '.rcode', 'references'),
+        binDir: path.join(target, '.rcode', 'bin'),
+      };
+    case 'grok':
+      // Grok Build (xAI CLI) is Claude-Code-compatible: it reads slash commands
+      // from .claude/commands/*.md (project) and ~/.claude/commands (global), same
+      // as Claude Code. So grok maps to the identical .claude/ layout — verified
+      // live: `/rcode-add-phase` surfaces in grok from these dirs.
       return {
         agentsDir: path.join(target, '.claude', 'agents'),
         commandsDir: path.join(target, '.claude', 'commands'),
@@ -1079,7 +1099,7 @@ function installSkills(packageRoot, target, options = {}) {
   // prefix, Claude Code reads from BOTH global and project, showing every
   // /rcode-* twice in the slash picker. Skip the project copy for any rcode-*
   // skill that already lives in the global skills dir.
-  const globalSkillsDir = path.join(os.homedir(), '.claude', 'skills');
+  const globalSkillsDir = path.join(homedir(), '.claude', 'skills');
   const globalRcodeSkills = (options.skipGlobalDuplicates && fs.existsSync(globalSkillsDir))
     ? new Set(fs.readdirSync(globalSkillsDir).filter(n => n.startsWith('rcode-')))
     : new Set();
@@ -1303,7 +1323,7 @@ function buildInstallPlan(ide = 'claude', target = process.cwd()) {
     const rel = path.relative(path.join(SOURCE_ROOT, 'commands'), f);
     const ext = ide === 'cursor' ? '.mdc' : '.md';
     const baseName = path.basename(f, '.md');
-    const outName = (ide === 'claude' || ide === 'vscode')
+    const outName = (ide === 'claude' || ide === 'vscode' || ide === 'grok')
       ? `rcode-${baseName}${ext}`
       : baseName + ext;
     plan.push({ src: f, rel: path.join(relCommands, path.dirname(rel), outName), ide, cursor: ide === 'cursor' });
@@ -1452,8 +1472,8 @@ function generateAgentManifest(plan, target) {
   // Also scan rcode/agents/ in SOURCE_ROOT as a last-resort fallback so the
   // manifest is never empty when the package itself ships agent definitions.
   const extraScans = [
-    path.join(os.homedir(), '.claude', 'agents'),
-    path.join(os.homedir(), '.rcode', 'agents'),
+    path.join(homedir(), '.claude', 'agents'),
+    path.join(homedir(), '.rcode', 'agents'),
   ];
   // Final fallback: scan the package source itself.
   try {
@@ -1901,6 +1921,125 @@ function acquireInstallLock(target) {
   return { ok: false, pid: 0, lockPath };
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Native home-dir slash-command install.
+//
+// Some agentic CLIs surface their `/slash` command menu ONLY from a fixed
+// home directory (not from project dirs the way Claude Code / Grok do):
+//   • Codex      → ~/.codex/prompts/<name>.md          (flat prompt files)
+//   • Antigravity→ ~/.gemini/antigravity/skills/<name>/SKILL.md (skill dirs)
+// For those tools the normal project install writes files the CLI never reads,
+// so `/rcode-*` never appears. This installs the commands in each CLI's NATIVE
+// format into its NATIVE home dir, gated behind the opt-in `--global` flag.
+//
+// IDEs that read project dirs (claude, grok, cursor, vscode, windsurf) are a
+// no-op here — they already work via getPathsForIde().
+//
+// Each tool's writer lives in its own helper; the dispatcher routes by ide.
+// SOURCE_ROOT/commands/*.md is the canonical command source for all writers.
+// ─────────────────────────────────────────────────────────────────────────────
+
+// Codex + Antigravity surface NO file-based slash commands (verified live),
+// but BOTH support a prompt-submit hook (UserPromptSubmit / UserPrompt) that
+// can inject context. We install a hook ROUTER (cli/rcode-slash-router.cjs)
+// into each, plus a home-dir copy of every command body the router reads.
+// See cli/rcode-slash-router.cjs for the runtime contract.
+
+// Shared: copy every command body to ~/.rcode/slash-commands/<name>.md and the
+// router script to ~/.rcode/bin/. A fixed home-dir location lets the hook read
+// commands regardless of the user's cwd. Idempotent (plain overwrite).
+function installSlashRouterCommands(opts) {
+  const home = homedir();
+  const cmdDestDir = path.join(home, '.rcode', 'slash-commands');
+  const binDestDir = path.join(home, '.rcode', 'bin');
+  ensureDir(cmdDestDir);
+  ensureDir(binDestDir);
+
+  const srcCmdDir = path.join(SOURCE_ROOT, 'commands');
+  let copied = 0;
+  for (const file of fs.readdirSync(srcCmdDir)) {
+    if (!file.endsWith('.md')) continue;
+    fs.copyFileSync(path.join(srcCmdDir, file), path.join(cmdDestDir, file));
+    copied++;
+  }
+
+  const routerSrc = path.join(PACKAGE_ROOT, 'cli', 'rcode-slash-router.cjs');
+  const routerDest = path.join(binDestDir, 'rcode-slash-router.cjs');
+  fs.copyFileSync(routerSrc, routerDest);
+
+  if (opts && opts.global !== 'silent') {
+    console.log('  ' + ok(`Slash-router: ${copied} command bodies → ~/.rcode/slash-commands/ + router → ~/.rcode/bin/`));
+  }
+  return routerDest;
+}
+
+// The absolute command a hook entry runs. Matched by substring for idempotency
+// and for removal on uninstall — keep the basename stable.
+function slashRouterHookCommand() {
+  return `node "${path.join(homedir(), '.rcode', 'bin', 'rcode-slash-router.cjs')}"`;
+}
+
+// Merge a prompt-submit hook entry into an existing CLI hooks JSON file without
+// disturbing any pre-existing entries (e.g. herdr's). `eventKey` is the hook
+// event name that CLI uses (codex: UserPromptSubmit, antigravity: UserPrompt).
+// Idempotent: re-running detects the router by command substring and no-ops.
+function mergeSlashRouterHook(jsonPath, eventKey, command, label) {
+  let root = {};
+  if (fs.existsSync(jsonPath)) {
+    try {
+      root = JSON.parse(fs.readFileSync(jsonPath, 'utf8')) || {};
+    } catch {
+      // Unparseable file — don't clobber the user's config; bail loudly.
+      console.log('  ' + warn(`${label}: ${jsonPath} is not valid JSON — skipped slash-router wiring.`));
+      return false;
+    }
+  }
+  if (!root.hooks || typeof root.hooks !== 'object') root.hooks = {};
+  if (!Array.isArray(root.hooks[eventKey])) root.hooks[eventKey] = [];
+
+  const already = root.hooks[eventKey].some(group =>
+    Array.isArray(group?.hooks) &&
+    group.hooks.some(h => typeof h?.command === 'string' && h.command.includes('rcode-slash-router.cjs')),
+  );
+  if (already) {
+    console.log('  ' + ok(`${label}: slash-router hook already present (idempotent).`));
+    return false;
+  }
+
+  root.hooks[eventKey].push({ hooks: [{ type: 'command', command, timeout: 10 }] });
+  ensureDir(path.dirname(jsonPath));
+  fs.writeFileSync(jsonPath, JSON.stringify(root, null, 2) + '\n');
+  console.log('  ' + ok(`${label}: wired slash-router into ${eventKey} hook (existing hooks preserved).`));
+  return true;
+}
+
+// Codex: ~/.codex/hooks.json, event UserPromptSubmit.
+function installCodexSlashRouterHook(opts) {
+  installSlashRouterCommands(opts);
+  const jsonPath = path.join(homedir(), '.codex', 'hooks.json');
+  mergeSlashRouterHook(jsonPath, 'UserPromptSubmit', slashRouterHookCommand(), 'Codex');
+}
+
+// Antigravity: ~/.gemini/antigravity/settings.json, event UserPrompt.
+function installAntigravitySlashRouterHook(opts) {
+  installSlashRouterCommands(opts);
+  const jsonPath = path.join(homedir(), '.gemini', 'antigravity', 'settings.json');
+  mergeSlashRouterHook(jsonPath, 'UserPrompt', slashRouterHookCommand(), 'Antigravity');
+}
+
+function installNativeHomeSlashCommands(opts) {
+  if (!opts || !opts.global) return;
+  const ides = Array.isArray(opts.ides) ? opts.ides : [opts.ide].filter(Boolean);
+  for (const ide of ides) {
+    switch (ide) {
+      case 'codex': installCodexSlashRouterHook(opts); break;
+      case 'antigravity': installAntigravitySlashRouterHook(opts); break;
+      default:
+        break;
+    }
+  }
+}
+
 async function installInner(opts) {
   const pkgVersion = readPackageVersion();
 
@@ -1955,6 +2094,7 @@ async function installInner(opts) {
     console.error('    vscode       — VS Code (with Claude Code / Continue / Copilot extension)');
     console.error('    windsurf     — Windsurf (Codeium)');
     console.error('    antigravity  — Antigravity (experimental)');
+    console.error('    grok         — Grok Build (xAI CLI, Claude-Code-compatible)');
     console.error('');
     console.error('  Tracked for future:');
     console.error('    jetbrains    — IntelliJ / PyCharm');
@@ -2298,6 +2438,16 @@ async function installInner(opts) {
     } catch { /* non-fatal */ }
     console.log('');
     console.log(`  ${dim(`${skillsInstalled} skills installed globally`)}`);
+
+    // Native home-dir slash commands for CLIs that can't surface file-based
+    // /commands (codex, antigravity) but DO support a prompt-submit hook.
+    // This MUST run inside the --global block: the global path returns here,
+    // before the non-global call site below. Gated on opts.global inside.
+    try {
+      installNativeHomeSlashCommands(opts);
+    } catch (err) {
+      process.stderr.write(pc.yellow(`WARNING: native slash-command install skipped: ${err?.message || err}`) + '\n');
+    }
     return 0;
   }
 
@@ -2305,9 +2455,9 @@ async function installInner(opts) {
   // skip writing agents/commands to the project's .claude/ directory. Without this,
   // running `npx rcode install` in the home dir AND then in a project creates two sets
   // of identical files — Claude Code shows both as duplicate slash commands.
-  const globalClaudeCommands = path.join(os.homedir(), '.claude', 'commands');
+  const globalClaudeCommands = path.join(homedir(), '.claude', 'commands');
   const projectClaudeCommands = path.join(opts.target, '.claude', 'commands');
-  const isProjectInstall = opts.target !== os.homedir();
+  const isProjectInstall = opts.target !== homedir();
   // Run dedup even when force:true — only forceOverwrite skips it.
   if (isProjectInstall && !opts.forceOverwrite) {
     try {
@@ -2489,7 +2639,7 @@ async function installInner(opts) {
   }
 
   // ~/.rcode/agents/ global agents directory
-  const globalAgentsDir = path.join(os.homedir(), '.rcode', 'agents');
+  const globalAgentsDir = path.join(homedir(), '.rcode', 'agents');
   ensureDir(globalAgentsDir);
 
   // Issue #702: files-manifest.csv used to be written here, BEFORE
@@ -2674,9 +2824,9 @@ async function installInner(opts) {
     // the project skills folder may have only sidebar stubs while ~/.claude/
     // has the real skills — health check should see those.
     if (agentCount === 0 || commandCount === 0 || skillsInstalled < 20) {
-      const homeAgents = path.join(os.homedir(), '.claude/agents');
-      const homeCommands = path.join(os.homedir(), '.claude/commands');
-      const homeSkills = path.join(os.homedir(), '.claude/skills');
+      const homeAgents = path.join(homedir(), '.claude/agents');
+      const homeCommands = path.join(homedir(), '.claude/commands');
+      const homeSkills = path.join(homedir(), '.claude/skills');
       if (agentCount === 0 && fs.existsSync(homeAgents)) {
         // #669 — count both rcode-* and rcode-* prefixes; missing rcode-
         // branch produced "Agents: 0" alongside "Skills: 120".
@@ -2721,6 +2871,14 @@ async function installInner(opts) {
     }
   } catch { /* non-fatal */ }
 
+  // Native home-dir slash commands for CLIs that ONLY surface /commands from
+  // their own home dir (not project dirs). Opt-in via --global. See the fn def.
+  try {
+    installNativeHomeSlashCommands(opts);
+  } catch (err) {
+    process.stderr.write(pc.yellow(`WARNING: native slash-command install skipped: ${err?.message || err}`) + '\n');
+  }
+
   const version = readPackageVersion();
   console.log('');
   console.log(`  ${bold('Version:')}   ${pc.cyan('@hanzlaa/rcode@' + version)}`);
@@ -3071,3 +3229,8 @@ module.exports.install = install;
 module.exports.SUPPORTED_IDES = SUPPORTED_IDES;
 module.exports.migrateVscodeCommandsLayout = migrateVscodeCommandsLayout;
 module.exports.getPathsForIde = getPathsForIde;
+// Slash-router (hook-based /rcode-* support for codex + antigravity).
+module.exports.installSlashRouterCommands = installSlashRouterCommands;
+module.exports.installCodexSlashRouterHook = installCodexSlashRouterHook;
+module.exports.installAntigravitySlashRouterHook = installAntigravitySlashRouterHook;
+module.exports.installNativeHomeSlashCommands = installNativeHomeSlashCommands;

package/cli/lib/config.cjs

@@ -18,9 +18,11 @@
  */
 
 const fs = require('fs');
-const os = require('os');
 const path = require('path');
 const { writeJsonAtomic } = require('./fsutil.cjs');
+// HOME-aware home resolution (#889) — os.homedir() ignores a stubbed HOME
+// on Windows, which broke user-level defaults isolation in tests.
+const { homedir } = require('./homedir.cjs');
 
 // ---------- Schema ----------
 
@@ -102,7 +104,7 @@ const VALID_COMMUNICATION_MODES = new Set(['guided', 'yolo']);
 // ---------- Paths ----------
 
 function userLevelPath() {
-  return path.join(os.homedir(), '.rcode', 'defaults.json');
+  return path.join(homedir(), '.rcode', 'defaults.json');
 }
 
 function projectLevelPath(cwd) {

package/cli/lib/fsutil.cjs

@@ -115,8 +115,19 @@ function safeRmSync(targetPath, projectRoot) {
     }
   }
 
-  // Real path must stay inside the project root.
-  const root = path.resolve(projectRoot);
+  // Real path must stay inside the project root. The root must be
+  // realpathed too: on macOS os.tmpdir() lives behind a symlink
+  // (/tmp → /private/tmp, /var → /private/var), so comparing a realpathed
+  // target against a merely-resolved root misreports anything under /tmp
+  // as outside-root.
+  let root;
+  try {
+    root = fs.realpathSync(projectRoot);
+  } catch {
+    // Root missing/unreadable — fall back to a lexical resolve; the
+    // containment check below then fails closed for an existing target.
+    root = path.resolve(projectRoot);
+  }
   let resolved;
   try {
     resolved = fs.realpathSync(targetPath);

package/cli/lib/homedir.cjs

@@ -0,0 +1,21 @@
+/**
+ * cli/lib/homedir.cjs — user home directory resolution (#889).
+ *
+ * process.env.HOME wins over os.homedir() so a single env var redirects
+ * every home-relative read/write on EVERY platform. os.homedir() ignores
+ * HOME on Windows (it reads USERPROFILE), which made HOME-stubbed tests
+ * silently escape to the real profile dir on Windows CI — installs leaked
+ * ~/.codex / ~/.gemini / ~/.rcode into the runner's real home and broke
+ * unrelated tests. Honoring HOME also matches git/npm behavior on Windows
+ * (git-bash sets HOME), so real users get consistent paths across shells.
+ */
+
+'use strict';
+
+const os = require('os');
+
+function homedir() {
+  return process.env.HOME || os.homedir();
+}
+
+module.exports = { homedir };

package/cli/lib/schemas.cjs

@@ -35,9 +35,14 @@ const { z } = require('zod');
  * @returns {{ frontmatter: object, body: string }}
  */
 function parseFrontmatter(text) {
-  if (typeof text !== 'string' || !text.startsWith('---\n')) {
+  if (typeof text !== 'string') {
     return { frontmatter: {}, body: text || '' };
   }
+  // CRLF tolerance (#889): Windows checkouts/user files may use \r\n.
+  text = text.replace(/\r\n/g, '\n');
+  if (!text.startsWith('---\n')) {
+    return { frontmatter: {}, body: text };
+  }
   const end = text.indexOf('\n---\n', 4);
   if (end === -1) return { frontmatter: {}, body: text };
   const block = text.slice(4, end);

package/cli/nuke.js

@@ -20,9 +20,12 @@
 'use strict';
 
 const fs = require('fs');
-const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
+// HOME-aware home resolution (#889) — os.homedir() ignores a stubbed HOME
+// on Windows, so tests pointing HOME at a temp dir still scanned the real
+// profile dir there (and tripped over real ~/.rcode state).
+const { homedir } = require('./lib/homedir.cjs');
 
 function exists(p) {
   try { fs.accessSync(p); return true; } catch { return false; }
@@ -37,7 +40,7 @@ function readDirSafe(p) {
  * Returns a list of { manager, dir } — dir may not exist.
  */
 function getGlobalNodeModulesDirs() {
-  const home = os.homedir();
+  const home = homedir();
   const candidates = [];
 
   // npm — npm root -g resolves to the active node version's lib/node_modules.
@@ -106,7 +109,7 @@ function findRcodePackages(globalNodeModules) {
  * Resolve global bin directories where rcode/rcode/rcode may live.
  */
 function getGlobalBinDirs() {
-  const home = os.homedir();
+  const home = homedir();
   const dirs = new Set();
 
   // npm prefix bin
@@ -214,7 +217,7 @@ function findClaudeArtifacts(claudeDir) {
 }
 
 function buildPlan({ includePlanning }) {
-  const home = os.homedir();
+  const home = homedir();
   const cwd = process.cwd();
   const plan = {
     packages: [],
@@ -244,13 +247,15 @@ function buildPlan({ includePlanning }) {
   plan.globalClaude = findClaudeArtifacts(path.join(home, '.claude'));
 
   // Global state (~/.rcode/)
+  // #889: was `= globalRcode` (undefined) — a ReferenceError that only fired
+  // when ~/.rcode existed, crashing every dry-run on machines with global state.
   const globalrcode = path.join(home, '.rcode');
-  if (exists(globalrcode)) plan.globalrcode = globalRcode;
+  if (exists(globalrcode)) plan.globalrcode = globalrcode;
 
   // Project-level (CWD only — never recurse, user may have many projects)
   plan.projectClaude = findClaudeArtifacts(path.join(cwd, '.claude'));
   const projectrcode = path.join(cwd, '.rcode');
-  if (exists(projectrcode) && cwd !== home) plan.projectrcode = projectRcode;
+  if (exists(projectrcode) && cwd !== home) plan.projectrcode = projectrcode;
 
   if (includePlanning) {
     const projectPlanning = path.join(cwd, '.planning');
@@ -351,7 +356,7 @@ function executePlan(plan) {
     if (rmrf(a.path)) { console.log(`  ✓ removed ${a.path}`); removed++; }
   }
   if (plan.globalrcode && rmrf(plan.globalrcode)) {
-    console.log(`  ✓ removed ${plan.globalRcode}`); removed++;
+    console.log(`  ✓ removed ${plan.globalrcode}`); removed++;
   }
 
   // Claude artifacts (project)
@@ -359,7 +364,7 @@ function executePlan(plan) {
     if (rmrf(a.path)) { console.log(`  ✓ removed ${a.path}`); removed++; }
   }
   if (plan.projectrcode && rmrf(plan.projectrcode)) {
-    console.log(`  ✓ removed ${plan.projectRcode}`); removed++;
+    console.log(`  ✓ removed ${plan.projectrcode}`); removed++;
   }
   if (plan.projectPlanning && rmrf(plan.projectPlanning)) {
     console.log(`  ✓ removed ${plan.projectPlanning}`); removed++;

package/cli/postinstall.js

@@ -13,6 +13,17 @@
 const os = require('os');
 const path = require('path');
 
+/**
+ * Path containment check that survives Windows: path.relative normalizes
+ * separators (/ vs \) and compares drive letters case-insensitively, which
+ * a raw startsWith prefix compare does not.
+ */
+function isPathInside(child, parent) {
+  const rel = path.relative(parent, child);
+  if (rel === '') return true;
+  return rel !== '..' && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel);
+}
+
 /**
  * Decide whether the current postinstall invocation represents a GLOBAL
  * `npm install -g @hanzlaa/rcode` (true) or a transitive devDep install
@@ -28,17 +39,16 @@ const path = require('path');
 function isGlobalInstall(env, dirname, cwd) {
   try {
     if (env.npm_config_global === 'true') return true;
-    if (env.PNPM_HOME && dirname.startsWith(env.PNPM_HOME)) return true;
+    if (env.PNPM_HOME && isPathInside(dirname, env.PNPM_HOME)) return true;
     const globalPatterns = [
-      /\/node_modules\/@hanzlaa\/rcode/,
+      /[/\\]node_modules[/\\]@hanzlaa[/\\]rcode/,
       /[/\\]lib[/\\]node_modules[/\\]/,
       /\.nvm[/\\]versions[/\\]/,
       /\.pnpm[/\\]/,
       /\.yarn[/\\]global/,
     ];
     if (globalPatterns.some((re) => re.test(dirname))) return true;
-    const localNodeModules = path.join(cwd, 'node_modules');
-    if (!dirname.startsWith(localNodeModules)) return true;
+    if (!isPathInside(dirname, path.join(cwd, 'node_modules'))) return true;
     return false;
   } catch {
     return false;

package/cli/rcode-slash-router.cjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+'use strict';
+
+// rcode slash-command hook router.
+//
+// WHY this exists: Codex CLI and Antigravity CLI do NOT surface file-based
+// `/slash` commands the way Claude Code / Grok do (verified live). They DO,
+// however, support a prompt-submit hook (`UserPromptSubmit` / `UserPrompt`)
+// that can inject extra context into the model's turn. This router is wired
+// into that hook by the installer. When the user types `/rcode-<name> [args]`,
+// the router loads the matching command body and injects it as additional
+// context so the model executes that command — the closest thing to a native
+// slash command those CLIs allow.
+//
+// Dependency-free (Node stdlib only) so it can run from a stable home dir
+// (~/.rcode/bin/) without an install step. NEVER throws to the host CLI: any
+// error exits 0 with no output so a malfunctioning router can never break or
+// swallow the user's real prompt.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// Command bodies are copied here by the installer (installSlashRouterCommands).
+// A fixed home-dir location means the hook can always read them regardless of
+// the user's current working directory.
+// HOME wins over os.homedir() (#889): os.homedir() ignores HOME on Windows
+// (it reads USERPROFILE), so HOME-redirected runs (tests, git-bash) would read
+// the wrong profile dir. Inlined — this script is copied standalone to
+// ~/.rcode/bin/ and must stay dependency-free (no ./lib requires).
+const COMMANDS_DIR = path.join(process.env.HOME || os.homedir(), '.rcode', 'slash-commands');
+
+// Matches `/rcode-<name>` at the very start, optional whitespace, then the
+// rest of the line(s) as arguments. `\b` ends the command name so trailing
+// punctuation/args don't leak into <name>.
+const SLASH_RE = /^\/rcode-([a-z0-9-]+)\b[ \t]*([\s\S]*)$/;
+
+function readStdin() {
+  try {
+    return fs.readFileSync(0, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+// Strip a leading YAML frontmatter block (`---\n...\n---`). The frontmatter is
+// CLI-tooling metadata (name/description/allowed-tools) that only confuses the
+// model — we want the executable command body injected, not its header.
+// \r?\n because Windows checkouts may deliver CRLF command bodies (#889).
+function stripFrontmatter(text) {
+  return text.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '');
+}
+
+function emit(hookEventName, additionalContext) {
+  const payload = {
+    hookSpecificOutput: {
+      hookEventName: hookEventName || 'UserPromptSubmit',
+      additionalContext,
+    },
+  };
+  process.stdout.write(JSON.stringify(payload));
+}
+
+function main() {
+  const raw = readStdin();
+  if (!raw.trim()) return;
+
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return; // not JSON we understand → pass-through (no output)
+  }
+
+  // Field names vary across CLIs; accept the common spellings.
+  const prompt =
+    data.prompt ??
+    data.user_prompt ??
+    data.userPrompt ??
+    data.message ??
+    data.input ??
+    '';
+  const hookEventName = data.hook_event_name || data.hookEventName || 'UserPromptSubmit';
+
+  if (typeof prompt !== 'string') return;
+
+  const match = prompt.replace(/^\s+/, '').match(SLASH_RE);
+  if (!match) return; // not an rcode command → pass-through (no output)
+
+  const name = match[1];
+  const args = (match[2] || '').trim();
+
+  const cmdFile = path.join(COMMANDS_DIR, `${name}.md`);
+  if (!fs.existsSync(cmdFile)) {
+    // Unknown command: inject a short note rather than silently doing nothing,
+    // so the user learns the command name didn't resolve.
+    emit(
+      hookEventName,
+      `Unknown rcode command: /rcode-${name}. No matching command body was found in ${COMMANDS_DIR}.`,
+    );
+    return;
+  }
+
+  let body = stripFrontmatter(fs.readFileSync(cmdFile, 'utf8')).trim();
+  if (args) {
+    // Surface user-supplied args the way the command bodies expect ($ARGUMENTS).
+    body += `\n\nArguments: ${args}`;
+  }
+
+  emit(hookEventName, body);
+}
+
+try {
+  main();
+} catch {
+  // Never break the host CLI's prompt — fail open, silently.
+}
+process.exit(0);