0xray 4.0.19 → 4.0.21

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

@@ -23,13 +23,12 @@ import {
 } from '../../hooks/delegation-gate-runtime.mjs';
 import { appendHookActivity } from '../../grok/hooks/grok-hook-activity.js';
 import {
-  buildRepertoireResume,
+  heatLiveMemory,
   maybeCaptureSessionOnHeadMove,
-  readGitBrief,
-  stationDurableHoldsNpm,
+  stationBootNeedsRefresh,
 } from '../../hooks/station-hook-runtime.mjs';
 
-export { maybeCaptureSessionOnHeadMove };
+export { heatLiveMemory, maybeCaptureSessionOnHeadMove };
 
 export const CURSOR_HOST = 'cursor';
 export const EVENT_CLASS_HOST = 'cursor-host-precompact';
@@ -77,6 +76,112 @@ export function cursorWorkspaceRoot(event = {}) {
   );
 }
 
+function addHeatRoot(out, seen, value) {
+  if (!value) return;
+  const resolved = path.resolve(String(value));
+  if (seen.has(resolved)) return;
+  seen.add(resolved);
+  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 = [];
+  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') candidates.push(row);
+      else if (row && typeof row === 'object' && row.path) candidates.push(row.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));
+    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);
+  }
+  return out;
+}
+
 export function cursorSessionId(event = {}) {
   return (
     event.conversation_id ||
@@ -88,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 ?? {};
@@ -141,27 +250,21 @@ export function classifyPreCompactEvent(event = {}, argv = process.argv) {
 }
 
 export function cursorBootNeedsRefresh(existing, root) {
-  if (!existing || typeof existing !== 'object') return true;
-  if (existing.host !== CURSOR_HOST) return true;
-  if (!existing.suit_profile) return true;
-  if (existing.workspaceRoot && existing.workspaceRoot !== root) return true;
-  if (!existing.stationLine) return true;
-  const liveGit = readGitBrief(root);
-  const bootHead = existing.git && existing.git.head ? String(existing.git.head) : '';
-  if (liveGit && liveGit.head && bootHead !== liveGit.head) return true;
-  const liveResume = buildRepertoireResume(root);
-  if (liveResume && existing.repertoireResume && liveResume !== existing.repertoireResume) return true;
-  if (stationDurableHoldsNpm(root)) return true;
-  return false;
+  return stationBootNeedsRefresh(existing, root, CURSOR_HOST);
 }
 
 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)) {
-        maybeCaptureSessionOnHeadMove(root);
+        try {
+          heatLiveMemory(root);
+        } catch {
+          /* dest EACCES must not deny the host tool */
+        }
         return bootPath;
       }
     } catch {
@@ -172,9 +275,7 @@ export function ensureCursorSessionBoot(root, source = '0xray/cursor-pre-tool-us
     host: CURSOR_HOST,
     ...extra,
   });
-  const written = writeSessionBoot(root, payload) || bootPath;
-  maybeCaptureSessionOnHeadMove(root);
-  return written;
+  return writeSessionBoot(root, payload) || bootPath;
 }
 
 export function writeCursorPrecompactReceipt(root, fields) {

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,8 @@ import {
   appendHookActivity,
   buildSessionBootPayload,
   classifyPreCompactEvent,
+  cursorGenerationId,
+  cursorHeatRoots,
   cursorSessionId,
   cursorWorkspaceRoot,
   readStdinJson,
@@ -39,34 +41,49 @@ async function main() {
     eventClass = classifyPreCompactEvent(event);
     const eventRoot = cursorWorkspaceRoot(event);
     const sessionId = cursorSessionId(event);
+    const generationId = cursorGenerationId(event);
     const intent = extractIntent(event);
-    const payload = buildSessionBootPayload(eventRoot, '0xray/cursor-compact', {
-      host: 'cursor',
-      hookEvent: 'pre_compact',
-      event_class: eventClass,
-      sessionId,
-      ...(intent ? { intent } : {}),
-    });
-    const bootPath = writeSessionBoot(eventRoot, payload);
-    const receiptPath = writeCursorPrecompactReceipt(eventRoot, {
-      event_class: eventClass,
-      hookEvent: 'pre_compact',
-      trigger: event.trigger || 'synthetic',
-      sessionId,
-      bootPath,
-      timestamp: new Date().toISOString(),
-    });
-    const usagePath = writeCursorUsageReceipt(eventRoot, {
-      eventClass,
-      sessionId,
-      usage: hostUsageFromPreCompactEvent(event),
-    });
+    let bootPath = null;
+    let receiptPath = null;
+    let usagePath = null;
+    let stationLine = null;
+    for (const root of cursorHeatRoots(event)) {
+      const payload = buildSessionBootPayload(root, '0xray/cursor-compact', {
+        host: 'cursor',
+        hookEvent: 'pre_compact',
+        event_class: eventClass,
+        sessionId,
+        ...(intent ? { intent } : {}),
+      });
+      bootPath = writeSessionBoot(root, payload);
+      stationLine = payload.stationLine;
+      receiptPath = writeCursorPrecompactReceipt(root, {
+        event_class: eventClass,
+        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(),
+      });
+      usagePath = writeCursorUsageReceipt(root, {
+        eventClass,
+        sessionId,
+        usage: hostUsageFromPreCompactEvent(event),
+      });
+    }
     appendHookActivity(eventRoot, 'cursor-pre-compact', 'station-written', 'success', {
       bootPath,
       receiptPath,
       usagePath,
       event_class: eventClass,
-      stationLine: payload.stationLine,
+      stationLine,
     });
     console.log(
       JSON.stringify({

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

@@ -9,6 +9,7 @@ import {
   appendHookActivity,
   checkCodexPatterns,
   checkFullTestSuite,
+  cursorHeatRoots,
   cursorSessionId,
   cursorToolContext,
   cursorWorkspaceRoot,
@@ -47,57 +48,61 @@ async function main() {
   try {
     const event = await readStdinJson();
     const eventRoot = cursorWorkspaceRoot(event);
-    ensureCursorSessionBoot(eventRoot, '0xray/cursor-pre-tool-use-boot', {
-      sessionId: cursorSessionId(event),
-    });
+    const sessionId = cursorSessionId(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 sessionId = cursorSessionId(event);
 
     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,10 +307,12 @@ export function buildSessionBootPayload(root, source = '0xray/grok-session-start
     ...(conferPending ? { conferPending: true, conferTrigger: 'analyze-complexity at synthesis checkpoint' } : {}),
     ...(userAsideBoot ?? {}),
     sessionId,
-    timestamp: new Date().toISOString(),
-    source,
     ...extra,
     ...heat,
+    ...compactHold,
+    hook: source,
+    source,
+    timestamp: new Date().toISOString(),
   };
 }
 

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

@@ -468,6 +468,20 @@ async function handlePreProcess(input, projectRoot, logDir) {
   const { tool, args } = input;
   const startTime = Date.now();
 
+  try {
+    const gate = await import('../hooks/delegation-gate-runtime.mjs');
+    if (typeof gate.maybeHeatHostStation === 'function') {
+      gate.maybeHeatHostStation(projectRoot, 'hermes', {
+        source: '0xray/hermes-pre-process',
+        sessionId: input.sessionId || 'hermes',
+        hookEvent: 'pre_tool_use',
+        ...(input.intent ? { intent: input.intent } : {}),
+      });
+    }
+  } catch {
+    /* live memory is best-effort — quality gate still runs */
+  }
+
   logToolEvent(logDir, "start", tool, args);
   logToActivity(logDir, `pre-process: tool=${tool}`);