0xray 4.0.20 → 4.0.21

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

@@ -84,29 +84,101 @@ function addHeatRoot(out, seen, value) {
   out.push(resolved);
 }
 
+export function isCursorWorkspaceWrapper(root) {
+  if (!root) return false;
+  const resolved = path.resolve(String(root));
+  return (
+    fs.existsSync(path.join(resolved, 'repos', 'xray')) ||
+    fs.existsSync(path.join(resolved, 'repos', 'repertoire'))
+  );
+}
+
+export function heatRootHasCard(root) {
+  if (!root) return false;
+  const resolved = path.resolve(String(root));
+  return (
+    fs.existsSync(path.join(resolved, '.xray', 'state', 'STATION.md')) ||
+    fs.existsSync(path.join(resolved, '.xray', 'features.json'))
+  );
+}
+
+export function isHeatRootWritable(root) {
+  if (!root) return false;
+  const resolved = path.resolve(String(root));
+  try {
+    const probe = path.join(resolved, '.xray', 'state');
+    fs.mkdirSync(probe, { recursive: true });
+    fs.accessSync(probe, fs.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function shouldHeatRoot(root) {
+  if (!root) return false;
+  const resolved = path.resolve(String(root));
+  if (isCursorWorkspaceWrapper(resolved)) return false;
+  if (heatRootHasCard(resolved)) return isHeatRootWritable(resolved);
+  return isHeatRootWritable(resolved);
+}
+
+export function millRootFromToolPath(filePath) {
+  if (!filePath) return null;
+  const resolved = path.resolve(String(filePath));
+  const marker = `${path.sep}repos${path.sep}`;
+  const idx = resolved.indexOf(marker);
+  if (idx === -1) return null;
+  const after = resolved.slice(idx + marker.length);
+  const repo = after.split(path.sep)[0];
+  if (!repo) return null;
+  return resolved.slice(0, idx + marker.length + repo.length);
+}
+
+function addMillCardsUnderWrapper(out, seen, wrapper) {
+  if (!wrapper || !isCursorWorkspaceWrapper(wrapper)) return;
+  const mill = path.join(path.resolve(String(wrapper)), 'repos', 'xray');
+  if (heatRootHasCard(mill) && isHeatRootWritable(mill)) addHeatRoot(out, seen, mill);
+}
+
 /** Every live context that already has a Station card — cwd plus mill when they differ. */
 export function cursorHeatRoots(event = {}) {
   const seen = new Set();
   const out = [];
-  addHeatRoot(out, seen, event.cwd);
-  addHeatRoot(out, seen, event.workspaceRoot);
+  const candidates = [event.cwd, event.workspaceRoot];
   const listed = event.workspace_roots || event.workspaceRoots;
   if (Array.isArray(listed)) {
     for (const row of listed) {
-      if (typeof row === 'string') addHeatRoot(out, seen, row);
-      else if (row && typeof row === 'object' && row.path) addHeatRoot(out, seen, row.path);
+      if (typeof row === 'string') candidates.push(row);
+      else if (row && typeof row === 'object' && row.path) candidates.push(row.path);
     }
   }
-  addHeatRoot(out, seen, process.env.CURSOR_PROJECT_DIR);
-  const mill = process.env.XRAY_AI_PATH;
+  candidates.push(process.env.CURSOR_PROJECT_DIR);
+  for (const value of candidates) {
+    if (shouldHeatRoot(value)) addHeatRoot(out, seen, value);
+    addMillCardsUnderWrapper(out, seen, value);
+  }
+  const mill = process.env.XRAY_AI_PATH || process.env.XRAY_ROOT;
   if (mill) {
     const resolved = path.resolve(String(mill));
-    const millHasCard =
-      fs.existsSync(path.join(resolved, '.xray', 'state', 'STATION.md')) ||
-      fs.existsSync(path.join(resolved, '.xray', 'features.json'));
-    if (millHasCard) addHeatRoot(out, seen, resolved);
+    if (shouldHeatRoot(resolved)) addHeatRoot(out, seen, resolved);
+  }
+  const ctx = cursorToolContext(event);
+  for (const filePath of ctx.paths) {
+    const fromPath = millRootFromToolPath(filePath);
+    if (
+      fromPath &&
+      fs.existsSync(path.join(fromPath, '.xray', 'state', 'STATION.md')) &&
+      isHeatRootWritable(fromPath)
+    ) {
+      addHeatRoot(out, seen, fromPath);
+    }
+  }
+  if (out.length === 0) {
+    const fallback = cursorWorkspaceRoot(event);
+    if (shouldHeatRoot(fallback)) addHeatRoot(out, seen, fallback);
+    addMillCardsUnderWrapper(out, seen, fallback);
   }
-  if (out.length === 0) addHeatRoot(out, seen, cursorWorkspaceRoot(event));
   return out;
 }
 
@@ -121,6 +193,10 @@ export function cursorSessionId(event = {}) {
   );
 }
 
+export function cursorGenerationId(event = {}) {
+  return event.generation_id || event.generationId || null;
+}
+
 export function cursorToolContext(event = {}) {
   const toolName = event.tool_name || event.toolName || process.env.TOOL_NAME || 'unknown';
   const toolInput = event.tool_input ?? event.toolInput ?? {};
@@ -179,11 +255,16 @@ export function cursorBootNeedsRefresh(existing, root) {
 
 export function ensureCursorSessionBoot(root, source = '0xray/cursor-pre-tool-use-boot', extra = {}) {
   const bootPath = sessionBootPath(root);
+  if (!shouldHeatRoot(root)) return bootPath;
   if (fs.existsSync(bootPath)) {
     try {
       const existing = JSON.parse(fs.readFileSync(bootPath, 'utf8'));
       if (!cursorBootNeedsRefresh(existing, root)) {
-        heatLiveMemory(root);
+        try {
+          heatLiveMemory(root);
+        } catch {
+          /* dest EACCES must not deny the host tool */
+        }
         return bootPath;
       }
     } catch {

package/dist/integrations/cursor/hooks/cursor-usage-receipt.js

@@ -69,6 +69,9 @@ export function hostUsageFromPreCompactEvent(event = {}) {
   if (typeof event.windowCite === 'string' && event.windowCite) usage.windowCite = event.windowCite;
   if (typeof event.model === 'string' && event.model) usage.model = event.model;
   if (typeof event.bcId === 'string' && event.bcId) usage.bcId = event.bcId;
+  else if (typeof event.conversation_id === 'string' && event.conversation_id) {
+    usage.bcId = event.conversation_id;
+  }
   return usage;
 }
 

package/dist/integrations/cursor/hooks/hooks.json

@@ -3,17 +3,27 @@
   "hooks": {
     "preToolUse": [
       {
-        "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/cursor/hooks/pre-tool-use.js\""
+        "command": ".cursor/hooks/pre-tool-use.sh"
       }
     ],
     "preCompact": [
       {
-        "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/cursor/hooks/pre-compact.js\""
+        "command": ".cursor/hooks/pre-compact.sh"
       }
     ],
     "afterFileEdit": [
       {
-        "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/cursor/hooks/after-file-edit.js\""
+        "command": ".cursor/hooks/after-file-edit.sh"
+      }
+    ],
+    "beforeShellExecution": [
+      {
+        "command": ".cursor/hooks/before-shell-execution.sh"
+      }
+    ],
+    "beforeReadFile": [
+      {
+        "command": ".cursor/hooks/before-read-file.sh"
       }
     ]
   }

package/dist/integrations/cursor/hooks/pre-compact.js

@@ -9,6 +9,7 @@ import {
   appendHookActivity,
   buildSessionBootPayload,
   classifyPreCompactEvent,
+  cursorGenerationId,
   cursorHeatRoots,
   cursorSessionId,
   cursorWorkspaceRoot,
@@ -40,6 +41,7 @@ async function main() {
     eventClass = classifyPreCompactEvent(event);
     const eventRoot = cursorWorkspaceRoot(event);
     const sessionId = cursorSessionId(event);
+    const generationId = cursorGenerationId(event);
     const intent = extractIntent(event);
     let bootPath = null;
     let receiptPath = null;
@@ -60,6 +62,13 @@ async function main() {
         hookEvent: 'pre_compact',
         trigger: event.trigger || 'synthetic',
         sessionId,
+        conversation_id: sessionId,
+        generation_id: generationId,
+        is_first_compaction:
+          typeof event.is_first_compaction === 'boolean' ? event.is_first_compaction : null,
+        message_count: typeof event.message_count === 'number' ? event.message_count : null,
+        messages_to_compact:
+          typeof event.messages_to_compact === 'number' ? event.messages_to_compact : null,
         bootPath,
         timestamp: new Date().toISOString(),
       });

package/dist/integrations/cursor/hooks/pre-compact.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+HERE="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+exec /bin/sh "${HERE}/xray-cloud-hook.sh" preCompact pre-compact.js

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

@@ -49,56 +49,60 @@ async function main() {
     const event = await readStdinJson();
     const eventRoot = cursorWorkspaceRoot(event);
     const sessionId = cursorSessionId(event);
-    for (const root of cursorHeatRoots(event)) {
+    const heatRoots = cursorHeatRoots(event);
+    for (const root of heatRoots) {
       ensureCursorSessionBoot(root, '0xray/cursor-pre-tool-use-boot', { sessionId });
     }
+    const gateRoot = heatRoots[0] || eventRoot;
 
-    const features = loadFeatures(eventRoot);
-    const gateFeatures = loadDelegationGateFeatures(eventRoot, 'cursor');
+    const features = loadFeatures(gateRoot);
+    const gateFeatures = loadDelegationGateFeatures(gateRoot, 'cursor');
     const ctx = cursorToolContext(event);
     toolName = ctx.toolName;
     const { content, cmd, toolInput } = ctx;
 
     const gateBlock = evaluatePreToolGate(toolName, toolInput, {
-      projectRoot: eventRoot,
+      projectRoot: gateRoot,
       sessionId,
       features: gateFeatures,
       host: 'cursor',
     });
     if (!gateBlock.allow) {
-      finish(eventRoot, 'deny', gateBlock.reason, gateBlock.hint, toolName, { gate: gateBlock.gate });
+      finish(gateRoot, 'deny', gateBlock.reason, gateBlock.hint, toolName, { gate: gateBlock.gate });
     }
 
     if (isWriteTool(toolName) && content) {
       const extraBlock = checkCodexPatterns(content, { terms: [11, 29] });
-      if (extraBlock) finish(eventRoot, 'deny', extraBlock, null, toolName);
+      if (extraBlock) finish(gateRoot, 'deny', extraBlock, null, toolName);
     }
 
     if (isShellTool(toolName) && cmd) {
       const testHint = checkFullTestSuite(cmd, features);
-      if (testHint) finish(eventRoot, 'allow', null, testHint, toolName);
+      if (testHint) finish(gateRoot, 'allow', null, testHint, toolName);
     }
 
     if (gateBlock.reason) {
-      finish(eventRoot, 'allow', gateBlock.reason, gateBlock.hint, toolName, {
+      finish(gateRoot, 'allow', gateBlock.reason, gateBlock.hint, toolName, {
         gate: gateBlock.gate,
         warn: true,
       });
     }
 
-    finish(eventRoot, 'allow', null, null, toolName);
+    finish(gateRoot, 'allow', null, null, toolName);
   } 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.
     finish(
       fallbackRoot,
-      'deny',
-      `preToolUse hook error — blocked for safety: ${err.message}`,
+      'allow',
+      `preToolUse hook error — fail open: ${err.message}`,
       null,
       toolName,
-      { gate: 'hook-error' },
+      { gate: 'hook-error-fail-open' },
     );
   }
 }

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

@@ -0,0 +1,3 @@
+#!/bin/sh
+HERE="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+exec /bin/sh "${HERE}/xray-cloud-hook.sh" preToolUse pre-tool-use.js

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

@@ -0,0 +1,63 @@
+#!/bin/sh
+# Cloud-safe Cursor hook runner. Command in hooks.json must be a relative path.
+# Do not put env-assignment in hooks.json — Cloud execs argv[0] without a shell.
+set -eu
+
+EVENT="${1:-preToolUse}"
+JS="${2:-pre-tool-use.js}"
+MILL=""
+REL=""
+
+pick_mill() {
+  mill="$1"
+  rel="$2"
+  if [ -f "${mill}/${rel}" ]; then
+    MILL="$mill"
+    REL="$rel"
+    return 0
+  fi
+  return 1
+}
+
+if [ -n "${XRAY_AI_PATH:-}" ]; then
+  pick_mill "${XRAY_AI_PATH}" "src/integrations/cursor/hooks/${JS}" || \
+    pick_mill "${XRAY_AI_PATH}" "dist/integrations/cursor/hooks/${JS}" || true
+fi
+if [ -z "$MILL" ]; then
+  pick_mill "$(pwd)" "src/integrations/cursor/hooks/${JS}" || \
+    pick_mill "$(pwd)/../xray" "src/integrations/cursor/hooks/${JS}" || \
+    pick_mill "$(pwd)/repos/xray" "src/integrations/cursor/hooks/${JS}" || \
+    pick_mill "${CURSOR_PROJECT_DIR:-}/repos/xray" "src/integrations/cursor/hooks/${JS}" || \
+    pick_mill "$(pwd)/node_modules/0xray" "dist/integrations/cursor/hooks/${JS}" || \
+    pick_mill "$(pwd)/node_modules/0xray" "src/integrations/cursor/hooks/${JS}" || true
+fi
+
+if [ -n "$MILL" ] && [ -d "$MILL" ]; then
+  MILL="$(cd "$MILL" && pwd)"
+fi
+
+NODE_BIN="$(command -v node 2>/dev/null || true)"
+
+log_invoke() {
+  dest="$1"
+  mkdir -p "${dest}/.xray/state" 2>/dev/null || true
+  {
+    printf 'ts=%s event=%s cwd=%s mill=%s node=%s\n' \
+      "$(date -Iseconds)" "$EVENT" "$(pwd)" "${MILL:-MISSING}" "${NODE_BIN:-MISSING}"
+  } >> "${dest}/.xray/state/cursor-hook-invoke.log" 2>/dev/null || true
+}
+
+log_invoke "$(pwd)"
+if [ -n "$MILL" ]; then
+  log_invoke "$MILL"
+fi
+
+if [ -z "$NODE_BIN" ] || [ -z "$MILL" ] || [ ! -f "${MILL}/${REL}" ]; then
+  printf '{"permission":"allow","user_message":"xray-cloud-hook: mill missing — fail open"}\n'
+  exit 0
+fi
+
+export XRAY_HOOK_EVENT="$EVENT"
+export XRAY_AI_PATH="$MILL"
+export XRAY_ROOT="$MILL"
+exec "$NODE_BIN" "${MILL}/${REL}"

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

@@ -25,6 +25,7 @@ import {
   applyStationHeat,
   buildRepertoireResume as stationRepertoireResume,
   readExistingBoot,
+  retainCompactFields,
   writeStationMarkdown,
 } from '../../hooks/station-hook-runtime.mjs';
 
@@ -285,8 +286,8 @@ export function buildSessionBootPayload(root, source = '0xray/grok-session-start
   const frontier = gateFeatures.ceremony === 'lite';
   const existing = readExistingBoot(root);
   const heat = applyStationHeat(root, extra.host || 'grok', extra, existing);
+  const compactHold = retainCompactFields(existing, extra);
   return {
-    hook: source,
     lead_dev_mode: features.lead_dev_mode,
     no_new_surface: features.no_new_surface,
     host: extra.host || 'grok',
@@ -306,9 +307,9 @@ export function buildSessionBootPayload(root, source = '0xray/grok-session-start
     ...(conferPending ? { conferPending: true, conferTrigger: 'analyze-complexity at synthesis checkpoint' } : {}),
     ...(userAsideBoot ?? {}),
     sessionId,
-    source,
     ...extra,
     ...heat,
+    ...compactHold,
     hook: source,
     source,
     timestamp: new Date().toISOString(),