0xray 3.5.5 → 4.0.1

package/dist/integrations/grok/plugin/0xray/hooks/hooks.json

@@ -2,15 +2,11 @@
   "hooks": {
     "PreToolUse": [
       {
-        "matcher": ".*",
         "hooks": [
           {
             "type": "command",
-            "command": "node",
-            "args": [
-              "${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/pre-tool-use.js"
-            ],
-            "timeout": 30000
+            "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/pre-tool-use.js\"",
+            "timeout": 30
           }
         ]
       }
@@ -20,11 +16,8 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node",
-            "args": [
-              "${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/session-start.js"
-            ],
-            "timeout": 15000
+            "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/session-start.js\"",
+            "timeout": 30
           }
         ]
       }
@@ -34,30 +27,44 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node",
-            "args": [
-              "${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/session-start.js",
-              "--hook-event=user_prompt_submit"
-            ],
-            "timeout": 15000
+            "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/session-start.js\" --hook-event=user_prompt_submit",
+            "timeout": 30
           }
         ]
       }
     ],
     "PostToolUse": [
       {
-        "matcher": ".*",
         "hooks": [
           {
             "type": "command",
-            "command": "node",
-            "args": [
-              "${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/post-tool-use.js"
-            ],
-            "timeout": 15000
+            "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/post-tool-use.js\"",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/session-start.js\" --hook-event=pre_compact",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PostCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/session-start.js\" --hook-event=post_compact",
+            "timeout": 30
           }
         ]
       }
     ]
   }
-}
+}

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

@@ -332,6 +332,12 @@ async function runProcessors(tool, args, phase, projectRoot, logDir) {
         priority: 30,
         enabled: true,
       });
+      processorManager.registerProcessor({
+        name: "nudge",
+        type: "post",
+        priority: 78,
+        enabled: true,
+      });
     }
 
     let results;
@@ -436,6 +442,24 @@ async function handleSessionStart(input, projectRoot, logDir) {
     /* non-blocking — dist may be absent during dev */
   }
 
+  try {
+    const gate = await import('../hooks/delegation-gate-runtime.mjs');
+    if (typeof gate.writeSuitSessionBoot === 'function') {
+      const compact =
+        input.compact === true ||
+        input.hookEvent === 'pre_compact' ||
+        input.hookEvent === 'post_compact';
+      gate.writeSuitSessionBoot(projectRoot, 'hermes', {
+        source: compact ? '0xray/hermes-compact' : '0xray/hermes-session-start',
+        sessionId,
+        hookEvent: compact ? 'post_compact' : 'session_start',
+        ...(input.intent ? { intent: input.intent } : {}),
+      });
+    }
+  } catch {
+    /* dist may be absent during dev */
+  }
+
   logToActivity(logDir, `session-start: session=${sessionId} source=bridge`);
   return { ok: true, sessionId, planArchive };
 }
@@ -494,6 +518,7 @@ async function handlePostProcess(input, projectRoot, logDir) {
   });
 
   logToActivity(logDir, `post-process: complete duration=${duration}ms processors=${processorResult.success}`);
+  logToActivity(logDir, `[nudge] post-process tool=${tool}`);
 
   // Log routing outcome for test verification
   logRoutingOutcome(logDir, {
@@ -862,7 +887,7 @@ async function handleDelegationGate(command, projectRoot, logDir) {
       await recordHermesSynthesisTurn(projectRoot, sessionId);
     }
 
-    const features = gate.loadDelegationGateFeatures(projectRoot);
+    const features = gate.loadDelegationGateFeatures(projectRoot, host);
     const outcome = gate.evaluatePreToolGate(tool, args, {
       projectRoot,
       sessionId,

package/dist/integrations/hooks/delegation-gate-runtime.mjs

@@ -4,7 +4,8 @@
  * Used by Grok hooks, Hermes bridge, and verify fixtures.
  */
 import { createRequire } from 'node:module';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -35,17 +36,40 @@ function resolvePackageRoot() {
   return resolve(__dirname, '../../..');
 }
 
+function markedRoots() {
+  const files = [
+    join(homedir(), '.hermes', 'plugins', 'xray-hermes', 'xray-consumer-root.txt'),
+    join(homedir(), '.openclaw', 'xray-consumer-root.txt'),
+  ];
+  const roots = [];
+  for (const file of files) {
+    if (!existsSync(file)) continue;
+    try {
+      const marked = readFileSync(file, 'utf8').trim();
+      if (marked) {
+        roots.push(marked, join(marked, 'node_modules', '0xray'));
+      }
+    } catch {
+      /* ignore unreadable marker */
+    }
+  }
+  return roots;
+}
+
 function loadDelegationGate() {
   const root = resolvePackageRoot();
+  const envRoot = process.env.XRAY_AI_PATH || '';
   const candidates = [
     join(__dirname, '../../nucleus/delegation-gate.js'),
     join(root, 'dist/nucleus/delegation-gate.js'),
+    envRoot ? join(envRoot, 'dist/nucleus/delegation-gate.js') : '',
+    ...markedRoots().map((r) => join(r, 'dist/nucleus/delegation-gate.js')),
     join(process.cwd(), 'node_modules/0xray/dist/nucleus/delegation-gate.js'),
-  ];
+  ].filter(Boolean);
   const found = candidates.find((p) => existsSync(p));
   if (!found) {
     throw new Error(
-      'delegation-gate.js missing — run npm run build in 0xray or npm install 0xray@^3.5.1',
+      'delegation-gate.js missing — run npm run build in 0xray or npm install 0xray',
     );
   }
   return createRequire(import.meta.url)(found);
@@ -53,6 +77,9 @@ function loadDelegationGate() {
 
 const gate = loadDelegationGate();
 
+export const writeSuitSessionBoot = gate.writeSuitSessionBoot;
+export const maybeHeatHostStation = gate.maybeHeatHostStation;
+
 export const {
   loadDelegationGateFeatures,
   normalizeHostToolInput,
@@ -78,4 +105,6 @@ export const {
   buildReceiptFromConsultOutput,
   parseConsultVerdictFromText,
   isSynthesisConsultTodoId,
+  archiveStaleLeadDevPlan,
+  findRecentStalePlanArchive,
 } = gate;

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

@@ -189,7 +189,7 @@ export function runGrokPostprocessorLight(projectRoot, entry = {}) {
     phase: 'post-process-light',
     tool: entry.tool ?? 'unknown',
     paths: entry.paths ?? [],
-    mode: 'grok-pre-tool-light',
+    mode: 'grok-post-tool-light',
   };
   writeFileSync(markerPath, `${JSON.stringify(payload, null, 2)}\n`);
   appendActivity(projectRoot, 'postprocessor-light', 'info', {

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

@@ -0,0 +1,421 @@
+/**
+ * Station heat — compaction / host-swap card.
+ * SSOT remains session-boot.json. STATION.md is the projection the model Reads.
+ * Grok ignores SessionStart/UserPromptSubmit stdout; disk + AGENTS.md is the contract.
+ */
+const { execFileSync } = require("child_process");
+const { existsSync, mkdirSync, readFileSync, writeFileSync } = require("fs");
+const { join } = require("path");
+
+const HOOKS_DIR = __dirname;
+
+const INTENT_MAX = 240;
+
+function stationMarkdownPath(root) {
+  return join(root, ".xray", "state", "STATION.md");
+}
+
+function sessionBootPath(root) {
+  return join(root, ".xray", "state", "session-boot.json");
+}
+
+function clipIntent(raw) {
+  if (raw == null) return null;
+  const text = String(raw)
+    .replace(/<\/?user_query>/gi, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (!text) return null;
+  if (text.length <= INTENT_MAX) return text;
+  return `${text.slice(0, INTENT_MAX - 1)}…`;
+}
+
+function readExistingBoot(root) {
+  const bootPath = sessionBootPath(root);
+  if (!existsSync(bootPath)) return {};
+  try {
+    const data = JSON.parse(readFileSync(bootPath, "utf8"));
+    return data && typeof data === "object" ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+function readGitBrief(root) {
+  try {
+    const opts = { cwd: root, encoding: "utf8", timeout: 2000, stdio: ["ignore", "pipe", "ignore"] };
+    const head = execFileSync("git", ["rev-parse", "--short", "HEAD"], opts).trim();
+    const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], opts).trim();
+    if (!head) return null;
+    return { branch: branch || "HEAD", head };
+  } catch {
+    return null;
+  }
+}
+
+function readGitSubject(root) {
+  try {
+    const opts = { cwd: root, encoding: "utf8", timeout: 2000, stdio: ["ignore", "pipe", "ignore"] };
+    const subject = execFileSync("git", ["log", "-1", "--format=%s"], opts).trim();
+    return clipIntent(subject);
+  } catch {
+    return null;
+  }
+}
+
+function readLiveTodoLine(plan) {
+  const phases = Array.isArray(plan.phases) ? plan.phases : [];
+  for (const phase of phases) {
+    const todos = Array.isArray(phase && phase.todos) ? phase.todos : [];
+    for (const todo of todos) {
+      const status = String((todo && todo.status) || "pending");
+      if (status === "completed" || status === "cancelled") continue;
+      const task = clipIntent((todo && (todo.task || todo.description)) || "");
+      if (task) return task;
+    }
+  }
+  return null;
+}
+
+function readPlanLine(root) {
+  const planPath = join(root, ".xray", "state", "lead-dev-plan.json");
+  if (existsSync(planPath)) {
+    try {
+      const plan = JSON.parse(readFileSync(planPath, "utf8"));
+      if (plan && plan.active !== false) {
+        const live = readLiveTodoLine(plan);
+        if (live) return live;
+      }
+    } catch {
+      /* fall through to git subject — stale / empty plan is not the card */
+    }
+  }
+  return readGitSubject(root);
+}
+
+function resolveRepertoireProviderModule(root) {
+  const mr = readMemoryRoutingConfig(root);
+  if (mr && typeof mr.module_path === "string" && mr.module_path) {
+    const configured = mr.module_path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(mr.module_path)
+      ? mr.module_path
+      : join(root, mr.module_path);
+    if (existsSync(configured)) return configured;
+  }
+  const siblingRoot = join(root, "..", "repertoire");
+  const siblingProvider = join(siblingRoot, "dist", "provider", "memory-routing-provider.js");
+  const nmProvider = join(
+    root,
+    "node_modules",
+    "@0xray",
+    "repertoire",
+    "dist",
+    "provider",
+    "memory-routing-provider.js",
+  );
+  const vendorProvider = join(
+    root,
+    "vendor",
+    "@0xray",
+    "repertoire",
+    "dist",
+    "provider",
+    "memory-routing-provider.js",
+  );
+  if (existsSync(nmProvider)) return nmProvider;
+  if (existsSync(vendorProvider)) return vendorProvider;
+  try {
+    const pkg = JSON.parse(readFileSync(join(siblingRoot, "package.json"), "utf8"));
+    if ((pkg.name === "@0xray/repertoire" || pkg.name === "repertoire") && existsSync(siblingProvider)) {
+      return siblingProvider;
+    }
+  } catch {
+    /* sibling missing */
+  }
+  return null;
+}
+
+function countCuratedSignals(signalsPath) {
+  try {
+    const data = JSON.parse(readFileSync(signalsPath, "utf8"));
+    if (Array.isArray(data.signals)) return data.signals.length;
+    if (Array.isArray(data)) return data.length;
+  } catch {
+    /* unreadable */
+  }
+  return null;
+}
+
+function readMemoryRoutingConfig(root) {
+  const featuresPath = join(root, ".xray", "features.json");
+  if (!existsSync(featuresPath)) return {};
+  try {
+    return JSON.parse(readFileSync(featuresPath, "utf8")).memory_routing || {};
+  } catch {
+    return {};
+  }
+}
+
+function isExplicitMemoryRoutingOptOut(mr) {
+  return Boolean(mr) && mr.enabled === false && mr.provider === "repertoire";
+}
+
+function isLeftoverMemoryRoutingOff(mr) {
+  if (!mr || typeof mr !== "object") return true;
+  if (mr.enabled === true) return false;
+  if (isExplicitMemoryRoutingOptOut(mr)) return false;
+  const provider = mr.provider == null || mr.provider === "" ? "null" : mr.provider;
+  return provider === "null";
+}
+
+function isMemoryRoutingResolvedOn(mr, modulePath) {
+  if (!modulePath) return false;
+  if (isExplicitMemoryRoutingOptOut(mr)) return false;
+  if (mr.enabled === true && (mr.provider === "repertoire" || mr.provider === "custom")) return true;
+  return isLeftoverMemoryRoutingOff(mr);
+}
+
+function repertoireWorkingPath(root) {
+  return join(root, ".xray", "state", "repertoire-working.json");
+}
+
+function readRepertoireWorking(root) {
+  const dest = repertoireWorkingPath(root);
+  if (!existsSync(dest)) return null;
+  try {
+    const data = JSON.parse(readFileSync(dest, "utf8"));
+    return data && typeof data === "object" ? data : null;
+  } catch {
+    return null;
+  }
+}
+
+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;
+    out.push(name);
+    if (out.length >= 4) break;
+  }
+  return out;
+}
+
+function persistRepertoireWorking(root, snapshot) {
+  try {
+    mkdirSync(join(root, ".xray", "state"), { recursive: true });
+    const prev = readRepertoireWorking(root) || {};
+    const next = { ...prev, ...snapshot, updatedAt: new Date().toISOString() };
+    writeFileSync(repertoireWorkingPath(root), `${JSON.stringify(next, null, 2)}\n`);
+    return next;
+  } catch {
+    return null;
+  }
+}
+
+function matchStationSignalsSync(root, intent) {
+  if (!intent) return [];
+  const helper = join(HOOKS_DIR, "station-memory-match.mjs");
+  if (!existsSync(helper)) return [];
+  try {
+    const out = execFileSync(process.execPath, [helper, root, intent], {
+      encoding: "utf8",
+      timeout: 20000,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env,
+    });
+    const line = String(out).trim().split("\n").filter(Boolean).at(-1) || "[]";
+    const parsed = JSON.parse(line);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+function ingestCompactFeedbackSync(root, sessionId, hookEvent, signals) {
+  if (!signals.length) return;
+  const helper = join(HOOKS_DIR, "station-memory-ingest.mjs");
+  if (!existsSync(helper)) return;
+  try {
+    execFileSync(
+      process.execPath,
+      [helper, root, sessionId || "station", hookEvent || "post_compact", JSON.stringify(signals)],
+      {
+        encoding: "utf8",
+        timeout: 20000,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: process.env,
+      },
+    );
+  } catch {
+    /* working-state file is the session memory; registry ingest is best-effort */
+  }
+}
+
+function isCompactHook(extra) {
+  const hook = String(extra.hookEvent || extra.source || "");
+  return /compact/i.test(hook);
+}
+
+function formatWorkingLine(working) {
+  if (!working || typeof working !== "object") return null;
+  const matched = stationSafeSignals(working.matchedSignals);
+  if (matched.length) return `Working: ${matched.join(", ")}`;
+  const hook = typeof working.hookEvent === "string" ? working.hookEvent : null;
+  const head = working.git && working.git.head ? String(working.git.head) : null;
+  if (hook && head) return `Working: last ${hook} @ ${head}`;
+  if (hook) return `Working: last ${hook}`;
+  return "Working: station snapshot";
+}
+
+function buildRepertoireResume(root) {
+  const modulePath = resolveRepertoireProviderModule(root);
+  const mr = readMemoryRoutingConfig(root);
+  if (!modulePath) {
+    return "Repertoire: not installed (memory_routing stays off)";
+  }
+  let signalsPath = mr.config && mr.config.signalsPath;
+  if (signalsPath && !signalsPath.startsWith("/") && !/^[A-Za-z]:[\\/]/.test(signalsPath)) {
+    signalsPath = join(root, signalsPath);
+  }
+  if (!signalsPath) {
+    signalsPath = join(modulePath, "..", "..", "..", "data", "curated_signals.json");
+  }
+  const n = existsSync(signalsPath) ? countCuratedSignals(signalsPath) : null;
+  const count = n == null ? "" : ` — ${n} signals`;
+  if (isMemoryRoutingResolvedOn(mr, modulePath)) {
+    return `Repertoire: on${count}`;
+  }
+  return `Repertoire: present, memory_routing off${count}`;
+}
+
+function applyStationHeat(root, host, extra = {}, existing = {}) {
+  const prevHost = typeof existing.host === "string" ? existing.host : null;
+  const nextSwap = prevHost && host && prevHost !== host ? { from: prevHost, to: host } : null;
+  const keptSwap =
+    existing.hotSwap &&
+    typeof existing.hotSwap === "object" &&
+    existing.hotSwap.from &&
+    existing.hotSwap.to
+      ? existing.hotSwap
+      : null;
+  const hotSwap = nextSwap || keptSwap;
+  const intent =
+    clipIntent(extra.intent || extra.prompt || extra.userMessage || extra.user_prompt) ||
+    (typeof existing.intent === "string" ? existing.intent : null);
+  const git = readGitBrief(root);
+  const planLine = readPlanLine(root);
+  const repertoireResume =
+    typeof extra.repertoireResume === "string" ? extra.repertoireResume : buildRepertoireResume(root);
+  const swapBit = hotSwap ? `hot-swap ${hotSwap.from} → ${hotSwap.to}` : `host ${host}`;
+  const intentBit = intent ? `intent: ${intent}` : "intent: (none yet)";
+  const gitBit = git ? `git ${git.branch}@${git.head}` : "git: n/a";
+  const planBit = planLine ? `plan: ${planLine}` : "plan: (none)";
+  let matchedSignals = stationSafeSignals(extra.matchedSignals);
+  const priorWorking = readRepertoireWorking(root);
+  if (!matchedSignals.length && intent) {
+    if (
+      priorWorking &&
+      priorWorking.intent === intent &&
+      Array.isArray(priorWorking.matchedSignals) &&
+      priorWorking.matchedSignals.length
+    ) {
+      matchedSignals = stationSafeSignals(priorWorking.matchedSignals);
+    } else {
+      matchedSignals = stationSafeSignals(matchStationSignalsSync(root, intent));
+    }
+  }
+  if (!matchedSignals.length && priorWorking) {
+    matchedSignals = stationSafeSignals(priorWorking.matchedSignals);
+  }
+  const workingSnapshot = {
+    host,
+    intent,
+    git,
+    hotSwap,
+    hookEvent: extra.hookEvent || extra.source || null,
+    memoryRouting: repertoireResume.startsWith("Repertoire: on") ? "on" : "off",
+    repertoireResume,
+  };
+  if (matchedSignals.length) workingSnapshot.matchedSignals = matchedSignals;
+  const working = persistRepertoireWorking(root, workingSnapshot);
+  if (isCompactHook(extra) && matchedSignals.length) {
+    ingestCompactFeedbackSync(
+      root,
+      typeof extra.sessionId === "string" ? extra.sessionId : "station",
+      extra.hookEvent || extra.source || "post_compact",
+      matchedSignals,
+    );
+  }
+  const workingLine = formatWorkingLine(working);
+  const workingBit = workingLine ? workingLine : "working: (none)";
+  const stationLine = `${swapBit}. ${intentBit}. ${planBit}. ${gitBit}. ${repertoireResume}. ${workingBit}`;
+  return {
+    lastHost: prevHost,
+    hotSwap,
+    intent,
+    git,
+    planLine,
+    repertoireResume,
+    workingLine,
+    stationLine,
+  };
+}
+
+function formatStationMarkdown(fields) {
+  const host = fields.host || "unknown";
+  const profile = fields.suit_profile || "guided";
+  const lines = ["# Station", ""];
+  if (fields.hotSwap && fields.hotSwap.from && fields.hotSwap.to) {
+    lines.push(`Hot-swap: ${fields.hotSwap.from} → ${fields.hotSwap.to}`);
+  }
+  lines.push(`Host: ${host} (${profile})`);
+  lines.push(`Intent: ${fields.intent || "(none yet)"}`);
+  lines.push(`Plan: ${fields.planLine || "(none)"}`);
+  if (fields.git && fields.git.head) {
+    lines.push(`Git: ${fields.git.branch}@${fields.git.head}`);
+  } else {
+    lines.push("Git: n/a");
+  }
+  lines.push(fields.repertoireResume || "Repertoire: not installed (memory_routing stays off)");
+  if (fields.workingLine) {
+    lines.push(fields.workingLine);
+  }
+  lines.push("");
+  lines.push("Continue this card. Compaction and host change are the same cut. Do not cold-start.");
+  lines.push("Grok does not inject this file — Read it. OpenCode injects. Do not thicken the Grok exo.");
+  lines.push("");
+  return lines.join("\n");
+}
+
+function writeStationMarkdown(root, fields) {
+  try {
+    const dir = join(root, ".xray", "state");
+    mkdirSync(dir, { recursive: true });
+    const dest = stationMarkdownPath(root);
+    writeFileSync(dest, formatStationMarkdown(fields));
+    return dest;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  stationMarkdownPath,
+  sessionBootPath,
+  clipIntent,
+  readExistingBoot,
+  readGitBrief,
+  readGitSubject,
+  readPlanLine,
+  buildRepertoireResume,
+  isExplicitMemoryRoutingOptOut,
+  isLeftoverMemoryRoutingOff,
+  persistRepertoireWorking,
+  readRepertoireWorking,
+  formatWorkingLine,
+  applyStationHeat,
+  formatStationMarkdown,
+  writeStationMarkdown,
+};

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

@@ -0,0 +1,24 @@
+/**
+ * ESM face for station-hook-runtime.cjs — Grok hooks import this.
+ */
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const require = createRequire(import.meta.url);
+const impl = require(join(dirname(fileURLToPath(import.meta.url)), 'station-hook-runtime.cjs'));
+
+export const stationMarkdownPath = impl.stationMarkdownPath;
+export const sessionBootPath = impl.sessionBootPath;
+export const clipIntent = impl.clipIntent;
+export const readExistingBoot = impl.readExistingBoot;
+export const readGitBrief = impl.readGitBrief;
+export const readGitSubject = impl.readGitSubject;
+export const readPlanLine = impl.readPlanLine;
+export const buildRepertoireResume = impl.buildRepertoireResume;
+export const persistRepertoireWorking = impl.persistRepertoireWorking;
+export const readRepertoireWorking = impl.readRepertoireWorking;
+export const formatWorkingLine = impl.formatWorkingLine;
+export const applyStationHeat = impl.applyStationHeat;
+export const formatStationMarkdown = impl.formatStationMarkdown;
+export const writeStationMarkdown = impl.writeStationMarkdown;