0xray 4.0.12 → 4.0.13

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

@@ -1,211 +0,0 @@
-#!/usr/bin/env node
-/**
- * Pipeline facet hooks — reflection, routing outcomes, reporting, inference-improvement.
- * Loaded by Grok session-start / post-tool-use (rewire only, no new MCP surface).
- */
-import { createRequire } from 'node:module';
-import { execSync, spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-function resolvePackageRoot() {
-  let dir = __dirname;
-  for (let i = 0; i < 10; i++) {
-    const pkg = join(dir, 'package.json');
-    if (existsSync(pkg)) {
-      try {
-        const require = createRequire(join(dir, 'package.json'));
-        if (require('./package.json').name === '0xray') return dir;
-      } catch {
-        /* continue */
-      }
-    }
-    const nm = join(dir, 'node_modules', '0xray', 'package.json');
-    if (existsSync(nm)) return dirname(nm);
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return resolve(__dirname, '../../..');
-}
-
-function loadFeatures(projectRoot) {
-  const path = join(projectRoot, '.xray', 'features.json');
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(readFileSync(path, 'utf8'));
-  } catch {
-    return {};
-  }
-}
-
-function appendActivity(projectRoot, action, level, data = {}) {
-  const logDir = join(projectRoot, 'logs', 'framework');
-  mkdirSync(logDir, { recursive: true });
-  const line = JSON.stringify({
-    timestamp: new Date().toISOString(),
-    component: 'pipeline-hook',
-    action,
-    level,
-    data,
-  });
-  appendFileSync(join(logDir, 'activity.log'), `${line}\n`);
-}
-
-function gitCommitCount(projectRoot) {
-  try {
-    const out = execSync('git rev-list --count HEAD', { cwd: projectRoot, encoding: 'utf8' }).trim();
-    const n = parseInt(out, 10);
-    return Number.isFinite(n) ? n : 0;
-  } catch {
-    return 0;
-  }
-}
-
-/** P1.1 — reflection stub when synthesis.reflection triggers fire */
-export function maybeRunReflectionStub(projectRoot) {
-  const features = loadFeatures(projectRoot);
-  const reflection = features.synthesis?.reflection;
-  if (!reflection || reflection.mode === 'off') return null;
-
-  const threshold = reflection.thresholds?.[reflection.mode ?? 'minimal'];
-  const commitTrigger = reflection.triggers?.commit_threshold;
-  const commits = gitCommitCount(projectRoot);
-  const commitLimit = commitTrigger?.threshold ?? threshold?.commit_threshold ?? 25;
-
-  if (!commitTrigger?.enabled && !threshold?.auto_generate) return null;
-  if (commits > 0 && commits % commitLimit !== 0) return null;
-
-  const pkgRoot = resolvePackageRoot();
-  const generator = join(pkgRoot, 'scripts', 'node', 'auto-reflection-generator.mjs');
-  if (!existsSync(generator)) return null;
-
-  const result = spawnSync(
-    process.execPath,
-    [generator, '--trigger', 'commit-threshold', '--title', `Pipeline checkpoint (${commits} commits)`],
-    { cwd: projectRoot, encoding: 'utf8', timeout: 15000 },
-  );
-
-  appendActivity(projectRoot, 'reflection-stub', result.status === 0 ? 'success' : 'warning', {
-    commits,
-    exitCode: result.status,
-    stdout: (result.stdout || '').slice(0, 200),
-  });
-
-  return { triggered: true, commits, exitCode: result.status };
-}
-
-/** P1.2 — record routing outcome after orchestrate / Task spawn */
-export function recordRoutingOutcome(projectRoot, entry) {
-  const logDir = join(projectRoot, 'logs', 'framework');
-  mkdirSync(logDir, { recursive: true });
-  const path = join(logDir, 'routing-outcomes.json');
-  let outcomes = [];
-  if (existsSync(path)) {
-    try {
-      outcomes = JSON.parse(readFileSync(path, 'utf8'));
-      if (!Array.isArray(outcomes)) outcomes = [];
-    } catch {
-      outcomes = [];
-    }
-  }
-  outcomes.push({
-    timestamp: new Date().toISOString(),
-    tool: entry.tool ?? 'unknown',
-    agent: entry.agent ?? entry.subagent ?? null,
-    planTodoId: entry.planTodoId ?? null,
-    success: entry.success ?? true,
-    sessionId: entry.sessionId ?? null,
-  });
-  if (outcomes.length > 500) outcomes = outcomes.slice(-500);
-  writeFileSync(path, `${JSON.stringify(outcomes, null, 2)}\n`);
-  appendActivity(projectRoot, 'routing-outcome', 'info', {
-    tool: entry.tool,
-    agent: entry.agent ?? entry.subagent,
-    count: outcomes.length,
-  });
-  return outcomes.length;
-}
-
-/** P1.3 — mark autonomous reporting scheduled (framework reporter wired at boot in TS path) */
-export function scheduleAutonomousReportingMarker(projectRoot) {
-  const features = loadFeatures(projectRoot);
-  const reporting = features.autonomous_reporting;
-  if (!reporting?.enabled || !reporting?.auto_schedule) return null;
-
-  const reportsDir = join(projectRoot, 'reports');
-  mkdirSync(reportsDir, { recursive: true });
-  const marker = join(reportsDir, '.autonomous-reporting-scheduled.json');
-  writeFileSync(
-    marker,
-    `${JSON.stringify({
-      scheduledAt: new Date().toISOString(),
-      intervalMinutes: reporting.interval_minutes ?? 60,
-    }, null, 2)}\n`,
-  );
-  appendActivity(projectRoot, 'autonomous-report-scheduled', 'info', {
-    intervalMinutes: reporting.interval_minutes ?? 60,
-  });
-  return marker;
-}
-
-/** P1.7 — lightweight inference-improvement workflow stub */
-export function runInferenceImprovementLight(projectRoot) {
-  const features = loadFeatures(projectRoot);
-  if (features.inference_governance?.enabled === false) return null;
-
-  const infDir = join(projectRoot, '.xray', 'inference');
-  mkdirSync(infDir, { recursive: true });
-  const workflowPath = join(infDir, `workflow-${Date.now()}.json`);
-  const payload = {
-    timestamp: new Date().toISOString(),
-    phase: 'pending',
-    triggered: true,
-    mode: 'light',
-    dataLocations: {
-      reflections: 'docs/reflections',
-      logs: 'logs/framework',
-      reports: 'reports',
-    },
-  };
-  writeFileSync(workflowPath, `${JSON.stringify(payload, null, 2)}\n`);
-  appendActivity(projectRoot, 'inference-improvement-light', 'info', { workflowPath });
-  return workflowPath;
-}
-
-/** P2.2 — opt-in lightweight postprocessor on write tools (features.grok_postprocessor_light) */
-export function runGrokPostprocessorLight(projectRoot, entry = {}) {
-  const features = loadFeatures(projectRoot);
-  if (features.grok_postprocessor_light !== true) return null;
-
-  const infDir = join(projectRoot, '.xray', 'inference');
-  mkdirSync(infDir, { recursive: true });
-  const markerPath = join(infDir, 'postprocessor-light-latest.json');
-  const payload = {
-    timestamp: new Date().toISOString(),
-    phase: 'post-process-light',
-    tool: entry.tool ?? 'unknown',
-    paths: entry.paths ?? [],
-    mode: 'grok-post-tool-light',
-  };
-  writeFileSync(markerPath, `${JSON.stringify(payload, null, 2)}\n`);
-  appendActivity(projectRoot, 'postprocessor-light', 'info', {
-    tool: entry.tool,
-    pathCount: (entry.paths ?? []).length,
-  });
-  return markerPath;
-}
-
-/** P3.3 — pipeline facet snapshot for suit audit */
-export function writePipelineFacetSnapshot(projectRoot, counts) {
-  const outPath = join(projectRoot, 'docs', 'PIPELINE-FACET-SNAPSHOT.json');
-  mkdirSync(dirname(outPath), { recursive: true });
-  writeFileSync(
-    outPath,
-    `${JSON.stringify({ generatedAt: new Date().toISOString(), ...counts }, null, 2)}\n`,
-  );
-  return outPath;
-}

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

@@ -1,68 +0,0 @@
-#!/usr/bin/env node
-/**
- * Load lead-dev plan persistence from consumer or package dist.
- * Used by Grok/Hermes session-start for stale plan archival.
- */
-import { createRequire } from 'node:module';
-import { existsSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-function resolvePackageRoot() {
-  let dir = __dirname;
-  for (let i = 0; i < 10; i++) {
-    const pkg = join(dir, 'package.json');
-    if (existsSync(pkg)) {
-      try {
-        const require = createRequire(join(dir, 'package.json'));
-        const name = require('./package.json').name;
-        if (name === '0xray') return dir;
-      } catch {
-        /* continue */
-      }
-    }
-    const nm = join(dir, 'node_modules', '0xray', 'package.json');
-    if (existsSync(nm)) {
-      return dirname(nm);
-    }
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return resolve(__dirname, '../../..');
-}
-
-function loadPlanPersistence() {
-  const root = resolvePackageRoot();
-  const candidates = [
-    join(__dirname, '../../nucleus/lead-dev-plan-persistence.js'),
-    join(root, 'dist/nucleus/lead-dev-plan-persistence.js'),
-    join(process.cwd(), 'node_modules/0xray/dist/nucleus/lead-dev-plan-persistence.js'),
-  ];
-  const found = candidates.find((p) => existsSync(p));
-  if (!found) {
-    throw new Error(
-      'lead-dev-plan-persistence.js missing — run npm run build in 0xray',
-    );
-  }
-  return createRequire(import.meta.url)(found);
-}
-
-let persistence;
-
-function getPersistence() {
-  if (!persistence) {
-    persistence = loadPlanPersistence();
-  }
-  return persistence;
-}
-
-export function archiveStaleLeadDevPlan(projectRoot) {
-  return getPersistence().archiveStaleLeadDevPlan(projectRoot);
-}
-
-export function isLeadDevPlanStale(plan, projectRoot) {
-  return getPersistence().isLeadDevPlanStale(plan, projectRoot);
-}

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

@@ -1,421 +0,0 @@
-/**
- * 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,
-};