0xray 4.0.40 → 4.0.41

package/dist/integrations/grok/hooks/session-start.js

@@ -9,6 +9,7 @@ import {
   clearPendingDelegationsForSessionChange,
   ensureSessionBoot,
   readStdinJson,
+  resolveGrokHookEvent,
   resolveSessionId,
   normalizeWorkspaceRoot,
   workspaceRoot,
@@ -25,25 +26,6 @@ import {
 import { maintainLens } from '../../hooks/goggles-pipeline.mjs';
 import { readSavedFreshness, refreshFreshness } from '../../../nucleus/work-freshness.mjs';
 
-function resolveHookEvent(event) {
-  if (process.env.GROK_HOOK_EVENT) return process.env.GROK_HOOK_EVENT;
-  const flag = process.argv.find((a) => a.startsWith('--hook-event='));
-  if (flag) return flag.slice('--hook-event='.length);
-  const named = event.hookEventName || event.hook;
-  if (named === 'PreCompact' || named === 'pre_compact') return 'pre_compact';
-  if (named === 'PostCompact' || named === 'post_compact') return 'post_compact';
-  if (
-    event.prompt != null ||
-    event.userMessage != null ||
-    event.user_prompt != null ||
-    named === 'UserPromptSubmit' ||
-    named === 'user_prompt_submit'
-  ) {
-    return 'user_prompt_submit';
-  }
-  return 'session_start';
-}
-
 function extractIntent(event) {
   return event.prompt || event.userMessage || event.user_prompt || event.compactContext || null;
 }
@@ -117,7 +99,7 @@ async function main() {
   let HOOK_EVENT = 'session_start';
   try {
     const event = await readStdinJson();
-    HOOK_EVENT = resolveHookEvent(event);
+    HOOK_EVENT = resolveGrokHookEvent(event);
     const eventRoot = normalizeWorkspaceRoot(event.workspaceRoot || event.cwd || root);
     const sessionId = resolveSessionId(event);
     if (HOOK_EVENT === 'user_prompt_submit' && sessionId) {

package/dist/integrations/hooks/goggles-mcp.mjs

@@ -2,8 +2,8 @@
  * Goggles MCP. Stdio. Server name `goggles`.
  * Tools: look, status_lens. Same organ as the CLI.
  */
-import { existsSync, readFileSync, realpathSync } from 'node:fs';
-import { basename, join, resolve } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -162,6 +162,29 @@ function publicCard(view) {
     if (view.exam) notes.push(view.exam);
   }
   const skills = view.skills ? basename(String(view.skills)) : '';
+  const cascade = view.cascade
+    ? {
+      plane: view.cascade.plane,
+      station: view.cascade.station,
+      notesPage: view.cascade.notesPage,
+      index: view.cascade.index,
+      laws: Array.isArray(view.cascade.laws) ? view.cascade.laws : [],
+      notes: Array.isArray(view.cascade.notes) ? view.cascade.notes : [],
+    }
+    : null;
+  const sleeve = view.sleeve
+    ? {
+      on: Boolean(view.sleeve.on),
+      missing: Array.isArray(view.sleeve.missing) ? view.sleeve.missing : [],
+      stitches: Array.isArray(view.sleeve.stitches)
+        ? view.sleeve.stitches.map((row) => ({
+          name: String(row && row.name || ''),
+          on: Boolean(row && row.on),
+          at: Array.isArray(row && row.at) ? row.at.map((item) => String(item)) : [],
+        }))
+        : [],
+    }
+    : null;
   if (view.narrow) {
     return {
       plane: view.plane,
@@ -169,6 +192,8 @@ function publicCard(view) {
       digest: view.digest || '',
       files: Array.isArray(view.files) ? view.files : [],
       notes,
+      ...(cascade ? { cascade } : {}),
+      ...(sleeve ? { sleeve } : {}),
     };
   }
   return {
@@ -185,6 +210,8 @@ function publicCard(view) {
     teardown: view.teardown || '',
     worn: view.worn || '',
     notes,
+    ...(cascade ? { cascade } : {}),
+    ...(sleeve ? { sleeve } : {}),
   };
 }
 
@@ -205,11 +232,16 @@ export async function answerLook(raw, root) {
     return { ok: true, quiet: false, mode: 'kind0', content: line };
   }
   const argv = argvFrom(args);
-  const text = api.look(argv).text;
+  const text = api.look(argv, here).text;
   if (text === 'Name one plane.') return deny('name_one', 'Name one plane.');
-  const cards = api.lookCards(argv);
+  const cards = api.lookCards(argv, here);
   if (Array.isArray(cards) && cards.length) {
     const shown = cards.map(publicCard);
+    if (shown.length === 1 && shown[0] && typeof shown[0].plane === 'string') {
+      const dest = join(here, '.xray', 'state', 'goggles-plane.json');
+      mkdirSync(dirname(dest), { recursive: true });
+      writeFileSync(dest, `${JSON.stringify({ plane: shown[0].plane })}\n`);
+    }
     return {
       ok: true,
       quiet: false,

package/dist/integrations/hooks/goggles-pipeline.mjs

@@ -18,7 +18,7 @@ import { fileURLToPath } from 'node:url';
 const FIELD_ORDER = ['plate', 'entry', 'exit', 'files', 'skills', 'setup', 'teardown', 'worn'];
 const HERE = dirname(fileURLToPath(import.meta.url));
 const WORN_PLANES = ['dichotomy', 'syncopate', 'synthesis', 'digest', 'triage', 'loop'];
-const CARD_PLANES = ['ground', 'routing', 'house', 'boot', 'governance', 'memory-recall', 'orchestration', 'processor', 'reporting', 'stamp-plate', 'record-map', 'write-home', 'activity-log', 'session-capture', 'suit-wear', 'suit-organs', 'station-card', 'notes-page', 'reflection-page', 'site-manual', 'package-face', 'suit-settings', 'trail-state', 'inference-files', 'grok-compact', 'payload-heat', 'station-heat', 'pickup-stamp', 'cursor-compact', 'work-fresh', 'kept-line', 'lens-gate', 'pre-tool', 'lens-page'];
+const CARD_PLANES = ['ground', 'routing', 'house', 'boot', 'governance', 'memory-recall', 'orchestration', 'processor', 'reporting', 'stamp-plate', 'record-map', 'write-home', 'activity-log', 'session-capture', 'suit-wear', 'suit-organs', 'station-card', 'notes-page', 'reflection-page', 'site-manual', 'package-face', 'suit-settings', 'trail-state', 'inference-files', 'grok-compact', 'payload-heat', 'station-heat', 'pickup-stamp', 'cursor-compact', 'work-fresh', 'kept-line', 'lens-gate', 'pre-tool', 'lens-page', 'centrifuge'];
 const CARD_FLAVORS = ['digest', 'triage'];
 const SCOPE_ZOOM = ['ecosystem', 'part', 'one flow', 'one artifact'];
 
@@ -211,7 +211,7 @@ function namesTheSet(lower) {
   return planes.length === 1 && planes[0] === 'loop' && findScopes(lower).length === 0;
 }
 
-function gogglesAnswer(argv) {
+function gogglesAnswer(argv, projectRoot) {
   const words = [];
   for (const raw of argv || []) {
     const arg = String(raw || '').trim();
@@ -234,14 +234,14 @@ function gogglesAnswer(argv) {
   if (flavors.length === 1) {
     const others = acceptedPlanes().filter((name) => name !== flavors[0] && lower.includes(name));
     if (others.length) return none('');
-    const cards = collectCards(flavors[0], lower);
+    const cards = collectCards(flavors[0], lower, projectRoot);
     if (!cards) return none('');
     return { text: cards.map((card) => formatCardText(card)).join('\n\n'), cards };
   }
   const planes = acceptedPlanes().filter((name) => lower.includes(name));
   if (planes.length !== 1) {
     if (!planes.length && cardPlanesNamed(lower).length) {
-      const cards = collectCards('digest', lower);
+      const cards = collectCards('digest', lower, projectRoot);
       if (cards && cards.length) {
         return { text: cards.map((card) => formatCardText(card)).join('\n\n'), cards };
       }
@@ -255,12 +255,12 @@ function gogglesAnswer(argv) {
   return none(file ? `${line} File: ${file}` : line);
 }
 
-export function readGoggles(argv) {
-  return ok(gogglesAnswer(argv).text);
+export function readGoggles(argv, projectRoot) {
+  return ok(gogglesAnswer(argv, projectRoot).text);
 }
 
-export function lookCards(argv) {
-  return gogglesAnswer(argv).cards;
+export function lookCards(argv, projectRoot) {
+  return gogglesAnswer(argv, projectRoot).cards;
 }
 
 function cardPlanesNamed(lower) {
@@ -271,7 +271,22 @@ function listedFiles(plane) {
   return Array.isArray(plane.files) ? plane.files.map(String) : [];
 }
 
-function cardView(plane, scope, flavor, root) {
+function cascadeApi() {
+  return createRequire(import.meta.url)('./wake-cascade.cjs');
+}
+
+function sleeveApi() {
+  return createRequire(import.meta.url)('./sleeve.cjs');
+}
+
+function appendLining(text, view) {
+  let next = text;
+  if (view.cascade) next = `${next}\n${cascadeApi().formatCascadeReading(view.cascade)}`;
+  if (view.sleeve) next = `${next}\n${sleeveApi().formatSleeveReading(view.sleeve)}`;
+  return next;
+}
+
+function cardView(plane, scope, flavor, root, cascadeRoot) {
   const listed = listedFiles(plane);
   const view = {
     plane: plane.id,
@@ -290,6 +305,20 @@ function cardView(plane, scope, flavor, root) {
     worn: plane.worn || '',
   };
   view.exam = examinePlane(plane, root).text;
+  if (cascadeApi().isCascadePlane(plane.id)) {
+    try {
+      view.cascade = cascadeApi().readWakeCascade(cascadeRoot || stateRoot());
+    } catch {
+      view.cascade = null;
+    }
+  }
+  if (sleeveApi().isSleevePlane(plane.id)) {
+    try {
+      view.sleeve = sleeveApi().readSleeve(cascadeRoot || stateRoot());
+    } catch {
+      view.sleeve = null;
+    }
+  }
   if (flavor === 'triage') {
     const filled = new Set(filledOf(plane));
     view.empty = FIELD_ORDER.filter((name) => !filled.has(name));
@@ -328,7 +357,7 @@ function formatCardText(view) {
   } else if (typeof view.exam === 'string' && view.exam.startsWith('Drift:')) {
     text = `${text}\n${view.exam}`;
   }
-  return text;
+  return appendLining(text, view);
 }
 
 export function formatCardPane(view) {
@@ -345,10 +374,11 @@ export function formatCardPane(view) {
   const top = `┌ ${title} ${'─'.repeat(Math.max(0, width - title.length - 1))}┐`;
   const mid = body.map((line) => `│ ${line.padEnd(width)} │`);
   const bot = `└${'─'.repeat(width + 2)}┘`;
-  return [top, ...mid, bot].join('\n');
+  const pane = [top, ...mid, bot].join('\n');
+  return appendLining(pane, view);
 }
 
-function collectCards(flavor, lower) {
+function collectCards(flavor, lower, projectRoot) {
   const named = cardPlanesNamed(lower);
   const scopes = findScopes(lower.filter((word) => word !== flavor && !named.includes(word)));
   if (scopes.length > 1) return null;
@@ -359,7 +389,7 @@ function collectCards(flavor, lower) {
   const cards = [];
   for (const id of ids) {
     const plane = growPlane(id, platesDir, stateRoot());
-    cards.push(cardView(plane, scope, flavor, root));
+    cards.push(cardView(plane, scope, flavor, root, projectRoot));
   }
   return cards;
 }
@@ -929,6 +959,15 @@ function lensPage(root, names) {
   return parts.join('\n\n');
 }
 
+
+export function holdPlane(root, id) {
+  const plane = String(id || "").trim();
+  if (!plane || plane.includes(" ")) return;
+  const dest = join(root, ".xray", "state", "goggles-plane.json");
+  mkdirSync(dirname(dest), { recursive: true });
+  writeFileSync(dest, `${JSON.stringify({ plane })}\n`);
+}
+
 function stampPlane(root, id) {
   try {
     const plates = createRequire(import.meta.url)('./plates.cjs');
@@ -953,6 +992,7 @@ export function lensBeforeResearch(root, toolName, text) {
   if (!research) return null;
   const names = CARD_PLANES.filter((name) => intentWords(spoken).includes(name));
   if (names.length === 1) {
+    holdPlane(root, names[0]);
     stampPlane(root, names[0]);
     rememberOpened(root, spoken);
     return null;
@@ -1095,8 +1135,8 @@ export function examinePlane(plane, root) {
 }
 
 
-export function look(argv) {
-  return readGoggles(argv);
+export function look(argv, projectRoot) {
+  return readGoggles(argv, projectRoot);
 }
 
 

package/dist/integrations/hooks/goggles-planes.json

@@ -68,7 +68,7 @@
     "plates": ["review"]
   },
   "record-map": {
-    "files": ["docs-site/docs/plates/record-map.md"],
+    "files": ["docs-site/docs/plates/record-map.md", "src/integrations/hooks/wake-cascade.cjs", "src/integrations/hooks/session-note-index.cjs"],
     "skills": ".agents/skills/record-map/SKILL.md",
     "plates": ["station-card", "notes-page", "reflection-page", "site-manual", "package-face", "write-home", "activity-log", "session-capture", "lens-page"]
   },
@@ -103,13 +103,13 @@
     "plates": ["activity-log", "session-capture", "inference-files", "trail-state"]
   },
   "station-card": {
-    "files": ["src/integrations/hooks/station-hook-runtime.cjs"],
+    "files": ["src/integrations/hooks/station-hook-runtime.cjs", "src/integrations/hooks/wake-cascade.cjs"],
     "mark": "formatStationMarkdown",
     "skills": ".agents/skills/station-card/SKILL.md",
     "plates": ["notes-page", "record-map", "kept-line"]
   },
   "notes-page": {
-    "files": ["src/integrations/hooks/station-hook-runtime.cjs"],
+    "files": ["src/integrations/hooks/station-hook-runtime.cjs", "src/integrations/hooks/session-note-index.cjs"],
     "mark": "stampNotesPickup",
     "skills": ".agents/skills/notes-page/SKILL.md",
     "plates": ["station-card", "record-map"]
@@ -210,6 +210,12 @@
     "mark": "export function formatCardPane",
     "skills": ".agents/skills/lens-page/SKILL.md",
     "plates": ["record-map", "lens-gate"]
+  },
+  "centrifuge": {
+    "files": ["src/integrations/hooks/station-hook-runtime.cjs"],
+    "mark": "function wakeOrder",
+    "skills": ".agents/skills/centrifuge/SKILL.md",
+    "plates": ["station-card", "goggles"]
   }
 }
 

package/dist/integrations/hooks/plates.cjs

@@ -46,6 +46,7 @@ const PLATE_IDS = Object.freeze([
   "lens-gate",
   "pre-tool",
   "lens-page",
+  "centrifuge",
 ]);
 
 /** Id token, then extra phrases. Equal top scores recall nothing. */
@@ -229,6 +230,11 @@ const CUES = {
     [/lens page/i, 6],
     [/plates\/lens-page/i, 6],
   ],
+  centrifuge: [
+    [/centrifuge plate/i, 6],
+    [/the centrifuge/i, 5],
+    [/plates\/centrifuge/i, 6],
+  ],
 };
 
 function platesDir() {
@@ -317,6 +323,21 @@ function stampPlateIfMissing(projectRoot, id) {
   return { id, path, written: true };
 }
 
+function ensureWornPlate(projectRoot, id) {
+  const path = wornPlatePath(projectRoot, id);
+  const source = readFileSync(plateSourcePath(id), "utf8");
+  if (existsSync(path)) {
+    try {
+      if (readFileSync(path, "utf8") === source) return { id, path, written: false };
+    } catch {
+      /* rewrite a plate the process cannot keep */
+    }
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, source);
+  return { id, path, written: true };
+}
+
 function organFile(intent) {
   try {
     const { suitHint } = require("./goggles-pipeline.mjs");
@@ -342,6 +363,7 @@ module.exports = {
   loadPlate,
   recallPlate,
   stampPlateIfMissing,
+  ensureWornPlate,
   plateStockLine,
   wornPlatePath,
 };

package/dist/integrations/hooks/session-note-index.cjs

@@ -0,0 +1,298 @@
+/**
+ * Session notes beside repertoire laws.
+ * Laws stay in curated_signals.json. This file is the index.
+ * Cleanup drops a lone note only after STALE_AFTER_MS without another sighting.
+ * A replaced note stays on disk and is left out of the short index.
+ * The short index is a view of current notes. It does not delete history.
+ */
+const { createHash } = require("crypto");
+const { existsSync, mkdirSync, readFileSync, writeFileSync } = require("fs");
+const { join } = require("path");
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const STALE_AFTER_MS = 90 * DAY_MS;
+const SHORT_INDEX_LIMIT = 12;
+const LINE_MAX = 240;
+
+function sessionNotesPath(root) {
+  return join(root, ".xray", "state", "repertoire", "session-notes.json");
+}
+
+function lawsPath(root) {
+  return join(root, ".xray", "state", "repertoire", "curated_signals.json");
+}
+
+function clipLine(raw) {
+  if (raw == null) return null;
+  const text = String(raw).replace(/\s+/g, " ").trim();
+  if (!text) return null;
+  if (text.length <= LINE_MAX) return text;
+  return `${text.slice(0, LINE_MAX - 1)}…`;
+}
+
+function noteId(text) {
+  return createHash("sha256").update(text).digest("hex").slice(0, 12);
+}
+
+function loadIndex(root) {
+  const dest = sessionNotesPath(root);
+  if (!existsSync(dest)) return { notes: [], corrupt: false };
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(dest, "utf8"));
+  } catch {
+    return { notes: [], corrupt: true };
+  }
+  if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.notes)) {
+    return { notes: [], corrupt: true };
+  }
+  const notes = [];
+  for (const row of parsed.notes) {
+    if (!row || typeof row.text !== "string" || !row.text.trim()) continue;
+    const text = clipLine(row.text);
+    if (!text) continue;
+    const added = typeof row.added === "string" ? row.added : "";
+    const lastSeen = typeof row.last_seen === "string" && row.last_seen ? row.last_seen : added;
+    if (!added || !lastSeen) continue;
+    const note = {
+      id: typeof row.id === "string" && row.id ? row.id : noteId(text),
+      text,
+      added,
+      last_seen: lastSeen,
+    };
+    if (typeof row.source === "string") note.source = row.source;
+    if (typeof row.slot === "string" && row.slot) note.slot = row.slot;
+    if (typeof row.superseded_by === "string" && row.superseded_by) note.superseded_by = row.superseded_by;
+    if (typeof row.superseded_at === "string" && row.superseded_at) note.superseded_at = row.superseded_at;
+    notes.push(note);
+  }
+  return { notes, corrupt: false };
+}
+
+function writeIndex(root, notes) {
+  const dest = sessionNotesPath(root);
+  try {
+    mkdirSync(join(root, ".xray", "state", "repertoire"), { recursive: true });
+    const body = notes.map((note) => {
+      const row = {
+        id: note.id,
+        text: note.text,
+        added: note.added,
+        last_seen: note.last_seen,
+      };
+      if (note.source) row.source = note.source;
+      if (note.slot) row.slot = note.slot;
+      if (note.superseded_by) row.superseded_by = note.superseded_by;
+      if (note.superseded_at) row.superseded_at = note.superseded_at;
+      return row;
+    });
+    writeFileSync(dest, `${JSON.stringify({ notes: body }, null, 2)}\n`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function nowStamp(opts) {
+  return typeof opts.now === "string" && opts.now ? opts.now : new Date().toISOString();
+}
+
+function isCurrent(note) {
+  return !note.superseded_by;
+}
+
+/** The new line becomes current. The previous holder of the same slot stays on disk. */
+function closeSlot(notes, slot, keeperId, now) {
+  if (!slot) return 0;
+  let closed = 0;
+  for (const note of notes) {
+    if (note.id === keeperId) continue;
+    if (note.slot !== slot) continue;
+    if (note.superseded_by) continue;
+    note.superseded_by = keeperId;
+    note.superseded_at = now;
+    closed += 1;
+  }
+  return closed;
+}
+
+function rememberSessionNote(root, text, opts = {}) {
+  const line = clipLine(text);
+  if (!line) return { kept: false };
+  const loaded = loadIndex(root);
+  if (loaded.corrupt) return { kept: false, corrupt: true };
+  const now = nowStamp(opts);
+  const source = typeof opts.source === "string" ? opts.source : undefined;
+  const slot = typeof opts.slot === "string" && opts.slot ? opts.slot : undefined;
+  const existing = loaded.notes.find((note) => note.text === line);
+  if (existing) {
+    existing.last_seen = now;
+    if (source) existing.source = source;
+    // A notes page can still show the old line. That sighting must not
+    // revive it or demote the line that replaced it.
+    if (slot && !existing.superseded_by) {
+      existing.slot = slot;
+      closeSlot(loaded.notes, slot, existing.id, now);
+    }
+    const wrote = writeIndex(root, loaded.notes);
+    return { kept: wrote, bumped: true, id: existing.id, corrupt: false };
+  }
+  const created = {
+    id: noteId(line),
+    text: line,
+    added: now,
+    last_seen: now,
+  };
+  if (source) created.source = source;
+  if (slot) created.slot = slot;
+  loaded.notes.push(created);
+  if (slot) closeSlot(loaded.notes, slot, created.id, now);
+  const wrote = writeIndex(root, loaded.notes);
+  return { kept: wrote, bumped: false, id: created.id, corrupt: false };
+}
+
+function supersedeSessionNote(root, previousText, nextText, opts = {}) {
+  const previousLine = clipLine(previousText);
+  const nextLine = clipLine(nextText);
+  if (!previousLine || !nextLine || previousLine === nextLine) return { kept: false };
+  const loaded = loadIndex(root);
+  if (loaded.corrupt) return { kept: false, corrupt: true };
+  const previous = loaded.notes.find((note) => note.text === previousLine || note.id === previousLine);
+  if (!previous) return { kept: false, missing: true };
+  const now = nowStamp(opts);
+  const source = typeof opts.source === "string" ? opts.source : previous.source;
+  let next = loaded.notes.find((note) => note.text === nextLine);
+  if (!next) {
+    next = {
+      id: noteId(nextLine),
+      text: nextLine,
+      added: now,
+      last_seen: now,
+    };
+    if (source) next.source = source;
+    if (previous.slot) next.slot = previous.slot;
+    loaded.notes.push(next);
+  } else {
+    next.last_seen = now;
+    delete next.superseded_by;
+    delete next.superseded_at;
+    if (previous.slot) next.slot = previous.slot;
+  }
+  if (next.id === previous.id) return { kept: false };
+  previous.superseded_by = next.id;
+  previous.superseded_at = now;
+  if (next.slot) closeSlot(loaded.notes, next.slot, next.id, now);
+  const wrote = writeIndex(root, loaded.notes);
+  return { kept: wrote, id: next.id, supersededId: previous.id, corrupt: false };
+}
+
+function sessionNoteHistory(root, textOrId) {
+  const loaded = loadIndex(root);
+  const key = clipLine(textOrId) || String(textOrId || "");
+  const start = loaded.notes.find((note) => note.text === key || note.id === textOrId);
+  if (!start) return [];
+  const seen = new Set([start.id]);
+  const older = [];
+  let cursor = start.id;
+  while (cursor && seen.size < loaded.notes.length + 1) {
+    const prev = loaded.notes.find((note) => note.superseded_by === cursor && !seen.has(note.id));
+    if (!prev) break;
+    seen.add(prev.id);
+    older.push(prev);
+    cursor = prev.id;
+  }
+  return older;
+}
+
+function shortSessionIndex(root, limit = SHORT_INDEX_LIMIT) {
+  const loaded = loadIndex(root);
+  const cap = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : SHORT_INDEX_LIMIT;
+  const ordered = loaded.notes.filter(isCurrent).sort((a, b) => {
+    if (a.last_seen === b.last_seen) return a.added < b.added ? 1 : -1;
+    return a.last_seen < b.last_seen ? 1 : -1;
+  });
+  return ordered.slice(0, cap);
+}
+
+function dropStaleSessionNotes(root, opts = {}) {
+  const loaded = loadIndex(root);
+  if (loaded.corrupt) return { kept: 0, dropped: 0, corrupt: true };
+  const nowMs = typeof opts.now === "string" ? Date.parse(opts.now) : Date.now();
+  const windowMs = Number.isFinite(opts.staleAfterMs) ? opts.staleAfterMs : STALE_AFTER_MS;
+  if (!Number.isFinite(nowMs)) return { kept: loaded.notes.length, dropped: 0, corrupt: false };
+  const protectedIds = new Set();
+  for (const note of loaded.notes) {
+    if (!note.superseded_by) continue;
+    protectedIds.add(note.id);
+    protectedIds.add(note.superseded_by);
+  }
+  const kept = [];
+  let dropped = 0;
+  for (const note of loaded.notes) {
+    const seen = Date.parse(note.last_seen);
+    const stale = Number.isFinite(seen) && nowMs - seen > windowMs;
+    if (stale && !protectedIds.has(note.id)) {
+      dropped += 1;
+      continue;
+    }
+    kept.push(note);
+  }
+  if (dropped > 0) writeIndex(root, kept);
+  return { kept: kept.length, dropped, corrupt: false };
+}
+
+function linesFromNotes(text) {
+  const lines = [];
+  for (const raw of String(text || "").split("\n")) {
+    const trimmed = raw.trim();
+    if (!trimmed) continue;
+    if (/^#{1,6}\s/.test(trimmed)) continue;
+    const pickup = trimmed.match(/^\*\*Pickup line:\*\*\s*(.*)$/);
+    if (pickup) {
+      if (pickup[1].trim()) lines.push({ text: pickup[1].trim(), slot: "pickup" });
+      continue;
+    }
+    const bullet = trimmed.replace(/^[-*]\s+/, "");
+    if (bullet) lines.push({ text: bullet });
+  }
+  return lines;
+}
+
+function retainProjectNotes(root, opts = {}) {
+  const dest = join(root, ".xray", "state", "NOTES.md");
+  let remembered = 0;
+  if (existsSync(dest)) {
+    let text = "";
+    try {
+      text = readFileSync(dest, "utf8");
+    } catch {
+      text = "";
+    }
+    for (const line of linesFromNotes(text)) {
+      const saved = rememberSessionNote(root, line.text, {
+        ...opts,
+        source: opts.source || "NOTES.md",
+        slot: line.slot,
+      });
+      if (saved.corrupt) return { remembered, dropped: 0, kept: 0, corrupt: true };
+      if (saved.kept) remembered += 1;
+    }
+  }
+  const cleaned = dropStaleSessionNotes(root, opts);
+  return { remembered, ...cleaned };
+}
+
+module.exports = {
+  DAY_MS,
+  STALE_AFTER_MS,
+  SHORT_INDEX_LIMIT,
+  LINE_MAX,
+  sessionNotesPath,
+  lawsPath,
+  rememberSessionNote,
+  supersedeSessionNote,
+  sessionNoteHistory,
+  shortSessionIndex,
+  dropStaleSessionNotes,
+  retainProjectNotes,
+};

package/dist/integrations/hooks/session-note-index.mjs

@@ -0,0 +1,22 @@
+/**
+ * ESM face for session-note-index.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)), "session-note-index.cjs"));
+
+export const DAY_MS = impl.DAY_MS;
+export const STALE_AFTER_MS = impl.STALE_AFTER_MS;
+export const SHORT_INDEX_LIMIT = impl.SHORT_INDEX_LIMIT;
+export const LINE_MAX = impl.LINE_MAX;
+export const sessionNotesPath = impl.sessionNotesPath;
+export const lawsPath = impl.lawsPath;
+export const rememberSessionNote = impl.rememberSessionNote;
+export const supersedeSessionNote = impl.supersedeSessionNote;
+export const sessionNoteHistory = impl.sessionNoteHistory;
+export const shortSessionIndex = impl.shortSessionIndex;
+export const dropStaleSessionNotes = impl.dropStaleSessionNotes;
+export const retainProjectNotes = impl.retainProjectNotes;