0xray 4.0.23 → 4.0.24

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.24",
   "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 {

package/dist/memory-routing/plates.d.ts

@@ -0,0 +1,16 @@
+export declare const PLATE_IDS: readonly ["routing", "governance", "boot", "orchestration", "processor", "reporting", "memory-recall"];
+export type PlateId = (typeof PLATE_IDS)[number];
+export interface PlateStamp {
+    id: PlateId;
+    body: string;
+    sourcePath: string;
+}
+export interface PlateStampResult {
+    id: PlateId;
+    path: string;
+    written: boolean;
+}
+export declare function loadPlate(id: PlateId): PlateStamp;
+export declare function recallPlate(intent: string | null | undefined): PlateStamp | null;
+export declare function stampPlateIfMissing(projectRoot: string, id: PlateId): PlateStampResult;
+export declare function plateStockLine(intent: string | null | undefined): string | null;

package/dist/memory-routing/plates.js

@@ -0,0 +1,71 @@
+/**
+ * Typed plate API. The runtime reader is plates.cjs so Station and the
+ * Cursor preCompact hook share one implementation.
+ */
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const PLATE_IDS = [
+    'routing',
+    'governance',
+    'boot',
+    'orchestration',
+    'processor',
+    'reporting',
+    'memory-recall',
+];
+function isPlateId(value) {
+    return PLATE_IDS.includes(value);
+}
+function isRuntime(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const row = value;
+    return (typeof row.loadPlate === 'function'
+        && typeof row.recallPlate === 'function'
+        && typeof row.stampPlateIfMissing === 'function'
+        && typeof row.plateStockLine === 'function'
+        && Array.isArray(row.PLATE_IDS));
+}
+function loadRuntime() {
+    const require = createRequire(import.meta.url);
+    const runtimePath = join(dirname(fileURLToPath(import.meta.url)), '../integrations/hooks/plates.cjs');
+    const loaded = require(runtimePath);
+    if (!isRuntime(loaded)) {
+        throw new Error('plate runtime missing');
+    }
+    return loaded;
+}
+const runtime = loadRuntime();
+function asStamp(value) {
+    if (!value)
+        return null;
+    if (!isPlateId(value.id) || typeof value.body !== 'string') {
+        throw new Error('plate runtime returned an unknown stamp');
+    }
+    return value;
+}
+export function loadPlate(id) {
+    const stamp = asStamp(runtime.loadPlate(id));
+    if (!stamp)
+        throw new Error(`plate missing: ${id}`);
+    return stamp;
+}
+export function recallPlate(intent) {
+    return asStamp(runtime.recallPlate(intent));
+}
+export function stampPlateIfMissing(projectRoot, id) {
+    const result = runtime.stampPlateIfMissing(projectRoot, id);
+    if (!isPlateId(result.id) || typeof result.path !== 'string' || typeof result.written !== 'boolean') {
+        throw new Error('plate runtime returned an unknown stamp result');
+    }
+    return result;
+}
+export function plateStockLine(intent) {
+    const line = runtime.plateStockLine(intent);
+    if (line === null || line === undefined)
+        return null;
+    if (typeof line !== 'string')
+        throw new Error('plate stock line was not text');
+    return line;
+}

package/dist/memory-routing/types.d.ts

@@ -33,6 +33,8 @@ export interface MemoryTaskConfidence {
     complexityBoost: number;
     recommendedAgent: string | null;
 }
+/** Characters kept on one graded lesson line. lessonTrace stores with this cap. */
+export declare const LESSON_TEXT_CAP = 400;
 export interface MemoryLessonLine {
     taskId: string;
     decision: 'success' | 'failure';

package/dist/memory-routing/types.js

@@ -4,4 +4,5 @@
  * Repertoire is one implementation. Any provider exposing createMemoryRoutingProvider()
  * can be loaded via features.json memory_routing.module_path.
  */
-export {};
+/** Characters kept on one graded lesson line. lessonTrace stores with this cap. */
+export const LESSON_TEXT_CAP = 400;

package/dist/processors/implementations/inference-improvement-processor.d.ts

@@ -33,4 +33,9 @@ export declare class InferenceImprovementProcessor extends PostProcessor {
     private generateCodeReviewerPrompt;
     private generateEnforcerPrompt;
     private triggerAgentWorkflow;
+    /**
+     * The operation is finished once its prompt result text is on disk.
+     * One session per operation id. Empty speech writes nothing.
+     */
+    private captureFinishedOperationSpeech;
 }