0xray 4.0.42 → 4.1.0

package/dist/cli/commands/plugin-commands.js

@@ -152,24 +152,25 @@ export async function pluginStatusCommand(pluginName) {
     console.log(`  Type:        ${m.type}`);
     console.log(`  Description: ${m.description}`);
     console.log(`  License:     ${m.license || "N/A"}`);
-    if (m.capabilities) {
+    if (Array.isArray(m.capabilities)) {
         console.log("\n  Capabilities:");
         for (const cap of m.capabilities) {
-            console.log(`    - ${cap}`);
+            console.log(`    - ${String(cap)}`);
         }
     }
-    if (m.tools) {
+    if (Array.isArray(m.tools)) {
         console.log("\n  Tools:");
         for (const tool of m.tools) {
-            console.log(`    - ${tool.name}: ${tool.description}`);
+            const row = tool;
+            console.log(`    - ${String(row.name)}: ${String(row.description)}`);
         }
     }
-    if (m.runtime) {
+    if (m.runtime && typeof m.runtime === "object" && !Array.isArray(m.runtime)) {
         const runtime = m.runtime;
         console.log("\n  Runtime:");
-        console.log(`    Command: ${runtime.command}`);
-        if (runtime.args) {
-            console.log(`    Args:    ${runtime.args.join(" ")}`);
+        console.log(`    Command: ${String(runtime.command)}`);
+        if (Array.isArray(runtime.args)) {
+            console.log(`    Args:    ${runtime.args.map((arg) => String(arg)).join(" ")}`);
         }
     }
     console.log("\n" + "═".repeat(50) + "\n");
@@ -195,51 +196,93 @@ function validateManifest(manifest) {
         }
     }
 }
-function parseYaml(content) {
-    const lines = content.split("\n");
-    const result = {};
-    let currentKey = "";
-    const stack = [
-        { indent: -1, obj: result },
-    ];
-    for (const line of lines) {
+function parseScalar(raw) {
+    const value = raw.trim();
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    if (value.startsWith("[") && value.endsWith("]")) {
+        const inner = value.slice(1, -1).trim();
+        if (!inner)
+            return [];
+        return inner.split(",").map((part) => parseScalar(part));
+    }
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    if (/^-?\d+$/.test(value))
+        return Number(value);
+    return value;
+}
+/** Subset of YAML used by plugin.yaml: maps, scalar lists, and lists of maps. */
+export function parseYaml(content) {
+    const root = {};
+    const stack = [{ indent: -1, container: root }];
+    for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("#"))
             continue;
         const indent = line.search(/\S/);
-        const isListItem = trimmed.startsWith("- ");
-        if (isListItem) {
-            const value = trimmed.slice(2).trim();
+        while (stack.length > 1) {
             const top = stack[stack.length - 1];
-            if (top && currentKey && !Array.isArray(top.obj[currentKey])) {
-                top.obj[currentKey] = [];
-            }
-            if (top && currentKey) {
-                top.obj[currentKey].push(value);
-            }
-            continue;
+            if (!top || indent > top.indent)
+                break;
+            stack.pop();
         }
-        const colonIndex = trimmed.indexOf(":");
-        if (colonIndex > 0) {
-            const key = trimmed.slice(0, colonIndex).trim();
-            const value = trimmed.slice(colonIndex + 1).trim();
-            const top = stack[stack.length - 1];
-            while (top && stack.length > 1 && indent <= top.indent) {
+        if (trimmed.startsWith("- ")) {
+            let owner = stack[stack.length - 1];
+            if (owner &&
+                !Array.isArray(owner.container) &&
+                Object.keys(owner.container).length === 0 &&
+                stack.length > 1) {
+                const holder = stack[stack.length - 2];
+                const emptyIndent = owner.indent;
                 stack.pop();
+                if (holder && !Array.isArray(holder.container) && holder.key) {
+                    const list = [];
+                    holder.container[holder.key] = list;
+                    stack.push({ indent: emptyIndent, container: list });
+                }
+                owner = stack[stack.length - 1];
             }
-            const current = stack[stack.length - 1];
-            if (!current)
+            if (!owner || !Array.isArray(owner.container))
                 continue;
-            const parent = current.obj;
-            if (value) {
-                parent[key] = value;
+            const rest = trimmed.slice(2).trim();
+            const colon = rest.indexOf(":");
+            const quoted = rest.startsWith('"') || rest.startsWith("'");
+            if (!quoted && colon > 0) {
+                const item = {};
+                const key = rest.slice(0, colon).trim();
+                const value = rest.slice(colon + 1).trim();
+                item[key] = value ? parseScalar(value) : {};
+                owner.container.push(item);
+                stack.push({ indent, container: item, key });
             }
             else {
-                parent[key] = {};
-                stack.push({ indent, obj: parent[key] });
+                owner.container.push(parseScalar(rest));
             }
-            currentKey = key;
+            continue;
+        }
+        const colonIndex = trimmed.indexOf(":");
+        if (colonIndex <= 0)
+            continue;
+        const key = trimmed.slice(0, colonIndex).trim();
+        const value = trimmed.slice(colonIndex + 1).trim();
+        const current = stack[stack.length - 1];
+        if (!current || Array.isArray(current.container))
+            continue;
+        if (value) {
+            current.container[key] = parseScalar(value);
+            current.key = key;
+        }
+        else {
+            const child = {};
+            current.container[key] = child;
+            current.key = key;
+            stack.push({ indent, container: child });
         }
     }
-    return result;
+    return root;
 }

package/dist/core/config-loader.js

@@ -93,9 +93,9 @@ export class XrayConfigLoader {
         }
         const cfg = config;
         return {
-            enabled: typeof cfg.enabled === 'boolean' ? cfg.enabled : true,
+            enabled: typeof cfg.enabled === 'boolean' ? cfg.enabled : false,
             interval_minutes: Math.max(5, Math.min(1440, typeof cfg.interval_minutes === 'number' ? cfg.interval_minutes : 60)),
-            auto_schedule: typeof cfg.auto_schedule === 'boolean' ? cfg.auto_schedule : true,
+            auto_schedule: typeof cfg.auto_schedule === 'boolean' ? cfg.auto_schedule : false,
             include_health_assessment: typeof cfg.include_health_assessment === 'boolean' ? cfg.include_health_assessment : true,
             include_agent_activities: typeof cfg.include_agent_activities === 'boolean' ? cfg.include_agent_activities : true,
             include_pipeline_operations: typeof cfg.include_pipeline_operations === 'boolean' ? cfg.include_pipeline_operations : true,
@@ -123,9 +123,9 @@ export class XrayConfigLoader {
                 session_persistence: true,
             },
             autonomous_reporting: {
-                enabled: true,
+                enabled: false,
                 interval_minutes: 60,
-                auto_schedule: true,
+                auto_schedule: false,
                 include_health_assessment: true,
                 include_agent_activities: true,
                 include_pipeline_operations: true,

package/dist/core/features-config.d.ts

@@ -406,7 +406,7 @@ export interface FeaturesConfig {
         enabled?: boolean;
     };
     memory_routing?: MemoryRoutingConfig;
-    /** P2.2 — lightweight Grok write-tool postprocessor marker */
+    /** Marker is opt-in and the shipped default is off. */
     grok_postprocessor_light?: boolean;
     /** P2 — git post-commit session inference capture */
     inference_session_capture?: {

package/dist/core/features-config.js

@@ -342,9 +342,9 @@ export class FeaturesConfigLoader {
                 no_new_surface: true,
             },
             autonomous_reporting: {
-                enabled: true,
+                enabled: false,
                 interval_minutes: 60,
-                auto_schedule: true,
+                auto_schedule: false,
                 include_health_assessment: true,
                 include_agent_activities: true,
                 include_pipeline_operations: true,
@@ -410,7 +410,7 @@ export class FeaturesConfigLoader {
                 max_cache_size_mb: 50,
             },
             inference: {
-                description: "Self-improvement cycle that grades a new named session into repertoire",
+                description: "The cycle runs from the CLI command inference:run and the session wake does not start it.",
                 enabled: true,
                 workflow_dir: ".xray/inference",
                 reports_dir: ".xray/reports",

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

@@ -3,7 +3,8 @@
   "hooks": {
     "preToolUse": [
       {
-        "command": ".cursor/hooks/pre-tool-use.sh"
+        "command": ".cursor/hooks/pre-tool-use.sh",
+        "failClosed": true
       }
     ],
     "preCompact": [
@@ -18,12 +19,14 @@
     ],
     "beforeShellExecution": [
       {
-        "command": ".cursor/hooks/before-shell-execution.sh"
+        "command": ".cursor/hooks/before-shell-execution.sh",
+        "failClosed": true
       }
     ],
     "beforeReadFile": [
       {
-        "command": ".cursor/hooks/before-read-file.sh"
+        "command": ".cursor/hooks/before-read-file.sh",
+        "failClosed": true
       }
     ]
   }

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 };
@@ -32,22 +49,38 @@ function finish(root, permission, reason, hint, toolName, extra = {}) {
   if (hint && permission === 'allow') {
     out.user_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 +93,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 +110,65 @@ 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 });
+    }
+    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/hooks/pre-tool-use.js

@@ -22,65 +22,9 @@ import {
 } 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 { 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 };

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

@@ -914,9 +914,22 @@ 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) {
+      return {
+        allow: false,
+        phase: "pre",
+        gate: lens.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);