0xray 4.0.40 → 4.0.41

package/dist/integrations/hooks/sleeve.cjs

@@ -0,0 +1,335 @@
+/**
+ * Sleeve: on means the previous ticket came back, the worn plate already
+ * matched the package, that ticket already matched the working record,
+ * and inspect has passed for the skills on disk.
+ * Session start and compact run the mill. A later prompt reads the report.
+ */
+const { execFileSync } = require("child_process");
+const { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } = require("fs");
+const { dirname, join } = require("path");
+
+const STITCHES = ["loop", "domain", "state", "foundry"];
+const SLEEVE_PLANES = [
+  "record-map",
+  "station-card",
+  "notes-page",
+  "memory-recall",
+  "suit-wear",
+  "suit-organs",
+  "suit-settings",
+  "trail-state",
+];
+const FOUNDRY_FILES = ["cli.mjs", "mill-root.mjs", "inspect.mjs", "reconcile-version.mjs"];
+
+function isSleevePlane(id) {
+  return SLEEVE_PLANES.includes(String(id || ""));
+}
+
+function stitch(name, on, at) {
+  return {
+    name,
+    on: Boolean(on),
+    at: Array.isArray(at) ? at.filter((item) => typeof item === "string" && item) : [],
+  };
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function stationText(root) {
+  const file = join(root, ".xray", "state", "STATION.md");
+  if (!existsSync(file)) return "";
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function fieldValue(text, label) {
+  const line = String(text || "").split(/\r?\n/).find((row) => row.startsWith(`${label}: `));
+  return line ? line.slice(label.length + 2).trim() : "";
+}
+
+function ticketIntent(root) {
+  return fieldValue(stationText(root), "Intent");
+}
+
+function ticketHost(root) {
+  const line = fieldValue(stationText(root), "Host");
+  return line.split(/\s+/)[0] || "";
+}
+
+function workingFile(root) {
+  return readJson(join(root, ".xray", "state", "repertoire-working.json"));
+}
+
+function oneLine(value) {
+  return String(value || "").replace(/\s+/g, " ").trim().slice(0, 80);
+}
+
+function loopStitch(root) {
+  const card = ticketIntent(root);
+  const working = workingFile(root);
+  const prior = working && typeof working.priorIntent === "string" ? working.priorIntent : "";
+  const kept = working && typeof working.intent === "string" ? working.intent : "";
+  const returned = Boolean(prior && kept && card && prior === kept && card === kept);
+  return stitch("loop", returned, returned ? [oneLine(kept)] : []);
+}
+
+function plateBody(raw) {
+  return String(raw || "").replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "").trim();
+}
+
+function domainStitch(root) {
+  const intent = ticketIntent(root);
+  if (!intent) return stitch("domain", false, []);
+  let plates = null;
+  try {
+    plates = require("./plates.cjs");
+  } catch {
+    return stitch("domain", false, []);
+  }
+  let plate = null;
+  try {
+    plate = plates.recallPlate(intent);
+  } catch {
+    plate = null;
+  }
+  if (!plate || !plate.id || !plate.body) return stitch("domain", false, []);
+  const worn = join(root, ".xray", "state", "plates", `${plate.id}.md`);
+  if (!existsSync(worn)) return stitch("domain", false, []);
+  let raw = "";
+  try {
+    raw = readFileSync(worn, "utf8");
+  } catch {
+    return stitch("domain", false, []);
+  }
+  if (plateBody(raw) !== plate.body) return stitch("domain", false, []);
+  return stitch("domain", true, [plate.id]);
+}
+
+function stateStitch(root) {
+  const card = ticketIntent(root);
+  const host = ticketHost(root);
+  const working = workingFile(root);
+  const priorCard = working && typeof working.priorIntent === "string" ? working.priorIntent : "";
+  const priorHost = working && typeof working.priorHost === "string" ? working.priorHost : "";
+  const priorKept = working && typeof working.priorWorkingIntent === "string" ? working.priorWorkingIntent : "";
+  const priorHeld = working && typeof working.priorWorkingHost === "string" ? working.priorWorkingHost : "";
+  const agreed = Boolean(
+    priorCard && priorHost && priorKept && priorHeld
+    && priorCard === priorKept
+    && priorHost === priorHeld
+    && card === priorCard
+    && host === priorHost,
+  );
+  return stitch("state", agreed, agreed ? [".xray/state/STATION.md"] : []);
+}
+
+function foundryDir(root) {
+  const candidates = [
+    join(root, "scripts", "foundry"),
+    join(root, "node_modules", "0xray", "scripts", "foundry"),
+  ];
+  for (const dir of candidates) {
+    if (FOUNDRY_FILES.every((name) => existsSync(join(dir, name)))) return dir;
+  }
+  return "";
+}
+
+function millPath(root) {
+  return join(root, ".xray", "state", "sleeve-mill.json");
+}
+
+function packageVersion(dir) {
+  let current = dir;
+  for (let depth = 0; depth < 6; depth += 1) {
+    const pkg = readJson(join(current, "package.json"));
+    if (pkg && typeof pkg.version === "string" && pkg.version) return pkg.version;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return "";
+}
+
+function gitHead(root) {
+  try {
+    return execFileSync("git", ["rev-parse", "--short", "HEAD"], {
+      cwd: root,
+      encoding: "utf8",
+      timeout: 2000,
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+
+function wornSkillFingerprint(root) {
+  const homes = [
+    ".opencode/skills",
+    ".grok/plugins/0xray/skills",
+    ".hermes/plugins/xray-hermes/skills",
+    ".openclaw/skills",
+  ];
+  const names = [];
+  for (const rel of homes) {
+    const dir = join(root, rel);
+    if (!existsSync(dir)) continue;
+    let entries = [];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (!existsSync(join(dir, entry.name, "SKILL.md"))) continue;
+      names.push(`${rel}/${entry.name}`);
+    }
+  }
+  names.sort();
+  return names.join(",");
+}
+
+function millStamp(root, dir) {
+  return `${packageVersion(dir)}|${gitHead(root)}|${wornSkillFingerprint(root)}`;
+}
+
+function runInspect(root, cli) {
+  let out = "";
+  try {
+    out = execFileSync(process.execPath, [cli, "inspect", "--skip-live"], {
+      cwd: root,
+      env: {
+        ...process.env,
+        FOUNDRY_ROOT: root,
+      },
+      encoding: "utf8",
+      timeout: 20000,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  } catch (err) {
+    if (err && (err.killed || err.signal === "SIGTERM")) {
+      return stitch("foundry", false, ["inspect-timeout"]);
+    }
+    out = err && err.stdout ? String(err.stdout) : "";
+  }
+  try {
+    return inspectStitch(JSON.parse(out));
+  } catch {
+    return stitch("foundry", false, ["inspect"]);
+  }
+}
+
+function inspectStitch(report) {
+  if (report && report.ok === true) return stitch("foundry", true, ["inspect --skip-live"]);
+  const failed = report && Array.isArray(report.failed) ? report.failed.map(String) : [];
+  const blocking = failed.filter((id) => id !== "machinePlugin");
+  if (failed.length > 0 && blocking.length === 0) {
+    return stitch("foundry", true, ["inspect --skip-live"]);
+  }
+  if (!blocking.length) return stitch("foundry", false, ["inspect"]);
+  return stitch("foundry", false, blocking);
+}
+
+function writeMill(root, result, stamp) {
+  const dest = millPath(root);
+  mkdirSync(dirname(dest), { recursive: true });
+  writeFileSync(dest, `${JSON.stringify({
+    ok: result.on,
+    failed: result.on ? [] : result.at,
+    stamp,
+    ranAt: new Date().toISOString(),
+  })}\n`);
+}
+
+function runFoundryMill(root) {
+  const dir = foundryDir(root);
+  if (!dir) {
+    const missing = stitch("foundry", false, []);
+    writeMill(root, missing, "");
+    return missing;
+  }
+  const stamp = millStamp(root, dir);
+  const result = runInspect(root, join(dir, "cli.mjs"));
+  writeMill(root, result, stamp);
+  return result;
+}
+
+function foundryStitch(root) {
+  const saved = readJson(millPath(root));
+  if (!saved || typeof saved !== "object") return stitch("foundry", false, []);
+  const dir = foundryDir(root);
+  const stamp = dir ? millStamp(root, dir) : "";
+  if (!stamp || saved.stamp !== stamp) return stitch("foundry", false, saved.stamp ? ["stale"] : []);
+  if (saved.ok === true) return stitch("foundry", true, ["inspect --skip-live"]);
+  const failed = Array.isArray(saved.failed) ? saved.failed.map(String) : [];
+  // The wear leaves ~/.grok/plugins/0xray in place and scrubs it. That check is not the mill.
+  const blocking = failed.filter((id) => id !== "machinePlugin");
+  if (failed.length > 0 && blocking.length === 0) {
+    return stitch("foundry", true, ["inspect --skip-live"]);
+  }
+  return stitch("foundry", false, blocking.length ? blocking : failed);
+}
+
+function readSleeve(root) {
+  const stitches = [
+    loopStitch(root),
+    domainStitch(root),
+    stateStitch(root),
+    foundryStitch(root),
+  ];
+  const missing = stitches.filter((row) => !row.on).map((row) => row.name);
+  return { on: missing.length === 0, missing, stitches };
+}
+
+function rowsOf(sleeve) {
+  const listed = sleeve && Array.isArray(sleeve.stitches) ? sleeve.stitches : [];
+  return STITCHES.map((name) => {
+    const found = listed.find((row) => row && row.name === name);
+    return found ? stitch(name, found.on, found.at) : stitch(name, false, []);
+  });
+}
+
+function formatSleevePointer(sleeve) {
+  if (sleeve && sleeve.on) return "Sleeve: on";
+  const missing = sleeve && Array.isArray(sleeve.missing) && sleeve.missing.length
+    ? STITCHES.filter((name) => sleeve.missing.includes(name))
+    : rowsOf(sleeve).filter((row) => !row.on).map((row) => row.name);
+  const names = missing.length ? missing : STITCHES.slice();
+  return `Sleeve: off ${names.join(", ")}`;
+}
+
+function stitchText(row) {
+  if (row.at.length) return row.at.join(", ");
+  return row.on ? "on" : "off";
+}
+
+function labelOf(name) {
+  return name ? name.charAt(0).toUpperCase() + name.slice(1) : "";
+}
+
+function formatSleeveReading(sleeve) {
+  const lines = [formatSleevePointer(sleeve)];
+  for (const row of rowsOf(sleeve)) lines.push(`${labelOf(row.name)}: ${stitchText(row)}`);
+  return lines.join("\n");
+}
+
+module.exports = {
+  STITCHES,
+  SLEEVE_PLANES,
+  isSleevePlane,
+  readSleeve,
+  runFoundryMill,
+  inspectStitch,
+  formatSleevePointer,
+  formatSleeveReading,
+};

package/dist/integrations/hooks/sleeve.mjs

@@ -0,0 +1,18 @@
+/**
+ * ESM face for sleeve.cjs.
+ */
+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)), "sleeve.cjs"));
+
+export const STITCHES = impl.STITCHES;
+export const SLEEVE_PLANES = impl.SLEEVE_PLANES;
+export const isSleevePlane = impl.isSleevePlane;
+export const readSleeve = impl.readSleeve;
+export const runFoundryMill = impl.runFoundryMill;
+export const inspectStitch = impl.inspectStitch;
+export const formatSleevePointer = impl.formatSleevePointer;
+export const formatSleeveReading = impl.formatSleeveReading;

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

@@ -20,7 +20,10 @@ const {
 const { join, resolve } = require("path");
 
 const HOOKS_DIR = __dirname;
-const { plateStockLine, recallPlate, stampPlateIfMissing } = require("./plates.cjs");
+const { ensureWornPlate, plateStockLine, recallPlate } = require("./plates.cjs");
+const { rememberSessionNote, retainProjectNotes } = require("./session-note-index.cjs");
+const { formatCascadePointer, readWakeCascade } = require("./wake-cascade.cjs");
+const { formatSleevePointer, readSleeve, runFoundryMill } = require("./sleeve.cjs");
 
 const INTENT_MAX = 240;
 
@@ -111,6 +114,12 @@ function isStockTicket(value) {
   return !text || text === "(none)" || text === "(none yet)";
 }
 
+function readStationHostToken(root) {
+  const md = readExistingStationMarkdown(root);
+  const match = md.match(/^Host:\s*(\S+)/m);
+  return match ? match[1] : "";
+}
+
 function readStationTicketField(root, field) {
   const md = readExistingStationMarkdown(root);
   const re = field === "Plan" ? /^Plan:\s*(.*)$/im : /^Intent:\s*(.*)$/im;
@@ -136,9 +145,20 @@ function resolveHeatIntent(root, extra, existing) {
   const pickup = clipIntent(readNotesPickup(root));
   const bootIntent = typeof existing.intent === "string" ? clipIntent(existing.intent) : null;
   const cardIsBootEcho = Boolean(card && bootIntent && card === bootIntent);
-  const hook = String(extra.hookEvent || extra.source || "");
-  const keepsTicket = /user_prompt|compact/i.test(hook);
-  const compact = /compact/i.test(hook);
+  const named = String(extra.hookEvent || "");
+  const channel = String(extra.hookEvent || extra.source || "");
+  const keepsTicket = /user_prompt|compact/i.test(channel);
+  const compact = /compact/i.test(channel);
+  let receipt = null;
+  try {
+    receipt = readSleeve(root);
+  } catch {
+    receipt = null;
+  }
+  // A proved receipt keeps the ticket. A new session must not restate it.
+  if (receipt && receipt.on && card && /^(session_start|session-start)$/i.test(named)) {
+    return { intent: card, rematch: false, kept: true };
+  }
   // A chat sentence or a compact summary does not replace a ticket already on disk.
   if (incoming && !(keepsTicket && (card || pickup))) {
     return { intent: incoming, rematch: true };
@@ -520,6 +540,7 @@ function stampNotesPickup(root, line) {
     : body
       ? `${marker}\n\n${body.replace(/^\n+/, "")}`
       : `${marker}\n`;
+  rememberSessionNote(root, text, { source: "NOTES.md", slot: "pickup" });
   if (next === body) return text;
   mkdirSync(join(root, ".xray", "state"), { recursive: true });
   writeFileSync(dest, next.endsWith("\n") ? next : `${next}\n`);
@@ -973,6 +994,7 @@ function buildRepertoireResume(root) {
 }
 
 function applyStationHeat(root, host, extra = {}, existing = {}) {
+  retainProjectNotes(root);
   const mr = readMemoryRoutingConfig(root);
   const memoryOff = isExplicitMemoryRoutingOptOut(mr);
   const promptHook = isPromptHook(extra);
@@ -1005,6 +1027,8 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
       ? existing.hotSwap
       : null;
   const hotSwap = nextSwap || keptSwap;
+  const priorIntent = readStationTicketField(root, "Intent");
+  const priorHost = readStationHostToken(root);
   const resolved = resolveHeatIntent(root, extra, existing);
   const intent = resolved.intent;
   const rematch = resolved.rematch;
@@ -1018,7 +1042,10 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
   }
   const matchText = clipIntent([intent, pickup, approaches].filter(Boolean).join(" "));
   const git = readGitBrief(root);
-  const planLine = resolveHeatPlan(root, extra, existing);
+  let planLine = resolveHeatPlan(root, extra, existing);
+  if (priorIntent && intent && intent !== priorIntent && !(extra.plan || extra.planLine)) {
+    planLine = null;
+  }
   // A passed string is the previous card. Count the project file after this wake.
   const repertoireResume = buildRepertoireResume(root);
   const swapBit = hotSwap ? `hot-swap ${hotSwap.from} → ${hotSwap.to}` : `host ${host}`;
@@ -1056,11 +1083,20 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
   if (!matchedSignals.length && priorWorking) {
     matchedSignals = stationSafeSignals(priorWorking.matchedSignals);
   }
+  if (resolved.kept) {
+    matchedSignals = preferLawHits(priorWorking && priorWorking.matchedSignals, 8);
+  }
   const compactHold = retainCompactFields(existing, extra);
   const nextHook = compactHold.hookEvent || extra.hookEvent || extra.source || null;
   const workingSnapshot = {
     host,
     intent,
+    priorIntent: priorIntent || null,
+    priorHost: priorHost || null,
+    priorWorkingIntent: priorWorking && typeof priorWorking.intent === "string" ? priorWorking.intent : null,
+    priorWorkingHost: priorWorking && typeof priorWorking.host === "string"
+      ? (priorWorking.host.split(/\s+/)[0] || null)
+      : null,
     git,
     hotSwap,
     memoryRouting: repertoireResume.startsWith("Repertoire: on") ? "on" : "off",
@@ -1074,6 +1110,13 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
   const growReceipt = workingGrowSnapshot(grow);
   if (growReceipt) workingSnapshot.grow = growReceipt;
   if (matchedSignals.length) workingSnapshot.matchedSignals = matchedSignals.slice(0, 8);
+  const cascade = readWakeCascade(root, { laws: matchedSignals });
+  workingSnapshot.cascade = {
+    plane: cascade.plane,
+    laws: cascade.laws,
+    notes: cascade.notes.length,
+  };
+  const cascadeLine = formatCascadePointer(cascade);
   const opProcNames = readOpProcNames(root);
   if (opProcNames.length) workingSnapshot.opProcNames = opProcNames;
   const pickupChanged = Boolean(pickup && (!priorWorking || priorWorking.pickup !== pickup));
@@ -1106,8 +1149,10 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
     repertoireResume,
     workingLine,
     stationLine,
+    cascadeLine,
     ...(notesLine ? { notesLine } : {}),
     ...compactHold,
+    arrivedHook: extra && extra.hookEvent ? String(extra.hookEvent) : "",
   };
 }
 
@@ -1122,7 +1167,12 @@ const STOCK_STATION_PREFIXES = [
   "working:",
   "plate:",
   "library:",
+  "cascade:",
+  "sleeve:",
   "notes:",
+  "plane:",
+  "judgement:",
+  "payments:",
 ];
 
 /** Stock design map. Exact lines so a later heat does not preserve a second copy. */
@@ -1318,6 +1368,11 @@ function formatStationMarkdown(fields) {
   const plateLine = plateStockLine(fields.intent);
   if (plateLine) lines.push(plateLine);
   lines.push("Library: record-map — .agents/skills/record-map/SKILL.md");
+  if (fields.cascadeLine) lines.push(fields.cascadeLine);
+  if (fields.sleeveLine) lines.push(fields.sleeveLine);
+  lines.push(`Plane: ${fields.plane || "(none)"}`);
+  lines.push(`Judgement: ${fields.judgement || "start"}`);
+  lines.push(`Payments: ${fields.payments === "on" ? "on" : "off"}`);
   if (fields.notesLine) lines.push(fields.notesLine);
   lines.push("");
   lines.push(...DESIGN_MAP_LINES);
@@ -1338,19 +1393,160 @@ function readExistingStationMarkdown(root) {
   }
 }
 
+
+
+function ticketIsPayment(intent) {
+  return /\b(pay|payment|payments|x402|invoice)\b/i.test(String(intent || ""));
+}
+
+function readHeldPlane(root) {
+  try {
+    const data = JSON.parse(readFileSync(join(root, ".xray", "state", "goggles-plane.json"), "utf8"));
+    return data && typeof data.plane === "string" ? data.plane : "";
+  } catch {
+    return "";
+  }
+}
+
+function missKey(proved) {
+  const missing = proved && Array.isArray(proved.missing) ? proved.missing.slice() : [];
+  const rows = proved && Array.isArray(proved.stitches) ? proved.stitches : [];
+  const at = {};
+  for (const row of rows) {
+    if (!row || !missing.includes(row.name)) continue;
+    at[row.name] = Array.isArray(row.at) ? row.at.slice() : [];
+  }
+  return JSON.stringify({ missing, at });
+}
+
+function judgementLine(order, saved, proved) {
+  const wake = order && order.wake ? order.wake : "start";
+  if (wake === "repair") {
+    const prior = saved && Number.isFinite(saved.retries) ? saved.retries : 0;
+    const key = missKey(proved);
+    if (saved && saved.missKey === key && prior > 0) return `retry ${prior}`;
+    const next = prior + 1;
+    if (saved) {
+      saved.retries = next;
+      saved.missKey = key;
+    }
+    return `retry ${next}`;
+  }
+  if (saved) {
+    saved.retries = 0;
+    delete saved.missKey;
+  }
+  if (wake === "continue" || wake === "stop" || wake === "start") return wake;
+  return "start";
+}
+
+function isMissPlan(line) {
+  return typeof line === "string" && line.startsWith("The work is ");
+}
+
+function missWork(missing) {
+  const words = { loop: "the ticket", domain: "the plate", state: "the record", foundry: "the mill" };
+  const parts = (Array.isArray(missing) ? missing : []).map((name) => words[name]).filter(Boolean);
+  if (parts.length === 1) return `The work is ${parts[0]}.`;
+  if (parts.length > 1) {
+    const last = parts[parts.length - 1];
+    return `The work is ${parts.slice(0, -1).join(", ")} and ${last}.`;
+  }
+  return "The work is the suit.";
+}
+
+function wakeOrder(saved, proved, fields) {
+  const missing = proved && Array.isArray(proved.missing) ? proved.missing : [];
+  const sameJob = Boolean(saved && saved.priorIntent && saved.intent === saved.priorIntent);
+  const suitMiss = missing.some((name) => name === "domain" || name === "foundry" || name === "state");
+  if (proved && proved.on) {
+    const paused = saved && typeof saved.pausedPlan === "string" ? saved.pausedPlan : "";
+    if (isMissPlan(fields && fields.planLine) && saved && Object.prototype.hasOwnProperty.call(saved, "pausedPlan")) {
+      return { wake: "continue", planLine: paused, pausedPlan: undefined };
+    }
+    return { wake: "continue", pausedPlan: undefined };
+  }
+  if (!saved || !saved.priorIntent) return { wake: "start" };
+  if (saved.intent && saved.priorIntent && saved.intent !== saved.priorIntent) {
+    return { wake: "stop", pausedPlan: undefined };
+  }
+  if (sameJob && !missing.includes("loop") && suitMiss) {
+    const current = fields && fields.planLine ? String(fields.planLine) : "";
+    const paused = isMissPlan(current)
+      ? (typeof saved.pausedPlan === "string" ? saved.pausedPlan : "")
+      : current;
+    return { wake: "repair", planLine: missWork(missing), pausedPlan: paused };
+  }
+  return { wake: "start" };
+}
+
 function writeStationMarkdown(root, fields) {
   try {
     const dir = join(root, ".xray", "state");
     mkdirSync(dir, { recursive: true });
+    const arrivedKnown = Boolean(fields && Object.prototype.hasOwnProperty.call(fields, "arrivedHook"));
+    const wake = arrivedKnown
+      ? String(fields.arrivedHook || "")
+      : String((fields && fields.hookEvent) || "");
+    if (/^(session_start|session-start|pre_compact|post_compact)$/i.test(wake)) {
+      try {
+        runFoundryMill(root);
+      } catch {
+        /* the card still writes when the mill does not */
+      }
+    }
+    const dest = stationMarkdownPath(root);
+    const base = { ...(fields || {}) };
+    delete base.sleeveLine;
+    writeFileSync(dest, mergeStationMarkdown(formatStationMarkdown(base), readExistingStationMarkdown(root)));
+    // Solar phase is not this judgement. The moral overlay cannot pass alone.
+    fields.plane = readHeldPlane(root);
+    fields.payments = ticketIsPayment(fields.intent) ? "on" : "off";
+    let sleeveLine = "Sleeve: off loop, domain, state, foundry";
+    try {
+      const proved = readSleeve(root);
+      sleeveLine = formatSleevePointer(proved);
+      const workingPath = join(root, ".xray", "state", "repertoire-working.json");
+      if (existsSync(workingPath)) {
+        const saved = JSON.parse(readFileSync(workingPath, "utf8"));
+        if (saved && typeof saved === "object") {
+          const order = wakeOrder(saved, proved, fields);
+          fields.wake = order.wake;
+          if (Object.prototype.hasOwnProperty.call(order, "planLine")) {
+            fields.planLine = order.planLine;
+          }
+          fields.judgement = judgementLine(order, saved, proved);
+          saved.wake = order.wake;
+          saved.retries = saved.retries || 0;
+          saved.judgement = fields.judgement;
+          saved.plane = fields.plane;
+          saved.payments = fields.payments;
+          if (order.pausedPlan !== undefined) saved.pausedPlan = order.pausedPlan;
+          else delete saved.pausedPlan;
+          saved.sleeve = {
+            on: proved.on,
+            missing: proved.missing,
+            stitches: proved.stitches,
+          };
+          writeFileSync(workingPath, `${JSON.stringify(saved)}\n`);
+        }
+      }
+    } catch {
+      /* the card still writes; the sleeve stays off */
+    }
+    writeFileSync(
+      dest,
+      mergeStationMarkdown(
+        formatStationMarkdown({ ...(fields || {}), sleeveLine }),
+        readExistingStationMarkdown(root),
+      ),
+    );
     try {
       const plate = recallPlate(fields && fields.intent);
-      if (plate) stampPlateIfMissing(root, plate.id);
+      if (plate) ensureWornPlate(root, plate.id);
     } catch {
       /* a missing plate doc must not block the card */
     }
-    const dest = stationMarkdownPath(root);
-    const next = mergeStationMarkdown(formatStationMarkdown(fields), readExistingStationMarkdown(root));
-    writeFileSync(dest, next);
     return dest;
   } catch {
     return null;