0xray 4.0.42 → 4.1.1

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

@@ -5,23 +5,40 @@
  * Does not rely on sessionStart (unavailable on managed cloud).
  */
 
-import {
-  appendHookActivity,
-  checkCodexPatterns,
-  checkFullTestSuite,
-  cursorGateRoot,
-  cursorHeatRoots,
-  cursorSessionId,
-  cursorToolContext,
-  cursorWorkspaceRoot,
-  ensureCursorSessionBoot,
-  evaluatePreToolGate,
-  isShellTool,
-  isWriteTool,
-  loadDelegationGateFeatures,
-  loadFeatures,
-  readStdinJson,
-} from './cursor-hook-utils.js';
+// Gate modules load inside main()'s try (dynamic import): a missing or broken module must deny, not crash
+// before the handler with no JSON (Cursor would then fail open). Nothing here may import them statically.
+let appendHookActivity = () => {};
+
+/** Deny JSON on stdout and exit 0. Used when the gate cannot run at all. */
+function denyHard(reason) {
+  try {
+    process.stdout.write(`${JSON.stringify({ permission: 'deny', user_message: reason, agent_message: reason })}\n`);
+  } finally {
+    process.exit(0);
+  }
+}
+
+export function cursorHookErrorPermission(err) {
+  if (err?.code === 'EACCES') return 'allow';   // code only: a message mentioning EACCES is not a permission error
+  return 'deny';
+}
+
+// Bootstrap: a fresh checkout has no build yet, so gate modules can be missing.
+// Only the exact build commands may run then, so the hook cannot block the build that creates it.
+const BOOTSTRAP_CMDS = new Set(['npm ci', 'npm run build', 'npm ci && npm run build', 'npm install && npm run build']);
+export function cursorBootstrapPermission(err, event) {
+  if (err?.code !== 'ERR_MODULE_NOT_FOUND') return 'deny';
+  const cmd = String(event?.tool_input?.command ?? event?.command ?? '').trim().replace(/\s+/g, ' ');
+  return BOOTSTRAP_CMDS.has(cmd) ? 'allow' : 'deny';
+}
+
+async function readRawEvent() {
+  try {
+    let raw = '';
+    for await (const c of process.stdin) raw += c;
+    return JSON.parse(raw);
+  } catch { return null; }
+}
 
 function finish(root, permission, reason, hint, toolName, extra = {}) {
   const out = { permission };
@@ -31,23 +48,40 @@ function finish(root, permission, reason, hint, toolName, extra = {}) {
   }
   if (hint && permission === 'allow') {
     out.user_message = hint;
+    out.agent_message = hint;
   }
+  if (extra.hookSpecificOutput) out.hookSpecificOutput = extra.hookSpecificOutput;
   console.log(JSON.stringify(out));
-  appendHookActivity(root, 'cursor-pre-tool-use', permission, permission === 'deny' ? 'error' : 'info', {
-    tool: toolName,
-    reason: reason || hint || null,
-    gate: extra.gate || null,
-    livePath: true,
-  });
+  try {
+    appendHookActivity(root, 'cursor-pre-tool-use', permission, permission === 'deny' ? 'error' : 'info', {
+      tool: toolName,
+      reason: reason || hint || null,
+      gate: extra.gate || null,
+      livePath: true,
+    });
+  } catch { /* the verdict is already on stdout; activity logging must not change it */ }
   process.exit(0);
 }
 
 async function main() {
-  const fallbackRoot = cursorWorkspaceRoot();
+  let fallbackRoot = process.cwd();
   let toolName = 'unknown';
 
   try {
+    const u = await import('./cursor-hook-utils.js');
+    const { lensDecision, repertoireRoute } = await import('../../hooks/pre-tool-speak.mjs');
+    const {
+      checkCodexPatterns, checkFullTestSuite, cursorGateRoot, cursorHeatRoots, cursorSessionId, cursorToolContext,
+      cursorWorkspaceRoot, ensureCursorSessionBoot, evaluatePreToolGate, isShellTool, isWriteTool,
+      loadDelegationGateFeatures, loadFeatures, readStdinJson,
+    } = u;
+    appendHookActivity = u.appendHookActivity;
+    fallbackRoot = cursorWorkspaceRoot();
     const event = await readStdinJson();
+    // readStdinJson returns {} for empty or malformed stdin; Cursor always sends a JSON object, so deny those.
+    if (!event || typeof event !== 'object' || Array.isArray(event) || Object.keys(event).length === 0) {
+      finish(fallbackRoot, 'deny', 'preToolUse: empty or malformed hook input — denied', null, toolName, { gate: 'bad-input' });
+    }
     const eventRoot = cursorWorkspaceRoot(event);
     const sessionId = cursorSessionId(event);
     const heatRoots = cursorHeatRoots(event);
@@ -60,7 +94,7 @@ async function main() {
     const gateFeatures = loadDelegationGateFeatures(gateRoot, 'cursor');
     const ctx = cursorToolContext(event);
     toolName = ctx.toolName;
-    const { content, cmd, toolInput } = ctx;
+    const { content, cmd, toolInput, paths } = ctx;
 
     const gateBlock = evaluatePreToolGate(toolName, toolInput, {
       projectRoot: gateRoot,
@@ -77,35 +111,68 @@ async function main() {
       if (extraBlock) finish(gateRoot, 'deny', extraBlock, null, toolName);
     }
 
+    const spoken = [content, cmd, toolInput.pattern, toolInput.query, ...(paths || [])].filter(Boolean).join('\n');
+    const lensStop = lensDecision(gateRoot, toolName, spoken);
+    if (lensStop?.decision === 'deny') {
+      finish(gateRoot, 'deny', lensStop.reason, null, toolName, { gate: lensStop.gate });
+    }
+    if (lensStop?.decision === 'allow' && lensStop.reason) {
+      finish(gateRoot, 'allow', lensStop.reason, lensStop.reason, toolName, { gate: lensStop.gate });
+    }
+    const route = repertoireRoute([toolName, cmd, content].filter(Boolean).join(' '));
+
     if (isShellTool(toolName) && cmd) {
       const testHint = checkFullTestSuite(cmd, features);
-      if (testHint) finish(gateRoot, 'allow', null, testHint, toolName);
+      if (testHint) finish(gateRoot, 'allow', null, testHint, toolName, { ...(route || {}) });
     }
 
     if (gateBlock.reason) {
       finish(gateRoot, 'allow', gateBlock.reason, gateBlock.hint, toolName, {
         gate: gateBlock.gate,
         warn: true,
+        ...(route || {}),
       });
     }
 
-    finish(gateRoot, 'allow', null, null, toolName);
+    finish(gateRoot, 'allow', null, null, toolName, { ...(route || {}) });
   } catch (err) {
-    appendHookActivity(fallbackRoot, 'cursor-pre-tool-use', 'hook-error', 'error', {
-      tool: toolName,
-      error: err.message,
-      failOpen: true,
-    });
-    // Dest EACCES on a Cloud workspace wrapper must not deny every tool.
+    if (err?.code === 'ERR_MODULE_NOT_FOUND' && cursorBootstrapPermission(err, await readRawEvent()) === 'allow') {
+      console.log(JSON.stringify({ permission: 'allow', user_message: 'preToolUse: build not present — bootstrap build allowed' }));
+      process.exit(0);
+    }
+    const failOpen = cursorHookErrorPermission(err) === 'allow';
+    try {
+      appendHookActivity(fallbackRoot, 'cursor-pre-tool-use', 'hook-error', 'error', {
+        tool: toolName,
+        error: err.message,
+        failOpen,
+      });
+    } catch { /* logging must not turn a deny into a crash */ }
+    if (failOpen) {
+      // Dest EACCES on a Cloud workspace wrapper must not deny every tool.
+      finish(
+        fallbackRoot,
+        'allow',
+        `preToolUse hook error — fail open: ${err.message}`,
+        null,
+        toolName,
+        { gate: 'hook-error-fail-open' },
+      );
+    }
     finish(
       fallbackRoot,
-      'allow',
-      `preToolUse hook error — fail open: ${err.message}`,
+      'deny',
+      `preToolUse hook error blocked the tool: ${err.message}`,
       null,
       toolName,
-      { gate: 'hook-error-fail-open' },
+      { gate: 'hook-error' },
     );
   }
 }
 
-main();
+const launchedAsCli = Boolean(process.argv[1] && process.argv[1].endsWith('pre-tool-use.js'));
+if (launchedAsCli) {
+  process.on('uncaughtException', (err) => denyHard(`preToolUse hook crashed — denied: ${err?.message || err}`));
+  process.on('unhandledRejection', (err) => denyHard(`preToolUse hook crashed — denied: ${err?.message || err}`));
+  main().catch((err) => denyHard(`preToolUse hook crashed — denied: ${err?.message || err}`));
+}

package/dist/integrations/cursor/hooks/xray-cloud-hook.sh

@@ -110,7 +110,15 @@ if [ -n "$MILL" ]; then
 fi
 
 if [ -z "$NODE_BIN" ] || [ -z "$MILL" ] || [ ! -f "${MILL}/${REL}" ]; then
-  printf '{"permission":"allow","user_message":"xray-cloud-hook: mill missing — fail open"}\n'
+  # Gate events fail closed: no node or no hook file means the gate cannot run, so the tool is denied.
+  case "$EVENT" in
+    preToolUse|beforeShellExecution|beforeReadFile)
+      printf '{"permission":"deny","user_message":"xray-cloud-hook: node or hook file missing — denied (fail closed)","agent_message":"xray-cloud-hook: node or hook file missing — denied (fail closed)"}\n'
+      ;;
+    *)
+      printf '{"permission":"allow","user_message":"xray-cloud-hook: node or hook file missing — %s skipped"}\n' "$EVENT"
+      ;;
+  esac
   exit 0
 fi
 

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

@@ -80,17 +80,15 @@ export async function installForGrokCLI(options = {}) {
                 frameworkLogger.log('grok-integration', 'plugin-copied', 'info', { destination: dest });
                 console.log(`\x1b[32m✓ Copied Grok plugin to ${dest}\x1b[0m`);
             }
-            if (millSuit.wantsCostume(targetDir)) {
-                const skillsCopied = syncBuiltinSkills(path.join(dest, 'skills'));
-                if (skillsCopied > 0) {
-                    console.log(`\x1b[32m✓ Synced ${skillsCopied} builtin skills to Grok plugin\x1b[0m`);
-                }
-                frameworkLogger.log('grok-integration', 'skills-synced', 'info', { count: skillsCopied });
+            const skillsCopied = syncBuiltinSkills(path.join(dest, 'skills'));
+            if (skillsCopied > 0) {
+                console.log(`\x1b[32m✓ Synced ${skillsCopied} builtin skills to Grok plugin\x1b[0m`);
             }
+            frameworkLogger.log('grok-integration', 'skills-synced', 'info', { count: skillsCopied });
             pinGrokPluginToInstalledDist(dest, packageRoot, targetDir);
             wearGrokHookCommands(dest, packageRoot, targetDir);
         }
-        if (isolated && millSuit.wantsCostume(targetDir)) {
+        if (isolated) {
             const home = millSuit.processHome(env);
             const globalCopied = syncBuiltinSkills(path.join(home, '.grok', 'skills'));
             if (globalCopied > 0) {

package/dist/integrations/grok/hooks/grok-hook-utils.js

@@ -28,7 +28,7 @@ import {
   retainCompactFields,
   writeStationMarkdown,
 } from '../../hooks/station-hook-runtime.mjs';
-import { handCard } from '../../hooks/goggles-pipeline.mjs';
+import { handCard, planeCard } from '../../hooks/goggles-pipeline.mjs';
 
 export {
   checkPendingDelegationGate,
@@ -315,6 +315,7 @@ export function buildSessionBootPayload(root, source = '0xray/grok-session-start
   const existing = readExistingBoot(root);
   const heat = applyStationHeat(root, extra.host || 'grok', extra, existing);
   const compactHold = retainCompactFields(existing, extra);
+  const shown = planeCard(root);
   return {
     lead_dev_mode: features.lead_dev_mode,
     no_new_surface: features.no_new_surface,
@@ -348,6 +349,8 @@ export function buildSessionBootPayload(root, source = '0xray/grok-session-start
     hook: source,
     source,
     timestamp: new Date().toISOString(),
+    plane: shown.plane,
+    card: shown.card,
   };
 }
 

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

@@ -21,66 +21,10 @@ import {
   workspaceRoot,
 } from './grok-hook-utils.js';
 import { appendHookActivity } from './grok-hook-activity.js';
-import { cardStop, lensBeforeResearch } from '../../hooks/goggles-pipeline.mjs';
-import { createRequire } from 'node:module';
-import { existsSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const hookDir = dirname(fileURLToPath(import.meta.url));
-let scoreAndRouteFn;
-
-function loadScoreAndRoute() {
-  if (scoreAndRouteFn !== undefined) return scoreAndRouteFn;
-  scoreAndRouteFn = null;
-  const require = createRequire(import.meta.url);
-  const candidates = [
-    join(hookDir, '../../../nucleus/thin-dispatch.js'),
-    join(hookDir, '../../../../dist/nucleus/thin-dispatch.js'),
-  ];
-  for (const candidate of candidates) {
-    if (!existsSync(candidate)) continue;
-    try {
-      const loaded = require(candidate);
-      if (typeof loaded.scoreAndRoute === 'function') {
-        scoreAndRouteFn = loaded.scoreAndRoute;
-        return scoreAndRouteFn;
-      }
-    } catch {
-      /* next built copy */
-    }
-  }
-  return null;
-}
-
-/** Speak only when the organ changes the agent. A match that leaves the agent is quiet. */
-export function repertoireDecisionFields(routed) {
-  if (!routed?.memoryRouting?.overridden || !routed.agent) return null;
-  const signals = Array.isArray(routed.memoryRouting.signals)
-    ? routed.memoryRouting.signals.slice(0, 4).filter(Boolean)
-    : [];
-  const why = signals.length ? ` on ${signals.join(', ')}` : '';
-  return {
-    agent: routed.agent,
-    gate: 'repertoire',
-    hookSpecificOutput: {
-      hookEventName: 'PreToolUse',
-      additionalContext: `Repertoire changed the route to ${routed.agent}${why}. Follow that agent for this work.`,
-    },
-  };
-}
+import { lensBeforeResearch } from '../../hooks/goggles-pipeline.mjs';
+import { repertoireDecisionFields, repertoireRoute } from '../../hooks/pre-tool-speak.mjs';
 
-function repertoireRoute(operation) {
-  const text = String(operation || '').slice(0, 500).trim();
-  if (!text) return null;
-  try {
-    const scoreAndRoute = loadScoreAndRoute();
-    if (!scoreAndRoute) return null;
-    return repertoireDecisionFields(scoreAndRoute(text, {}));
-  } catch {
-    return null;
-  }
-}
+export { repertoireDecisionFields };
 
 function finish(root, decision, reason, hint, toolName, extra = {}) {
   const out = { decision, ...extra };
@@ -137,28 +81,14 @@ async function main() {
       if (extraBlock) finish(eventRoot, 'deny', extraBlock, null, toolName);
     }
 
-    const stop = cardStop(
-      eventRoot,
-      toolName,
-      [cmd, content, toolInput.pattern, toolInput.query, ...(ctx.paths || [])].filter(Boolean).join('\n'),
-      ctx.paths || [],
-      toolInput,
-    );
-    if (stop?.decision === 'deny') {
-      finish(eventRoot, 'deny', stop.reason, null, toolName, { gate: stop.gate });
-    }
-    if (stop?.decision === 'allow') {
-      finish(eventRoot, 'allow', null, null, toolName, {
-        gate: stop.gate,
-        hookSpecificOutput: stop.hookSpecificOutput,
-      });
-    }
-
     const spoken = [cmd, content, toolInput.pattern, toolInput.query, ...(ctx.paths || [])].filter(Boolean).join('\n');
     const lensStop = lensBeforeResearch(eventRoot, toolName, spoken);
     if (lensStop?.decision === 'deny') {
       finish(eventRoot, 'deny', lensStop.reason, null, toolName, { gate: lensStop.gate });
     }
+    if (lensStop?.decision === 'allow' && lensStop.reason) {
+      finish(eventRoot, 'allow', lensStop.reason, lensStop.reason, toolName, { gate: lensStop.gate });
+    }
 
     const route = repertoireRoute([toolName, cmd, content].filter(Boolean).join(' '));
 

package/dist/integrations/grok/hooks/session-start.js

@@ -24,7 +24,7 @@ import {
   runInferenceImprovementLight,
 } from '../../hooks/pipeline-hook-runtime.mjs';
 import { maintainLens } from '../../hooks/goggles-pipeline.mjs';
-import { readSavedFreshness, refreshFreshness } from '../../../nucleus/work-freshness.mjs';
+import { freshnessNeedsRefresh, readSavedFreshness, refreshFreshness } from '../../../nucleus/work-freshness.mjs';
 
 function extractIntent(event) {
   return event.prompt || event.userMessage || event.user_prompt || event.compactContext || null;
@@ -137,7 +137,9 @@ async function main() {
     let freshnessLine = null;
     if (!compact) {
       try {
-        freshnessLine = HOOK_EVENT === 'session_start'
+        const refresh = HOOK_EVENT === 'session_start'
+          || (HOOK_EVENT === 'user_prompt_submit' && freshnessNeedsRefresh(eventRoot));
+        freshnessLine = refresh
           ? refreshFreshness(eventRoot).freshnessLine
           : readSavedFreshness(eventRoot);
       } catch {

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

@@ -914,9 +914,25 @@ async function handleDelegationGate(command, projectRoot, logDir) {
         logDir,
         `[delegation-gate] deny tool=${tool} gate=${outcome.gate} reason=${outcome.reason}`,
       );
+      return { phase: "pre", ...outcome };
     }
 
-    return { phase: "pre", ...outcome };
+    const spoken = `${tool} ${JSON.stringify(args)}`.slice(0, 500);
+    const { lensDecision, repertoireRoute } = await import("../hooks/pre-tool-speak.mjs");
+    const lens = lensDecision(projectRoot, tool, spoken);
+    if (lens?.decision === "deny") {
+      return {
+        allow: false,
+        phase: "pre",
+        gate: lens.gate || "lens",
+        reason: lens.reason,
+      };
+    }
+    if (lens?.decision === "allow" && lens.reason) {
+      return { phase: "pre", ...outcome, gate: "lens", reason: lens.reason };
+    }
+    const route = repertoireRoute(spoken);
+    return { phase: "pre", ...outcome, ...(route || {}) };
   } catch (error) {
     const message = `delegation-gate failed: ${error.message || error}`;
     logToActivity(logDir, `[delegation-gate] error ${message}`);

package/dist/integrations/hooks/delegation-gate-runtime.mjs

@@ -68,8 +68,9 @@ function loadDelegationGate() {
   ].filter(Boolean);
   const found = candidates.find((p) => existsSync(p));
   if (!found) {
-    throw new Error(
-      'delegation-gate.js missing — run npm run build in 0xray or npm install 0xray',
+    throw Object.assign(
+      new Error('delegation-gate.js missing — run npm run build in 0xray or npm install 0xray'),
+      { code: 'ERR_MODULE_NOT_FOUND' },
     );
   }
   return createRequire(import.meta.url)(found);