0xray 4.0.41 → 4.1.0

package/scripts/node/bridge-mcp-wiring.cjs

@@ -869,7 +869,125 @@ function resolveOpenClawPluginDir(packageRoot) {
   ].find((p) => fs.existsSync(path.join(p, "index.js"))) || null;
 }
 
-function installOpenClawHostWear(packageRoot) {
+function isCheckoutOpenClawPluginPath(pluginPath) {
+  const normalized = String(pluginPath || "").replace(/\\/g, "/");
+  return (
+    normalized.includes("/src/integrations/openclaw/plugin/xray-pre-tool") &&
+    !normalized.includes("/node_modules/")
+  );
+}
+
+function isInstalledOpenClawPluginPath(pluginPath) {
+  const normalized = String(pluginPath || "").replace(/\\/g, "/");
+  return (
+    normalized.includes("/node_modules/") &&
+    normalized.includes("/integrations/openclaw/plugin/xray-pre-tool")
+  );
+}
+
+/** Installed package first. A checkout src path drops once any installed plugin is present. */
+function settleOpenClawPluginPaths(paths, wornPluginDir) {
+  const list = (Array.isArray(paths) ? paths : []).map((entry) => String(entry));
+  const wornIsInstalled = Boolean(wornPluginDir && isInstalledOpenClawPluginPath(wornPluginDir));
+  const dropCheckout =
+    wornIsInstalled || list.some((entry) => isInstalledOpenClawPluginPath(entry));
+  const next = [];
+  const seen = new Set();
+  const push = (entry) => {
+    if (!entry) return;
+    const resolved = path.resolve(String(entry));
+    if (dropCheckout && isCheckoutOpenClawPluginPath(resolved)) return;
+    if (seen.has(resolved)) return;
+    seen.add(resolved);
+    next.push(resolved);
+  };
+  if (wornIsInstalled) push(wornPluginDir);
+  for (const entry of list) push(entry);
+  return next;
+}
+
+function resolveWornOpenClawPlugin(targetDir, packageRoot) {
+  const candidates = [];
+  if (targetDir) {
+    candidates.push(
+      path.join(targetDir, "node_modules", "0xray", "dist", "integrations", "openclaw", "plugin", "xray-pre-tool"),
+      path.join(targetDir, "node_modules", "0xray", "src", "integrations", "openclaw", "plugin", "xray-pre-tool"),
+    );
+  }
+  const fromPackage = resolveOpenClawPluginDir(packageRoot);
+  if (fromPackage) candidates.push(fromPackage);
+  return candidates.find((dir) => fs.existsSync(path.join(dir, "index.js"))) || null;
+}
+
+function replaceJsonPathsArray(raw, before, next) {
+  const keyAt = raw.indexOf('"paths"');
+  if (keyAt < 0) return null;
+  const bracket = raw.indexOf("[", keyAt);
+  if (bracket < 0) return null;
+  let depth = 0;
+  let end = -1;
+  for (let i = bracket; i < raw.length; i += 1) {
+    const ch = raw[i];
+    if (ch === "[") depth += 1;
+    else if (ch === "]") {
+      depth -= 1;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (end < 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw.slice(bracket, end + 1));
+  } catch {
+    return null;
+  }
+  if (JSON.stringify(parsed) !== JSON.stringify(before)) return null;
+  const lineStart = raw.lastIndexOf("\n", keyAt) + 1;
+  const indent = (raw.slice(lineStart, keyAt).match(/^\s*/) || [""])[0];
+  const itemIndent = `${indent}  `;
+  const body = next
+    .map((entry) => `${itemIndent}${JSON.stringify(entry)}`)
+    .join(",\n");
+  const array = `[\n${body}\n${indent}]`;
+  return `${raw.slice(0, bracket)}${array}${raw.slice(end + 1)}`;
+}
+
+/** Rewrite plugins.load.paths in place. Leaves the rest of the config file alone. */
+function pinOpenClawPluginLoad(configPath, wornPluginDir) {
+  if (!configPath || !fs.existsSync(configPath)) return null;
+  const raw = fs.readFileSync(configPath, "utf8");
+  const config = JSON.parse(raw);
+  if (!config.plugins || typeof config.plugins !== "object") return null;
+  if (!config.plugins.load || typeof config.plugins.load !== "object") config.plugins.load = {};
+  const before = Array.isArray(config.plugins.load.paths) ? config.plugins.load.paths : [];
+  const next = settleOpenClawPluginPaths(before, wornPluginDir);
+  if (JSON.stringify(before) === JSON.stringify(next)) return next;
+  const replaced = replaceJsonPathsArray(raw, before, next);
+  if (replaced == null) return null;
+  fs.writeFileSync(configPath, replaced);
+  return next;
+}
+
+function recordOpenClawProjectPlugin(targetDir, packageRoot) {
+  const pluginDir = resolveWornOpenClawPlugin(targetDir, packageRoot);
+  if (!pluginDir || !isInstalledOpenClawPluginPath(pluginDir)) return null;
+  const configPath = path.join(targetDir, ".xray", "config", "openclaw.json");
+  if (!fs.existsSync(configPath)) return null;
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+  } catch {
+    return null;
+  }
+  config.pluginPath = path.resolve(pluginDir);
+  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+  return config.pluginPath;
+}
+
+function installOpenClawHostWear(packageRoot, targetDir) {
   if (millSuit.isIsolatedHome()) return null;
   const source = resolveOpenClawPreToolHookSource(packageRoot);
   if (!source) return null;
@@ -878,6 +996,11 @@ function installOpenClawHostWear(packageRoot) {
   fs.mkdirSync(hookDir, { recursive: true });
   const dest = path.join(hookDir, "xray-pre-tool.mjs");
   fs.copyFileSync(source, dest);
+  const worn = resolveWornOpenClawPlugin(targetDir, packageRoot);
+  const hookRoot =
+    worn && isInstalledOpenClawPluginPath(worn) && targetDir
+      ? path.join(path.resolve(targetDir), "node_modules", "0xray")
+      : packageRoot;
   fs.writeFileSync(
     path.join(hookDir, "xray-pre-tool.json"),
     `${JSON.stringify(
@@ -887,17 +1010,16 @@ function installOpenClawHostWear(packageRoot) {
         args: [dest],
         stdin: "json",
         blockExitCode: 2,
-        env: { XRAY_AI_PATH: packageRoot },
+        env: { XRAY_AI_PATH: hookRoot },
       },
       null,
       2,
     )}\n`,
   );
 
-  const pluginSrc = resolveOpenClawPluginDir(packageRoot);
-  if (pluginSrc) {
+  if (worn && isInstalledOpenClawPluginPath(worn)) {
     try {
-      execFileSync("openclaw", ["plugins", "install", "-l", pluginSrc], {
+      execFileSync("openclaw", ["plugins", "install", "-l", path.resolve(worn)], {
         stdio: "pipe",
         encoding: "utf8",
         timeout: 60000,
@@ -915,6 +1037,13 @@ function installOpenClawHostWear(packageRoot) {
       /* enable is best-effort */
     }
   }
+  const configPath = resolveOpenClawConfigPath();
+  if (fs.existsSync(configPath)) {
+    pinOpenClawPluginLoad(
+      configPath,
+      worn && isInstalledOpenClawPluginPath(worn) ? worn : null,
+    );
+  }
   return dest;
 }
 
@@ -979,6 +1108,102 @@ function wireOpenClawBridge(targetDir) {
   return syncOpenClawMcpRegistry(targetDir);
 }
 
+function tomlString(value) {
+  return JSON.stringify(String(value));
+}
+
+function suitServerNames() {
+  return new Set(XRAY_MCP_SERVERS.map((server) => server.name));
+}
+
+function isSuitMcpHeader(line, names) {
+  const match = /^\[([^\]]+)\]\s*$/.exec(line.trim());
+  if (!match) return false;
+  const parts = match[1].split(".");
+  return parts[0] === "mcp_servers" && names.has(parts[1]);
+}
+
+function stripSuitMcpBlocks(toml, names) {
+  const kept = [];
+  let skip = false;
+  for (const line of String(toml || "").split(/\r?\n/)) {
+    if (/^\s*\[/.test(line)) skip = isSuitMcpHeader(line, names);
+    if (!skip) kept.push(line);
+  }
+  return kept.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+function suitMcpBlock(server, launch) {
+  const args = launch.args.map((arg) => `  ${tomlString(arg)},`).join("\n");
+  const lines = [
+    `[mcp_servers.${server.name}]`,
+    `command = ${tomlString(launch.command)}`,
+    "args = [",
+    args,
+    "]",
+    "enabled = true",
+  ];
+  const env = launch.env && typeof launch.env === "object" ? launch.env : {};
+  const envKeys = Object.keys(env);
+  if (envKeys.length > 0) {
+    lines.push("", `[mcp_servers.${server.name}.env]`);
+    for (const key of envKeys) lines.push(`${key} = ${tomlString(env[key])}`);
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Project `.grok/config.toml` replaces a same-named user server.
+ * The launch is the worn package, not `npx -y 0xray`.
+ */
+function writeProjectSuitMcp(targetDir) {
+  const root = path.resolve(targetDir);
+  const names = suitServerNames();
+  const blocks = XRAY_MCP_SERVERS.map((server) =>
+    suitMcpBlock(server, scopedMcpLaunch(root, server.mcpCmd, server.env)),
+  );
+  const grokDir = path.join(root, ".grok");
+  fs.mkdirSync(grokDir, { recursive: true });
+  const tomlPath = path.join(grokDir, "config.toml");
+  const existing = fs.existsSync(tomlPath) ? fs.readFileSync(tomlPath, "utf8") : "";
+  const kept = stripSuitMcpBlocks(existing, names);
+  const body = [kept, blocks.join("\n\n")].filter((part) => part && part.trim()).join("\n\n");
+  fs.writeFileSync(tomlPath, `${body.trim()}\n`);
+  return tomlPath;
+}
+
+function grokConfigHome(env) {
+  const source = env || process.env;
+  const home = source.HOME || source.USERPROFILE;
+  return home ? path.resolve(home) : os.homedir();
+}
+
+/** Grok 1.0.50 has no --trust flag. An untrusted folder skips project MCP. */
+function trustGrokFolder(targetDir, env) {
+  const home = grokConfigHome(env);
+  const grokDir = path.join(home, ".grok");
+  fs.mkdirSync(grokDir, { recursive: true });
+  const file = path.join(grokDir, "trusted_folders.toml");
+  let text = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+  const folders = [path.resolve(targetDir)];
+  try {
+    const real = fs.realpathSync(folders[0]);
+    if (real !== folders[0]) folders.push(real);
+  } catch {
+    /* the path is the one Grok will see */
+  }
+  const now = Math.floor(Date.now() / 1000);
+  let added = 0;
+  for (const folder of folders) {
+    const header = `[folders.${tomlString(folder)}]`;
+    if (text.includes(header)) continue;
+    text = `${text.replace(/\s*$/, "")}\n${header}\ntrusted = true\ndecided_at = ${now}\n`;
+    added += 1;
+  }
+  if (added > 0) fs.writeFileSync(file, text.endsWith("\n") ? text : `${text}\n`);
+  return file;
+}
+
 module.exports = {
   XRAY_MCP_SERVERS,
   HERMES_CONFIG_PATH,
@@ -1025,5 +1250,11 @@ module.exports = {
   resolveOpenClawPreToolHookSource,
   resolveOpenClawPluginDir,
   installOpenClawHostWear,
+  settleOpenClawPluginPaths,
+  pinOpenClawPluginLoad,
+  recordOpenClawProjectPlugin,
+  resolveWornOpenClawPlugin,
   maybeWriteOpenClawCliBackend,
+  writeProjectSuitMcp,
+  trustGrokFolder,
 };

package/scripts/node/confer-switch.cjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * Turn confer on or off in the worn .xray/features.json.
+ * A missing key stays off until this runs. Synthesis stays untouched.
+ */
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+function fail(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}
+
+function orchestrationBlock(data) {
+  const current = data.multi_agent_orchestration;
+  if (current && typeof current === "object" && !Array.isArray(current)) return current;
+  const created = {};
+  data.multi_agent_orchestration = created;
+  return created;
+}
+
+function conferBlock(orch) {
+  const current = orch.confer;
+  if (current && typeof current === "object" && !Array.isArray(current)) return current;
+  const created = {};
+  orch.confer = created;
+  return created;
+}
+
+function main() {
+  const state = process.argv[2];
+  if (state !== "on" && state !== "off") fail("confer: say on or off");
+
+  const featuresPath = path.join(process.cwd(), ".xray", "features.json");
+  if (!fs.existsSync(featuresPath)) {
+    fail("confer: .xray/features.json is missing. Run npx 0xray wear first.");
+  }
+
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(featuresPath, "utf8"));
+  } catch {
+    fail("confer: .xray/features.json is not valid JSON");
+  }
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    fail("confer: .xray/features.json is not valid JSON");
+  }
+
+  const orch = orchestrationBlock(data);
+  const confer = conferBlock(orch);
+  if (state === "on") {
+    confer.enabled = true;
+    if (confer.on_synthesis !== false) confer.on_synthesis = true;
+  } else {
+    confer.enabled = false;
+    confer.on_synthesis = false;
+    orch.confer_on_synthesis = false;
+  }
+
+  fs.writeFileSync(featuresPath, `${JSON.stringify(data, null, 2)}\n`);
+  process.stdout.write(`confer: ${state}\n`);
+}
+
+if (require.main === module) main();

package/scripts/node/install-bridges.cjs

@@ -7,7 +7,7 @@
 
 const fs = require("fs");
 const path = require("path");
-const { execFileSync, execSync } = require("child_process");
+const { execFileSync } = require("child_process");
 const {
   wantsCostume,
   isIsolatedHome,
@@ -22,18 +22,19 @@ const {
   wireOpencodeBridge,
   wireOpenClawBridge,
   deployPortableProjectMcpJson,
-  scopedMcpLaunch,
   mergeMcpMap,
   mergeNamedRecords,
   jsonDeepEqual,
   copyHermesFindProjectRootHelper,
   copyHermesHookRuntimes,
   installOpenClawHostWear,
+  recordOpenClawProjectPlugin,
   maybeWriteOpenClawCliBackend,
   isEphemeralInstallRoot,
   enableMemoryRoutingIfResolves,
   pinLauncherPackageRoot,
-  XRAY_MCP_SERVERS,
+  writeProjectSuitMcp,
+  trustGrokFolder,
 } = require("./bridge-mcp-wiring.cjs");
 
 const wearIo = { writes: 0, skips: 0 };
@@ -484,42 +485,11 @@ function findGrokPluginSource(packageRoot) {
   return candidates.find((p) => fs.existsSync(p));
 }
 
-function registerGrokMcpServers(targetDir, log, pluginDirs) {
-  try {
-    execSync("which grok", { stdio: "ignore" });
-  } catch {
-    log("grok-bridge", "grok CLI not on PATH — plugin .mcp.json still configured", "info");
-    return;
-  }
-
-  for (const s of XRAY_MCP_SERVERS) {
-    try {
-      const launch = scopedMcpLaunch(targetDir, s.mcpCmd, s.env);
-      const argv = ["mcp", "add", s.name, "--command", launch.command, "--args", launch.args[0], ...launch.args.slice(1)];
-      for (const [key, value] of Object.entries(launch.env)) {
-        argv.push("--env", `${key}=${value}`);
-      }
-      execFileSync("grok", argv, { stdio: "pipe" });
-      log("grok-bridge", `registered ${s.name} (mcp-launch)`, "info");
-    } catch {
-      // already registered or grok config conflict — non-blocking
-    }
-  }
-
-  const dirs =
-    Array.isArray(pluginDirs) && pluginDirs.length > 0
-      ? pluginDirs
-      : [path.join(targetDir, ".grok", "plugins", "0xray")];
-  for (const pluginDir of dirs) {
-    if (!fs.existsSync(pluginDir)) continue;
-    try {
-      execSync(`grok plugins trust "${pluginDir}"`, { stdio: "ignore" });
-      log("grok-bridge", "plugin trusted", "info", { path: pluginDir });
-      break;
-    } catch {
-      // best-effort
-    }
-  }
+function registerGrokMcpServers(targetDir, log, env) {
+  const tomlPath = writeProjectSuitMcp(targetDir);
+  log("grok-bridge", "project mcp config written", "info", { path: tomlPath });
+  const trustPath = trustGrokFolder(targetDir, env || process.env);
+  log("grok-bridge", "folder trusted", "info", { path: trustPath });
 }
 
 
@@ -742,8 +712,8 @@ function installGrokBridge(targetDir, packageRoot, log, opts) {
     if (globalCopied > 0) {
       log("grok-bridge", `global skills synced (${globalCopied})`, "info", { path: grokGlobalSkills });
     }
-    registerGrokMcpServers(targetDir, log, targets);
   }
+  registerGrokMcpServers(targetDir, log, env);
 }
 
 function installHermesBridge(targetDir, packageRoot, log) {
@@ -881,7 +851,7 @@ function installOpenclawBridge(targetDir, packageRoot, log) {
   }
 
   if (!ephemeralOpenclaw && !isolatedOpenclaw) {
-    const hook = installOpenClawHostWear(packageRoot);
+    const hook = installOpenClawHostWear(packageRoot, targetDir);
     if (hook) log("openclaw-bridge", "PreToolUse hook installed", "info", { path: hook });
     if (maybeWriteOpenClawCliBackend()) {
       log("openclaw-bridge", "opencode-cli backend written", "info");
@@ -895,6 +865,11 @@ function installOpenclawBridge(targetDir, packageRoot, log) {
       "info",
     );
   }
+
+  const recorded = recordOpenClawProjectPlugin(targetDir, packageRoot);
+  if (recorded) {
+    log("openclaw-bridge", "project plugin path recorded", "info", { path: recorded });
+  }
 }
 
 const XRAY_CONFIG_FILES = ["codex.json", "features.json", "features.schema.json", "config.json"];
@@ -1041,16 +1016,18 @@ const CURSOR_HOOK_EVENTS = [
   ["beforeReadFile", "before-read-file.sh"],
 ];
 
+const CURSOR_GATE_EVENTS = new Set(["preToolUse", "beforeShellExecution", "beforeReadFile"]);
+
 const CURSOR_WEAR_BACKUP = "hooks.json.xray-before";
 
 const CLOUD_SAFE_CURSOR_HOOKS = {
   version: 1,
   hooks: {
-    preToolUse: [{ command: ".cursor/hooks/pre-tool-use.sh" }],
+    preToolUse: [{ command: ".cursor/hooks/pre-tool-use.sh", failClosed: true }],
     preCompact: [{ command: ".cursor/hooks/pre-compact.sh" }],
     afterFileEdit: [{ command: ".cursor/hooks/after-file-edit.sh" }],
-    beforeShellExecution: [{ command: ".cursor/hooks/before-shell-execution.sh" }],
-    beforeReadFile: [{ command: ".cursor/hooks/before-read-file.sh" }],
+    beforeShellExecution: [{ command: ".cursor/hooks/before-shell-execution.sh", failClosed: true }],
+    beforeReadFile: [{ command: ".cursor/hooks/before-read-file.sh", failClosed: true }],
   },
 };
 
@@ -1096,6 +1073,9 @@ function mergeCloudSafeCursorHooks(existing) {
       !Array.isArray(current) || !current.some((h) => isRelativeCursorHookCommand(h && h.command));
     if (!current || leftover || missingRelative) {
       next.hooks[name] = entries;
+    } else if (entries[0].failClosed) {
+      // Gate events fail closed: our relative entry gets failClosed even on an existing hooks.json (re-wear upgrades it).
+      next.hooks[name] = current.map((h) => (h && isRelativeCursorHookCommand(h.command) ? { ...h, failClosed: true } : h));
     }
   }
   return next;
@@ -1304,7 +1284,10 @@ function installedHookCommand(fromDir, packageRoot, scriptName) {
 function installedCursorHookEntries(fromDir, packageRoot) {
   const hooks = {};
   for (const [event, script] of CURSOR_HOOK_EVENTS) {
-    hooks[event] = [{ command: installedHookCommand(fromDir, packageRoot, script) }];
+    const entry = { command: installedHookCommand(fromDir, packageRoot, script) };
+    // Gate events fail closed: Cursor denies when the hook crashes or prints no JSON.
+    if (CURSOR_GATE_EVENTS.has(event)) entry.failClosed = true;
+    hooks[event] = [entry];
   }
   return hooks;
 }
@@ -1635,8 +1618,10 @@ function ownedDeletionEdits(tokens, elements) {
   return edits;
 }
 
-function renderEventEntry(command) {
-  return `{ "command": ${JSON.stringify(command)} }`;
+function renderEventEntry(command, failClosed) {
+  return failClosed
+    ? `{ "command": ${JSON.stringify(command)}, "failClosed": true }`
+    : `{ "command": ${JSON.stringify(command)} }`;
 }
 
 function editJsoncHooks(text, xrayByEvent, targetDir) {
@@ -1652,7 +1637,7 @@ function editJsoncHooks(text, xrayByEvent, targetDir) {
   const hooksPair = root.pairs.find((pair) => pair.key === "hooks");
   if (!hooksPair) {
     const inner = Object.entries(xrayByEvent)
-      .map(([event, entries]) => `"${event}": [${renderEventEntry(entries[0].command)}]`)
+      .map(([event, entries]) => `"${event}": [${renderEventEntry(entries[0].command, entries[0].failClosed)}]`)
       .join(", ");
     const needsComma = root.pairs.length > 0;
     edits.push({
@@ -1667,9 +1652,10 @@ function editJsoncHooks(text, xrayByEvent, targetDir) {
   const missing = [];
   for (const [event, entries] of Object.entries(xrayByEvent)) {
     const command = entries[0].command;
+    const failClosed = entries[0].failClosed === true;
     const pair = hooksObj.pairs.find((item) => item.key === event);
     if (!pair) {
-      missing.push([event, command]);
+      missing.push([event, command, failClosed]);
       continue;
     }
     if (tokens[pair.valIdx].type !== "[") throw new Error(`${event} is not an array`);
@@ -1691,7 +1677,7 @@ function editJsoncHooks(text, xrayByEvent, targetDir) {
       edits.push({
         start: tokens[pair.valEnd].start,
         end: tokens[pair.valEnd].start,
-        insert: `${elements.length > 0 ? ", " : ""}${renderEventEntry(command)}`,
+        insert: `${elements.length > 0 ? ", " : ""}${renderEventEntry(command, failClosed)}`,
       });
       continue;
     }
@@ -1703,13 +1689,17 @@ function editJsoncHooks(text, xrayByEvent, targetDir) {
         insert: JSON.stringify(command),
       });
     }
+    if (failClosed && !objectPairs(tokens, first.el.startIdx).pairs.some((p) => p.key === "failClosed")) {
+      // Re-wear upgrades an older entry: gate events fail closed.
+      edits.push({ start: first.cmd.token.end, end: first.cmd.token.end, insert: ', "failClosed": true' });
+    }
     if (owned.length > 1) {
       edits.push(...ownedDeletionEdits(tokens, owned.slice(1).map((item) => item.el)));
     }
   }
   if (missing.length > 0) {
     const rendered = missing
-      .map(([event, command]) => `"${event}": [${renderEventEntry(command)}]`)
+      .map(([event, command, failClosed]) => `"${event}": [${renderEventEntry(command, failClosed)}]`)
       .join(", ");
     edits.push({
       start: tokens[hooksObj.closeIdx].start,
@@ -1803,20 +1793,21 @@ function mergeInstalledCursorHooks(existing, xrayByEvent) {
       continue;
     }
     const command = shipped[0].command;
+    const extra = shipped[0].failClosed ? { failClosed: true } : {};
     let replaced = false;
     const next = [];
     for (const entry of current) {
       const cmd = entry && typeof entry === "object" ? entry.command : "";
       if (isXrayHookCommand(cmd)) {
         if (!replaced) {
-          next.push({ ...entry, command });
+          next.push({ ...entry, command, ...extra });
           replaced = true;
         }
         continue;
       }
       next.push(entry);
     }
-    if (!replaced) next.push({ command });
+    if (!replaced) next.push({ command, ...extra });
     hooks[name] = next;
   }
   const doc = {};

package/scripts/node/pack-tmp-suit-proof.mjs

@@ -39,17 +39,25 @@ export function foundryCliPath(millRoot) {
   return path.join(millRoot, "cli.js");
 }
 
-export function runFoundryCli(millRoot, consumerRoot, args) {
+/** Clean-room foundry env. The machine home is empty so a plugin on the real machine cannot fail the seat inspect. */
+export function proofFoundryEnv(consumerRoot, baseEnv = process.env) {
   const isolatedHome = path.join(consumerRoot, ".proof-home");
+  const machineHome = path.join(consumerRoot, ".proof-machine");
   fs.mkdirSync(isolatedHome, { recursive: true });
+  fs.mkdirSync(machineHome, { recursive: true });
+  return {
+    ...baseEnv,
+    FOUNDRY_ROOT: consumerRoot,
+    HOME: isolatedHome,
+    FOUNDRY_MACHINE_HOME: machineHome,
+  };
+}
+
+export function runFoundryCli(millRoot, consumerRoot, args) {
   return spawnSync(process.execPath, [foundryCliPath(millRoot), ...args], {
     cwd: consumerRoot,
     encoding: "utf8",
-    env: {
-      ...process.env,
-      FOUNDRY_ROOT: consumerRoot,
-      HOME: isolatedHome,
-    },
+    env: proofFoundryEnv(consumerRoot),
   });
 }
 

package/src/integrations/openclaw/plugin/xray-pre-tool/index.js

@@ -2,7 +2,7 @@ import { createRequire } from 'node:module';
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { definePluginEntry } from 'openclaw/plugin-sdk/plugin-entry';
 
 const require = createRequire(import.meta.url);
@@ -39,7 +39,7 @@ export default definePluginEntry({
   register(api) {
     api.on(
       'before_tool_call',
-      (event, ctx) => {
+      async (event, ctx) => {
         try {
           const xrayRoot = resolveXrayRoot();
           if (!xrayRoot) {
@@ -61,6 +61,21 @@ export default definePluginEntry({
           if (!outcome.allow) {
             return { block: true, blockReason: outcome.reason || '0xRay constitution' };
           }
+          const spoken = `${event.toolName} ${JSON.stringify(event.params || {})}`.slice(0, 500);
+          const speakPath = [
+            join(xrayRoot, 'dist/integrations/hooks/pre-tool-speak.mjs'),
+            join(xrayRoot, 'src/integrations/hooks/pre-tool-speak.mjs'),
+          ].find((candidate) => existsSync(candidate));
+          if (!speakPath) return undefined;
+          const speak = await import(pathToFileURL(speakPath).href);
+          const lens = speak.lensDecision(projectRoot, event.toolName, spoken);
+          if (lens) {
+            return { block: true, blockReason: lens.reason };
+          }
+          const route = speak.repertoireRoute(spoken);
+          if (route?.hookSpecificOutput) {
+            return { block: false, hookSpecificOutput: route.hookSpecificOutput };
+          }
           return undefined;
         } catch (err) {
           return {

package/src/integrations/openclaw/plugin/xray-pre-tool/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xray-pre-tool",
-  "version": "4.0.41",
+  "version": "4.1.0",
   "private": true,
   "type": "module",
   "description": "0xRay constitution + temperament PreToolUse for OpenClaw",