0xray 4.0.20 → 4.0.22

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

@@ -1,6 +1,7 @@
 /**
  * Station heat — compaction / host-swap card.
- * SSOT remains session-boot.json. STATION.md is the projection the model Reads.
+ * STATION.md is the pickup ticket. session-boot.json is the snapshot.
+ * Heat must not paint leftover boot extras onto the card.
  * Grok ignores SessionStart/UserPromptSubmit stdout; disk + AGENTS.md is the contract.
  * Heat writers merge stock fields; unknown keys and ## Durable / ## Seed survive.
  */
@@ -104,6 +105,63 @@ function readPlanLine(root) {
   return readGitSubject(root);
 }
 
+function isStockTicket(value) {
+  const text = String(value || "").trim().toLowerCase();
+  return !text || text === "(none)" || text === "(none yet)";
+}
+
+function readStationTicketField(root, field) {
+  const md = readExistingStationMarkdown(root);
+  const re = field === "Plan" ? /^Plan:\s*(.*)$/im : /^Intent:\s*(.*)$/im;
+  const match = md.match(re);
+  if (!match) return null;
+  const value = clipIntent(match[1]);
+  if (!value || isStockTicket(value)) return null;
+  return value;
+}
+
+function bootHeadMoved(root, existing) {
+  const live = readGitBrief(root);
+  const bootHead = existing && existing.git && existing.git.head ? String(existing.git.head) : "";
+  return Boolean(live && live.head && bootHead && bootHead !== live.head);
+}
+
+/** Live ticket beats leftover boot. Extra spoken intent still wins. */
+function resolveHeatIntent(root, extra, existing) {
+  const incoming = clipIntent(
+    extra.intent || extra.prompt || extra.userMessage || extra.user_prompt,
+  );
+  if (incoming) return { intent: incoming, rematch: true };
+  const card = readStationTicketField(root, "Intent");
+  const pickup = clipIntent(readNotesPickup(root));
+  const bootIntent = typeof existing.intent === "string" ? clipIntent(existing.intent) : null;
+  const cardIsBootEcho = Boolean(card && bootIntent && card === bootIntent);
+  if (pickup && cardIsBootEcho && pickup !== bootIntent) {
+    return { intent: pickup, rematch: true };
+  }
+  if (card && !cardIsBootEcho) return { intent: card, rematch: card !== bootIntent };
+  if (pickup && pickup !== bootIntent) return { intent: pickup, rematch: true };
+  if (card) return { intent: card, rematch: false };
+  if (bootIntent) return { intent: bootIntent, rematch: false };
+  const git = readGitSubject(root);
+  return { intent: git, rematch: Boolean(git) };
+}
+
+function resolveHeatPlan(root, extra, existing) {
+  const incoming = clipIntent(extra.plan || extra.planLine);
+  if (incoming) return incoming;
+  const card = readStationTicketField(root, "Plan");
+  const bootPlan = typeof existing.planLine === "string" ? clipIntent(existing.planLine) : null;
+  const live = readPlanLine(root);
+  const cardIsBootEcho = Boolean(card && bootPlan && card === bootPlan);
+  if (card && !cardIsBootEcho) return card;
+  if (bootHeadMoved(root, existing) && bootPlan && live === bootPlan) {
+    return readGitSubject(root) || card || live;
+  }
+  if (card) return card;
+  return live;
+}
+
 function resolveRepertoireProviderModule(root) {
   const mr = readMemoryRoutingConfig(root);
   if (mr && typeof mr.module_path === "string" && mr.module_path) {
@@ -200,32 +258,44 @@ function readRepertoireWorking(root) {
   }
 }
 
+function isKeywordDestName(name) {
+  const n = String(name || "").trim().toLowerCase();
+  if (!n) return true;
+  if (n.startsWith("repo-") || n.startsWith("bedrock-")) return true;
+  if (n === "test-expansion" || n === "dead-code-removal" || n === "station-heat") return true;
+  if (/^release-v?\d/.test(n) || /^stamp-/.test(n) || /^drop-stale-/.test(n)) return true;
+  if (/\b4-0-\d{2}\b/.test(n) && /npm|package-lock|release|stamp/.test(n)) return true;
+  return false;
+}
+
+function isGenericFieldObservedSignal(signal) {
+  const definition = String((signal && signal.definition) || "");
+  return /field-observed domain primitive/i.test(definition);
+}
+
 function stationSafeSignals(names) {
   if (!Array.isArray(names)) return [];
   const out = [];
   for (const raw of names) {
     const name = String(raw || "").trim();
-    if (!name) continue;
-    if (name.toLowerCase().startsWith("bedrock-")) continue;
+    if (!name || isKeywordDestName(name)) continue;
     out.push(name);
     if (out.length >= 4) break;
   }
   return out;
 }
 
-/** Keep subject repo-* in the short list the card and working file hold. */
-function preferSubjectHits(names, cap = 8) {
+/** Laws only. Hangar repo-* and git-slug keywords stay off the card. */
+function preferLawHits(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 (!name || isKeywordDestName(name)) 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);
+  return unique.slice(0, cap);
 }
 
 function destSignalsPath(root) {
@@ -279,6 +349,76 @@ function signalNameSet(filePath) {
   return new Set(readSignalRecords(filePath).map((signal) => String(signal.name).trim()));
 }
 
+function destLawNameSet(root) {
+  const names = new Set();
+  for (const fileName of ["curated_signals.json", "stack-overlay.json"]) {
+    for (const name of signalNameSet(repertoireDataFile(root, fileName))) {
+      if (!isKeywordDestName(name)) names.add(name);
+    }
+  }
+  for (const name of signalNameSet(destSignalsPath(root))) {
+    if (!isKeywordDestName(name)) names.add(name);
+  }
+  return names;
+}
+
+/** Drop hangar repo-* and git-slug keywords. Keep factory + stack laws. */
+function pruneKeywordDest(root) {
+  const dest = destSignalsPath(root);
+  if (!dest || !existsSync(dest)) return { removed: 0, kept: 0 };
+  let data;
+  try {
+    data = JSON.parse(readFileSync(dest, "utf8"));
+  } catch {
+    return { removed: 0, kept: 0 };
+  }
+  if (!Array.isArray(data.signals)) return { removed: 0, kept: 0 };
+  const factory = signalNameSet(repertoireDataFile(root, "curated_signals.json"));
+  const stack = signalNameSet(repertoireDataFile(root, "stack-overlay.json"));
+  const kept = [];
+  let removed = 0;
+  for (const signal of data.signals) {
+    const name = String((signal && signal.name) || "").trim();
+    if (!name) continue;
+    const protectedLaw = factory.has(name) || stack.has(name);
+    if (!protectedLaw && (isKeywordDestName(name) || isGenericFieldObservedSignal(signal))) {
+      removed += 1;
+      continue;
+    }
+    kept.push(signal);
+  }
+  if (removed) {
+    data.signals = kept;
+    data.last_updated = new Date().toISOString();
+    writeFileSync(dest, `${JSON.stringify(data, null, 2)}\n`);
+  }
+  return { removed, kept: kept.length };
+}
+
+const STACK_LAW_FIELDS = [
+  "definition",
+  "tags",
+  "priority",
+  "evaluation_criteria",
+  "validation_experiment",
+  "example_inference_snippet",
+  "implementation_notes",
+];
+
+/** Stack text cadences onto an existing project law. Observation stats stay. */
+function refreshStackLaw(existing, signal) {
+  let dirty = false;
+  for (const field of STACK_LAW_FIELDS) {
+    if (signal[field] == null) continue;
+    const next = signal[field];
+    const prev = existing[field];
+    if (JSON.stringify(prev) === JSON.stringify(next)) continue;
+    existing[field] = next;
+    dirty = true;
+  }
+  return dirty;
+}
+
 function mergeMissingSignals(destPath, incoming) {
   if (!incoming.length || !existsSync(destPath)) return 0;
   let data;
@@ -288,27 +428,38 @@ function mergeMissingSignals(destPath, incoming) {
     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;
+  const byName = new Map();
+  for (const signal of data.signals) {
+    const name = String((signal && signal.name) || "").trim();
+    if (name) byName.set(name, signal);
+  }
+  let changed = 0;
   for (const signal of incoming) {
     const name = String(signal.name).trim();
-    if (!name || have.has(name)) continue;
-    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;
+    if (!name) continue;
+    const existing = byName.get(name);
+    if (!existing) {
+      const created = {
+        ...signal,
+        name,
+        tags: Array.isArray(signal.tags) ? signal.tags : [],
+        definition: typeof signal.definition === "string" ? signal.definition : name,
+      };
+      data.signals.push(created);
+      byName.set(name, created);
+      changed += 1;
+      continue;
+    }
+    if (refreshStackLaw(existing, signal)) changed += 1;
   }
-  if (added) writeFileSync(destPath, `${JSON.stringify(data, null, 2)}\n`);
-  return added;
+  if (changed) {
+    data.last_updated = new Date().toISOString();
+    writeFileSync(destPath, `${JSON.stringify(data, null, 2)}\n`);
+  }
+  return changed;
 }
 
-/** Hydrate project dest from seed + stack + subject overlays. Never write the tarball. */
+/** Hydrate project dest from seed + stack. Subject repo-* stay off dest. */
 function hydrateDestOnWake(root) {
   const dest = destSignalsPath(root);
   const seed = repertoireDataFile(root, "curated_signals.json");
@@ -317,10 +468,12 @@ function hydrateDestOnWake(root) {
     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 };
+  const added = mergeMissingSignals(
+    dest,
+    readSignalRecords(repertoireDataFile(root, "stack-overlay.json")),
+  );
+  const pruned = pruneKeywordDest(root);
+  return { dest, added, destCount: countCuratedSignals(dest) || 0, pruned };
 }
 
 function readNotesPickup(root) {
@@ -405,7 +558,12 @@ function sleepMs(ms) {
 /** 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 });
+  try {
+    mkdirSync(join(root, ".xray", "state", "repertoire"), { recursive: true });
+  } catch (err) {
+    if (err && (err.code === "EACCES" || err.code === "EPERM")) return null;
+    throw err;
+  }
   const started = Date.now();
   while (Date.now() - started < 50000) {
     try {
@@ -466,42 +624,18 @@ function stripConventionalSubject(message) {
     .trim();
 }
 
-/** Real git → dest names. Not a leftover catalog. Kernel structural names when the diff shows them. */
-function patternsFromGit(root, commits, span) {
+/** Observe existing laws mentioned in git. Do not mint commit slugs. */
+function patternsFromGit(root, commits) {
+  const text = (Array.isArray(commits) ? commits : [])
+    .map((row) => String((row && row.message) || ""))
+    .join("\n")
+    .toLowerCase();
   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");
-      }
+  if (!text.trim()) return patterns;
+  for (const name of destLawNameSet(root)) {
+    if (text.includes(name) || text.includes(name.replace(/-/g, " "))) {
+      patterns.push({ name, confidence: 0.7, description: "observe existing law from git" });
     }
-  } catch {
-    /* structural names are extra — commit slugs still grow dest */
   }
   return patterns;
 }
@@ -521,16 +655,22 @@ function latestSessionNewerThanGrow(root) {
 
 /** Capture then grow. Skip-path for floors that already have a live card. */
 function heatLiveMemory(root) {
-  const mr = readMemoryRoutingConfig(root);
-  if (isExplicitMemoryRoutingOptOut(mr)) {
+  try {
+    const mr = readMemoryRoutingConfig(root);
+    if (isExplicitMemoryRoutingOptOut(mr)) {
+      return { captured: null, grow: null };
+    }
+    const result = withDestLock(root, () => {
+      const captured = maybeCaptureSessionOnHeadMove(root);
+      const grow = captured || latestSessionNewerThanGrow(root) ? growDestOnWake(root) : null;
+      if (grow) persistRepertoireWorking(root, { grow });
+      return { captured, grow };
+    });
+    return result || { captured: null, grow: null };
+  } catch {
+    /* dest EACCES / unwritable heat root must not deny the host tool */
     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. */
@@ -556,6 +696,7 @@ function maybeCaptureSessionOnHeadMove(root) {
     from: stamp && stamp.head ? stamp.head : commits[commits.length - 1] ? commits[commits.length - 1].hash : git.head,
     to: git.head,
   };
+  const patterns = patternsFromGit(root, commits, span);
   const session = {
     sessionId,
     timestamp: new Date().toISOString(),
@@ -564,8 +705,8 @@ function maybeCaptureSessionOnHeadMove(root) {
     approaches,
     wrongTurns: [],
     solutions: [],
-    patterns: patternsFromGit(root, commits, span),
-    matched_primitives: [],
+    patterns,
+    matched_primitives: preferLawHits(patterns.map((row) => row && row.name)),
     metrics: { commits: commits.length },
   };
   const outDir = join(root, "docs", "inference");
@@ -648,7 +789,17 @@ function growDestOnWake(root) {
     });
     const line = String(out).trim().split("\n").filter(Boolean).at(-1) || "{}";
     const parsed = JSON.parse(line);
-    return parsed && typeof parsed === "object" ? parsed : null;
+    const pruned = pruneKeywordDest(root);
+    const destCount = countCuratedSignals(destSignalsPath(root)) || 0;
+    if (!parsed || typeof parsed !== "object") return { pruned: pruned.removed, destCount };
+    const heated = Array.isArray(parsed.heated) ? parsed.heated.length : 0;
+    return {
+      ...parsed,
+      observed: heated,
+      pruned: pruned.removed,
+      destCount,
+      after: destCount,
+    };
   } catch {
     return null;
   }
@@ -679,6 +830,53 @@ function isCompactHook(extra) {
   return /compact/i.test(hook);
 }
 
+function isCompactEventName(value) {
+  return /compact/i.test(String(value || ""));
+}
+
+/** Keep Compact boot fields after later preToolUse / HEAD rewrite. */
+function retainCompactFields(existing, extra = {}) {
+  const incomingHook = extra && (extra.hookEvent || extra.source || extra.hook);
+  if (isCompactEventName(incomingHook) || (extra && extra.event_class)) {
+    const kept = {};
+    if (extra.hookEvent) kept.hookEvent = extra.hookEvent;
+    if (extra.conversation_id) kept.conversation_id = extra.conversation_id;
+    if (extra.generation_id) kept.generation_id = extra.generation_id;
+    if (extra.event_class) kept.event_class = extra.event_class;
+    return kept;
+  }
+  const prior = existing && typeof existing === "object" ? existing : {};
+  if (!isCompactEventName(prior.hookEvent) && !prior.event_class) return {};
+  const kept = {};
+  if (prior.hookEvent) kept.hookEvent = prior.hookEvent;
+  if (prior.conversation_id) kept.conversation_id = prior.conversation_id;
+  if (prior.generation_id) kept.generation_id = prior.generation_id;
+  if (prior.event_class) kept.event_class = prior.event_class;
+  return kept;
+}
+
+/** Persist heated length. A number stays a number. An array is a count. Never drop a number to 0. */
+function workingGrowSnapshot(grow) {
+  if (!grow || typeof grow !== "object") return null;
+  if (typeof grow.after !== "number") {
+    return typeof grow.skipped === "string" ? grow.skipped : null;
+  }
+  const observed =
+    typeof grow.observed === "number"
+      ? grow.observed
+      : Array.isArray(grow.observed)
+        ? grow.observed.length
+        : Array.isArray(grow.heated)
+          ? grow.heated.length
+          : 0;
+  return {
+    before: grow.before,
+    after: grow.after,
+    imported: grow.imported,
+    observed,
+  };
+}
+
 function formatWorkingLine(working) {
   if (!working || typeof working !== "object") return null;
   const matched = stationSafeSignals(working.matchedSignals);
@@ -694,7 +892,7 @@ function buildRepertoireResume(root) {
   const modulePath = resolveRepertoireProviderModule(root);
   const mr = readMemoryRoutingConfig(root);
   if (!modulePath) {
-    return "Repertoire: not installed (memory_routing stays off)";
+    return "Repertoire: module unresolved";
   }
   const destPath = destSignalsPath(root);
   let signalsPath = existsSync(destPath) ? destPath : mr.config && mr.config.signalsPath;
@@ -744,14 +942,12 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
       ? existing.hotSwap
       : null;
   const hotSwap = nextSwap || keptSwap;
-  const incomingIntent = clipIntent(
-    extra.intent || extra.prompt || extra.userMessage || extra.user_prompt,
-  );
-  const intent = incomingIntent || (typeof existing.intent === "string" ? existing.intent : null);
+  const resolved = resolveHeatIntent(root, extra, existing);
+  const intent = resolved.intent;
+  const rematch = resolved.rematch;
   const matchText = clipIntent([intent, pickup, approaches].filter(Boolean).join(" "));
-  const rematch = Boolean(incomingIntent);
   const git = readGitBrief(root);
-  const planLine = readPlanLine(root);
+  const planLine = resolveHeatPlan(root, extra, existing);
   const repertoireResume =
     typeof extra.repertoireResume === "string" ? extra.repertoireResume : buildRepertoireResume(root);
   const swapBit = hotSwap ? `hot-swap ${hotSwap.from} → ${hotSwap.to}` : `host ${host}`;
@@ -760,7 +956,7 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
   const planBit = planLine ? `plan: ${planLine}` : "plan: (none)";
   let matchedSignals = [];
   if (Array.isArray(extra.matchedSignals) && extra.matchedSignals.length) {
-    matchedSignals = preferSubjectHits(extra.matchedSignals, 8);
+    matchedSignals = preferLawHits(extra.matchedSignals, 8);
   }
   const priorWorking = readRepertoireWorking(root);
   const destCount =
@@ -776,10 +972,10 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
       Array.isArray(priorWorking.matchedSignals) &&
       priorWorking.matchedSignals.length
     ) {
-      matchedSignals = preferSubjectHits(priorWorking.matchedSignals, 8);
+      matchedSignals = preferLawHits(priorWorking.matchedSignals, 8);
     } else {
-      matchedSignals = preferSubjectHits(
-        matchStationSignalsSync(root, rematch && incomingIntent ? incomingIntent : matchText),
+      matchedSignals = preferLawHits(
+        matchStationSignalsSync(root, rematch && intent ? intent : matchText),
         8,
       );
     }
@@ -787,32 +983,26 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
   if (!matchedSignals.length && priorWorking) {
     matchedSignals = stationSafeSignals(priorWorking.matchedSignals);
   }
+  const compactHold = retainCompactFields(existing, extra);
+  const nextHook = compactHold.hookEvent || extra.hookEvent || extra.source || null;
   const workingSnapshot = {
     host,
     intent,
     git,
     hotSwap,
-    hookEvent: extra.hookEvent || extra.source || null,
     memoryRouting: repertoireResume.startsWith("Repertoire: on") ? "on" : "off",
     repertoireResume,
     destCount,
   };
+  if (nextHook) workingSnapshot.hookEvent = nextHook;
   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,
-    };
-  }
+  const growReceipt = workingGrowSnapshot(grow);
+  if (growReceipt) workingSnapshot.grow = growReceipt;
   if (matchedSignals.length) workingSnapshot.matchedSignals = matchedSignals.slice(0, 8);
   const opProcNames = readOpProcNames(root);
   if (opProcNames.length) workingSnapshot.opProcNames = opProcNames;
-  const working = persistRepertoireWorking(root, workingSnapshot);
   const pickupChanged = Boolean(pickup && (!priorWorking || priorWorking.pickup !== pickup));
   if (
     !memoryOff &&
@@ -826,6 +1016,11 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
       matchedSignals,
     );
   }
+  if (!memoryOff) {
+    const latePrune = pruneKeywordDest(root);
+    if (latePrune.kept) workingSnapshot.destCount = latePrune.kept;
+  }
+  const working = persistRepertoireWorking(root, workingSnapshot);
   const workingLine = formatWorkingLine(working);
   const workingBit = workingLine ? workingLine : "working: (none)";
   const stationLine = `${swapBit}. ${intentBit}. ${planBit}. ${gitBit}. ${repertoireResume}. ${workingBit}`;
@@ -838,6 +1033,7 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
     repertoireResume,
     workingLine,
     stationLine,
+    ...compactHold,
   };
 }
 
@@ -884,6 +1080,12 @@ function stationBootNeedsRefresh(existing, root, host) {
   const liveResume = buildRepertoireResume(root);
   if (liveResume && existing.repertoireResume && liveResume !== existing.repertoireResume) return true;
   if (stationDurableHoldsNpm(root)) return true;
+  const cardIntent = readStationTicketField(root, "Intent");
+  const bootIntent = typeof existing.intent === "string" ? clipIntent(existing.intent) : null;
+  if (cardIntent && bootIntent && cardIntent !== bootIntent) return true;
+  const cardPlan = readStationTicketField(root, "Plan");
+  const bootPlan = typeof existing.planLine === "string" ? clipIntent(existing.planLine) : null;
+  if (cardPlan && bootPlan && cardPlan !== bootPlan) return true;
   return false;
 }
 
@@ -965,7 +1167,7 @@ function formatStationMarkdown(fields) {
   } else {
     lines.push("Git: n/a");
   }
-  lines.push(fields.repertoireResume || "Repertoire: not installed (memory_routing stays off)");
+  lines.push(fields.repertoireResume || "Repertoire: module unresolved");
   if (fields.workingLine) {
     lines.push(fields.workingLine);
   }
@@ -1022,7 +1224,12 @@ module.exports = {
   readNotesPickup,
   maybeCaptureSessionOnHeadMove,
   formatWorkingLine,
+  workingGrowSnapshot,
   applyStationHeat,
+  isStockTicket,
+  readStationTicketField,
+  resolveHeatIntent,
+  resolveHeatPlan,
   extractPreservedStationLines,
   mergeStationMarkdown,
   formatStationMarkdown,
@@ -1030,4 +1237,9 @@ module.exports = {
   isHoldNpmLine,
   stationDurableHoldsNpm,
   stationBootNeedsRefresh,
+  isKeywordDestName,
+  pruneKeywordDest,
+  preferLawHits,
+  retainCompactFields,
+  destLawNameSet,
 };

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

@@ -28,7 +28,12 @@ export const patternsFromGit = impl.patternsFromGit;
 export const readNotesPickup = impl.readNotesPickup;
 export const maybeCaptureSessionOnHeadMove = impl.maybeCaptureSessionOnHeadMove;
 export const formatWorkingLine = impl.formatWorkingLine;
+export const workingGrowSnapshot = impl.workingGrowSnapshot;
 export const applyStationHeat = impl.applyStationHeat;
+export const isStockTicket = impl.isStockTicket;
+export const readStationTicketField = impl.readStationTicketField;
+export const resolveHeatIntent = impl.resolveHeatIntent;
+export const resolveHeatPlan = impl.resolveHeatPlan;
 export const extractPreservedStationLines = impl.extractPreservedStationLines;
 export const mergeStationMarkdown = impl.mergeStationMarkdown;
 export const formatStationMarkdown = impl.formatStationMarkdown;
@@ -36,3 +41,8 @@ export const writeStationMarkdown = impl.writeStationMarkdown;
 export const isHoldNpmLine = impl.isHoldNpmLine;
 export const stationDurableHoldsNpm = impl.stationDurableHoldsNpm;
 export const stationBootNeedsRefresh = impl.stationBootNeedsRefresh;
+export const isKeywordDestName = impl.isKeywordDestName;
+export const pruneKeywordDest = impl.pruneKeywordDest;
+export const preferLawHits = impl.preferLawHits;
+export const retainCompactFields = impl.retainCompactFields;
+export const destLawNameSet = impl.destLawNameSet;

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

@@ -118,7 +118,6 @@ async function growDest(projectRoot) {
       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)
@@ -129,13 +128,15 @@ async function growDest(projectRoot) {
         sources: [...(kernel.sources || []), ...cleanup.sources],
       });
       const after = service.signalsManager.load().signals.length;
+      const heatedNames = Array.isArray(diary.heated) ? diary.heated : [];
       process.stdout.write(
         `${JSON.stringify({
           before,
           after,
           imported: sessions.imported,
-          observed: siblings.observed,
-          heated: diary.heated,
+          observed: heatedNames.length,
+          heated: heatedNames,
+          destCount: after,
         })}\n`,
       );
       return;

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

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

package/dist/memory-routing/provider-loader.d.ts

@@ -1,6 +1,8 @@
 import type { MemoryRoutingConfig, MemoryRoutingProvider } from './types.js';
 export declare function isExplicitMemoryRoutingOptOut(config: MemoryRoutingConfig): boolean;
-/** Leftover shipped default: enabled false + provider null. Not an explicit opt-out. */
+/** Leftover shipped default: enabled false + provider null. Not an explicit opt-out.
+ *  resolveLeftoverEnabledConfig migrates old tarballs when the organ is on disk.
+ *  Explicit opt-out is enabled: false + provider: repertoire. */
 export declare function isLeftoverMemoryRoutingOff(config: MemoryRoutingConfig): boolean;
 export declare function resolveLeftoverEnabledConfig(config: MemoryRoutingConfig, cwd: string): MemoryRoutingConfig | null;
 export declare function loadMemoryRoutingProvider(config: MemoryRoutingConfig, cwd?: string): Promise<MemoryRoutingProvider>;