0xray 4.0.18 → 4.0.20

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

@@ -1,12 +1,161 @@
 #!/usr/bin/env node
 /**
- * Compact ingest — persist matched signals back into the organ (project-local copy).
+ * Station organ write — compact ingest + wake grow.
+ * Grow uses the worn RepertoireService. Groover field stays off.
  */
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
 
 const root = process.argv[2];
-const sessionId = process.argv[3] || 'station';
+const mode = process.argv[3] || 'station';
+
+function readRouting(projectRoot) {
+  let routing = { enabled: false, provider: 'null' };
+  const featuresPath = join(projectRoot, '.xray', 'features.json');
+  if (existsSync(featuresPath)) {
+    try {
+      routing = JSON.parse(readFileSync(featuresPath, 'utf8')).memory_routing || routing;
+    } catch {
+      /* leftover */
+    }
+  }
+  return routing;
+}
+
+function isExplicitOptOut(routing) {
+  return routing && routing.enabled === false && routing.provider === 'repertoire';
+}
+
+function organServiceCandidates(projectRoot, routing) {
+  const configured = routing.module_path
+    ? routing.module_path.startsWith('/') || /^[A-Za-z]:[\\/]/.test(routing.module_path)
+      ? routing.module_path
+      : join(projectRoot, routing.module_path)
+    : null;
+  const fromProvider = configured
+    ? configured.replace(/provider\/memory-routing-provider\.js$/, 'RepertoireService.js')
+    : null;
+  const raw = [
+    fromProvider,
+    join(projectRoot, 'node_modules', '@0xray', 'repertoire', 'dist', 'RepertoireService.js'),
+    join(projectRoot, 'vendor', '@0xray', 'repertoire', 'dist', 'RepertoireService.js'),
+    join(projectRoot, '..', 'repertoire', 'dist', 'RepertoireService.js'),
+  ].filter(Boolean);
+  const seen = new Set();
+  const out = [];
+  for (const dest of raw) {
+    if (seen.has(dest) || !existsSync(dest)) continue;
+    seen.add(dest);
+    out.push(dest);
+  }
+  return out;
+}
+
+function ensureDestShape(destSignals) {
+  if (!existsSync(destSignals)) return;
+  try {
+    const data = JSON.parse(readFileSync(destSignals, 'utf8'));
+    if (!Array.isArray(data.signals)) return;
+    let dirty = false;
+    for (const signal of data.signals) {
+      if (!signal) continue;
+      if (!Array.isArray(signal.tags)) {
+        signal.tags = [];
+        dirty = true;
+      }
+      if (typeof signal.definition !== 'string') {
+        signal.definition = String(signal.name || '');
+        dirty = true;
+      }
+    }
+    if (dirty) writeFileSync(destSignals, `${JSON.stringify(data, null, 2)}\n`);
+  } catch {
+    /* leftover */
+  }
+}
+
+function readCleanupDiary(projectRoot) {
+  const files = [
+    join(projectRoot, '.xray', 'state', 'NOTES.md'),
+    join(projectRoot, '.xray', 'state', 'CLEANSE-LIST.md'),
+    join(projectRoot, 'docs', 'archive', 'README.md'),
+  ];
+  const parts = [];
+  const sources = [];
+  for (const dest of files) {
+    if (!existsSync(dest)) continue;
+    try {
+      parts.push(readFileSync(dest, 'utf8'));
+      sources.push(dest);
+    } catch {
+      /* leftover */
+    }
+  }
+  return { text: parts.join('\n'), sources };
+}
+
+async function growDest(projectRoot) {
+  const routing = readRouting(projectRoot);
+  if (isExplicitOptOut(routing)) {
+    process.stdout.write(`${JSON.stringify({ skipped: 'opt-out' })}\n`);
+    return;
+  }
+  for (const dest of organServiceCandidates(projectRoot, routing)) {
+    try {
+      const mod = await import(pathToFileURL(dest).href);
+      const RepertoireService = mod.RepertoireService;
+      if (typeof RepertoireService !== 'function') continue;
+      const pathsMod = await import(pathToFileURL(dest.replace(/RepertoireService\.js$/, 'paths.js')).href);
+      const destSignals = join(projectRoot, '.xray', 'state', 'repertoire', 'curated_signals.json');
+      ensureDestShape(destSignals);
+      const service = new RepertoireService({
+        projectRoot,
+        signalsPath: destSignals,
+        syncXray: false,
+        syncField: false,
+      });
+      ensureDestShape(destSignals);
+      const before = service.signalsManager.load().signals.length;
+      const sessions = service.syncXrayMemory();
+      const siblings = service.syncWorkspaceRepos();
+      const kernel =
+        typeof pathsMod.collectKernelDiaryText === 'function'
+          ? pathsMod.collectKernelDiaryText(projectRoot)
+          : { text: '', sources: [] };
+      const cleanup = readCleanupDiary(projectRoot);
+      const diary = service.heatKernelDiary({
+        text: [kernel.text, cleanup.text].filter(Boolean).join('\n'),
+        sources: [...(kernel.sources || []), ...cleanup.sources],
+      });
+      const after = service.signalsManager.load().signals.length;
+      process.stdout.write(
+        `${JSON.stringify({
+          before,
+          after,
+          imported: sessions.imported,
+          observed: siblings.observed,
+          heated: diary.heated,
+        })}\n`,
+      );
+      return;
+    } catch {
+      /* try next organ */
+    }
+  }
+  process.stdout.write(`${JSON.stringify({ skipped: 'no-organ' })}\n`);
+}
+
+if (!root) {
+  process.exit(0);
+}
+
+if (mode === '--grow') {
+  await growDest(root);
+  process.exit(0);
+}
+
+const sessionId = mode;
 const hookEvent = process.argv[4] || 'post_compact';
 let signals = [];
 try {
@@ -14,7 +163,7 @@ try {
 } catch {
   signals = [];
 }
-if (!root || !Array.isArray(signals) || signals.length === 0) {
+if (!Array.isArray(signals) || signals.length === 0) {
   process.exit(0);
 }
 

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

@@ -32,19 +32,19 @@ function providerCandidates() {
       : 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, 'node_modules', '@0xray', 'repertoire', 'dist', 'provider', 'memory-routing-provider.js'),
     join(root, 'vendor', '@0xray', 'repertoire', 'dist', 'provider', 'memory-routing-provider.js'),
+    join(root, '..', 'repertoire', 'dist', 'provider', 'memory-routing-provider.js'),
   ].filter(Boolean);
-  const withSubject = [];
-  const rest = [];
+  const seen = new Set();
+  const out = [];
   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);
+    if (seen.has(dest)) continue;
+    seen.add(dest);
+    out.push(dest);
   }
-  return [...withSubject, ...rest];
+  return out;
 }
 
 async function loadProvider() {

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

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

package/dist/nucleus/delegation-gate.js

@@ -462,17 +462,16 @@ export function evaluateConstitutionGate(toolName, toolInput, ctx) {
     return { allow: true };
 }
 export function evaluatePreToolGate(toolName, toolInput, ctx) {
-    if (ctx.host === 'openclaw') {
-        try {
-            maybeHeatHostStation(ctx.projectRoot, 'openclaw', {
-                source: '0xray/openclaw-pre-tool',
-                sessionId: ctx.sessionId || 'openclaw',
-                hookEvent: ctx.hookEvent || 'session_start',
-            });
-        }
-        catch {
-            /* station heat is best-effort — constitution still runs */
-        }
+    const host = ctx.host || 'generic';
+    try {
+        maybeHeatHostStation(ctx.projectRoot, host, {
+            source: `0xray/${host}-pre-tool`,
+            sessionId: ctx.sessionId || host,
+            hookEvent: ctx.hookEvent || 'pre_tool_use',
+        });
+    }
+    catch {
+        /* station heat is best-effort — constitution still runs */
     }
     const constitution = evaluateConstitutionGate(toolName, toolInput, ctx);
     if (!constitution.allow)

package/dist/nucleus/suit-temperament.js

@@ -111,7 +111,11 @@ export function maybeHeatHostStation(projectRoot, host, extra = {}) {
     const existingSessionId = concreteSessionId(existing.sessionId);
     const sameHost = existing.host === host;
     const sameSession = existingSessionId !== null && sessionId !== null && existingSessionId === sessionId;
-    if (sameHost && sameSession && fs.existsSync(cardPath)) {
+    if (sameHost &&
+        sameSession &&
+        fs.existsSync(cardPath) &&
+        !stationHeat.stationBootNeedsRefresh(existing, projectRoot, host)) {
+        stationHeat.heatLiveMemory(projectRoot);
         return bootPath;
     }
     return writeSuitSessionBoot(projectRoot, host, extra);

package/package.json

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

package/scripts/node/consumer-install-smoke.mjs

@@ -92,7 +92,7 @@ function assertOrganRequire(tmpRoot) {
   if (organPkg.name !== "@0xray/repertoire") {
     throw new Error(`required organ name ${organPkg.name}`);
   }
-  if (organPkg.version !== "0.2.0") {
+  if (organPkg.version !== "0.2.5") {
     throw new Error(`required organ version ${organPkg.version}`);
   }
   if (fs.existsSync(path.join(tmpRoot, "vendor"))) {
@@ -165,8 +165,8 @@ function assertFreshInstallDefaults(tmpRoot, version) {
     throw new Error("vendored @0xray/repertoire missing from fresh tarball install");
   }
   const organ = JSON.parse(fs.readFileSync(organPkg, "utf-8"));
-  if (organ.version !== "0.2.0") {
-    throw new Error(`expected organ 0.2.0, got ${organ.version}`);
+  if (organ.version !== "0.2.5") {
+    throw new Error(`expected organ 0.2.5, got ${organ.version}`);
   }
   console.log("  ✅ .xray/features.json fresh-install defaults (opt-in off)");
   return { consumerFeaturesPath, features };

package/scripts/node/wear-vendored-repertoire.cjs

@@ -37,6 +37,41 @@ function destIsUsableRepertoire(dest) {
   return repertoirePackageName(dest) === "@0xray/repertoire";
 }
 
+function packageVersion(dir) {
+  try {
+    const version = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")).version;
+    return typeof version === "string" ? version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+function versionLessThan(left, right) {
+  const a = String(left || "0").split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const b = String(right || "0").split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const n = Math.max(a.length, b.length);
+  for (let i = 0; i < n; i += 1) {
+    const av = a[i] || 0;
+    const bv = b[i] || 0;
+    if (av < bv) return true;
+    if (av > bv) return false;
+  }
+  return false;
+}
+
+function removeDestTree(dest) {
+  try {
+    const st = fs.lstatSync(dest);
+    if (st.isSymbolicLink()) {
+      fs.unlinkSync(dest);
+      return;
+    }
+  } catch {
+    return;
+  }
+  fs.rmSync(dest, { recursive: true, force: true });
+}
+
 function removeBrokenDest(dest) {
   try {
     const st = fs.lstatSync(dest);
@@ -51,7 +86,10 @@ function removeBrokenDest(dest) {
 function wearOne(vendor, dest, log) {
   removeBrokenDest(dest);
   if (destAlreadyWorn(dest, vendor)) return true;
-  if (fs.existsSync(dest) && destIsUsableRepertoire(dest)) return true;
+  if (fs.existsSync(dest) && destIsUsableRepertoire(dest)) {
+    if (!versionLessThan(packageVersion(dest), packageVersion(vendor))) return true;
+    removeDestTree(dest);
+  }
 
   fs.mkdirSync(path.dirname(dest), { recursive: true });
   const rel = path.relative(path.dirname(dest), vendor);

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

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

package/vendor/@0xray/repertoire/AGENTS.md

@@ -74,9 +74,11 @@ Configure in `.xray/features.json`:
 "memory_routing": {
   "enabled": true,
   "provider": "repertoire",
-  "module_path": "../repertoire/dist/provider/memory-routing-provider.js",
+  "module_path": "./dist/provider/memory-routing-provider.js",
   "config": {
-    "signalsPath": "../repertoire/data/curated_signals.json"
+    "signalsPath": ".xray/state/repertoire/curated_signals.json",
+    "statePath": ".xray/state/repertoire/inference-state.json",
+    "feedbackDir": ".xray/state/repertoire/feedback"
   }
 }
 ```
@@ -94,6 +96,10 @@ Without Repertoire: `{ "enabled": false, "provider": "null" }`.
 
 Tools: `repertoire__get_task_confidence`, `repertoire__get_high_confidence_signals`, `repertoire__search_primitives`, `repertoire__ingest_feedback`.
 
+Factory seed (`data/curated_signals.json`) is read-only (8 names). `data/stack-overlay.json` merges into the project copy on hydrate so stack language survives a new clone. `data/subject-overlay.json` merges after that so dest knows what each organ/hangar is. `reloadOpProc` is factory + stack only. Live writes hydrate `.xray/state/repertoire/` even when cwd is this organ repo. Do not pin 0.1.8. Station is the survive-the-cut card — not this organ.
+
+Lead cadence lives in worn 0xRay (`grok-bot/ops/LEAD-CADENCE.md` + `orchestrator` skill). Project-local names `lead-cadence-syncopation`, `live-loop-not-pacer`, `peer-wears-without-commands` must route on this copy. A peer continues from Station + these names — no command stream.
+
 ## Codex OS (always on — not optional)
 
 The Universal Development Codex (`.xray/codex.json`, **69 terms**) is enforced by **PreToolUse** (blocks) and this section (brain). MCP enforcer is audit — not the gate.

package/vendor/@0xray/repertoire/README.md

@@ -2,7 +2,7 @@
 
 Factory memory organ for [0xRay](https://github.com/0xRayAI/xray): seed primitives, in-process memory routing, extra MCP (not an 8th `xray-*` server).
 
-**v0.2.0** · 0xRay **4.0** wear. Runtime does **not** depend on `0xray` (optional peer for suit-verify scripts).
+**v0.2.5** · 0xRay **4.0** wear. Runtime does **not** depend on `0xray` (optional peer for suit-verify scripts).
 
 ## Install
 
@@ -43,13 +43,17 @@ Default operating model: **`autonomy-command`** — lead dev, phased todos, suba
 }
 ```
 
-Bundled `data/curated_signals.json` is used by default. Override with env:
+Bundled `data/curated_signals.json` is **read-only** (8 factory trap names). `data/stack-overlay.json` is the committed stack-language overlay (OP-PROC). `data/subject-overlay.json` is what each workspace organ/hangar *is*. The provider hydrates a project copy under `.xray/state/repertoire/curated_signals.json` (seed + stack + subject) — including when cwd is this organ repo. Feedback never writes the tarball seed. Do not pin 0.1.8.
+
+Override with env:
 
 | Env | Default |
 |-----|---------|
-| `CURATED_SIGNALS_PATH` | `<package>/data/curated_signals.json` |
-| `REPERTOIRE_DATA_DIR` | `<package>/data` |
-| `REPERTOIRE_LOG_DIR` | `<package>/logs/groover-inference` |
+| `CURATED_SIGNALS_PATH` | factory seed (hydrated to `.xray/state/repertoire/curated_signals.json`) |
+| `REPERTOIRE_DATA_DIR` | `.xray/state/repertoire` |
+| `REPERTOIRE_STATE_PATH` | `.xray/state/repertoire/inference-state.json` |
+| `REPERTOIRE_LOG_DIR` | `.xray/state/repertoire/logs` |
+| `REPERTOIRE_FEEDBACK_DIR` | `.xray/state/repertoire/feedback` |
 
 ### Tools
 
@@ -60,6 +64,8 @@ Bundled `data/curated_signals.json` is used by default. Override with env:
 | `repertoire__get_high_confidence_signals` | Validated signals above threshold |
 | `repertoire__ingest_feedback` | Record orchestrator outcomes |
 
+Routing confidence is **time-weighted**: excess above the 0.55 gate fades after a 14-day grace (60-day half-life). Factory seed sitting on the gate keeps routing. `npm run signals:hygiene` reports decay on the hydrated project copy under `.xray/state/repertoire/`; it dry-runs in this repo unless `--i-mean-it` (writes the project copy, never the tarball).
+
 ## 0xRay memory routing (in-process)
 
 In `.xray/features.json` or `xray/features.json`:
@@ -76,8 +82,10 @@ In `.xray/features.json` or `xray/features.json`:
 
 ```json
 "config": {
-  "signalsPath": ".xray/curated_signals.json",
-  "logDir": "logs/groover-inference"
+  "signalsPath": ".xray/state/repertoire/curated_signals.json",
+  "statePath": ".xray/state/repertoire/inference-state.json",
+  "feedbackDir": ".xray/state/repertoire/feedback",
+  "logDir": ".xray/state/repertoire/logs"
 }
 ```
 
@@ -98,7 +106,26 @@ provider.getTaskConfidence?.({
 
 ## Field actuation add-ons (optional)
 
-Repertoire has **no Moltbook dependency**. It ingests **enriched JSONL** from any producer (`matched_primitives` + `match_confidence`) and closes the memory loop via consult, feedback, and post-tick ingest.
+Repertoire has **no Moltbook dependency**. It ingests **enriched JSONL** from an **explicit** producer (`matched_primitives` + `match_confidence`) and can grow the project dest — unknown primitives that pass the 0.55 gate are proposed as `field-observed`. **Groover is not Repertoire.** Groover was a broken experiment of how this organ was supposed to work. Do not treat Groover field (145-name `repertoire-brain`, sibling inference JSONL) as the dest becoming real. The factory seed stays 8 names. Do not pin `0.1.8`.
+
+```bash
+REPERTOIRE_FIELD_LOGS=/path/to/this-project/enriched npm run ingest
+npm run health:repertoire
+```
+
+`ingest` without `--path` and `--source groover` reads `REPERTOIRE_FIELD_LOGS` only. It does **not** walk `../groover/`. Health reads `.xray/state/repertoire/`, not the package tarball.
+
+## Compact reload (the 37 overlay names are OP-PROC)
+
+Station is the ticket. The overlay names (`station-survives-the-cut`, `repertoire-is-long-running-kb`, `compact-rekey-from-disk`, …) are the operating procedure.
+
+After compact the suit reloads OP-PROC by hydrating `.xray/state/repertoire/curated_signals.json` and reading that dest — not by restating commands and not by dumping names onto `STATION.md`. `reloadOpProc()` is that snapshot. 0xRay heat writes the same names onto `.xray/state/repertoire-working.json`.
+
+```bash
+npm run ingest -- --source xray
+```
+
+Walks `docs/inference` / `.xray/inference` `session-*.json` on this project and suited siblings. Grows dest from session-capture. Heats overlay names that already live on dest. `REPERTOIRE_XRAY_LOGS` is an explicit extra colon list.
 
 Each project activates its own public field surface if it wants one: