0xray 3.0.12 → 3.1.0

package/dist/integrations/grok/grok-cli.js

@@ -1,5 +1,5 @@
 /**
- * Grok CLI Integration for 0xRay
+ * Grok CLI Integration for StringRay / 0xRay
  *
  * This module provides the integration points for using 0xRay with the official Grok CLI.
  *
@@ -31,65 +31,53 @@ export async function installForGrokCLI(options = {}) {
     ];
     let sourceDir = possibleSources.find(p => fs.existsSync(p));
     if (!sourceDir) {
-        frameworkLogger.log('grok-cli', 'Could not locate the 0xray Grok plugin inside the package.', 'error', {});
+        console.error('[Grok] Could not locate the 0xray Grok plugin inside the package.');
         return;
     }
     if (options.dryRun) {
-        frameworkLogger.log('grok-cli', `Dry run: Would copy plugin from ${sourceDir} → ${targetPluginDir}`, 'info', {});
+        console.log(`[Grok] Dry run: Would copy plugin from ${sourceDir} → ${targetPluginDir}`);
         return;
     }
     try {
         if (fs.existsSync(targetPluginDir) && !options.force) {
-            frameworkLogger.log('grok-cli', '0xray Grok plugin is already installed.', 'info', {});
-            frameworkLogger.log('grok-cli', 'Use --force to reinstall.', 'info', {});
+            console.log('[Grok] 0xray Grok plugin is already installed.');
+            console.log('Use --force to reinstall.');
             return;
         }
         fs.cpSync(sourceDir, targetPluginDir, { recursive: true, force: true });
         frameworkLogger.log('grok-integration', 'plugin-copied', 'info', { destination: targetPluginDir });
-        frameworkLogger.log('grok-cli', `Copied Grok plugin to ${targetPluginDir}`, 'info', {});
+        console.log(`\x1b[32m✓ Copied Grok plugin to ${targetPluginDir}\x1b[0m`);
         // Attempt auto-trust (best effort)
         try {
             execSync(`grok plugins trust "${targetPluginDir}"`, { stdio: 'ignore' });
-            frameworkLogger.log('grok-cli', 'Auto-trusted the 0xray plugin with Grok CLI', 'info', {});
+            console.log('\x1b[32m✓ Auto-trusted the 0xray plugin with Grok CLI\x1b[0m');
         }
         catch {
-            frameworkLogger.log('grok-cli', 'Please run this command to fully trust the plugin:', 'info', {});
-            frameworkLogger.log('grok-cli', `  grok plugins trust "${targetPluginDir}"`, 'info', {});
+            console.log('\nPlease run this command to fully trust the plugin:');
+            console.log(`  grok plugins trust "${targetPluginDir}"`);
         }
         // Register MCP servers via grok mcp add (most reliable mechanism)
-        const xrayRoot = path.resolve(__dirname, '..', '..', '..');
-        const govMcpPath = path.join(xrayRoot, 'dist/mcps/governance.server.js');
-        const skillsMcpPath = path.join(xrayRoot, 'dist/mcps/knowledge-skills/skill-invocation.server.js');
-        const enforcerMcpPath = path.join(xrayRoot, 'dist/mcps/enforcer-tools.server.js');
-        const orchestratorMcpPath = path.join(xrayRoot, 'dist/mcps/orchestrator/server.js');
-        const mcpServers = [
-            { name: 'xray-governance', path: govMcpPath },
-            { name: 'xray-skills', path: skillsMcpPath },
-            { name: 'xray-enforcer', path: enforcerMcpPath },
-            { name: 'xray-orchestrator', path: orchestratorMcpPath },
-        ];
+        const govMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/governance.server.js');
+        const skillsMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/knowledge-skills/skill-invocation.server.js');
         try {
-            for (const server of mcpServers) {
-                execSync(`grok mcp add ${server.name} --command node --args "${server.path}" --env "XRAY_ROOT=${xrayRoot}"`, { stdio: 'pipe' });
-            }
-            frameworkLogger.log('grok-cli', 'Registered xray MCP servers with Grok CLI', 'info', {});
+            execSync(`grok mcp add strray-governance --command node --args "${govMcpPath}" --env "STRRAY_FORCE_MCP_GOVERNANCE=true" --env "STRRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
+            execSync(`grok mcp add strray-skills --command node --args "${skillsMcpPath}" --env "STRRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
+            console.log('\x1b[32m✓ Registered strray MCP servers with Grok CLI\x1b[0m');
         }
         catch {
-            frameworkLogger.log('grok-cli', 'Could not auto-register MCP servers. Run manually:', 'info', {});
-            for (const server of mcpServers) {
-                frameworkLogger.log('grok-cli', `  grok mcp add ${server.name} --command node --args "${server.path}"`, 'info', {});
-            }
+            console.log('\nCould not auto-register MCP servers. Run manually:');
+            console.log(`  grok mcp add strray-governance --command node --args "${govMcpPath}"`);
+            console.log(`  grok mcp add strray-skills --command node --args "${skillsMcpPath}"`);
         }
-        frameworkLogger.log('grok-cli', '0xRay is now installed as a first-class Grok CLI plugin!', 'info', {});
-        frameworkLogger.log('grok-cli', 'Restart Grok or run `grok` to load the new hooks and MCP servers.', 'info', {});
+        console.log('\n✅ 0xRay is now installed as a first-class Grok CLI plugin!');
+        console.log('Restart Grok or run `grok` to load the new hooks and MCP servers.');
     }
     catch (err) {
         frameworkLogger.log('grok-integration', 'install-error', 'error', { error: err.message });
-        frameworkLogger.log('grok-cli', 'Failed to install Grok plugin:', 'error', { error: err.message });
+        console.error('Failed to install Grok plugin:', err.message);
     }
     frameworkLogger.log('grok-integration', 'install-complete', 'info', {});
 }
 export default {
     installForGrokCLI,
 };
-//# sourceMappingURL=grok-cli.js.map

package/dist/integrations/grok/hooks/pre-tool-use.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Grok CLI PreToolUse Hook Handler for 0xRay — First Class Citizen
+ * Grok CLI PreToolUse Hook Handler for StringRay (0xRay) — First Class Citizen
  *
  * Real governance enforcement hook.
  * When Grok is about to execute a tool (write_file, edit, terminal cmd, etc.),
@@ -10,34 +10,13 @@
 import fs from 'fs';
 import path from 'path';
 
-let fLogger = null;
-
-function safeLog(component, action, details = {}) {
-  if (!fLogger) return;
-  try { fLogger.log(component, action, 'info', details).catch(() => {}); } catch {}
-}
-
-function flushLog() {
-  if (!fLogger) return;
-  try { fLogger.flushSync(); } catch {}
-}
-
-async function initLogger() {
-  try {
-    const here = path.dirname(new URL(import.meta.url).pathname);
-    const loggerPath = path.resolve(here, '../../../core/framework-logger.js');
-    const mod = await import(`file://${loggerPath}`);
-    fLogger = mod.frameworkLogger || mod.default?.frameworkLogger;
-  } catch {}
-}
-
 const log = (msg) => { try { console.error(`[0xRay:GrokHook] ${msg}`); } catch { /* noop */ } };
 
 function findGovernanceCore() {
   const here = path.dirname(new URL(import.meta.url).pathname);
 
   // Priority: explicit dev root
-  const devRoot = process.env.XRAY_DEV_ROOT || '';
+  const devRoot = process.env.STRRAY_ROOT;
   if (devRoot) {
     const devCandidate = path.resolve(devRoot, 'dist/governance/governance-core.js');
     if (fs.existsSync(devCandidate)) return devCandidate;
@@ -100,15 +79,12 @@ function deriveResonance(toolName, extra = '') {
 }
 
 async function main() {
-  await initLogger();
-
   try {
     const toolName = process.env.TOOL_NAME || process.env.HOOK_TOOL || 'unknown_tool';
     const cwd = process.env.PWD || process.cwd();
     const extraContext = process.env.HOOK_ARGS || process.env.TOOL_ARGS || '';
 
     log(`PreToolUse: ${toolName}`);
-    safeLog('grok-hook', 'pre-tool-use', { tool: toolName, cwd });
 
     const corePath = findGovernanceCore();
     let recommendation = 'ALLOW';
@@ -116,13 +92,25 @@ async function main() {
     let govDetails = null;
 
     if (corePath) {
-      // Governance core no longer exposes the legacy PHI/TAU matrix (purged in v3).
-      // Resonance is still derived locally for logging/decision notes.
-      log(`Using local resonance derivation (core matrix purged)`);
-      safeLog('grok-hook', 'governance-core-found', { corePath });
+      try {
+        const core = await import(`file://${corePath}`);
+        if (typeof core.applyDecisionMatrix === 'function') {
+          const result = core.applyDecisionMatrix({
+            resonance,
+            isotopicRatio: resonance > 0.8 ? 0.96 : 0.7,
+            vortexVolume: 1_000_000,
+            historicalCoherence: 0.82,
+            solarActivity: 'active',
+          });
+          govDetails = result;
+          recommendation = result.recommendation || 'NEEDS_REVISION';
+          log(`Solar decision: ${recommendation} (resonance=${resonance.toFixed(2)})`);
+        }
+      } catch (e) {
+        log(`Governance core error: ${e.message}`);
+      }
     } else {
       log('Governance core not located — using safe default');
-      safeLog('grok-hook', 'governance-core-not-found', {});
     }
 
     const decision = {
@@ -135,14 +123,10 @@ async function main() {
       source: '0xray/grok-pre-tool-use',
     };
 
-    safeLog('grok-hook', 'decision', { tool: toolName, decision: decision.decision, resonance: decision.resonance });
-    flushLog();
     console.log(JSON.stringify(decision));
     process.exit(0); // non-blocking rollout; future versions can exit(1) on strong reject
   } catch (err) {
     log(`Hook failure (non-fatal): ${err.message}`);
-    safeLog('grok-hook', 'hook-failure', { error: err.message });
-    flushLog();
     process.exit(0);
   }
 }

package/dist/integrations/grok/plugin/0xray/.mcp.json

@@ -1,20 +1,23 @@
 {
   "mcpServers": {
-    "xray-governance": {
+    "0xray-governance": {
       "command": "npx",
-      "args": ["-y", "0xray", "mcp", "governance"]
+      "args": ["-y", "0xray", "mcp", "governance"],
+      "env": {
+        "XRAY_FORCE_MCP_GOVERNANCE": "true"
+      }
     },
-    "xray-skills": {
+    "0xray-skills": {
       "command": "npx",
       "args": ["-y", "0xray", "mcp", "skills"]
     },
-    "xray-enforcer": {
+    "0xray-orchestrator": {
       "command": "npx",
-      "args": ["-y", "0xray", "mcp", "enforcer"]
+      "args": ["-y", "0xray", "mcp", "orchestrator"]
     },
-    "xray-orchestrator": {
+    "0xray-enforcer": {
       "command": "npx",
-      "args": ["-y", "0xray", "mcp", "orchestrator"]
+      "args": ["-y", "0xray", "mcp", "enforcer"]
     }
   }
-}
+}

package/dist/integrations/grok/plugin/0xray/hooks/hooks.json

@@ -8,7 +8,7 @@
             "type": "command",
             "command": "node",
             "args": [
-              "${XRAY_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/pre-tool-use.js"
+              "${STRRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/pre-tool-use.js"
             ],
             "timeout": 30000
           }
@@ -21,7 +21,7 @@
           {
             "type": "command",
             "command": "echo",
-            "args": ["[0xRay] Grok session started with 0xRay governance enabled"]
+            "args": ["[0xRay] Grok session started with StringRay governance enabled"]
           }
         ]
       }

package/dist/integrations/hermes-agent/.mcp.json

@@ -0,0 +1,32 @@
+{
+  "mcpServers": {
+    "xray-governance": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "governance"]
+    },
+    "xray-skills": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "skills"]
+    },
+    "xray-researcher": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "researcher"]
+    },
+    "xray-code-review": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "code-review"]
+    },
+    "xray-architect-tools": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "architect-tools"]
+    },
+    "xray-enforcer": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "enforcer"]
+    },
+    "xray-orchestrator": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "orchestrator"]
+    }
+  }
+}

package/dist/integrations/hermes-agent/__init__.py

@@ -41,15 +41,9 @@ BRIDGE_PATH = PLUGIN_DIR / "bridge.mjs"
 # so walking up from PLUGIN_DIR will never find the project. Instead:
 #   1. Check XRAY_PROJECT_ROOT env var (explicit override)
 #   2. Walk up from cwd looking for node_modules/0xray (consumer install)
-
-def _find_project_root():
-    cwd = os.getcwd()
-    home = Path.home()
-    d = Path(cwd).resolve()
-    while True:
         ...
         # node_modules/0xray — consumer install marker
-        if (d / "node_modules" / "0xray" / "package.json").exists():
+        if (d / "node_modules" / "0xray" / "package.json").exists() or (d / "node_modules" / "0xray" / "package.json").exists():
             return d
         # .opencode/xray — dev repo marker
         if (d / ".opencode" / "xray" / "features.json").exists():
@@ -211,7 +205,7 @@ def _on_pre_tool_call(tool_name: str, args: dict, task_id: str, **kwargs):
     # Xray MCP tools — track but don't interfere
     if _is_xray_mcp(tool_name):
         _session_stats["xray_mcp_calls"] += 1
-        _log_to_file("activity.log", f"[quality-gate] SKIP (xray-mcp): {tool_name}")
+        _log_to_file("activity.log", f"[quality-gate] SKIP [xray-mcp]: {tool_name}")
         return
 
     # delegate_task: snapshot working tree so post_hook can validate changes
@@ -296,7 +290,7 @@ def _on_pre_tool_call(tool_name: str, args: dict, task_id: str, **kwargs):
         if isinstance(cmd, str):
             for pattern, tip in _TERMINAL_NUDGE_PATTERNS.items():
                 if pattern in cmd:
-                    logger.info(                    "[xray] Tip: %s — %s", tool_name, tip)
+                    logger.info("[xray] Tip: %s — %s", tool_name, tip)
                     _log_to_file("activity.log",
                         f"[nudge] {tool_name}: {tip}")
                     break
@@ -666,25 +660,25 @@ def register(ctx):
     # ── Register tools ────────────────────────────────────────
     ctx.register_tool(
         name="xray_validate",
-        toolset="0xray-hermes",
+        toolset="xray-hermes",
         schema=schemas.XRAY_VALIDATE,
         handler=tools.xray_validate,
     )
     ctx.register_tool(
         name="xray_codex_check",
-        toolset="0xray-hermes",
+        toolset="xray-hermes",
         schema=schemas.XRAY_CODEX_CHECK,
         handler=tools.xray_codex_check,
     )
     ctx.register_tool(
         name="xray_health",
-        toolset="0xray-hermes",
+        toolset="xray-hermes",
         schema=schemas.XRAY_HEALTH,
         handler=tools.xray_health,
     )
     ctx.register_tool(
         name="xray_hooks",
-        toolset="0xray-hermes",
+        toolset="xray-hermes",
         schema=schemas.XRAY_HOOKS,
         handler=tools.xray_hooks,
     )

package/dist/integrations/hermes-agent/bridge.mjs

@@ -42,15 +42,6 @@ import { homedir } from "os";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-// Redirect console methods to stderr so only the final JSON result goes to stdout.
-// Any dynamically loaded module using console.log/info/debug/warn will then
-// write diagnostic output to stderr, keeping stdout clean for JSON.parse.
-const _stderrWrite = process.stderr.write.bind(process.stderr);
-console.log = (...args) => { _stderrWrite(args.join(' ') + '\n'); };
-console.info = (...args) => { _stderrWrite('[INFO] ' + args.join(' ') + '\n'); };
-console.debug = (...args) => { _stderrWrite('[DEBUG] ' + args.join(' ') + '\n'); };
-console.warn = (...args) => { _stderrWrite('[WARN] ' + args.join(' ') + '\n'); };
-
 // ── Framework components (lazy-loaded) ───────────────────────
 let ProcessorManager = null;
 let XrayStateManager = null;
@@ -76,7 +67,7 @@ function findProjectRoot() {
       const pkgPath = join(dir, "package.json");
       if (existsSync(pkgPath)) {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        if (pkg.name === "strray-ai" || pkg.dependencies?.["strray-ai"] || pkg.name === "0xray" || pkg.dependencies?.["0xray"]) {
+        if (pkg.name === "0xray" || pkg.dependencies?.["0xray"] || pkg.name === "0xray" || pkg.dependencies?.["0xray"]) {
           return dir;
         }
       }
@@ -162,7 +153,7 @@ async function loadFramework(projectRoot) {
         const smPath = join(distDir, "state", "state-manager.js");
         if (existsSync(smPath)) {
           const sm = await import(smPath);
-          XrayStateManager = sm.XrayStateManager || sm.StrRayStateManager;
+          XrayStateManager = sm.XrayStateManager;
         }
       }
 
@@ -239,7 +230,7 @@ async function runQualityGateCheck(context, projectRoot, logDir) {
 
 // ── Processor Pipeline ───────────────────────────────────────
 async function runProcessors(tool, args, phase, projectRoot, logDir) {
-    if (!ProcessorManager || !XrayStateManager) {
+  if (!ProcessorManager || !XrayStateManager) {
     return { ran: false, reason: "framework modules not loaded" };
   }
 
@@ -299,12 +290,12 @@ async function runProcessors(tool, args, phase, projectRoot, logDir) {
       });
     }
 
-    let rawResults;
+    let results;
     if (phase === "pre") {
       if (typeof processorManager.executePreProcessors !== "function") {
         return { ran: false, reason: "executePreProcessors not available" };
       }
-      rawResults = await processorManager.executePreProcessors({
+      results = await processorManager.executePreProcessors({
         tool,
         args: args || {},
         context: {
@@ -317,7 +308,7 @@ async function runProcessors(tool, args, phase, projectRoot, logDir) {
       if (typeof processorManager.executePostProcessors !== "function") {
         return { ran: false, reason: "executePostProcessors not available" };
       }
-      rawResults = await processorManager.executePostProcessors(tool, {
+      results = await processorManager.executePostProcessors(tool, {
         directory: projectRoot,
         operation: tool,
         filePath: args?.filePath || args?.path,
@@ -330,23 +321,17 @@ async function runProcessors(tool, args, phase, projectRoot, logDir) {
       }, []);
     }
 
-    // Normalize: executePreProcessors returns { success, results: [...] }
-    // executePostProcessors returns [...] directly
-    const results = Array.isArray(rawResults) ? rawResults : (rawResults.results || []);
-    const allSuccess = Array.isArray(rawResults) ? results.every((r) => r.success) : rawResults.success;
-
-    const details = results.map((r) => ({
-      name: r.processorName || r.name,
-      success: r.success,
-      error: r.error,
-    }));
-
-    // Log individual processor results
-    const phaseTag = phase === "pre" ? "pre-processor" : "post-processor";
-    for (const d of details) {
-      const status = d.success ? "ok" : `FAILED${d.error ? `: ${d.error}` : ""}`;
-      logToActivity(logDir, `[${phaseTag}] ${d.name} — ${status}`);
-    }
+    const allSuccess = Array.isArray(results)
+      ? results.every((r) => r.success)
+      : results.success;
+
+    const details = Array.isArray(results)
+      ? results.map((r) => ({
+          name: r.processorName || r.name,
+          success: r.success,
+          error: r.error,
+        }))
+      : [];
 
     return {
       ran: true,
@@ -413,10 +398,7 @@ async function handlePreProcess(input, projectRoot, logDir) {
 
   const duration = Date.now() - startTime;
 
-  logToActivity(logDir, `pre-process: complete duration=${duration}ms quality=${qualityResult.passed} processors=${processorResult.processorCount || 0}`);
-  if (processorResult.ran) {
-    logToActivity(logDir, `[pre-processors] ${processorResult.processorCount} processor(s)`);
-  }
+  logToActivity(logDir, `pre-process: complete duration=${duration}ms quality=${qualityResult.passed}`);
 
   return {
     passed: qualityResult.passed,
@@ -447,9 +429,6 @@ async function handlePostProcess(input, projectRoot, logDir) {
   });
 
   logToActivity(logDir, `post-process: complete duration=${duration}ms processors=${processorResult.success}`);
-  if (processorResult.ran) {
-    logToActivity(logDir, `[post-processors] ${processorResult.processorCount} processor(s)`);
-  }
 
   return {
     duration,
@@ -507,7 +486,21 @@ async function handleCodexCheck(input, projectRoot, logDir) {
   // Phase 2: Enforcement validators (deep code analysis — security, quality, architecture)
   //    Use ValidatorRegistry directly instead of RuleEnforcer.validateOperation()
   //    to avoid the dependency chain cascade that blocks validators on snippet analysis.
-  //    Run all registered validators — v3: full registry
+  //    Only run content-analysis validators — skip project-level validators that
+  //    require full context (docs, tests, CI, package.json) and always fail on snippets.
+  const SNIPPET_SAFE_RULES = new Set([
+    "security-by-design",
+    "input-validation",
+    "clean-debug-logs",
+    "console-log-usage",
+    "no-duplicate-code",
+    "loop-safety",
+    "no-over-engineering",
+    "single-responsibility",
+    "error-resolution",
+    "module-system-consistency",
+  ]);
+
   if (enforcerValidators && codeLen > 0) {
     try {
       const ctx = { operation: "write", newCode: code, files: [] };
@@ -515,9 +508,18 @@ async function handleCodexCheck(input, projectRoot, logDir) {
       let enforcerViolations = 0;
 
       for (const v of validators) {
-        // Run all registered validators — v3: full registry
-        if (focusAreas && focusAreas !== "all" && Array.isArray(focusAreas) && focusAreas.length > 0) {
-          if (!focusAreas.includes(v.category)) continue;
+        // Only run snippet-safe validators, or respect focus areas
+        if (!SNIPPET_SAFE_RULES.has(v.ruleId)) {
+          // Still run if focus area explicitly requests this category
+          if (focusAreas && focusAreas !== "all" && Array.isArray(focusAreas)) {
+            if (focusAreas.includes(v.category)) {
+              // Fall through to validate
+            } else {
+              continue;
+            }
+          } else {
+            continue;
+          }
         }
 
         try {
@@ -538,7 +540,7 @@ async function handleCodexCheck(input, projectRoot, logDir) {
       }
 
       enforcerRan = true;
-      logToActivity(logDir, `codex-check: Validators ran against ${validators.length} rules, ${enforcerViolations} violations`);
+      logToActivity(logDir, `codex-check: Validators ran against ${validators.length} rules (${SNIPPET_SAFE_RULES.size} snippet-safe), ${enforcerViolations} violations`);
     } catch (e) {
       logToActivity(logDir, `codex-check: Validator error: ${e.message}`);
     }
@@ -580,7 +582,7 @@ function handleHooks(input, projectRoot) {
       } else {
         try {
           const content = readFileSync(gitHook, "utf-8");
-          if (content.includes("StringRay") || content.includes("strray") || content.includes("run-hook.js")) {
+          if (content.includes("Xray") || content.includes("xray") || content.includes("strray") || content.includes("run-hook.js")) {
             result.managed.push(hookName);
           } else {
             result.external.push(hookName);
@@ -624,7 +626,7 @@ function handleHooks(input, projectRoot) {
         // Backup existing non-xray hooks
         if (existsSync(dst)) {
           const content = readFileSync(dst, "utf-8");
-          if (!content.includes("StringRay") && !content.includes("strray") && !content.includes("run-hook.js")) {
+          if (!content.includes("Xray") && !content.includes("xray") && !content.includes("strray") && !content.includes("run-hook.js")) {
             renameSync(dst, `${dst}.xray-backup`);
           } else {
             unlinkSync(dst);
@@ -663,7 +665,7 @@ function handleHooks(input, projectRoot) {
 
       try {
         const content = readFileSync(dst, "utf-8");
-        const isXray = content.includes("StringRay") || content.includes("strray") || content.includes("run-hook.js");
+        const isXray = content.includes("Xray") || content.includes("xray") || content.includes("strray") || content.includes("run-hook.js");
 
         if (isXray || lstatSync(dst).isSymbolicLink()) {
           unlinkSync(dst);

package/dist/integrations/hermes-agent/conftest.py

@@ -0,0 +1,14 @@
+"""Pytest configuration for Hermes Agent plugin tests.
+
+Prevents pytest from collecting __init__.py as a test module,
+since it uses relative imports that fail outside the Hermes runtime.
+"""
+
+collect_ignore = ["__init__.py"]
+
+
+def pytest_ignore_collect(collection_path, config):
+    """Ignore __init__.py in this directory."""
+    if collection_path.name == "__init__.py":
+        return True
+    return None

package/dist/integrations/hermes-agent/plugin.yaml

@@ -1,4 +1,4 @@
-name: 0xray-hermes
+name: xray-hermes
 version: 2.2.0
 description: 0xRay AI integration plugin — auto-enforcement hooks, quality gates, git hooks, and tool awareness for Hermes Agent
 author: 0xRay AI