0xray 4.0.19 → 4.0.21

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

@@ -1,11 +1,22 @@
 /**
  * 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.
  */
 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;
@@ -94,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) {
@@ -190,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) {
@@ -269,6 +349,52 @@ 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 };
+}
+
 function mergeMissingSignals(destPath, incoming) {
   if (!incoming.length || !existsSync(destPath)) return 0;
   let data;
@@ -285,7 +411,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;
   }
@@ -293,7 +424,7 @@ function mergeMissingSignals(destPath, incoming) {
   return added;
 }
 
-/** 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");
@@ -302,10 +433,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) {
@@ -374,7 +507,138 @@ 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);
+  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 {
+      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();
+}
+
+/** 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 = [];
+  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" });
+    }
+  }
+  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) {
+  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 };
+  }
+}
+
+/** 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 +657,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 +741,26 @@ 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);
+    const pruned = pruneKeywordDest(root);
+    if (!parsed || typeof parsed !== "object") return { pruned };
+    return { ...parsed, pruned: pruned.removed, destCount: countCuratedSignals(destSignalsPath(root)) };
+  } catch {
+    return null;
+  }
+}
+
 function ingestCompactFeedbackSync(root, sessionId, hookEvent, signals) {
   if (!signals.length) return;
   const helper = join(HOOKS_DIR, "station-memory-ingest.mjs");
@@ -501,6 +786,31 @@ 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;
+}
+
 function formatWorkingLine(working) {
   if (!working || typeof working !== "object") return null;
   const matched = stationSafeSignals(working.matchedSignals);
@@ -537,8 +847,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;
@@ -551,14 +876,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}`;
@@ -567,10 +890,13 @@ 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 = 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 &&
@@ -580,10 +906,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,
       );
     }
@@ -591,23 +917,33 @@ 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,
+    };
+  }
   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 &&
@@ -621,6 +957,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}`;
@@ -633,6 +974,7 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
     repertoireResume,
     workingLine,
     stationLine,
+    ...compactHold,
   };
 }
 
@@ -666,6 +1008,28 @@ 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;
+  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;
+}
+
 function stationDurableHoldsNpm(root) {
   return readExistingStationMarkdown(root)
     .split(/\r?\n/)
@@ -793,14 +1157,29 @@ module.exports = {
   readRepertoireWorking,
   readOpProcNames,
   hydrateDestOnWake,
+  growDestOnWake,
+  heatLiveMemory,
+  withDestLock,
+  slugPrimitiveName,
+  patternsFromGit,
   readNotesPickup,
   maybeCaptureSessionOnHeadMove,
   formatWorkingLine,
   applyStationHeat,
+  isStockTicket,
+  readStationTicketField,
+  resolveHeatIntent,
+  resolveHeatPlan,
   extractPreservedStationLines,
   mergeStationMarkdown,
   formatStationMarkdown,
   writeStationMarkdown,
   isHoldNpmLine,
   stationDurableHoldsNpm,
+  stationBootNeedsRefresh,
+  isKeywordDestName,
+  pruneKeywordDest,
+  preferLawHits,
+  retainCompactFields,
+  destLawNameSet,
 };

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

@@ -20,13 +20,28 @@ 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;
 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;
 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;