0xray 4.0.23 → 4.0.25

package/dist/integrations/cursor/hooks/pre-compact.js

@@ -22,6 +22,74 @@ import {
   writeCursorUsageReceipt,
 } from './cursor-usage-receipt.js';
 
+async function loadPlates() {
+  const { existsSync } = await import('node:fs');
+  const { dirname, join } = await import('node:path');
+  const { fileURLToPath, pathToFileURL } = await import('node:url');
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(here, '../../hooks/plates.cjs'),
+    join(here, '../../../integrations/hooks/plates.cjs'),
+  ];
+  const found = candidates.find((candidate) => existsSync(candidate));
+  if (!found) return null;
+  const loaded = await import(pathToFileURL(found).href);
+  if (typeof loaded.recallPlate === 'function') return loaded;
+  if (loaded.default && typeof loaded.default.recallPlate === 'function') return loaded.default;
+  return null;
+}
+
+async function memoryRoutingModule() {
+  const { existsSync } = await import('node:fs');
+  const { dirname, join } = await import('node:path');
+  const { fileURLToPath, pathToFileURL } = await import('node:url');
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(here, '../../../memory-routing/index.js'),
+    join(here, '../../../../dist/memory-routing/index.js'),
+  ];
+  const found = candidates.find((candidate) => existsSync(candidate));
+  if (!found) throw new Error('memory-routing module missing');
+  return pathToFileURL(found).href;
+}
+
+async function lessonSpeechForIntent(root, intent) {
+  if (!intent) return [];
+  try {
+    const { readFileSync, existsSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const { loadMemoryRoutingProvider } = await import(await memoryRoutingModule());
+    let routing = { enabled: false, provider: 'null' };
+    const featuresPath = join(root, '.xray', 'features.json');
+    if (existsSync(featuresPath)) {
+      try {
+        routing = JSON.parse(readFileSync(featuresPath, 'utf8')).memory_routing || routing;
+      } catch {
+        /* leftover default */
+      }
+    }
+    const provider = await loadMemoryRoutingProvider(routing, root);
+    if (!provider || provider.id === 'null' || typeof provider.buildRoutingContext !== 'function') {
+      return [];
+    }
+    const context = provider.buildRoutingContext(String(intent));
+    const matched = new Set(Array.isArray(context.matchedSignals) ? context.matchedSignals : []);
+    const lines = [];
+    for (const lesson of context.lessons || []) {
+      if (!matched.has(lesson.name)) continue;
+      for (const line of lesson.lines || []) {
+        const text = String(line.text || '').trim().slice(0, 400);
+        if (text.length === 0) continue;
+        lines.push(`${lesson.name}: ${text}`);
+        if (lines.length >= 4) return lines;
+      }
+    }
+    return lines;
+  } catch {
+    return [];
+  }
+}
+
 function extractIntent(event) {
   return (
     event.prompt ||
@@ -47,6 +115,13 @@ async function main() {
     let receiptPath = null;
     let usagePath = null;
     let stationLine = null;
+    let plates = null;
+    let plateBody = '';
+    try {
+      plates = await loadPlates();
+    } catch {
+      plates = null;
+    }
     for (const root of cursorHeatRoots(event)) {
       const payload = buildSessionBootPayload(root, '0xray/cursor-compact', {
         host: 'cursor',
@@ -77,6 +152,17 @@ async function main() {
         sessionId,
         usage: hostUsageFromPreCompactEvent(event),
       });
+      if (plates) {
+        try {
+          const named = plates.recallPlate(payload.intent || intent || '');
+          if (named) {
+            plates.stampPlateIfMissing(root, named.id);
+            if (!plateBody) plateBody = `\n\n${String(named.body || '').trim()}`;
+          }
+        } catch {
+          /* plate stamp is observational */
+        }
+      }
     }
     appendHookActivity(eventRoot, 'cursor-pre-compact', 'station-written', 'success', {
       bootPath,
@@ -85,10 +171,12 @@ async function main() {
       event_class: eventClass,
       stationLine,
     });
+    const lessonLines = await lessonSpeechForIntent(eventRoot, intent);
+    const lessonNote = lessonLines.length > 0 ? ` Lessons: ${lessonLines.join(' | ')}` : '';
     console.log(
       JSON.stringify({
         user_message:
-          `0xRay Station written. Read .xray/state/STATION.md — do not cold-start. event_class=${eventClass}`,
+          `0xRay Station written. Read .xray/state/STATION.md — do not cold-start. event_class=${eventClass}${lessonNote}${plateBody}`,
       }),
     );
     process.exit(0);

package/dist/integrations/hooks/plates.cjs

@@ -0,0 +1,165 @@
+/**
+ * Runtime plate reader. One implementation.
+ * src/memory-routing/plates.ts is the typed API and delegates here so
+ * Station (CJS) and the Cursor preCompact hook (plain node) cannot drift.
+ */
+const { existsSync, mkdirSync, readFileSync, writeFileSync } = require("fs");
+const { dirname, join } = require("path");
+
+const PLATE_IDS = Object.freeze([
+  "routing",
+  "governance",
+  "boot",
+  "orchestration",
+  "processor",
+  "reporting",
+  "memory-recall",
+]);
+
+/** Id token, then extra phrases. Equal top scores recall nothing. */
+const CUES = {
+  routing: [
+    [/\brouting\b/i, 5],
+    [/thindispatch/i, 4],
+    [/task-skill-router|taskskillrouter/i, 4],
+    [/scoreandroute/i, 3],
+    [/\broute(?:s|d)?\b/i, 3],
+  ],
+  governance: [
+    [/\bgovernance\b/i, 5],
+    [/rule-enforcer|ruleenforcer/i, 4],
+    [/dynamo solar/i, 3],
+  ],
+  boot: [
+    [/\bboot\b/i, 5],
+    [/boot-orchestrator|bootorchestrator/i, 4],
+    [/executebootsequence/i, 4],
+  ],
+  orchestration: [
+    [/\borchestrat\w*/i, 5],
+    [/aside-?context/i, 4],
+    [/spawnaside|spawn aside/i, 3],
+    [/analyze-complexity/i, 2],
+    [/govern-and-apply/i, 2],
+  ],
+  processor: [
+    [/\bprocessors?\b/i, 5],
+    [/pre[\s-]+processors?/i, 6],
+    [/post[\s-]+processors?/i, 4],
+    [/executepreprocessors|execute-pre-processors/i, 6],
+    [/processor-?manager/i, 4],
+  ],
+  reporting: [
+    [/\breporting\b/i, 5],
+    [/framework-reporting|framework report/i, 4],
+    [/activity report/i, 4],
+    [/\breports?\b/i, 2],
+  ],
+  "memory-recall": [
+    [/\bmemory-recall\b/i, 5],
+    [/memory\s+recall/i, 5],
+    [/recall(?:s|ed|ing)?\s+(?:a\s+|one\s+|the\s+)?plate/i, 5],
+    [/stamp(?:ed|ing)?\s+plates?/i, 4],
+  ],
+};
+
+function platesDir() {
+  let dir = __dirname;
+  for (let depth = 0; depth < 8; depth += 1) {
+    const candidate = join(dir, "docs-site", "docs", "plates");
+    if (existsSync(join(candidate, "index.md"))) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+function assertPlateId(id) {
+  if (!PLATE_IDS.includes(id)) {
+    throw new Error(`unknown plate: ${id}`);
+  }
+}
+
+function plateSourcePath(id) {
+  assertPlateId(id);
+  const dir = platesDir();
+  if (!dir) throw new Error("plate docs missing");
+  const sourcePath = join(dir, `${id}.md`);
+  if (!existsSync(sourcePath)) throw new Error(`plate file missing: ${id}`);
+  return sourcePath;
+}
+
+function stripFrontmatter(markdown) {
+  return String(markdown).replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "").trim();
+}
+
+function loadPlate(id) {
+  const sourcePath = plateSourcePath(id);
+  const raw = readFileSync(sourcePath, "utf8");
+  return {
+    id,
+    body: stripFrontmatter(raw),
+    sourcePath,
+  };
+}
+
+function scorePlate(id, text) {
+  const cues = CUES[id] || [];
+  let score = 0;
+  for (const [pattern, weight] of cues) {
+    if (pattern.test(text)) score += weight;
+  }
+  return score;
+}
+
+function recallPlate(intent) {
+  const text = String(intent || "").trim();
+  if (!text || !platesDir()) return null;
+  let bestId = null;
+  let best = 0;
+  let second = 0;
+  for (const id of PLATE_IDS) {
+    const score = scorePlate(id, text);
+    if (score > best) {
+      second = best;
+      best = score;
+      bestId = id;
+    } else if (score > second) {
+      second = score;
+    }
+  }
+  if (!bestId || best === 0 || best === second) return null;
+  return loadPlate(bestId);
+}
+
+function wornPlatePath(projectRoot, id) {
+  assertPlateId(id);
+  return join(projectRoot, ".xray", "state", "plates", `${id}.md`);
+}
+
+function stampPlateIfMissing(projectRoot, id) {
+  const path = wornPlatePath(projectRoot, id);
+  if (existsSync(path)) {
+    return { id, path, written: false };
+  }
+  const sourcePath = plateSourcePath(id);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, readFileSync(sourcePath, "utf8"));
+  return { id, path, written: true };
+}
+
+function plateStockLine(intent) {
+  const plate = recallPlate(intent);
+  if (!plate) return null;
+  return `Plate: ${plate.id} — .xray/state/plates/${plate.id}.md`;
+}
+
+module.exports = {
+  PLATE_IDS,
+  loadPlate,
+  recallPlate,
+  stampPlateIfMissing,
+  plateStockLine,
+  wornPlatePath,
+};

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

@@ -20,6 +20,7 @@ const {
 const { join } = require("path");
 
 const HOOKS_DIR = __dirname;
+const { plateStockLine } = require("./plates.cjs");
 
 const INTENT_MAX = 240;
 
@@ -673,7 +674,11 @@ function heatLiveMemory(root) {
   }
 }
 
-/** Every floor that heats. Dedup per HEAD. Patterns come from git, not a leftover catalog. */
+/**
+ * Station note on HEAD move. Dedup per HEAD.
+ * Commit subjects are match text for the card, not a graded lesson.
+ * Do not mint session-<date>-<short HEAD> under docs/inference.
+ */
 function maybeCaptureSessionOnHeadMove(root) {
   const cfg = readSessionCaptureConfig(root);
   if (!cfg.enabled) return null;
@@ -690,34 +695,28 @@ function maybeCaptureSessionOnHeadMove(root) {
     ? gitCommitSubjects(root, [`${stamp.head}..HEAD`])
     : gitCommitSubjects(root, ["-n", String(cfg.lookback)]);
   if (commits.length < cfg.minCommits) return null;
-  const sessionId = `session-${new Date().toISOString().slice(0, 10)}-${git.head}`;
   const approaches = commits.map((row) => row.message).filter(Boolean);
   const span = {
     from: stamp && stamp.head ? stamp.head : commits[commits.length - 1] ? commits[commits.length - 1].hash : git.head,
     to: git.head,
   };
   const patterns = patternsFromGit(root, commits, span);
-  const session = {
-    sessionId,
+  const stationNote = {
     timestamp: new Date().toISOString(),
     span,
-    problems: [],
     approaches,
-    wrongTurns: [],
-    solutions: [],
     patterns,
     matched_primitives: preferLawHits(patterns.map((row) => row && row.name)),
     metrics: { commits: commits.length },
   };
   const outDir = join(root, "docs", "inference");
   mkdirSync(outDir, { recursive: true });
-  const filePath = join(outDir, `session-${sessionId.replace(/^session-/, "")}.json`);
-  writeFileSync(filePath, `${JSON.stringify(session, null, 2)}\n`);
-  writeFileSync(join(outDir, "latest-session.json"), `${JSON.stringify(session, null, 2)}\n`);
+  const filePath = join(outDir, "latest-session.json");
+  writeFileSync(filePath, `${JSON.stringify(stationNote, null, 2)}\n`);
   mkdirSync(join(root, ".xray", "state"), { recursive: true });
   writeFileSync(
     sessionCaptureStampPath(root),
-    `${JSON.stringify({ head: git.head, sessionId, path: filePath, updatedAt: session.timestamp }, null, 2)}\n`,
+    `${JSON.stringify({ head: git.head, path: filePath, updatedAt: stationNote.timestamp }, null, 2)}\n`,
   );
   return filePath;
 }
@@ -1045,6 +1044,20 @@ const STOCK_STATION_PREFIXES = [
   "git:",
   "repertoire:",
   "working:",
+  "plate:",
+];
+
+/** Stock design map. Exact lines so a later heat does not preserve a second copy. */
+const DESIGN_MAP_LINES = [
+  "Subsystem map:",
+  "+----------------------+------------------------------------------+",
+  "| Subsystem            | After compact                            |",
+  "+----------------------+------------------------------------------+",
+  "| Inference            | proposals, reflection, Repertoire        |",
+  "| External Governance  | Dynamo vote, Codex                       |",
+  "| Autonomous Engine    | thinDispatch, AsideContext               |",
+  "| Lessons              | hot lines on the signal; this card       |",
+  "+----------------------+------------------------------------------+",
 ];
 
 const STOCK_STATION_FOOTERS = [
@@ -1099,6 +1112,7 @@ function isStockStationLine(line) {
   const trimmed = String(line || "").trim();
   if (!trimmed) return true;
   if (/^#\s+station\s*$/i.test(trimmed)) return true;
+  if (DESIGN_MAP_LINES.includes(trimmed)) return true;
   const lower = trimmed.toLowerCase();
   if (STOCK_STATION_FOOTERS.includes(lower)) return true;
   return STOCK_STATION_PREFIXES.some((prefix) => lower.startsWith(prefix));
@@ -1171,6 +1185,10 @@ function formatStationMarkdown(fields) {
   if (fields.workingLine) {
     lines.push(fields.workingLine);
   }
+  const plateLine = plateStockLine(fields.intent);
+  if (plateLine) lines.push(plateLine);
+  lines.push("");
+  lines.push(...DESIGN_MAP_LINES);
   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.");

package/dist/integrations/hooks/station-memory-ingest.mjs

@@ -3,10 +3,24 @@
  * Station organ write — compact ingest + wake grow.
  * Grow uses the worn RepertoireService. Groover field stays off.
  */
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 
+/** Tail cap for diary files the kernel list does not open. Heat only. */
+const UNREAD_DIARY_CAP = 80_000;
+
+/**
+ * Suit logs with a writer and no brain reader.
+ * Graded sessions and the five kernel-diary files stay on their existing readers.
+ * latest-session.json stays a station note, not a corpus session.
+ */
+const UNREAD_DIARY_FILES = [
+  ['logs', 'framework', 'activity-report.json'],
+  ['logs', 'framework', 'plugin-tool-events.log'],
+  ['.xray', 'inference', 'postprocessor-light-latest.json'],
+];
+
 const root = process.argv[2];
 const mode = process.argv[3] || 'station';
 
@@ -95,6 +109,50 @@ function readCleanupDiary(projectRoot) {
   return { text: parts.join('\n'), sources };
 }
 
+function pushMatching(dir, pattern, into) {
+  if (!existsSync(dir)) return;
+  let names = [];
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return;
+  }
+  const matched = names.filter((name) => pattern.test(name)).sort().reverse();
+  for (const name of matched) into.push(join(dir, name));
+}
+
+/**
+ * Diary, activity, and workflow files the kernel candidate list does not open.
+ * Text is heat for last_seen. It is not a lesson and not a graded session.
+ */
+export function collectUnreadSuitDiary(projectRoot) {
+  const files = UNREAD_DIARY_FILES.map((parts) => join(projectRoot, ...parts));
+  pushMatching(join(projectRoot, '.xray', 'inference'), /^workflow-\d+\.json$/, files);
+  pushMatching(join(projectRoot, 'logs', 'monitoring'), /^memory-monitor-.+\.log$/, files);
+  pushMatching(join(projectRoot, '.opencode', 'logs'), /^xray-plugin-.+\.log$/, files);
+  const sources = [];
+  const chunks = [];
+  let used = 0;
+  for (const file of files) {
+    const resolved = resolve(file);
+    if (!existsSync(resolved) || sources.includes(resolved)) continue;
+    let raw = '';
+    try {
+      raw = readFileSync(resolved, 'utf8');
+    } catch {
+      continue;
+    }
+    if (!raw.trim()) continue;
+    const remain = UNREAD_DIARY_CAP - used;
+    if (remain <= 0) break;
+    const slice = raw.length > remain ? raw.slice(-remain) : raw;
+    chunks.push(slice);
+    sources.push(resolved);
+    used += slice.length;
+  }
+  return { text: chunks.join('\n'), sources };
+}
+
 async function growDest(projectRoot) {
   const routing = readRouting(projectRoot);
   if (isExplicitOptOut(routing)) {
@@ -123,9 +181,10 @@ async function growDest(projectRoot) {
           ? pathsMod.collectKernelDiaryText(projectRoot)
           : { text: '', sources: [] };
       const cleanup = readCleanupDiary(projectRoot);
+      const unread = collectUnreadSuitDiary(projectRoot);
       const diary = service.heatKernelDiary({
-        text: [kernel.text, cleanup.text].filter(Boolean).join('\n'),
-        sources: [...(kernel.sources || []), ...cleanup.sources],
+        text: [kernel.text, cleanup.text, unread.text].filter(Boolean).join('\n'),
+        sources: [...(kernel.sources || []), ...cleanup.sources, ...unread.sources],
       });
       const after = service.signalsManager.load().signals.length;
       const heatedNames = Array.isArray(diary.heated) ? diary.heated : [];
@@ -147,49 +206,57 @@ async function growDest(projectRoot) {
   process.stdout.write(`${JSON.stringify({ skipped: 'no-organ' })}\n`);
 }
 
-if (!root) {
-  process.exit(0);
+function invokedAsScript() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  return import.meta.url === pathToFileURL(entry).href;
 }
 
-if (mode === '--grow') {
-  await growDest(root);
-  process.exit(0);
-}
+if (invokedAsScript()) {
+  if (!root) {
+    process.exit(0);
+  }
 
-const sessionId = mode;
-const hookEvent = process.argv[4] || 'post_compact';
-let signals = [];
-try {
-  signals = JSON.parse(process.argv[5] || '[]');
-} catch {
-  signals = [];
-}
-if (!Array.isArray(signals) || signals.length === 0) {
-  process.exit(0);
-}
+  if (mode === '--grow') {
+    await growDest(root);
+    process.exit(0);
+  }
 
-let routing = { enabled: false, provider: 'null' };
-const featuresPath = join(root, '.xray', 'features.json');
-if (existsSync(featuresPath)) {
+  const sessionId = mode;
+  const hookEvent = process.argv[4] || 'post_compact';
+  let signals = [];
   try {
-    routing = JSON.parse(readFileSync(featuresPath, 'utf8')).memory_routing || routing;
+    signals = JSON.parse(process.argv[5] || '[]');
   } catch {
-    /* leftover */
+    signals = [];
+  }
+  if (!Array.isArray(signals) || signals.length === 0) {
+    process.exit(0);
   }
-}
 
-const { loadMemoryRoutingProvider } = await import('../../memory-routing/index.js');
-const provider = await loadMemoryRoutingProvider(routing, root);
-if (!provider || typeof provider.ingestFeedback !== 'function') process.exit(0);
-
-provider.ingestFeedback({
-  timestamp: new Date().toISOString(),
-  sessionId,
-  taskId: `station-${hookEvent}`,
-  assignedAgent: 'station',
-  memorySignals: signals,
-  complexity: 0,
-  success: true,
-  durationMs: 0,
-});
-process.exit(0);
+  let routing = { enabled: false, provider: 'null' };
+  const featuresPath = join(root, '.xray', 'features.json');
+  if (existsSync(featuresPath)) {
+    try {
+      routing = JSON.parse(readFileSync(featuresPath, 'utf8')).memory_routing || routing;
+    } catch {
+      /* leftover */
+    }
+  }
+
+  const { loadMemoryRoutingProvider } = await import('../../memory-routing/index.js');
+  const provider = await loadMemoryRoutingProvider(routing, root);
+  if (!provider || typeof provider.ingestFeedback !== 'function') process.exit(0);
+
+  provider.ingestFeedback({
+    timestamp: new Date().toISOString(),
+    sessionId,
+    taskId: `station-${hookEvent}`,
+    assignedAgent: 'station',
+    memorySignals: signals,
+    complexity: 0,
+    success: true,
+    durationMs: 0,
+  });
+  process.exit(0);
+}

package/dist/integrations/openclaw/plugin/xray-pre-tool/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xray-pre-tool",
-  "version": "4.0.23",
+  "version": "4.0.25",
   "private": true,
   "type": "module",
   "description": "0xRay constitution + temperament PreToolUse for OpenClaw",

package/dist/mcps/researcher-confidence.d.ts

@@ -1,10 +1,14 @@
-import type { MemoryRoutingContext, MemoryTaskConfidence } from '../memory-routing/types.js';
+import { type MemoryRoutingContext, type MemorySignalLessons, type MemoryTaskConfidence } from '../memory-routing/types.js';
 export interface ResearcherMemoryContext {
     providerId: string;
     confidence: MemoryTaskConfidence;
     matchedSignals: string[];
     recommendedAgent: string | null;
     triggeredBy: 'trap-language' | 'high-confidence-primitives';
+    /** Graded lines for signals this task already matched. */
+    lessons?: MemorySignalLessons[];
+    /** Proposal text used to recall at most one pipeline plate. */
+    proposalText?: string;
 }
 export declare function shouldQueryRepertoireConfidence(description: string, proposalType?: string): boolean;
 export declare function hasHighConfidencePrimitiveMatch(routingContext: MemoryRoutingContext, minConfidence?: number): boolean;

package/dist/mcps/researcher-confidence.js

@@ -1,5 +1,7 @@
 import { frameworkLogger } from '../core/framework-logger.js';
 import { getMemoryRoutingProvider } from '../memory-routing/index.js';
+import { recallPlate } from '../memory-routing/plates.js';
+import { LESSON_TEXT_CAP, } from '../memory-routing/types.js';
 const TRAP_LANGUAGE = /TYPE:\s*ontological-trap|ontological[- ]trap/i;
 const DEFAULT_MIN_CONFIDENCE_GATE = 0.55;
 export function shouldQueryRepertoireConfidence(description, proposalType = '') {
@@ -40,12 +42,15 @@ export async function resolveResearcherMemoryContext(input) {
     const matchedSignals = confidence.matchedSignals.length > 0
         ? confidence.matchedSignals
         : routingContext.matchedSignals;
+    const lessons = lessonsForMatchedSignals(routingContext.lessons, matchedSignals);
     const context = {
         providerId: provider.id,
         confidence,
         matchedSignals,
         recommendedAgent: confidence.recommendedAgent,
         triggeredBy: trapLanguageDetected ? 'trap-language' : 'high-confidence-primitives',
+        proposalText: taskText,
+        ...(lessons.length > 0 ? { lessons } : {}),
     };
     if (confidence.highConfidenceTrapPresent) {
         frameworkLogger.log('mcps/researcher', 'repertoire-trap-detected', 'info', {
@@ -73,6 +78,10 @@ export function buildMemoryRoutingEvidence(context) {
     if (recommendedAgent) {
         lines.push(`Recommended agent for trap handling: ${recommendedAgent}`);
     }
+    for (const line of lessonSpeechLines(context.lessons, matchedSignals)) {
+        lines.push(`Lesson: ${line}`);
+    }
+    appendRecalledPlate(lines, context.proposalText);
     return lines;
 }
 export function formatMemoryRoutingBlock(context) {
@@ -88,5 +97,33 @@ export function formatMemoryRoutingBlock(context) {
     if (recommendedAgent) {
         lines.push(`  recommendedAgent: ${recommendedAgent}`);
     }
+    for (const line of lessonSpeechLines(context.lessons, matchedSignals)) {
+        lines.push(`  lesson: ${line}`);
+    }
+    appendRecalledPlate(lines, context.proposalText);
     return lines.join('\n');
 }
+function appendRecalledPlate(lines, proposalText) {
+    const plate = recallPlate(proposalText);
+    if (!plate)
+        return;
+    lines.push(`Plate: ${plate.id}`);
+    lines.push(plate.body);
+}
+function lessonsForMatchedSignals(lessons, matchedSignals) {
+    const matched = new Set(matchedSignals);
+    return (lessons ?? []).filter((lesson) => matched.has(lesson.name));
+}
+/** Stored lesson text for signals this task matched. Empty text is omitted. */
+function lessonSpeechLines(lessons, matchedSignals) {
+    const speech = [];
+    for (const lesson of lessonsForMatchedSignals(lessons, matchedSignals)) {
+        for (const line of lesson.lines) {
+            const text = line.text.trim().slice(0, LESSON_TEXT_CAP);
+            if (text.length === 0)
+                continue;
+            speech.push(`${lesson.name}: ${text}`);
+        }
+    }
+    return speech;
+}

package/dist/mcps/researcher.server.js

@@ -388,7 +388,7 @@ class XrayLibrarianServer extends XrayKnowledgeSkillBase {
             proposalType,
         });
         const enrichedEvidence = [...(evidence || [])];
-        if (memoryContext?.confidence.highConfidenceTrapPresent) {
+        if (memoryContext) {
             enrichedEvidence.push(...buildMemoryRoutingEvidence(memoryContext));
         }
         const vote = (await tryLLMGovernance("researcher", proposalTitle || "", proposalDescription || "", enrichedEvidence, proposalType || "")) ??
@@ -398,7 +398,7 @@ class XrayLibrarianServer extends XrayKnowledgeSkillBase {
                 highConfidenceTrapPresent: memoryContext?.confidence.highConfidenceTrapPresent,
                 recommendedAgent: memoryContext?.recommendedAgent,
             });
-        const memoryRoutingBlock = memoryContext?.confidence.highConfidenceTrapPresent
+        const memoryRoutingBlock = memoryContext
             ? `\n${formatMemoryRoutingBlock(memoryContext)}`
             : "";
         return {