0xray 4.0.36 → 4.0.38

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', {

package/dist/metrics/agent-metrics.d.ts

@@ -106,6 +106,12 @@ export declare class AgentMetricsSystem {
     private getInvocations;
     private saveInvocations;
     private generateId;
+    private newAgentAcc;
+    private addAgent;
+    private finishAgent;
+    private newCountAcc;
+    private addCount;
+    private finishCount;
     trackInvocation(params: {
         agentName: string;
         agentType: AgentType;
@@ -131,12 +137,15 @@ export declare class AgentMetricsSystem {
     getInvocationsByTimeRange(start: number, end: number): AgentInvocation[];
     filterInvocations(filter: AgentMetricsFilter): AgentInvocation[];
     aggregateMetrics(filter?: AgentMetricsFilter): AggregatedAgentMetrics;
-    private getHourKey;
-    private getDayKey;
-    private getWeekKey;
-    private getMonthKey;
-    private getWeekNumber;
+    private aggregateInvocations;
+    private addPeriod;
+    private freshPeriodCursor;
+    private periodKeys;
+    private weekNumber;
     private getPeriodType;
+    private utcStamp;
+    private utcPeriodRange;
+    private groupNumber;
     getAgentSummary(agentName: string): AgentInvocationSummary | null;
     getTimePeriodSummary(period: string, periodType: "hour" | "day" | "week" | "month"): TimePeriodSummary | null;
     getComplexitySummary(level: ComplexityLevel): ComplexitySummary | null;