0xray 4.0.35 → 4.0.37

package/dist/integrations/hooks/plates.cjs

@@ -14,12 +14,38 @@ const PLATE_IDS = Object.freeze([
   "processor",
   "reporting",
   "memory-recall",
+  "stamp-plate",
   "house",
+  "review",
   "goggles",
   "suit",
   "kits",
   "host-pack",
   "glossary",
+  "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",
 ]);
 
 /** Id token, then extra phrases. Equal top scores recall nothing. */
@@ -73,6 +99,13 @@ const CUES = {
     [/GROK_BOT_HOUSE/i, 4],
     [/setup-house/i, 4],
   ],
+  review: [
+    [/review plate/i, 6],
+    [/plates\/review\b/i, 6],
+    [/re-review/i, 5],
+    [/critic\s+FAIL/i, 5],
+    [/critic\s+PASS/i, 5],
+  ],
   goggles: [
     [/\bgoggles\b/i, 6],
   ],
@@ -91,6 +124,111 @@ const CUES = {
   glossary: [
     [/\bglossary\b/i, 6],
   ],
+  "stamp-plate": [
+    [/stamp plate/i, 6],
+    [/plates\/stamp-plate/i, 6],
+  ],
+  "record-map": [
+    [/record map/i, 6],
+    [/five pages the agent/i, 6],
+    [/plates\/record-map/i, 6],
+  ],
+  "write-home": [
+    [/write home/i, 6],
+    [/\.xray\/logs/i, 6],
+    [/plates\/write-home/i, 6],
+  ],
+  "activity-log": [
+    [/activity log pipeline/i, 6],
+    [/plates\/activity-log/i, 6],
+  ],
+  "session-capture": [
+    [/session capture/i, 6],
+    [/latest-session\.json/i, 5],
+    [/plates\/session-capture/i, 6],
+  ],
+  "suit-wear": [
+    [/suit wear/i, 6],
+    [/consumer gitignore/i, 5],
+    [/plates\/suit-wear/i, 6],
+  ],
+  "suit-organs": [
+    [/suit organs/i, 6],
+    [/plates\/suit-organs/i, 6],
+  ],
+  "station-card": [
+    [/station card/i, 6],
+    [/plates\/station-card/i, 6],
+  ],
+  "notes-page": [
+    [/notes page/i, 6],
+    [/plates\/notes-page/i, 6],
+  ],
+  "reflection-page": [
+    [/reflection page/i, 6],
+    [/plates\/reflection-page/i, 6],
+  ],
+  "site-manual": [
+    [/site manual/i, 6],
+    [/plates\/site-manual/i, 6],
+  ],
+  "package-face": [
+    [/package face/i, 6],
+    [/plates\/package-face/i, 6],
+  ],
+  "suit-settings": [
+    [/suit settings/i, 6],
+    [/plates\/suit-settings/i, 6],
+  ],
+  "trail-state": [
+    [/trail state/i, 6],
+    [/plates\/trail-state/i, 6],
+  ],
+  "inference-files": [
+    [/inference files/i, 6],
+    [/plates\/inference-files/i, 6],
+  ],
+  "grok-compact": [
+    [/grok compact/i, 6],
+    [/plates\/grok-compact/i, 6],
+  ],
+  "payload-heat": [
+    [/payload heat/i, 6],
+    [/plates\/payload-heat/i, 6],
+  ],
+  "station-heat": [
+    [/station heat/i, 6],
+    [/plates\/station-heat/i, 6],
+  ],
+  "pickup-stamp": [
+    [/pickup stamp/i, 6],
+    [/plates\/pickup-stamp/i, 6],
+  ],
+  "cursor-compact": [
+    [/cursor compact/i, 6],
+    [/plates\/cursor-compact/i, 6],
+  ],
+  "work-fresh": [
+    [/work fresh/i, 6],
+    [/freshness line/i, 6],
+    [/plates\/work-fresh/i, 6],
+  ],
+  "kept-line": [
+    [/kept line/i, 6],
+    [/plates\/kept-line/i, 6],
+  ],
+  "lens-gate": [
+    [/lens gate/i, 6],
+    [/plates\/lens-gate/i, 6],
+  ],
+  "pre-tool": [
+    [/pre tool/i, 6],
+    [/plates\/pre-tool/i, 6],
+  ],
+  "lens-page": [
+    [/lens page/i, 6],
+    [/plates\/lens-page/i, 6],
+  ],
 };
 
 function platesDir() {

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

@@ -526,6 +526,19 @@ function stampNotesPickup(root, line) {
   return text;
 }
 
+function notesMark(root) {
+  let body = "";
+  const dest = notesPath(root);
+  if (existsSync(dest)) {
+    try {
+      body = readFileSync(dest, "utf8");
+    } catch {
+      body = "";
+    }
+  }
+  return /^## Working notes\b/m.test(body) ? "Notes: present" : "Notes: THIN";
+}
+
 function readLatestSessionApproaches(root) {
   const latest = join(root, "docs", "inference", "latest-session.json");
   if (!existsSync(latest)) return null;
@@ -995,9 +1008,13 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
   const resolved = resolveHeatIntent(root, extra, existing);
   const intent = resolved.intent;
   const rematch = resolved.rematch;
-  if (isCompactHook(extra) && intent && (readStationTicketField(root, "Intent") || pickup || clipIntent(extra.intent))) {
-    const stamped = stampNotesPickup(root, intent);
-    if (stamped) pickup = stamped;
+  let notesLine = null;
+  if (isCompactHook(extra)) {
+    if (intent && (readStationTicketField(root, "Intent") || pickup || clipIntent(extra.intent))) {
+      const stamped = stampNotesPickup(root, intent);
+      if (stamped) pickup = stamped;
+    }
+    notesLine = notesMark(root);
   }
   const matchText = clipIntent([intent, pickup, approaches].filter(Boolean).join(" "));
   const git = readGitBrief(root);
@@ -1089,6 +1106,7 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
     repertoireResume,
     workingLine,
     stationLine,
+    ...(notesLine ? { notesLine } : {}),
     ...compactHold,
   };
 }
@@ -1099,9 +1117,12 @@ const STOCK_STATION_PREFIXES = [
   "intent:",
   "plan:",
   "git:",
+  "fresh:",
   "repertoire:",
   "working:",
   "plate:",
+  "library:",
+  "notes:",
 ];
 
 /** Stock design map. Exact lines so a later heat does not preserve a second copy. */
@@ -1222,10 +1243,45 @@ function extractPreservedStationLines(existing) {
   return preserved;
 }
 
+function latestFreshLine(existingMd) {
+  const lines = String(existingMd || "").split(/\r?\n/).map((line) => line.trim()).filter((line) => /^Fresh:/.test(line));
+  return lines.length ? lines[lines.length - 1] : "";
+}
+
+function withOneFreshLine(stockMd, existingMd) {
+  const stock = String(stockMd || "");
+  if (/^Fresh:/m.test(stock)) return stock;
+  const fresh = latestFreshLine(existingMd);
+  if (!fresh) return stock;
+  const rows = stock.split(/\r?\n/);
+  const at = rows.findIndex((row) => row.startsWith("Repertoire:"));
+  if (at >= 0) rows.splice(at, 0, fresh);
+  else rows.splice(Math.min(rows.length, 6), 0, fresh);
+  return rows.join("\n");
+}
+
+function latestNotesLine(existingMd) {
+  const lines = String(existingMd || "").split(/\r?\n/).map((line) => line.trim()).filter((line) => /^Notes:/.test(line));
+  return lines.length ? lines[lines.length - 1] : "";
+}
+
+function withOneNotesLine(stockMd, existingMd) {
+  const stock = String(stockMd || "");
+  if (/^Notes:/m.test(stock)) return stock;
+  const notes = latestNotesLine(existingMd);
+  if (!notes) return stock;
+  const rows = stock.split(/\r?\n/);
+  const at = rows.findIndex((row) => row.startsWith("Library:"));
+  if (at >= 0) rows.splice(at + 1, 0, notes);
+  else rows.splice(Math.min(rows.length, 8), 0, notes);
+  return rows.join("\n");
+}
+
 function mergeStationMarkdown(stockMd, existingMd) {
+  const stockWithFresh = withOneNotesLine(withOneFreshLine(stockMd, existingMd), existingMd);
   const preserved = extractPreservedStationLines(existingMd);
-  if (!preserved.length) return stockMd;
-  const stock = String(stockMd || "");
+  if (!preserved.length) return stockWithFresh;
+  const stock = stockWithFresh;
   const block = preserved.join("\n");
   const marker = "Continue this card.";
   const idx = stock.indexOf(marker);
@@ -1261,6 +1317,8 @@ 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.notesLine) lines.push(fields.notesLine);
   lines.push("");
   lines.push(...DESIGN_MAP_LINES);
   lines.push("");

package/dist/integrations/hooks/write-home.cjs

@@ -0,0 +1,59 @@
+/**
+ * Where the suit writes. One home, under .xray.
+ * Readers still open the old path when the new file is not there yet.
+ */
+const { existsSync } = require("fs");
+const { join } = require("path");
+
+function logsDir(root) {
+  return join(root, ".xray", "logs");
+}
+
+function activityLog(root) {
+  return join(logsDir(root), "activity.log");
+}
+
+function inferenceDir(root) {
+  return join(root, ".xray", "inference");
+}
+
+function latestSession(root) {
+  return join(inferenceDir(root), "latest-session.json");
+}
+
+function activityLogForRead(root) {
+  const next = activityLog(root);
+  const prev = join(root, "logs", "framework", "activity.log");
+  if (existsSync(next) || !existsSync(prev)) return next;
+  return prev;
+}
+
+function latestSessionForRead(root) {
+  const next = latestSession(root);
+  const prev = join(root, "docs", "inference", "latest-session.json");
+  if (existsSync(next) || !existsSync(prev)) return next;
+  return prev;
+}
+
+/** Old feature values that used to scatter writes. */
+function isLegacyLogPath(logPath) {
+  if (!logPath) return true;
+  const normalized = String(logPath).replace(/\\/g, "/").replace(/\/$/, "");
+  return (
+    normalized === ".opencode/logs" ||
+    normalized === ".opencode" ||
+    normalized === "logs" ||
+    normalized === "logs/framework" ||
+    normalized.endsWith("/logs/framework")
+  );
+}
+
+module.exports = {
+  logsDir,
+  activityLog,
+  inferenceDir,
+  latestSession,
+  activityLogForRead,
+  latestSessionForRead,
+  isLegacyLogPath,
+};

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

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

package/dist/mcps/architect-tools.server.d.ts

@@ -5,6 +5,12 @@
  * Provides contextual analysis capabilities via MCP protocol
  */
 import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+export declare function renderArchitectureAssessment(args: Record<string, unknown> | undefined): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;
 declare class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
     constructor();
     setupToolHandlers(): void;

package/dist/mcps/architect-tools.server.js

@@ -8,7 +8,24 @@ import { CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 import * as fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
-import { contextAnalysis as architectContextAnalysis, codebaseStructure as architectCodebaseStructure, dependencyAnalysis as architectDependencyAnalysis, architectureAssessment as architectArchitectureAssessment, } from "../architect/architect-tools.js";
+import { contextAnalysis as architectContextAnalysis, codebaseStructure as architectCodebaseStructure, dependencyAnalysis as architectDependencyAnalysis, architectureAssessment as architectArchitectureAssessment, formatConferArchitectureText, } from "../architect/architect-tools.js";
+export async function renderArchitectureAssessment(args) {
+    const projectRoot = typeof args?.projectRoot === "string" ? args.projectRoot : "";
+    const assessmentType = args?.assessmentType === "quick" || args?.assessmentType === "comprehensive"
+        ? args.assessmentType
+        : "comprehensive";
+    const conferPrompt = typeof args?.conferPrompt === "string" ? args.conferPrompt : "";
+    frameworkLogger.log("mcps/architect-tools", "architecture-assessment", "info", { projectRoot });
+    const result = await architectArchitectureAssessment(projectRoot, assessmentType);
+    return {
+        content: [
+            {
+                type: "text",
+                text: formatConferArchitectureText(conferPrompt, result),
+            },
+        ],
+    };
+}
 class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
     constructor() {
         super("architect-tools", "3.1.0");
@@ -191,23 +208,7 @@ class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
         };
     }
     async architectureAssessment(args) {
-        const projectRoot = args?.projectRoot || "";
-        const assessmentType = args?.assessmentType || "comprehensive";
-        const conferPrompt = typeof args?.conferPrompt === "string" ? args.conferPrompt : "";
-        frameworkLogger.log("mcps/architect-tools", "architecture-assessment", "info", { projectRoot });
-        const result = await architectArchitectureAssessment(projectRoot, assessmentType);
-        const assessmentJson = JSON.stringify(result, null, 2);
-        const text = conferPrompt.trim()
-            ? `${conferPrompt.trim()}\n\n## Architecture assessment\n${assessmentJson}\n\nVerdict: CONDITIONAL\nTop risks: review assessment metrics above\nHardening: address high-complexity or coupling findings before resuming`
-            : assessmentJson;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text,
-                },
-            ],
-        };
+        return renderArchitectureAssessment(args);
     }
 }
 if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {

package/dist/mcps/orchestrator/server.d.ts

@@ -12,11 +12,12 @@ export declare class OrchestratorServer {
     private server;
     private activeTasks;
     private taskHistory;
-    private taskHandler;
-    private complexityHandler;
+    private taskHandlerPromise;
+    private complexityHandlerPromise;
     private statusHandler;
-    private coordinator;
     constructor();
+    private loadTaskHandler;
+    private loadComplexityHandler;
     /**
      * Initialize tool definitions
      */

package/dist/mcps/orchestrator/server.js

@@ -9,10 +9,6 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import * as fs from 'fs';
 import { frameworkLogger } from '../../core/framework-logger.js';
-import { XrayStateManager } from '../../state/state-manager.js';
-import { MultiAgentOrchestrationCoordinator } from '../../orchestrator/multi-agent-orchestration-coordinator.js';
-import { TaskHandler } from './handlers/task-handler.js';
-import { ComplexityHandler } from './handlers/complexity-handler.js';
 import { StatusHandler } from './handlers/status-handler.js';
 import { spawnAside, closeAside, closeAllAsides, addObservations, getActiveAsideCount, getActiveAsideIds, getAsideState, extractGovernanceObservations, } from './aside-context.js';
 /**
@@ -23,19 +19,11 @@ export class OrchestratorServer {
     server;
     activeTasks = new Map();
     taskHistory = [];
-    // Handlers
-    taskHandler;
-    complexityHandler;
+    // Task and complexity handlers import the planner and nucleus. Load on tool call.
+    taskHandlerPromise = null;
+    complexityHandlerPromise = null;
     statusHandler;
-    // Actual orchestration coordinator
-    coordinator;
     constructor() {
-        // Initialize actual coordinator
-        const stateManager = new XrayStateManager();
-        this.coordinator = new MultiAgentOrchestrationCoordinator(stateManager);
-        // Initialize handlers
-        this.taskHandler = new TaskHandler();
-        this.complexityHandler = new ComplexityHandler();
         this.statusHandler = new StatusHandler();
         // Create MCP server
         this.server = new Server({
@@ -52,6 +40,28 @@ export class OrchestratorServer {
             message: '0xRay Orchestrator MCP Server initialized',
         });
     }
+    loadTaskHandler() {
+        if (!this.taskHandlerPromise) {
+            this.taskHandlerPromise = import('./handlers/task-handler.js')
+                .then(({ TaskHandler }) => new TaskHandler())
+                .catch((error) => {
+                this.taskHandlerPromise = null;
+                throw error;
+            });
+        }
+        return this.taskHandlerPromise;
+    }
+    loadComplexityHandler() {
+        if (!this.complexityHandlerPromise) {
+            this.complexityHandlerPromise = import('./handlers/complexity-handler.js')
+                .then(({ ComplexityHandler }) => new ComplexityHandler())
+                .catch((error) => {
+                this.complexityHandlerPromise = null;
+                throw error;
+            });
+        }
+        return this.complexityHandlerPromise;
+    }
     /**
      * Initialize tool definitions
      */
@@ -268,7 +278,8 @@ export class OrchestratorServer {
                             inheritedContext: { taskCount: orchArgs.tasks?.length ?? 0, executionMode: orchArgs.executionMode ?? 'optimized' },
                         });
                         try {
-                            const result = await this.taskHandler.handleOrchestrateTask(orchArgs, { taskHistory: this.taskHistory, activeTasks: this.activeTasks, asideId: aside.asideId });
+                            const taskHandler = await this.loadTaskHandler();
+                            const result = await taskHandler.handleOrchestrateTask(orchArgs, { taskHistory: this.taskHistory, activeTasks: this.activeTasks, asideId: aside.asideId });
                             return result;
                         }
                         finally {
@@ -348,7 +359,8 @@ export class OrchestratorServer {
                             inheritedContext,
                         });
                         try {
-                            const result = await this.complexityHandler.handleAnalyzeComplexity({
+                            const complexityHandler = await this.loadComplexityHandler();
+                            const result = await complexityHandler.handleAnalyzeComplexity({
                                 ...complexityArgs,
                                 ...(sessionId ? { sessionId } : {}),
                                 ...(synthesisDue

package/dist/memory-routing/lookup-cache.d.ts

@@ -0,0 +1,8 @@
+import type { MemoryRoutingProvider } from './types.js';
+export declare function resetOrganFileCacheStats(): void;
+export declare function organFileCacheStats(): {
+    hits: number;
+    misses: number;
+};
+/** Attach the file cache to a loaded Repertoire provider. Other providers are left alone. */
+export declare function bindOrganFileCache(provider: MemoryRoutingProvider): void;

package/dist/memory-routing/lookup-cache.js

@@ -0,0 +1,72 @@
+import { statSync } from 'node:fs';
+const boundStores = new WeakSet();
+let cacheHits = 0;
+let cacheMisses = 0;
+export function resetOrganFileCacheStats() {
+    cacheHits = 0;
+    cacheMisses = 0;
+}
+export function organFileCacheStats() {
+    return { hits: cacheHits, misses: cacheMisses };
+}
+function stampFile(filePath) {
+    try {
+        const info = statSync(filePath);
+        const mtimeNs = typeof info.mtimeNs === 'bigint'
+            ? info.mtimeNs
+            : BigInt(Math.round(info.mtimeMs * 1_000_000));
+        return { exists: true, size: info.size, mtimeNs };
+    }
+    catch {
+        return { exists: false, size: 0, mtimeNs: 0n };
+    }
+}
+function sameStamp(left, right) {
+    return left.exists === right.exists
+        && left.size === right.size
+        && left.mtimeNs === right.mtimeNs;
+}
+function bindStore(store) {
+    if (!store || typeof store !== 'object')
+        return;
+    if (boundStores.has(store))
+        return;
+    const organ = store;
+    const read = organ.load;
+    const filePath = organ.filePath;
+    if (typeof read !== 'function' || typeof filePath !== 'string' || filePath.length === 0)
+        return;
+    boundStores.add(store);
+    let filled = false;
+    let cached;
+    let stamp = null;
+    organ.load = () => {
+        const before = stampFile(filePath);
+        if (filled && stamp && sameStamp(stamp, before)) {
+            cacheHits += 1;
+            return cached;
+        }
+        cacheMisses += 1;
+        const value = read.call(organ);
+        const after = stampFile(filePath);
+        if (sameStamp(before, after)) {
+            cached = value;
+            stamp = after;
+            filled = true;
+        }
+        else {
+            filled = false;
+            stamp = null;
+        }
+        return value;
+    };
+}
+/** Attach the file cache to a loaded Repertoire provider. Other providers are left alone. */
+export function bindOrganFileCache(provider) {
+    const service = provider.service;
+    if (!service || typeof service !== 'object')
+        return;
+    const row = service;
+    bindStore(row.signalsManager);
+    bindStore(row.stateManager);
+}

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

@@ -1,4 +1,4 @@
-export declare const PLATE_IDS: readonly ["routing", "governance", "boot", "orchestration", "processor", "reporting", "memory-recall", "house", "goggles", "suit", "kits", "host-pack", "glossary"];
+export declare const PLATE_IDS: readonly ["routing", "governance", "boot", "orchestration", "processor", "reporting", "memory-recall", "stamp-plate", "house", "review", "goggles", "suit", "kits", "host-pack", "glossary", "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"];
 export type PlateId = (typeof PLATE_IDS)[number];
 export interface PlateStamp {
     id: PlateId;

package/dist/memory-routing/plates.js

@@ -13,12 +13,38 @@ export const PLATE_IDS = [
     'processor',
     'reporting',
     'memory-recall',
+    'stamp-plate',
     'house',
+    'review',
     'goggles',
     'suit',
     'kits',
     'host-pack',
     'glossary',
+    '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',
 ];
 function isPlateId(value) {
     return PLATE_IDS.includes(value);

package/dist/memory-routing/provider-loader.js

@@ -3,6 +3,7 @@ import { createRequire } from 'node:module';
 import { resolve, dirname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { frameworkLogger } from '../core/framework-logger.js';
+import { bindOrganFileCache } from './lookup-cache.js';
 import { createMemoryRoutingProvider as createNullProvider } from './null-provider.js';
 import { validateMemoryRoutingConfig } from './validate-config.js';
 // Opening the organ must not merge subject repo-* back onto the project file.
@@ -139,6 +140,7 @@ export function loadMemoryRoutingProviderSync(config, cwd = process.cwd()) {
     try {
         const mod = require(resolved.modulePath);
         const provider = providerFromModule(mod, resolved.modulePath, resolved.effective);
+        bindOrganFileCache(provider);
         if (!provider.isAvailable())
             return null;
         return provider;
@@ -179,6 +181,7 @@ export async function loadMemoryRoutingProvider(config, cwd = process.cwd()) {
         if (!provider?.id || typeof provider.isAvailable !== 'function') {
             throw new Error(`Invalid memory routing provider from ${modulePath}`);
         }
+        bindOrganFileCache(provider);
         const availabilityReason = resolveUnavailableReason(provider);
         if (!provider.isAvailable()) {
             await frameworkLogger.log('memory-routing', 'provider-unavailable', 'error', {