0xray 4.0.19 → 4.0.20

package/.grok-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "4.0.19",
+  "version": "4.0.20",
   "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.19",
+  "version": "4.0.20",
   "description": "0xRay Framework - Unified Feature Configuration",
   "suit_temperament": {
     "profile": "auto",

package/dist/CHANGELOG.md

@@ -7,6 +7,8 @@ The format is based on [Conventional Commits](https://www.conventionalcommits.or
 ## [Unreleased]
 
 ### ✨ Features
+- **Cleanup is memory** — `applyStationHeat` grows the project copy when Repertoire is on: kernel sessions, sibling `repo-*` names, and NOTES/CLEANSE diary heat. Groover field stays off. Opt-out still skips seed and grow. Station stays the pickup card. Not a new MCP/skill.
+- **Live context memory** — capture then grow. Session `patterns` come from real git (commit slugs + structural names), not a leftover catalog. Cursor skip / afterFileEdit, Grok heat, Hermes pre-process, and OpenClaw pre-tool share one dest lock so parallel seats write one project copy. Not a new MCP/skill.
 - **Vendored Repertoire 0.2.5** — `vendor/@0xray/repertoire` is the published 0.2.5 package (overlays included). Wear replaces an older leftover in `node_modules`. A newer user-installed copy is left alone. Boot reads worn `node_modules`, then vendor, then a sibling checkout last. Repertoire stays optional (`enabled: false` + `provider: repertoire`); Station is the memory when it is off.
 - **Cursor fifth wear** — `install-bridges.cjs` fastens project `.cursor/hooks.json` (preToolUse / preCompact / afterFileEdit) so Cursor Cloud heats Station and gates tools. Leaves an existing file alone. Not a fifth chat TUI. No new MCP/skill surface. Pack gate (`REQUIRED_PACK_PATHS`) now requires `dist/integrations/cursor/hooks/{hooks.json,pre-tool-use.js,pre-compact.js,after-file-edit.js,cursor-hook-utils.js,cursor-usage-receipt.js}` so a published tarball cannot ship a dead consumer command. `preToolUse` / `afterFileEdit` rewrite the card when git HEAD or Repertoire count diverges — Ticket / Durable / Seed stay. OP-PROC stays in the hook, not on Station.
 
@@ -35,6 +37,17 @@ The format is based on [Conventional Commits](https://www.conventionalcommits.or
 
 ---
 
+## [4.0.20] - 2026-09-22
+
+### 🔄 Changes
+
+### 🐛 Bug Fixes
+- fix: rewrite session-boot when HEAD moves — first-wins skip froze metal (same session still heats dest)
+- fix: grow dest from live git on every floor (a7685eb09)
+- fix: heat grows the project copy — cleanup is memory (be10c82eb)
+
+---
+
 ## [4.0.19] - 2026-09-22
 
 ### ✨ Features

package/dist/integrations/cursor/hooks/after-file-edit.js

@@ -6,6 +6,7 @@
 
 import {
   appendHookActivity,
+  cursorHeatRoots,
   cursorSessionId,
   cursorWorkspaceRoot,
   ensureCursorSessionBoot,
@@ -17,9 +18,11 @@ async function main() {
   try {
     const event = await readStdinJson();
     const eventRoot = cursorWorkspaceRoot(event);
-    const bootPath = ensureCursorSessionBoot(eventRoot, '0xray/cursor-after-file-edit-boot', {
-      sessionId: cursorSessionId(event),
-    });
+    const sessionId = cursorSessionId(event);
+    let bootPath = null;
+    for (const root of cursorHeatRoots(event)) {
+      bootPath = ensureCursorSessionBoot(root, '0xray/cursor-after-file-edit-boot', { sessionId });
+    }
     appendHookActivity(eventRoot, 'cursor-after-file-edit', 'session-boot', 'info', {
       bootPath,
       file: event.file_path || event.path || null,

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

@@ -23,13 +23,12 @@ import {
 } from '../../hooks/delegation-gate-runtime.mjs';
 import { appendHookActivity } from '../../grok/hooks/grok-hook-activity.js';
 import {
-  buildRepertoireResume,
+  heatLiveMemory,
   maybeCaptureSessionOnHeadMove,
-  readGitBrief,
-  stationDurableHoldsNpm,
+  stationBootNeedsRefresh,
 } from '../../hooks/station-hook-runtime.mjs';
 
-export { maybeCaptureSessionOnHeadMove };
+export { heatLiveMemory, maybeCaptureSessionOnHeadMove };
 
 export const CURSOR_HOST = 'cursor';
 export const EVENT_CLASS_HOST = 'cursor-host-precompact';
@@ -77,6 +76,40 @@ export function cursorWorkspaceRoot(event = {}) {
   );
 }
 
+function addHeatRoot(out, seen, value) {
+  if (!value) return;
+  const resolved = path.resolve(String(value));
+  if (seen.has(resolved)) return;
+  seen.add(resolved);
+  out.push(resolved);
+}
+
+/** Every live context that already has a Station card — cwd plus mill when they differ. */
+export function cursorHeatRoots(event = {}) {
+  const seen = new Set();
+  const out = [];
+  addHeatRoot(out, seen, event.cwd);
+  addHeatRoot(out, seen, event.workspaceRoot);
+  const listed = event.workspace_roots || event.workspaceRoots;
+  if (Array.isArray(listed)) {
+    for (const row of listed) {
+      if (typeof row === 'string') addHeatRoot(out, seen, row);
+      else if (row && typeof row === 'object' && row.path) addHeatRoot(out, seen, row.path);
+    }
+  }
+  addHeatRoot(out, seen, process.env.CURSOR_PROJECT_DIR);
+  const mill = process.env.XRAY_AI_PATH;
+  if (mill) {
+    const resolved = path.resolve(String(mill));
+    const millHasCard =
+      fs.existsSync(path.join(resolved, '.xray', 'state', 'STATION.md')) ||
+      fs.existsSync(path.join(resolved, '.xray', 'features.json'));
+    if (millHasCard) addHeatRoot(out, seen, resolved);
+  }
+  if (out.length === 0) addHeatRoot(out, seen, cursorWorkspaceRoot(event));
+  return out;
+}
+
 export function cursorSessionId(event = {}) {
   return (
     event.conversation_id ||
@@ -141,18 +174,7 @@ export function classifyPreCompactEvent(event = {}, argv = process.argv) {
 }
 
 export function cursorBootNeedsRefresh(existing, root) {
-  if (!existing || typeof existing !== 'object') return true;
-  if (existing.host !== CURSOR_HOST) return true;
-  if (!existing.suit_profile) return true;
-  if (existing.workspaceRoot && existing.workspaceRoot !== root) return true;
-  if (!existing.stationLine) return true;
-  const liveGit = readGitBrief(root);
-  const bootHead = existing.git && existing.git.head ? String(existing.git.head) : '';
-  if (liveGit && liveGit.head && bootHead !== liveGit.head) return true;
-  const liveResume = buildRepertoireResume(root);
-  if (liveResume && existing.repertoireResume && liveResume !== existing.repertoireResume) return true;
-  if (stationDurableHoldsNpm(root)) return true;
-  return false;
+  return stationBootNeedsRefresh(existing, root, CURSOR_HOST);
 }
 
 export function ensureCursorSessionBoot(root, source = '0xray/cursor-pre-tool-use-boot', extra = {}) {
@@ -161,7 +183,7 @@ export function ensureCursorSessionBoot(root, source = '0xray/cursor-pre-tool-us
     try {
       const existing = JSON.parse(fs.readFileSync(bootPath, 'utf8'));
       if (!cursorBootNeedsRefresh(existing, root)) {
-        maybeCaptureSessionOnHeadMove(root);
+        heatLiveMemory(root);
         return bootPath;
       }
     } catch {
@@ -172,9 +194,7 @@ export function ensureCursorSessionBoot(root, source = '0xray/cursor-pre-tool-us
     host: CURSOR_HOST,
     ...extra,
   });
-  const written = writeSessionBoot(root, payload) || bootPath;
-  maybeCaptureSessionOnHeadMove(root);
-  return written;
+  return writeSessionBoot(root, payload) || bootPath;
 }
 
 export function writeCursorPrecompactReceipt(root, fields) {

package/dist/integrations/cursor/hooks/pre-compact.js

@@ -9,6 +9,7 @@ import {
   appendHookActivity,
   buildSessionBootPayload,
   classifyPreCompactEvent,
+  cursorHeatRoots,
   cursorSessionId,
   cursorWorkspaceRoot,
   readStdinJson,
@@ -40,33 +41,40 @@ async function main() {
     const eventRoot = cursorWorkspaceRoot(event);
     const sessionId = cursorSessionId(event);
     const intent = extractIntent(event);
-    const payload = buildSessionBootPayload(eventRoot, '0xray/cursor-compact', {
-      host: 'cursor',
-      hookEvent: 'pre_compact',
-      event_class: eventClass,
-      sessionId,
-      ...(intent ? { intent } : {}),
-    });
-    const bootPath = writeSessionBoot(eventRoot, payload);
-    const receiptPath = writeCursorPrecompactReceipt(eventRoot, {
-      event_class: eventClass,
-      hookEvent: 'pre_compact',
-      trigger: event.trigger || 'synthetic',
-      sessionId,
-      bootPath,
-      timestamp: new Date().toISOString(),
-    });
-    const usagePath = writeCursorUsageReceipt(eventRoot, {
-      eventClass,
-      sessionId,
-      usage: hostUsageFromPreCompactEvent(event),
-    });
+    let bootPath = null;
+    let receiptPath = null;
+    let usagePath = null;
+    let stationLine = null;
+    for (const root of cursorHeatRoots(event)) {
+      const payload = buildSessionBootPayload(root, '0xray/cursor-compact', {
+        host: 'cursor',
+        hookEvent: 'pre_compact',
+        event_class: eventClass,
+        sessionId,
+        ...(intent ? { intent } : {}),
+      });
+      bootPath = writeSessionBoot(root, payload);
+      stationLine = payload.stationLine;
+      receiptPath = writeCursorPrecompactReceipt(root, {
+        event_class: eventClass,
+        hookEvent: 'pre_compact',
+        trigger: event.trigger || 'synthetic',
+        sessionId,
+        bootPath,
+        timestamp: new Date().toISOString(),
+      });
+      usagePath = writeCursorUsageReceipt(root, {
+        eventClass,
+        sessionId,
+        usage: hostUsageFromPreCompactEvent(event),
+      });
+    }
     appendHookActivity(eventRoot, 'cursor-pre-compact', 'station-written', 'success', {
       bootPath,
       receiptPath,
       usagePath,
       event_class: eventClass,
-      stationLine: payload.stationLine,
+      stationLine,
     });
     console.log(
       JSON.stringify({

package/dist/integrations/cursor/hooks/pre-tool-use.js

@@ -9,6 +9,7 @@ import {
   appendHookActivity,
   checkCodexPatterns,
   checkFullTestSuite,
+  cursorHeatRoots,
   cursorSessionId,
   cursorToolContext,
   cursorWorkspaceRoot,
@@ -47,16 +48,16 @@ async function main() {
   try {
     const event = await readStdinJson();
     const eventRoot = cursorWorkspaceRoot(event);
-    ensureCursorSessionBoot(eventRoot, '0xray/cursor-pre-tool-use-boot', {
-      sessionId: cursorSessionId(event),
-    });
+    const sessionId = cursorSessionId(event);
+    for (const root of cursorHeatRoots(event)) {
+      ensureCursorSessionBoot(root, '0xray/cursor-pre-tool-use-boot', { sessionId });
+    }
 
     const features = loadFeatures(eventRoot);
     const gateFeatures = loadDelegationGateFeatures(eventRoot, 'cursor');
     const ctx = cursorToolContext(event);
     toolName = ctx.toolName;
     const { content, cmd, toolInput } = ctx;
-    const sessionId = cursorSessionId(event);
 
     const gateBlock = evaluatePreToolGate(toolName, toolInput, {
       projectRoot: eventRoot,

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

@@ -306,10 +306,12 @@ export function buildSessionBootPayload(root, source = '0xray/grok-session-start
     ...(conferPending ? { conferPending: true, conferTrigger: 'analyze-complexity at synthesis checkpoint' } : {}),
     ...(userAsideBoot ?? {}),
     sessionId,
-    timestamp: new Date().toISOString(),
     source,
     ...extra,
     ...heat,
+    hook: source,
+    source,
+    timestamp: new Date().toISOString(),
   };
 }
 

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

@@ -468,6 +468,20 @@ async function handlePreProcess(input, projectRoot, logDir) {
   const { tool, args } = input;
   const startTime = Date.now();
 
+  try {
+    const gate = await import('../hooks/delegation-gate-runtime.mjs');
+    if (typeof gate.maybeHeatHostStation === 'function') {
+      gate.maybeHeatHostStation(projectRoot, 'hermes', {
+        source: '0xray/hermes-pre-process',
+        sessionId: input.sessionId || 'hermes',
+        hookEvent: 'pre_tool_use',
+        ...(input.intent ? { intent: input.intent } : {}),
+      });
+    }
+  } catch {
+    /* live memory is best-effort — quality gate still runs */
+  }
+
   logToolEvent(logDir, "start", tool, args);
   logToActivity(logDir, `pre-process: tool=${tool}`);
 

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

@@ -5,7 +5,17 @@
  * Heat writers merge stock fields; unknown keys and ## Durable / ## Seed survive.
  */
 const { execFileSync } = require("child_process");
-const { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } = require("fs");
+const {
+  closeSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} = require("fs");
 const { join } = require("path");
 
 const HOOKS_DIR = __dirname;
@@ -285,7 +295,12 @@ function mergeMissingSignals(destPath, incoming) {
   for (const signal of incoming) {
     const name = String(signal.name).trim();
     if (!name || have.has(name)) continue;
-    data.signals.push(signal);
+    data.signals.push({
+      ...signal,
+      name,
+      tags: Array.isArray(signal.tags) ? signal.tags : [],
+      definition: typeof signal.definition === "string" ? signal.definition : name,
+    });
     have.add(name);
     added += 1;
   }
@@ -374,7 +389,151 @@ function gitCommitSubjects(root, args) {
   }
 }
 
-/** Every floor that heats. Dedup per HEAD. Cursor-only copy was the leftover. */
+function destLockPath(root) {
+  return join(root, ".xray", "state", "repertoire", "dest.lock");
+}
+
+function sleepMs(ms) {
+  try {
+    const buf = new Int32Array(new SharedArrayBuffer(4));
+    Atomics.wait(buf, 0, 0, ms);
+  } catch {
+    /* lock retry is best-effort */
+  }
+}
+
+/** Parallel live contexts share one project copy. Exclusive create; stale after 60s. */
+function withDestLock(root, fn) {
+  const lockPath = destLockPath(root);
+  mkdirSync(join(root, ".xray", "state", "repertoire"), { recursive: true });
+  const started = Date.now();
+  while (Date.now() - started < 50000) {
+    try {
+      const fd = openSync(lockPath, "wx");
+      try {
+        writeFileSync(fd, `${JSON.stringify({ pid: process.pid, at: new Date().toISOString() })}\n`);
+        return fn();
+      } finally {
+        try {
+          closeSync(fd);
+        } catch {
+          /* leftover */
+        }
+        try {
+          unlinkSync(lockPath);
+        } catch {
+          /* leftover */
+        }
+      }
+    } catch (err) {
+      if (!err || err.code !== "EEXIST") return fn();
+      try {
+        const st = statSync(lockPath);
+        if (Date.now() - st.mtimeMs > 60000) unlinkSync(lockPath);
+      } catch {
+        /* leftover */
+      }
+      sleepMs(40);
+    }
+  }
+  return fn();
+}
+
+function slugPrimitiveName(raw) {
+  const trimmed = String(raw || "").trim();
+  if (!trimmed) return null;
+  const bare = trimmed.replace(/^@[^/]+\//, "");
+  const slug = bare
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  if (!/^[a-z][a-z0-9-]{2,119}$/.test(slug)) return null;
+  if (/^phase-\d/.test(slug)) return null;
+  if (/^\d/.test(slug)) return null;
+  if (
+    slug === "criteria-selection-gap" ||
+    slug === "external-norm-smuggling-risk" ||
+    slug === "model-latent-geometry-as-true-invariant"
+  ) {
+    return null;
+  }
+  return slug;
+}
+
+function stripConventionalSubject(message) {
+  return String(message || "")
+    .replace(/^(feat|fix|chore|docs|test|refactor|perf|style|ci|build|revert)(\([^)]+\))?:\s*/i, "")
+    .trim();
+}
+
+/** Real git → dest names. Not a leftover catalog. Kernel structural names when the diff shows them. */
+function patternsFromGit(root, commits, span) {
+  const patterns = [];
+  const seen = new Set();
+  const add = (raw, confidence, description) => {
+    const slug = slugPrimitiveName(raw);
+    if (!slug || seen.has(slug)) return;
+    seen.add(slug);
+    patterns.push({ name: slug, confidence, description: description || String(raw) });
+  };
+  for (const row of commits) {
+    add(stripConventionalSubject(row.message), 0.55, row.message);
+  }
+  try {
+    const from = span && span.from ? String(span.from) : "";
+    const to = span && span.to ? String(span.to) : "HEAD";
+    if (from && !from.startsWith("HEAD~")) {
+      const out = execFileSync("git", ["diff", "--name-status", `${from}..${to}`], {
+        cwd: root,
+        encoding: "utf8",
+        timeout: 4000,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+      const lines = String(out).split("\n").filter(Boolean);
+      if (lines.some((line) => /\.(test|spec)\.[jt]sx?|__tests__|\/tests\//.test(line))) {
+        add("test-expansion", 0.55, "git test files");
+      }
+      if (lines.some((line) => /^D[\t ]/.test(line))) {
+        add("dead-code-removal", 0.55, "git deletions");
+      }
+      if (lines.some((line) => /hooks\/station|session-capture|semantic-patterns/.test(line))) {
+        add("station-heat", 0.55, "heat path");
+      }
+    }
+  } catch {
+    /* structural names are extra — commit slugs still grow dest */
+  }
+  return patterns;
+}
+
+function latestSessionNewerThanGrow(root) {
+  const latest = join(root, "docs", "inference", "latest-session.json");
+  if (!existsSync(latest)) return false;
+  const working = readRepertoireWorking(root);
+  const grownAt = working && working.grow && (working.grow.at || working.updatedAt);
+  if (!grownAt) return true;
+  try {
+    return statSync(latest).mtimeMs > Date.parse(String(grownAt));
+  } catch {
+    return true;
+  }
+}
+
+/** Capture then grow. Skip-path for floors that already have a live card. */
+function heatLiveMemory(root) {
+  const mr = readMemoryRoutingConfig(root);
+  if (isExplicitMemoryRoutingOptOut(mr)) {
+    return { captured: null, grow: null };
+  }
+  return withDestLock(root, () => {
+    const captured = maybeCaptureSessionOnHeadMove(root);
+    const grow = captured || latestSessionNewerThanGrow(root) ? growDestOnWake(root) : null;
+    if (grow) persistRepertoireWorking(root, { grow });
+    return { captured, grow };
+  });
+}
+
+/** Every floor that heats. Dedup per HEAD. Patterns come from git, not a leftover catalog. */
 function maybeCaptureSessionOnHeadMove(root) {
   const cfg = readSessionCaptureConfig(root);
   if (!cfg.enabled) return null;
@@ -393,18 +552,19 @@ function maybeCaptureSessionOnHeadMove(root) {
   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 span = {
+    from: stamp && stamp.head ? stamp.head : commits[commits.length - 1] ? commits[commits.length - 1].hash : git.head,
+    to: git.head,
+  };
   const session = {
     sessionId,
     timestamp: new Date().toISOString(),
-    span: {
-      from: stamp && stamp.head ? stamp.head : `HEAD~${cfg.lookback}`,
-      to: git.head,
-    },
+    span,
     problems: [],
     approaches,
     wrongTurns: [],
     solutions: [],
-    patterns: [],
+    patterns: patternsFromGit(root, commits, span),
     matched_primitives: [],
     metrics: { commits: commits.length },
   };
@@ -476,6 +636,24 @@ function matchStationSignalsSync(root, intent) {
   }
 }
 
+function growDestOnWake(root) {
+  const helper = join(HOOKS_DIR, "station-memory-ingest.mjs");
+  if (!existsSync(helper)) return null;
+  try {
+    const out = execFileSync(process.execPath, [helper, root, "--grow"], {
+      encoding: "utf8",
+      timeout: 45000,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, REPERTOIRE_FIELD_SYNC: "0", REPERTOIRE_DEST_LOCK: "held" },
+    });
+    const line = String(out).trim().split("\n").filter(Boolean).at(-1) || "{}";
+    const parsed = JSON.parse(line);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
 function ingestCompactFeedbackSync(root, sessionId, hookEvent, signals) {
   if (!signals.length) return;
   const helper = join(HOOKS_DIR, "station-memory-ingest.mjs");
@@ -537,8 +715,23 @@ function buildRepertoireResume(root) {
 function applyStationHeat(root, host, extra = {}, existing = {}) {
   const mr = readMemoryRoutingConfig(root);
   const memoryOff = isExplicitMemoryRoutingOptOut(mr);
-  const hydrate = memoryOff ? { dest: null, added: 0, destCount: 0 } : hydrateDestOnWake(root);
-  const captured = maybeCaptureSessionOnHeadMove(root);
+  const live = memoryOff
+    ? { hydrate: { dest: null, added: 0, destCount: 0 }, captured: null, grow: null }
+    : withDestLock(root, () => {
+        const hydrateInner = hydrateDestOnWake(root);
+        const capturedInner = maybeCaptureSessionOnHeadMove(root);
+        const growInner = growDestOnWake(root);
+        return { hydrate: hydrateInner, captured: capturedInner, grow: growInner };
+      });
+  const hydrate = live.hydrate;
+  const captured = live.captured;
+  const grow = live.grow;
+  const destCountAfterGrow =
+    grow && typeof grow.after === "number"
+      ? grow.after
+      : existsSync(destSignalsPath(root))
+        ? countCuratedSignals(destSignalsPath(root)) || 0
+        : hydrate.destCount;
   const pickup = readNotesPickup(root);
   const approaches = readLatestSessionApproaches(root);
   const prevHost = typeof existing.host === "string" ? existing.host : null;
@@ -570,7 +763,10 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
     matchedSignals = preferSubjectHits(extra.matchedSignals, 8);
   }
   const priorWorking = readRepertoireWorking(root);
-  const destCount = hydrate.destCount || (existsSync(destSignalsPath(root)) ? countCuratedSignals(destSignalsPath(root)) : 0);
+  const destCount =
+    destCountAfterGrow ||
+    hydrate.destCount ||
+    (existsSync(destSignalsPath(root)) ? countCuratedSignals(destSignalsPath(root)) : 0);
   if (!memoryOff && !matchedSignals.length && matchText) {
     if (
       !rematch &&
@@ -604,6 +800,15 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
   if (pickup) workingSnapshot.pickup = pickup;
   if (matchText) workingSnapshot.matchText = matchText;
   if (captured) workingSnapshot.sessionCapture = captured;
+  if (grow && grow.skipped) workingSnapshot.grow = grow.skipped;
+  if (grow && typeof grow.after === "number") {
+    workingSnapshot.grow = {
+      before: grow.before,
+      after: grow.after,
+      imported: grow.imported,
+      observed: Array.isArray(grow.observed) ? grow.observed.length : 0,
+    };
+  }
   if (matchedSignals.length) workingSnapshot.matchedSignals = matchedSignals.slice(0, 8);
   const opProcNames = readOpProcNames(root);
   if (opProcNames.length) workingSnapshot.opProcNames = opProcNames;
@@ -666,6 +871,22 @@ function stripHoldNpm(line) {
     .replace(/[ \t]+$/g, "");
 }
 
+/** Same-session skip must still rewrite when HEAD, organ count, or Hold npm diverges. */
+function stationBootNeedsRefresh(existing, root, host) {
+  if (!existing || typeof existing !== "object") return true;
+  if (host && existing.host && existing.host !== host) return true;
+  if (!existing.suit_profile) return true;
+  if (existing.workspaceRoot && existing.workspaceRoot !== root) return true;
+  if (!existing.stationLine) return true;
+  const liveGit = readGitBrief(root);
+  const bootHead = existing.git && existing.git.head ? String(existing.git.head) : "";
+  if (liveGit && liveGit.head && bootHead !== liveGit.head) return true;
+  const liveResume = buildRepertoireResume(root);
+  if (liveResume && existing.repertoireResume && liveResume !== existing.repertoireResume) return true;
+  if (stationDurableHoldsNpm(root)) return true;
+  return false;
+}
+
 function stationDurableHoldsNpm(root) {
   return readExistingStationMarkdown(root)
     .split(/\r?\n/)
@@ -793,6 +1014,11 @@ module.exports = {
   readRepertoireWorking,
   readOpProcNames,
   hydrateDestOnWake,
+  growDestOnWake,
+  heatLiveMemory,
+  withDestLock,
+  slugPrimitiveName,
+  patternsFromGit,
   readNotesPickup,
   maybeCaptureSessionOnHeadMove,
   formatWorkingLine,
@@ -803,4 +1029,5 @@ module.exports = {
   writeStationMarkdown,
   isHoldNpmLine,
   stationDurableHoldsNpm,
+  stationBootNeedsRefresh,
 };

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

@@ -20,6 +20,11 @@ export const persistRepertoireWorking = impl.persistRepertoireWorking;
 export const readRepertoireWorking = impl.readRepertoireWorking;
 export const readOpProcNames = impl.readOpProcNames;
 export const hydrateDestOnWake = impl.hydrateDestOnWake;
+export const growDestOnWake = impl.growDestOnWake;
+export const heatLiveMemory = impl.heatLiveMemory;
+export const withDestLock = impl.withDestLock;
+export const slugPrimitiveName = impl.slugPrimitiveName;
+export const patternsFromGit = impl.patternsFromGit;
 export const readNotesPickup = impl.readNotesPickup;
 export const maybeCaptureSessionOnHeadMove = impl.maybeCaptureSessionOnHeadMove;
 export const formatWorkingLine = impl.formatWorkingLine;
@@ -30,3 +35,4 @@ export const formatStationMarkdown = impl.formatStationMarkdown;
 export const writeStationMarkdown = impl.writeStationMarkdown;
 export const isHoldNpmLine = impl.isHoldNpmLine;
 export const stationDurableHoldsNpm = impl.stationDurableHoldsNpm;
+export const stationBootNeedsRefresh = impl.stationBootNeedsRefresh;

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/openclaw/plugin/xray-pre-tool/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xray-pre-tool",
-  "version": "4.0.19",
+  "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.19",
+  "version": "4.0.20",
   "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.19",
+  "version": "4.0.20",
   "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.19",
+  "version": "4.0.20",
   "description": "0xRay Framework - Unified Feature Configuration",
   "suit_temperament": {
     "profile": "auto",