0xray 4.0.17 → 4.0.18

package/.grok-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "4.0.17",
+  "version": "4.0.18",
   "description": "0xRay suit for Grok, Hermes, OpenClaw, OpenCode: mill+inspect, Codex, 7 MCP servers. Costume 45/42 is opt-in foundry, not the default wear.",
   "author": {
     "name": "0xRay AI",

package/.xray/features.json

@@ -1,6 +1,6 @@
 {
   "$schema": "./features.schema.json",
-  "version": "4.0.17",
+  "version": "4.0.18",
   "description": "0xRay Framework - Unified Feature Configuration",
   "suit_temperament": {
     "profile": "auto",

package/dist/CHANGELOG.md

@@ -34,6 +34,22 @@ The format is based on [Conventional Commits](https://www.conventionalcommits.or
 
 ---
 
+## [4.0.18] - 2026-09-22
+
+### 🔄 Changes
+
+### ✨ Features
+- feat: wake heat joins bookmark, index, and mind (ad596aae2)
+
+### 🐛 Bug Fixes
+- fix: pin subject hits on wake rematch (65de9d37a)
+- fix: wake match loads 0.2.5 and keeps subject hits (80b61236d)
+
+### 📚 Documentation
+- docs: memory-wake join — BRAIN-003 (1c128e69c)
+
+---
+
 ## [4.0.17] - 2026-09-22
 
 ### 🔄 Changes

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

@@ -4,7 +4,6 @@
  * sessionStart is unavailable on managed cloud; first preToolUse / afterFileEdit boots.
  */
 
-import { execFileSync } from 'node:child_process';
 import fs from 'fs';
 import path from 'path';
 import {
@@ -25,10 +24,13 @@ import {
 import { appendHookActivity } from '../../grok/hooks/grok-hook-activity.js';
 import {
   buildRepertoireResume,
+  maybeCaptureSessionOnHeadMove,
   readGitBrief,
   stationDurableHoldsNpm,
 } from '../../hooks/station-hook-runtime.mjs';
 
+export { maybeCaptureSessionOnHeadMove };
+
 export const CURSOR_HOST = 'cursor';
 export const EVENT_CLASS_HOST = 'cursor-host-precompact';
 export const EVENT_CLASS_SYNTHETIC = 'cursor-precompact-synthetic';
@@ -153,105 +155,6 @@ export function cursorBootNeedsRefresh(existing, root) {
   return false;
 }
 
-function sessionCaptureStampPath(root) {
-  return path.join(root, '.xray', 'state', 'session-capture-stamp.json');
-}
-
-function readSessionCaptureConfig(root) {
-  let cfg = {};
-  try {
-    const raw = JSON.parse(fs.readFileSync(path.join(root, '.xray', 'features.json'), 'utf8'));
-    cfg = raw.inference_session_capture || {};
-  } catch {
-    cfg = {};
-  }
-  return {
-    enabled: cfg.enabled === true,
-    minCommits: typeof cfg.min_commits === 'number' && cfg.min_commits > 0 ? cfg.min_commits : 3,
-    lookback: typeof cfg.lookback_commits === 'number' && cfg.lookback_commits > 0 ? cfg.lookback_commits : 20,
-  };
-}
-
-function readSessionCaptureStamp(root) {
-  try {
-    return JSON.parse(fs.readFileSync(sessionCaptureStampPath(root), 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function gitCommitSubjects(root, args) {
-  try {
-    const out = execFileSync('git', ['log', '--format=%h||%s', '--no-merges', ...args], {
-      cwd: root,
-      encoding: 'utf8',
-      timeout: 5000,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    return String(out)
-      .split('\n')
-      .map((line) => line.trim())
-      .filter(Boolean)
-      .map((line) => {
-        const idx = line.indexOf('||');
-        return {
-          hash: idx === -1 ? line : line.slice(0, idx),
-          message: idx === -1 ? '' : line.slice(idx + 2),
-        };
-      });
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Cursor never runs the git post-commit hook. When HEAD moves, write the same
- * session-*.json the kernel already knows how to ingest. Dedup per HEAD.
- */
-export function maybeCaptureSessionOnHeadMove(root) {
-  const cfg = readSessionCaptureConfig(root);
-  if (!cfg.enabled) return null;
-  const git = readGitBrief(root);
-  if (!git || !git.head) return null;
-  const stamp = readSessionCaptureStamp(root);
-  if (stamp && stamp.head === git.head) return null;
-
-  const commits = stamp && stamp.head
-    ? gitCommitSubjects(root, [`${stamp.head}..HEAD`])
-    : gitCommitSubjects(root, ['-n', String(cfg.lookback)]);
-  if (commits.length < cfg.minCommits) return null;
-
-  const sessionId = `session-${new Date().toISOString().slice(0, 10)}-${git.head}`;
-  const approaches = commits.map((c) => c.message).filter(Boolean);
-  const session = {
-    sessionId,
-    timestamp: new Date().toISOString(),
-    span: {
-      from: stamp && stamp.head ? stamp.head : `HEAD~${cfg.lookback}`,
-      to: git.head,
-    },
-    problems: [],
-    approaches,
-    wrongTurns: [],
-    solutions: [],
-    patterns: [],
-    matched_primitives: [],
-    metrics: { commits: commits.length },
-  };
-
-  const outDir = path.join(root, 'docs', 'inference');
-  fs.mkdirSync(outDir, { recursive: true });
-  const filePath = path.join(outDir, `session-${sessionId.replace(/^session-/, '')}.json`);
-  fs.writeFileSync(filePath, `${JSON.stringify(session, null, 2)}\n`);
-  fs.writeFileSync(path.join(outDir, 'latest-session.json'), `${JSON.stringify(session, null, 2)}\n`);
-  fs.mkdirSync(path.dirname(sessionCaptureStampPath(root)), { recursive: true });
-  fs.writeFileSync(
-    sessionCaptureStampPath(root),
-    `${JSON.stringify({ head: git.head, sessionId, path: filePath, updatedAt: session.timestamp }, null, 2)}\n`,
-  );
-  return filePath;
-}
-
 export function ensureCursorSessionBoot(root, source = '0xray/cursor-pre-tool-use-boot', extra = {}) {
   const bootPath = sessionBootPath(root);
   if (fs.existsSync(bootPath)) {

package/dist/integrations/hooks/station-hook-runtime.cjs

@@ -5,7 +5,7 @@
  * Heat writers merge stock fields; unknown keys and ## Durable / ## Seed survive.
  */
 const { execFileSync } = require("child_process");
-const { existsSync, mkdirSync, readFileSync, writeFileSync } = require("fs");
+const { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } = require("fs");
 const { join } = require("path");
 
 const HOOKS_DIR = __dirname;
@@ -203,10 +203,231 @@ function stationSafeSignals(names) {
   return out;
 }
 
-/** Overlay + factory names on dest. OP-PROC lives here — not on Station.md. */
+/** Keep subject repo-* in the short list the card and working file hold. */
+function preferSubjectHits(names, cap = 8) {
+  if (!Array.isArray(names)) return [];
+  const unique = [];
+  for (const raw of names) {
+    const name = String(raw || "").trim();
+    if (!name || name.toLowerCase().startsWith("bedrock-")) continue;
+    if (unique.includes(name)) continue;
+    unique.push(name);
+  }
+  const subject = unique.filter((name) => name.startsWith("repo-"));
+  const rest = unique.filter((name) => !name.startsWith("repo-"));
+  return [...subject, ...rest].slice(0, cap);
+}
+
+function destSignalsPath(root) {
+  return join(root, ".xray", "state", "repertoire", "curated_signals.json");
+}
+
+function notesPath(root) {
+  return join(root, ".xray", "state", "NOTES.md");
+}
+
+function repertoirePackageRoots(root) {
+  const candidates = [
+    join(root, "node_modules", "@0xray", "repertoire"),
+    join(root, "..", "repertoire"),
+    join(root, "vendor", "@0xray", "repertoire"),
+  ];
+  const out = [];
+  for (const pkgRoot of candidates) {
+    const pkgFile = join(pkgRoot, "package.json");
+    if (!existsSync(pkgFile)) continue;
+    try {
+      const pkg = JSON.parse(readFileSync(pkgFile, "utf8"));
+      if (pkg.name === "@0xray/repertoire" || pkg.name === "repertoire") out.push(pkgRoot);
+    } catch {
+      /* skip */
+    }
+  }
+  return out;
+}
+
+function repertoireDataFile(root, fileName) {
+  for (const pkgRoot of repertoirePackageRoots(root)) {
+    const dest = join(pkgRoot, "data", fileName);
+    if (existsSync(dest)) return dest;
+  }
+  return null;
+}
+
+function readSignalRecords(filePath) {
+  if (!filePath || !existsSync(filePath)) return [];
+  try {
+    const data = JSON.parse(readFileSync(filePath, "utf8"));
+    const signals = Array.isArray(data.signals) ? data.signals : [];
+    return signals.filter((signal) => signal && String(signal.name || "").trim());
+  } catch {
+    return [];
+  }
+}
+
+function signalNameSet(filePath) {
+  return new Set(readSignalRecords(filePath).map((signal) => String(signal.name).trim()));
+}
+
+function mergeMissingSignals(destPath, incoming) {
+  if (!incoming.length || !existsSync(destPath)) return 0;
+  let data;
+  try {
+    data = JSON.parse(readFileSync(destPath, "utf8"));
+  } catch {
+    return 0;
+  }
+  if (!Array.isArray(data.signals)) return 0;
+  const have = new Set(
+    data.signals.map((signal) => String((signal && signal.name) || "").trim()).filter(Boolean),
+  );
+  let added = 0;
+  for (const signal of incoming) {
+    const name = String(signal.name).trim();
+    if (!name || have.has(name)) continue;
+    data.signals.push(signal);
+    have.add(name);
+    added += 1;
+  }
+  if (added) writeFileSync(destPath, `${JSON.stringify(data, null, 2)}\n`);
+  return added;
+}
+
+/** Hydrate project dest from seed + stack + subject overlays. Never write the tarball. */
+function hydrateDestOnWake(root) {
+  const dest = destSignalsPath(root);
+  const seed = repertoireDataFile(root, "curated_signals.json");
+  if (!existsSync(dest) && seed) {
+    mkdirSync(join(root, ".xray", "state", "repertoire"), { recursive: true });
+    copyFileSync(seed, dest);
+  }
+  if (!existsSync(dest)) return { dest: null, added: 0, destCount: 0 };
+  const added =
+    mergeMissingSignals(dest, readSignalRecords(repertoireDataFile(root, "stack-overlay.json"))) +
+    mergeMissingSignals(dest, readSignalRecords(repertoireDataFile(root, "subject-overlay.json")));
+  return { dest, added, destCount: countCuratedSignals(dest) || 0 };
+}
+
+function readNotesPickup(root) {
+  const dest = notesPath(root);
+  if (!existsSync(dest)) return null;
+  try {
+    const text = readFileSync(dest, "utf8");
+    const match = text.match(/\*\*Pickup line:\*\*\s*([^\n]+)/);
+    return clipIntent(match && match[1] ? match[1] : null);
+  } catch {
+    return null;
+  }
+}
+
+function readLatestSessionApproaches(root) {
+  const latest = join(root, "docs", "inference", "latest-session.json");
+  if (!existsSync(latest)) return null;
+  try {
+    const data = JSON.parse(readFileSync(latest, "utf8"));
+    const approaches = Array.isArray(data.approaches) ? data.approaches : [];
+    return clipIntent(approaches.filter(Boolean).join(" "));
+  } catch {
+    return null;
+  }
+}
+
+function sessionCaptureStampPath(root) {
+  return join(root, ".xray", "state", "session-capture-stamp.json");
+}
+
+function readSessionCaptureConfig(root) {
+  let cfg = {};
+  try {
+    cfg = JSON.parse(readFileSync(join(root, ".xray", "features.json"), "utf8")).inference_session_capture || {};
+  } catch {
+    cfg = {};
+  }
+  return {
+    enabled: cfg.enabled === true,
+    minCommits: typeof cfg.min_commits === "number" && cfg.min_commits > 0 ? cfg.min_commits : 3,
+    lookback: typeof cfg.lookback_commits === "number" && cfg.lookback_commits > 0 ? cfg.lookback_commits : 20,
+  };
+}
+
+function gitCommitSubjects(root, args) {
+  try {
+    const out = execFileSync("git", ["log", "--format=%h||%s", "--no-merges", ...args], {
+      cwd: root,
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    return String(out)
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => {
+        const idx = line.indexOf("||");
+        return {
+          hash: idx === -1 ? line : line.slice(0, idx),
+          message: idx === -1 ? "" : line.slice(idx + 2),
+        };
+      });
+  } catch {
+    return [];
+  }
+}
+
+/** Every floor that heats. Dedup per HEAD. Cursor-only copy was the leftover. */
+function maybeCaptureSessionOnHeadMove(root) {
+  const cfg = readSessionCaptureConfig(root);
+  if (!cfg.enabled) return null;
+  const git = readGitBrief(root);
+  if (!git || !git.head) return null;
+  let stamp = null;
+  try {
+    stamp = JSON.parse(readFileSync(sessionCaptureStampPath(root), "utf8"));
+  } catch {
+    stamp = null;
+  }
+  if (stamp && stamp.head === git.head) return null;
+  const commits = stamp && stamp.head
+    ? gitCommitSubjects(root, [`${stamp.head}..HEAD`])
+    : gitCommitSubjects(root, ["-n", String(cfg.lookback)]);
+  if (commits.length < cfg.minCommits) return null;
+  const sessionId = `session-${new Date().toISOString().slice(0, 10)}-${git.head}`;
+  const approaches = commits.map((row) => row.message).filter(Boolean);
+  const session = {
+    sessionId,
+    timestamp: new Date().toISOString(),
+    span: {
+      from: stamp && stamp.head ? stamp.head : `HEAD~${cfg.lookback}`,
+      to: git.head,
+    },
+    problems: [],
+    approaches,
+    wrongTurns: [],
+    solutions: [],
+    patterns: [],
+    matched_primitives: [],
+    metrics: { commits: commits.length },
+  };
+  const outDir = join(root, "docs", "inference");
+  mkdirSync(outDir, { recursive: true });
+  const filePath = join(outDir, `session-${sessionId.replace(/^session-/, "")}.json`);
+  writeFileSync(filePath, `${JSON.stringify(session, null, 2)}\n`);
+  writeFileSync(join(outDir, "latest-session.json"), `${JSON.stringify(session, null, 2)}\n`);
+  mkdirSync(join(root, ".xray", "state"), { recursive: true });
+  writeFileSync(
+    sessionCaptureStampPath(root),
+    `${JSON.stringify({ head: git.head, sessionId, path: filePath, updatedAt: session.timestamp }, null, 2)}\n`,
+  );
+  return filePath;
+}
+
+/** Overlay + factory names on dest. Subject repo-* stay off this list. */
 function readOpProcNames(root) {
-  const dest = join(root, ".xray", "state", "repertoire", "curated_signals.json");
+  const dest = destSignalsPath(root);
   if (!existsSync(dest)) return [];
+  const factory = signalNameSet(repertoireDataFile(root, "curated_signals.json"));
+  const stack = signalNameSet(repertoireDataFile(root, "stack-overlay.json"));
+  const filter = factory.size || stack.size;
   try {
     const data = JSON.parse(readFileSync(dest, "utf8"));
     if (!Array.isArray(data.signals)) return [];
@@ -214,6 +435,8 @@ function readOpProcNames(root) {
     for (const signal of data.signals) {
       const name = String(signal && signal.name ? signal.name : "").trim();
       if (!name || name.toLowerCase().startsWith("bedrock-")) continue;
+      if (name.toLowerCase().startsWith("repo-")) continue;
+      if (filter && !factory.has(name) && !stack.has(name)) continue;
       names.push(name);
     }
     return names;
@@ -295,8 +518,9 @@ function buildRepertoireResume(root) {
   if (!modulePath) {
     return "Repertoire: not installed (memory_routing stays off)";
   }
-  let signalsPath = mr.config && mr.config.signalsPath;
-  if (signalsPath && !signalsPath.startsWith("/") && !/^[A-Za-z]:[\\/]/.test(signalsPath)) {
+  const destPath = destSignalsPath(root);
+  let signalsPath = existsSync(destPath) ? destPath : mr.config && mr.config.signalsPath;
+  if (signalsPath && signalsPath !== destPath && !signalsPath.startsWith("/") && !/^[A-Za-z]:[\\/]/.test(signalsPath)) {
     signalsPath = join(root, signalsPath);
   }
   if (!signalsPath) {
@@ -311,6 +535,10 @@ function buildRepertoireResume(root) {
 }
 
 function applyStationHeat(root, host, extra = {}, existing = {}) {
+  const hydrate = hydrateDestOnWake(root);
+  const captured = maybeCaptureSessionOnHeadMove(root);
+  const pickup = readNotesPickup(root);
+  const approaches = readLatestSessionApproaches(root);
   const prevHost = typeof existing.host === "string" ? existing.host : null;
   const nextSwap = prevHost && host && prevHost !== host ? { from: prevHost, to: host } : null;
   const keptSwap =
@@ -321,9 +549,12 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
       ? existing.hotSwap
       : null;
   const hotSwap = nextSwap || keptSwap;
-  const intent =
-    clipIntent(extra.intent || extra.prompt || extra.userMessage || extra.user_prompt) ||
-    (typeof existing.intent === "string" ? existing.intent : null);
+  const incomingIntent = clipIntent(
+    extra.intent || extra.prompt || extra.userMessage || extra.user_prompt,
+  );
+  const intent = incomingIntent || (typeof existing.intent === "string" ? existing.intent : null);
+  const matchText = clipIntent([intent, pickup, approaches].filter(Boolean).join(" "));
+  const rematch = Boolean(incomingIntent);
   const git = readGitBrief(root);
   const planLine = readPlanLine(root);
   const repertoireResume =
@@ -332,18 +563,27 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
   const intentBit = intent ? `intent: ${intent}` : "intent: (none yet)";
   const gitBit = git ? `git ${git.branch}@${git.head}` : "git: n/a";
   const planBit = planLine ? `plan: ${planLine}` : "plan: (none)";
-  let matchedSignals = stationSafeSignals(extra.matchedSignals);
+  let matchedSignals = [];
+  if (Array.isArray(extra.matchedSignals) && extra.matchedSignals.length) {
+    matchedSignals = preferSubjectHits(extra.matchedSignals, 8);
+  }
   const priorWorking = readRepertoireWorking(root);
-  if (!matchedSignals.length && intent) {
+  const destCount = hydrate.destCount || (existsSync(destSignalsPath(root)) ? countCuratedSignals(destSignalsPath(root)) : 0);
+  if (!matchedSignals.length && matchText) {
     if (
+      !rematch &&
       priorWorking &&
-      priorWorking.intent === intent &&
+      priorWorking.matchText === matchText &&
+      priorWorking.destCount === destCount &&
       Array.isArray(priorWorking.matchedSignals) &&
       priorWorking.matchedSignals.length
     ) {
-      matchedSignals = stationSafeSignals(priorWorking.matchedSignals);
+      matchedSignals = preferSubjectHits(priorWorking.matchedSignals, 8);
     } else {
-      matchedSignals = stationSafeSignals(matchStationSignalsSync(root, intent));
+      matchedSignals = preferSubjectHits(
+        matchStationSignalsSync(root, rematch && incomingIntent ? incomingIntent : matchText),
+        8,
+      );
     }
   }
   if (!matchedSignals.length && priorWorking) {
@@ -357,16 +597,24 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
     hookEvent: extra.hookEvent || extra.source || null,
     memoryRouting: repertoireResume.startsWith("Repertoire: on") ? "on" : "off",
     repertoireResume,
+    destCount,
   };
-  if (matchedSignals.length) workingSnapshot.matchedSignals = matchedSignals;
+  if (pickup) workingSnapshot.pickup = pickup;
+  if (matchText) workingSnapshot.matchText = matchText;
+  if (captured) workingSnapshot.sessionCapture = captured;
+  if (matchedSignals.length) workingSnapshot.matchedSignals = matchedSignals.slice(0, 8);
   const opProcNames = readOpProcNames(root);
   if (opProcNames.length) workingSnapshot.opProcNames = opProcNames;
   const working = persistRepertoireWorking(root, workingSnapshot);
-  if (isCompactHook(extra) && matchedSignals.length) {
+  const pickupChanged = Boolean(pickup && (!priorWorking || priorWorking.pickup !== pickup));
+  if (
+    matchedSignals.length &&
+    (isCompactHook(extra) || hydrate.added > 0 || pickupChanged)
+  ) {
     ingestCompactFeedbackSync(
       root,
       typeof extra.sessionId === "string" ? extra.sessionId : "station",
-      extra.hookEvent || extra.source || "post_compact",
+      extra.hookEvent || extra.source || (isCompactHook(extra) ? "post_compact" : "wake"),
       matchedSignals,
     );
   }
@@ -541,6 +789,9 @@ module.exports = {
   persistRepertoireWorking,
   readRepertoireWorking,
   readOpProcNames,
+  hydrateDestOnWake,
+  readNotesPickup,
+  maybeCaptureSessionOnHeadMove,
   formatWorkingLine,
   applyStationHeat,
   extractPreservedStationLines,

package/dist/integrations/hooks/station-hook-runtime.mjs

@@ -19,6 +19,9 @@ export const buildRepertoireResume = impl.buildRepertoireResume;
 export const persistRepertoireWorking = impl.persistRepertoireWorking;
 export const readRepertoireWorking = impl.readRepertoireWorking;
 export const readOpProcNames = impl.readOpProcNames;
+export const hydrateDestOnWake = impl.hydrateDestOnWake;
+export const readNotesPickup = impl.readNotesPickup;
+export const maybeCaptureSessionOnHeadMove = impl.maybeCaptureSessionOnHeadMove;
 export const formatWorkingLine = impl.formatWorkingLine;
 export const applyStationHeat = impl.applyStationHeat;
 export const extractPreservedStationLines = impl.extractPreservedStationLines;

package/dist/integrations/hooks/station-memory-match.mjs

@@ -2,9 +2,11 @@
 /**
  * Sync helper for station-hook-runtime.cjs — match Repertoire signals for an intent.
  * Prints a JSON string array. Used on every floor's station heat, not only Grok.
+ * Loads the worn provider from dest, not xray src TypeScript.
  */
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
 
 const root = process.argv[2];
 const intent = process.argv[3] || '';
@@ -23,8 +25,52 @@ if (existsSync(featuresPath)) {
   }
 }
 
-const { loadMemoryRoutingProvider } = await import('../../memory-routing/index.js');
-const provider = await loadMemoryRoutingProvider(routing, root);
+function providerCandidates() {
+  const configured = routing.module_path
+    ? routing.module_path.startsWith('/') || /^[A-Za-z]:[\\/]/.test(routing.module_path)
+      ? routing.module_path
+      : join(root, routing.module_path)
+    : null;
+  const raw = [
+    join(root, '..', 'repertoire', 'dist', 'provider', 'memory-routing-provider.js'),
+    join(root, 'node_modules', '@0xray', 'repertoire', 'dist', 'provider', 'memory-routing-provider.js'),
+    configured,
+    join(root, 'vendor', '@0xray', 'repertoire', 'dist', 'provider', 'memory-routing-provider.js'),
+  ].filter(Boolean);
+  const withSubject = [];
+  const rest = [];
+  for (const dest of raw) {
+    const overlay = dest.replace(/dist\/provider\/memory-routing-provider\.js$/, 'data/subject-overlay.json');
+    if (existsSync(overlay)) withSubject.push(dest);
+    else rest.push(dest);
+  }
+  return [...withSubject, ...rest];
+}
+
+async function loadProvider() {
+  for (const dest of providerCandidates()) {
+    if (!existsSync(dest)) continue;
+    try {
+      const mod = await import(pathToFileURL(dest).href);
+      if (typeof mod.createMemoryRoutingProvider === 'function') {
+        return mod.createMemoryRoutingProvider({
+          projectRoot: root,
+          signalsPath: routing.config && routing.config.signalsPath,
+          statePath: routing.config && routing.config.statePath,
+          feedbackDir: routing.config && routing.config.feedbackDir,
+        });
+      }
+      if (typeof mod.loadMemoryRoutingProvider === 'function') {
+        return mod.loadMemoryRoutingProvider(routing, root);
+      }
+    } catch {
+      /* try next */
+    }
+  }
+  return null;
+}
+
+const provider = await loadProvider();
 if (!provider || provider.id === 'null' || typeof provider.getTaskConfidence !== 'function') {
   process.stdout.write('[]\n');
   process.exit(0);
@@ -41,7 +87,7 @@ for (const signalName of names) {
   const name = String(signalName || '').trim();
   if (!name || name.toLowerCase().startsWith('bedrock-')) continue;
   safe.push(name);
-  if (safe.length >= 4) break;
+  if (safe.length >= 12) break;
 }
 process.stdout.write(`${JSON.stringify(safe)}\n`);
 process.exit(0);

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "4.0.17",
+  "version": "4.0.18",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",

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

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

package/xray/features.json

@@ -1,6 +1,6 @@
 {
   "$schema": "./features.schema.json",
-  "version": "4.0.17",
+  "version": "4.0.18",
   "description": "0xRay Framework - Unified Feature Configuration",
   "suit_temperament": {
     "profile": "auto",