0xray 4.0.41 → 4.0.42

package/scripts/mjs/verify-confer-core.mjs

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 /**
- * Confer quorum fixture — 3-agent synthesis consult completes via fixture mode.
+ * Confer quorum fixture.
+ * PASS completes. FAIL and no-LLM UNREVIEWED leave the todo open and the checkpoint due.
+ * Temp projects opt into synthesis so a due checkpoint can be observed. The repo default stays off.
  */
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -10,10 +12,14 @@ import { fileURLToPath } from 'node:url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageRoot = join(__dirname, '../..');
 
+// Fixture PASS is refused unless this process is a test. The live orchestrate-task
+// flag and XRAY_CONFER_FIXTURE stay unreachable when NODE_ENV is not test.
+process.env.NODE_ENV = 'test';
+
 const { buildSynthesisCheckpointPlan } = await import(
   join(packageRoot, 'dist/nucleus/autonomy-kernel.js')
 );
-const { savePersistedLeadDevPlan, areSynthesisConsultTodosComplete } = await import(
+const { savePersistedLeadDevPlan, areSynthesisConsultTodosComplete, loadPersistedLeadDevPlan } = await import(
   join(packageRoot, 'dist/nucleus/lead-dev-plan-persistence.js')
 );
 const { recordExecutionSlice, isSynthesisCheckpointDue } = await import(
@@ -22,46 +28,103 @@ const { recordExecutionSlice, isSynthesisCheckpointDue } = await import(
 const { runConferQuorum, loadConferCheckpoint, CONFER_AGENTS } = await import(
   join(packageRoot, 'dist/nucleus/confer.js')
 );
+const { loadSynthesisConsultReceipt } = await import(
+  join(packageRoot, 'dist/nucleus/synthesis-consult-receipt.js')
+);
+const { readConferReviewHint } = await import(
+  join(packageRoot, 'src/integrations/hooks/confer-hook-runtime.mjs')
+);
+const { buildSessionBootPayload } = await import(
+  join(packageRoot, 'src/integrations/grok/hooks/grok-hook-utils.js')
+);
 
-const sessionId = 'verify-confer-core';
 let failed = 0;
+let checks = 0;
 function pass(n) {
+  checks++;
   console.log(`✅ ${n}`);
 }
 function fail(n, d = '') {
   failed++;
+  checks++;
   console.error(`❌ ${n}${d ? ` — ${d}` : ''}`);
 }
 
-const tmp = mkdtempSync(join(tmpdir(), 'xray-confer-verify-'));
-mkdirSync(join(tmp, '.xray', 'state'), { recursive: true });
-writeFileSync(
-  join(tmp, '.xray', 'features.json'),
-  JSON.stringify({
-    multi_agent_orchestration: { lead_dev_mode: true, confer_on_synthesis: true },
-    synthesis: { enabled: true, every_n_gates: 1, every_n_turns: 0, every_n_todos_completed: 0 },
-  }),
-);
+function assertRepoSynthesisStaysOff() {
+  const source = readFileSync(join(packageRoot, 'src/nucleus/synthesis.ts'), 'utf8');
+  const defaults = source.match(/function defaultSynthesisConfig\(\)[\s\S]*?return \{([\s\S]*?)\n  \};/);
+  if (defaults && /enabled:\s*false/.test(defaults[1])) pass('repo defaultSynthesisConfig stays enabled: false');
+  else fail('repo defaultSynthesisConfig stays enabled: false');
 
-try {
-  recordExecutionSlice('gate', { projectRoot: tmp, sessionId });
-  if (!isSynthesisCheckpointDue(tmp, sessionId)) fail('step 1: synthesis due');
-  else pass('step 1: synthesis checkpoint due');
+  for (const rel of ['xray/features.json', '.xray/features.json']) {
+    const data = JSON.parse(readFileSync(join(packageRoot, rel), 'utf8'));
+    if (data.synthesis?.enabled === false) pass(`${rel} synthesis.enabled stays false`);
+    else fail(`${rel} synthesis.enabled stays false`, JSON.stringify(data.synthesis));
+  }
+}
 
+function makeProject() {
+  const tmp = mkdtempSync(join(tmpdir(), 'xray-confer-verify-'));
+  mkdirSync(join(tmp, '.xray', 'state'), { recursive: true });
+  writeFileSync(
+    join(tmp, '.xray', 'features.json'),
+    JSON.stringify({
+      multi_agent_orchestration: { lead_dev_mode: true, confer_on_synthesis: true },
+      synthesis: { enabled: true, every_n_gates: 1, every_n_turns: 0, every_n_todos_completed: 0 },
+    }),
+  );
+  return tmp;
+}
+
+function seedDuePlan(tmp, sessionId) {
+  recordExecutionSlice('gate', { projectRoot: tmp, sessionId });
+  const due = isSynthesisCheckpointDue(tmp, sessionId);
   const plan = buildSynthesisCheckpointPlan('gate threshold (1/1)', tmp);
-  if (!plan) fail('step 2: synthesis plan');
-  else {
+  if (plan) {
     savePersistedLeadDevPlan(
       { ...plan, persistedAt: new Date().toISOString(), sessionId },
       tmp,
     );
-    pass('step 2: synthesis plan persisted');
   }
+  return { due, plan };
+}
+
+function blocksCheckpoint(label, tmp, sessionId, result, verdict) {
+  const receipt = loadSynthesisConsultReceipt('s.1', tmp);
+  if (result.status === 'partial' && result.agents[0]?.verdict === verdict && result.agents[0]?.todoCompleted === false) {
+    pass(`${label}: quorum stopped on ${verdict}`);
+  } else {
+    fail(`${label}: quorum stopped on ${verdict}`, JSON.stringify(result));
+  }
+  if (receipt?.verdict === verdict) pass(`${label}: receipt verdict ${verdict}`);
+  else fail(`${label}: receipt verdict ${verdict}`, JSON.stringify(receipt));
+  if (!areSynthesisConsultTodosComplete(loadPersistedLeadDevPlan(tmp))) {
+    pass(`${label}: consult todo stays open`);
+  } else {
+    fail(`${label}: consult todo stays open`);
+  }
+  if (isSynthesisCheckpointDue(tmp, sessionId)) pass(`${label}: synthesis checkpoint stays due`);
+  else fail(`${label}: synthesis checkpoint stays due`);
+  const state = loadConferCheckpoint(tmp);
+  if (state?.status === 'failed') pass(`${label}: confer checkpoint not cleared`);
+  else fail(`${label}: confer checkpoint not cleared`, JSON.stringify(state));
+}
+
+assertRepoSynthesisStaysOff();
+
+const passRoot = makeProject();
+const passSession = 'verify-confer-core-pass';
+try {
+  const seeded = seedDuePlan(passRoot, passSession);
+  if (!seeded.due) fail('step 1: synthesis due');
+  else pass('step 1: synthesis checkpoint due');
+  if (!seeded.plan) fail('step 2: synthesis plan');
+  else pass('step 2: synthesis plan persisted');
 
   if (CONFER_AGENTS.length !== 3) fail('step 3: confer agent count', String(CONFER_AGENTS.length));
   else pass('step 3: three confer agents defined');
 
-  const result = await runConferQuorum(tmp, sessionId, {
+  const result = await runConferQuorum(passRoot, passSession, {
     collocatedText: 'verify confer fixture context',
     dueReason: 'gate threshold',
     fixture: true,
@@ -73,31 +136,92 @@ try {
     fail('step 4: confer quorum', JSON.stringify(result));
   }
 
-  const state = loadConferCheckpoint(tmp);
+  const state = loadConferCheckpoint(passRoot);
   if (state?.status === 'completed' && state.completedAgents.length === 3) {
     pass('step 5: confer checkpoint state completed');
   } else {
     fail('step 5: confer state', JSON.stringify(state));
   }
 
-  if (areSynthesisConsultTodosComplete(
-    (await import(join(packageRoot, 'dist/nucleus/lead-dev-plan-persistence.js'))).loadPersistedLeadDevPlan(tmp),
-  )) {
+  if (areSynthesisConsultTodosComplete(loadPersistedLeadDevPlan(passRoot))) {
     pass('step 6: synthesis consult todos complete after confer');
   } else {
     fail('step 6: consult todos incomplete');
   }
 
-  if (!isSynthesisCheckpointDue(tmp, sessionId)) pass('step 7: synthesis checkpoint cleared');
+  if (!isSynthesisCheckpointDue(passRoot, passSession)) pass('step 7: synthesis checkpoint cleared');
   else fail('step 7: checkpoint still due');
 } finally {
-  rmSync(tmp, { recursive: true, force: true });
+  rmSync(passRoot, { recursive: true, force: true });
+}
+
+const failRoot = makeProject();
+const failSession = 'verify-confer-core-fail';
+try {
+  seedDuePlan(failRoot, failSession);
+  const result = await runConferQuorum(failRoot, failSession, {
+    fixture: true,
+    fixtureVerdict: 'FAIL',
+  });
+  blocksCheckpoint('FAIL', failRoot, failSession, result, 'FAIL');
+} finally {
+  rmSync(failRoot, { recursive: true, force: true });
+}
+
+const unreviewedRoot = makeProject();
+const unreviewedSession = 'verify-confer-core-unreviewed';
+try {
+  seedDuePlan(unreviewedRoot, unreviewedSession);
+  const result = await runConferQuorum(unreviewedRoot, unreviewedSession, {
+    fixture: true,
+    fixtureNoLlm: true,
+  });
+  blocksCheckpoint('no-LLM', unreviewedRoot, unreviewedSession, result, 'UNREVIEWED');
+  if (readConferReviewHint(unreviewedRoot) === 'UNREVIEWED') {
+    pass('no-LLM: confer review hint is UNREVIEWED');
+  } else {
+    fail('no-LLM: confer review hint is UNREVIEWED');
+  }
+  const boot = buildSessionBootPayload(unreviewedRoot, 'verify/session-start');
+  if (boot.conferReview === 'UNREVIEWED' && String(boot.conferReviewHint).includes('UNREVIEWED')) {
+    pass('no-LLM: session-boot hint records UNREVIEWED');
+  } else {
+    fail('no-LLM: session-boot hint records UNREVIEWED', JSON.stringify({
+      conferReview: boot.conferReview,
+      conferReviewHint: boot.conferReviewHint,
+    }));
+  }
+} finally {
+  rmSync(unreviewedRoot, { recursive: true, force: true });
+}
+
+const conditionalRoot = makeProject();
+const conditionalSession = 'verify-confer-core-conditional';
+try {
+  seedDuePlan(conditionalRoot, conditionalSession);
+  const result = await runConferQuorum(conditionalRoot, conditionalSession, {
+    fixture: true,
+    fixtureVerdict: 'CONDITIONAL',
+  });
+  const verdicts = result.agents.map((agent) => agent.verdict);
+  if (result.status === 'partial' && verdicts[0] === 'CONDITIONAL' && result.agents[0]?.todoCompleted === false) {
+    pass('CONDITIONAL: explicit conditional does not complete');
+  } else {
+    fail('CONDITIONAL: explicit conditional does not complete', JSON.stringify(result));
+  }
+  if (isSynthesisCheckpointDue(conditionalRoot, conditionalSession)) {
+    pass('CONDITIONAL: checkpoint stays due');
+  } else {
+    fail('CONDITIONAL: checkpoint stays due');
+  }
+} finally {
+  rmSync(conditionalRoot, { recursive: true, force: true });
 }
 
 console.log(
   '\n' +
     (failed === 0
-      ? '🎉 Confer verify passed (7/7).'
+      ? `🎉 Confer verify passed (${checks}/${checks}).`
       : `⚠️  ${failed} confer check(s) failed.`),
 );
-process.exit(failed === 0 ? 0 : 1);
+process.exit(failed === 0 ? 0 : 1);

package/scripts/mjs/verify-user-aside-core.mjs

@@ -75,16 +75,15 @@ try {
     35,
     tmp,
   );
-  if (aside?.plan.phases[0]?.todos[0]?.id !== 'suit-nft.a.1.1') {
-    fail('step 3: build aside plan', aside?.plan.phases[0]?.todos[0]?.id);
+  const todo = aside?.plan.phases.flatMap((phase) => phase.todos)[0];
+  if (todo?.id !== 'suit-nft.a.2.1') {
+    fail('step 3: build aside plan', todo?.id);
   } else pass('step 3: namespaced aside todos');
 
   saveUserAside(aside, tmp);
   setActiveAsideId('suit-nft', tmp, 'verify-session');
   if (getActiveAsideId(tmp, 'verify-session') !== 'suit-nft') fail('step 4: active pointer');
   else pass('step 4: active aside pointer with session');
-
-  const todo = aside.plan.phases[0].todos[0];
   const resolved = resolveSpawnPlan({ planTodoId: todo.id }, tmp, 'verify-session');
   if (resolved.source !== 'aside') fail('step 5: resolve spawn plan', JSON.stringify(resolved));
   else pass('step 5: spawn plan resolves to aside');

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();