0xray 2.1.2 → 2.1.3

package/dist/integrations/grok/grok-cli.js

@@ -31,50 +31,50 @@ export async function installForGrokCLI(options = {}) {
     ];
     let sourceDir = possibleSources.find(p => fs.existsSync(p));
     if (!sourceDir) {
-        console.error('[Grok] Could not locate the 0xray Grok plugin inside the package.');
+        frameworkLogger.log('grok-cli', 'Could not locate the 0xray Grok plugin inside the package.', 'error', {});
         return;
     }
     if (options.dryRun) {
-        console.log(`[Grok] Dry run: Would copy plugin from ${sourceDir} → ${targetPluginDir}`);
+        frameworkLogger.log('grok-cli', `Dry run: Would copy plugin from ${sourceDir} → ${targetPluginDir}`, 'info', {});
         return;
     }
     try {
         if (fs.existsSync(targetPluginDir) && !options.force) {
-            console.log('[Grok] 0xray Grok plugin is already installed.');
-            console.log('Use --force to reinstall.');
+            frameworkLogger.log('grok-cli', '0xray Grok plugin is already installed.', 'info', {});
+            frameworkLogger.log('grok-cli', 'Use --force to reinstall.', 'info', {});
             return;
         }
         fs.cpSync(sourceDir, targetPluginDir, { recursive: true, force: true });
         frameworkLogger.log('grok-integration', 'plugin-copied', 'info', { destination: targetPluginDir });
-        console.log(`\x1b[32m✓ Copied Grok plugin to ${targetPluginDir}\x1b[0m`);
+        frameworkLogger.log('grok-cli', `Copied Grok plugin to ${targetPluginDir}`, 'info', {});
         // Attempt auto-trust (best effort)
         try {
             execSync(`grok plugins trust "${targetPluginDir}"`, { stdio: 'ignore' });
-            console.log('\x1b[32m✓ Auto-trusted the 0xray plugin with Grok CLI\x1b[0m');
+            frameworkLogger.log('grok-cli', 'Auto-trusted the 0xray plugin with Grok CLI', 'info', {});
         }
         catch {
-            console.log('\nPlease run this command to fully trust the plugin:');
-            console.log(`  grok plugins trust "${targetPluginDir}"`);
+            frameworkLogger.log('grok-cli', 'Please run this command to fully trust the plugin:', 'info', {});
+            frameworkLogger.log('grok-cli', `  grok plugins trust "${targetPluginDir}"`, 'info', {});
         }
         // Register MCP servers via grok mcp add (most reliable mechanism)
         const govMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/governance.server.js');
         const skillsMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/knowledge-skills/skill-invocation.server.js');
         try {
-            execSync(`grok mcp add xray-governance --command node --args "${govMcpPath}" --env "STRRAY_FORCE_MCP_GOVERNANCE=true" --env "STRRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
-            execSync(`grok mcp add xray-skills --command node --args "${skillsMcpPath}" --env "STRRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
-            console.log('\x1b[32m✓ Registered xray MCP servers with Grok CLI\x1b[0m');
+            execSync(`grok mcp add xray-governance --command node --args "${govMcpPath}" --env "XRAY_FORCE_MCP_GOVERNANCE=true" --env "XRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
+            execSync(`grok mcp add xray-skills --command node --args "${skillsMcpPath}" --env "XRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
+            frameworkLogger.log('grok-cli', 'Registered xray MCP servers with Grok CLI', 'info', {});
         }
         catch {
-            console.log('\nCould not auto-register MCP servers. Run manually:');
-            console.log(`  grok mcp add xray-governance --command node --args "${govMcpPath}"`);
-            console.log(`  grok mcp add xray-skills --command node --args "${skillsMcpPath}"`);
+            frameworkLogger.log('grok-cli', 'Could not auto-register MCP servers. Run manually:', 'info', {});
+            frameworkLogger.log('grok-cli', `  grok mcp add xray-governance --command node --args "${govMcpPath}"`, 'info', {});
+            frameworkLogger.log('grok-cli', `  grok mcp add xray-skills --command node --args "${skillsMcpPath}"`, 'info', {});
         }
-        console.log('\n✅ 0xRay is now installed as a first-class Grok CLI plugin!');
-        console.log('Restart Grok or run `grok` to load the new hooks and MCP servers.');
+        frameworkLogger.log('grok-cli', '0xRay is now installed as a first-class Grok CLI plugin!', 'info', {});
+        frameworkLogger.log('grok-cli', 'Restart Grok or run `grok` to load the new hooks and MCP servers.', 'info', {});
     }
     catch (err) {
         frameworkLogger.log('grok-integration', 'install-error', 'error', { error: err.message });
-        console.error('Failed to install Grok plugin:', err.message);
+        frameworkLogger.log('grok-cli', 'Failed to install Grok plugin:', 'error', { error: err.message });
     }
     frameworkLogger.log('grok-integration', 'install-complete', 'info', {});
 }

package/dist/integrations/grok/hooks/pre-tool-use.js

@@ -16,7 +16,7 @@ function findGovernanceCore() {
   const here = path.dirname(new URL(import.meta.url).pathname);
 
   // Priority: explicit dev root
-  const devRoot = process.env.STRRAY_ROOT;
+  const devRoot = ;
   if (devRoot) {
     const devCandidate = path.resolve(devRoot, 'dist/governance/governance-core.js');
     if (fs.existsSync(devCandidate)) return devCandidate;

package/dist/integrations/hermes-agent/bridge.mjs

@@ -53,7 +53,7 @@ let frameworkLoadAttempted = false;
 
 // ── Project root detection ───────────────────────────────────
 function findProjectRoot() {
-  const envHome = process.env.STRRAY_HOME;
+  const envHome = ;
   if (envHome && existsSync(join(envHome, "package.json"))) return envHome;
 
   const candidates = [

package/dist/integrations/openclaw/api-server.d.ts

@@ -28,7 +28,6 @@ export declare class XrayAPIServer {
     private apiKey;
     private stats;
     private responseTimes;
-    private logger;
     constructor(config: XrayAPIServerConfig);
     /**
      * Set the agent invoker

package/dist/integrations/openclaw/api-server.js

@@ -7,6 +7,7 @@
  * @version 1.0.0
  * @since 2026-03-14
  */
+import { frameworkLogger } from '../../core/framework-logger.js';
 import * as crypto from 'crypto';
 import * as http from 'http';
 /**
@@ -26,7 +27,6 @@ export class XrayAPIServer {
         errors: 0,
     };
     responseTimes = [];
-    logger;
     constructor(config) {
         this.config = {
             port: config.port || 18431,
@@ -38,7 +38,6 @@ export class XrayAPIServer {
                 maxRequests: 100,
             },
         };
-        this.logger = console;
     }
     /**
      * Set the agent invoker
@@ -51,7 +50,7 @@ export class XrayAPIServer {
      */
     async start() {
         if (this.server) {
-            this.logger.warn('[XrayAPIServer] Server already running');
+            frameworkLogger.log('openclaw-api-server', 'Server already running', 'warning', {});
             return;
         }
         return new Promise((resolve, reject) => {
@@ -59,13 +58,13 @@ export class XrayAPIServer {
                 this.handleRequest(req, res);
             });
             this.server.on('error', (error) => {
-                this.logger.error('[XrayAPIServer] Server error:', error);
+                frameworkLogger.log('openclaw-api-server', 'Server error:', 'error', { error });
                 this.stats.errors++;
                 reject(error);
             });
             this.server.listen(this.config.port, this.config.host, () => {
                 this.stats.startedAt = Date.now();
-                this.logger.info(`[XrayAPIServer] Listening on http://${this.config.host}:${this.config.port}`);
+                frameworkLogger.log('openclaw-api-server', `Listening on http://${this.config.host}:${this.config.port}`, 'info', {});
                 resolve();
             });
         });
@@ -77,7 +76,7 @@ export class XrayAPIServer {
         return new Promise((resolve) => {
             if (this.server) {
                 this.server.close(() => {
-                    this.logger.info('[XrayAPIServer] Server stopped');
+                    frameworkLogger.log('openclaw-api-server', 'Server stopped', 'info', {});
                     this.server = null;
                     resolve();
                 });
@@ -123,9 +122,7 @@ export class XrayAPIServer {
             // to prevent cross-origin attacks where a malicious site could make
             // authenticated requests using the API key from a victim's browser.
             if (this.config.apiKey) {
-                this.logger.warn('[XrayAPIServer] Security: API key is set with CORS enabled. ' +
-                    'Restricting Access-Control-Allow-Origin to localhost only. ' +
-                    'Configure explicit allowed origins if cross-origin access is needed.');
+                frameworkLogger.log('openclaw-api-server', 'Security: API key is set with CORS enabled. Restricting Access-Control-Allow-Origin to localhost only. Configure explicit allowed origins if cross-origin access is needed.', 'warning', {});
                 const origin = req.headers.origin;
                 if (origin && ['http://localhost', 'http://127.0.0.1', 'http://localhost:3000',
                     'http://127.0.0.1:3000', 'http://localhost:5173', 'http://127.0.0.1:5173'].includes(origin)) {
@@ -203,7 +200,7 @@ export class XrayAPIServer {
             }
         }
         catch (error) {
-            this.logger.error(`[XrayAPIServer] Error handling request:`, error);
+            frameworkLogger.log('openclaw-api-server', 'Error handling request:', 'error', { error });
             this.stats.errors++;
             const errorMessage = error instanceof Error ? error.message : 'Internal server error';
             this.sendResponse(res, 500, { error: errorMessage });

package/dist/integrations/openclaw/client.d.ts

@@ -22,7 +22,6 @@ export declare class OpenClawClient {
     private reconnectTimeout;
     private pingInterval;
     private stats;
-    private logger;
     constructor(config: OpenClawClientConfig);
     /**
      * Connect to OpenClaw Gateway

package/dist/integrations/openclaw/client.js

@@ -7,6 +7,7 @@
  * @version 1.0.0
  * @since 2026-03-14
  */
+import { frameworkLogger } from '../../core/framework-logger.js';
 import { WebSocket } from 'ws';
 import * as crypto from 'crypto';
 import { isOpenClawResponse, isOpenClawEvent, OpenClawTimeoutError, OpenClawConnectionError, } from './types.js';
@@ -32,7 +33,6 @@ export class OpenClawClient {
         reconnects: 0,
         errors: 0,
     };
-    logger;
     constructor(config) {
         this.config = {
             gatewayUrl: config.gatewayUrl || 'ws://127.0.0.1:18789',
@@ -45,8 +45,6 @@ export class OpenClawClient {
             pingInterval: config.pingInterval ?? 30000,
             requestTimeout: config.requestTimeout ?? 30000,
         };
-        // Use console but can be replaced with proper logger
-        this.logger = console;
     }
     /**
      * Connect to OpenClaw Gateway
@@ -56,7 +54,7 @@ export class OpenClawClient {
     _handshakeTimeout = null;
     async connect() {
         if (this.state === 'connected' || this.state === 'authenticating') {
-            this.logger.warn('[OpenClawClient] Already connected or connecting');
+            frameworkLogger.log('openclaw-client', 'Already connected or connecting', 'warning', {});
             return;
         }
         this.setState('connecting');
@@ -71,7 +69,7 @@ export class OpenClawClient {
             try {
                 this.ws = new WebSocket(this.config.gatewayUrl);
                 this.ws.on('open', () => {
-                    this.logger.info('[OpenClawClient] WebSocket connected, waiting for challenge...');
+                    frameworkLogger.log('openclaw-client', 'WebSocket connected, waiting for challenge...', 'info', {});
                     this.handshakeResolve = resolve;
                     this.handshakeReject = reject;
                 });
@@ -80,21 +78,21 @@ export class OpenClawClient {
                     this.handleMessage(message);
                 });
                 this.ws.on('close', (code, reason) => {
-                    this.logger.info(`[OpenClawClient] Connection closed: ${code} ${String(reason)}`);
+                    frameworkLogger.log('openclaw-client', `Connection closed: ${code} ${String(reason)}`, 'info', {});
                     this.handleDisconnect(Number(code), String(reason));
                 });
                 this.ws.on('error', (error) => {
-                    this.logger.error('[OpenClawClient] WebSocket error:', error instanceof Error ? error.message : String(error));
+                    frameworkLogger.log('openclaw-client', 'WebSocket error:', 'error', { error: error instanceof Error ? error.message : String(error) });
                     this.stats.errors++;
                     if (this.state === 'connecting') {
                         reject(new OpenClawConnectionError(`Failed to connect to ${this.config.gatewayUrl}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined));
                     }
                 });
                 this.ws.on('ping', () => {
-                    this.logger.debug('[OpenClawClient] Received ping');
+                    frameworkLogger.log('openclaw-client', 'Received ping', 'debug', {});
                 });
                 this.ws.on('pong', () => {
-                    this.logger.debug('[OpenClawClient] Received pong');
+                    frameworkLogger.log('openclaw-client', 'Received pong', 'debug', {});
                 });
             }
             catch (error) {
@@ -107,7 +105,7 @@ export class OpenClawClient {
      * Disconnect from OpenClaw Gateway
      */
     disconnect() {
-        this.logger.info('[OpenClawClient] Disconnecting...');
+        frameworkLogger.log('openclaw-client', 'Disconnecting...', 'info', {});
         if (this._handshakeTimeout) {
             clearTimeout(this._handshakeTimeout);
             this._handshakeTimeout = null;
@@ -150,7 +148,7 @@ export class OpenClawClient {
             method,
             params,
         };
-        this.logger.debug(`[OpenClawClient] Sending request: ${method} (${id})`);
+        frameworkLogger.log('openclaw-client', `Sending request: ${method} (${id})`, 'debug', {});
         this.stats.requestsSent++;
         return new Promise((resolve, reject) => {
             // Set timeout
@@ -286,13 +284,13 @@ export class OpenClawClient {
             this.setState('authorized');
             this.startPingInterval();
             if (this.handshakeResolve) {
-                this.logger.info('[OpenClawClient] Handshake complete (connect response ok)');
+                frameworkLogger.log('openclaw-client', 'Handshake complete (connect response ok)', 'info', {});
                 this.handshakeResolve();
                 this.handshakeResolve = null;
                 this.handshakeReject = null;
             }
         }).catch((error) => {
-            this.logger.error('[OpenClawClient] Handshake failed:', error);
+            frameworkLogger.log('openclaw-client', 'Handshake failed:', 'error', { error });
             this.setState('error');
             if (this.handshakeReject) {
                 this.handshakeReject(error);
@@ -315,11 +313,11 @@ export class OpenClawClient {
                 this.handleEvent(frame);
             }
             else {
-                this.logger.warn('[OpenClawClient] Unknown frame type:', frame);
+                frameworkLogger.log('openclaw-client', 'Unknown frame type:', 'warning', { frame });
             }
         }
         catch (error) {
-            this.logger.error('[OpenClawClient] Failed to parse message:', error);
+            frameworkLogger.log('openclaw-client', 'Failed to parse message:', 'error', { error });
             this.stats.errors++;
         }
     }
@@ -340,17 +338,17 @@ export class OpenClawClient {
             }
         }
         else {
-            this.logger.warn('[OpenClawClient] Received response for unknown request:', frame.id);
+            frameworkLogger.log('openclaw-client', 'Received response for unknown request:', 'warning', { requestId: frame.id });
         }
     }
     /**
      * Handle event frame
      */
     handleEvent(frame) {
-        this.logger.debug('[OpenClawClient] Event:', frame.event);
+        frameworkLogger.log('openclaw-client', 'Event:', 'debug', { event: frame.event });
         // Handle specific events
         if (frame.event === 'connect.challenge') {
-            this.logger.info('[OpenClawClient] Received challenge, sending handshake...');
+            frameworkLogger.log('openclaw-client', 'Received challenge, sending handshake...', 'info', {});
             this.sendHandshake();
             return;
         }
@@ -375,7 +373,7 @@ export class OpenClawClient {
                     listener(frame.data);
                 }
                 catch (error) {
-                    this.logger.error('[OpenClawClient] Event listener error:', error);
+                    frameworkLogger.log('openclaw-client', 'Event listener error:', 'error', { error });
                 }
             }
         }
@@ -387,7 +385,7 @@ export class OpenClawClient {
                     listener(frame.event, frame.data);
                 }
                 catch (error) {
-                    this.logger.error('[OpenClawClient] All-event listener error:', error);
+                    frameworkLogger.log('openclaw-client', 'All-event listener error:', 'error', { error });
                 }
             }
         }
@@ -422,12 +420,12 @@ export class OpenClawClient {
         const delay = this.config.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
         const maxDelay = 30000;
         const actualDelay = Math.min(delay, maxDelay);
-        this.logger.info(`[OpenClawClient] Scheduling reconnect attempt ${this.reconnectAttempts}/${this.config.reconnectAttempts} in ${actualDelay}ms`);
+        frameworkLogger.log('openclaw-client', `Scheduling reconnect attempt ${this.reconnectAttempts}/${this.config.reconnectAttempts} in ${actualDelay}ms`, 'info', {});
         this.setState('reconnecting');
         this.reconnectTimeout = setTimeout(() => {
             this.reconnectTimeout = null;
             this.connect().catch((error) => {
-                this.logger.error('[OpenClawClient] Reconnection failed:', error);
+                frameworkLogger.log('openclaw-client', 'Reconnection failed:', 'error', { error });
             });
         }, actualDelay);
     }
@@ -448,14 +446,14 @@ export class OpenClawClient {
         const previousState = this.state;
         this.state = newState;
         if (previousState !== newState) {
-            this.logger.info(`[OpenClawClient] State: ${previousState} → ${newState}`);
+            frameworkLogger.log('openclaw-client', `State: ${previousState} → ${newState}`, 'info', {});
             // Notify state listeners
             for (const listener of this.stateListeners) {
                 try {
                     listener(newState, previousState);
                 }
                 catch (error) {
-                    this.logger.error('[OpenClawClient] State listener error:', error);
+                    frameworkLogger.log('openclaw-client', 'State listener error:', 'error', { error });
                 }
             }
         }

package/dist/integrations/openclaw/hooks/xray-hooks.d.ts

@@ -46,7 +46,6 @@ export declare class OpenClawHooksManager {
     private initialized;
     private toolBeforeCallbacks;
     private toolAfterCallbacks;
-    private logger;
     private eventQueue;
     private maxQueueSize;
     private isFlushing;

package/dist/integrations/openclaw/hooks/xray-hooks.js

@@ -7,6 +7,7 @@
  * @version 1.0.0
  * @since 2026-03-14
  */
+import { frameworkLogger } from '../../../core/framework-logger.js';
 /**
  * OpenClaw Hooks Manager
  */
@@ -16,7 +17,6 @@ export class OpenClawHooksManager {
     initialized = false;
     toolBeforeCallbacks = new Set();
     toolAfterCallbacks = new Set();
-    logger;
     // Offline event buffering
     eventQueue = [];
     maxQueueSize = 100;
@@ -30,7 +30,6 @@ export class OpenClawHooksManager {
             includeResult: config.includeResult ?? true,
             ...(config.toolFilter ? { toolFilter: config.toolFilter } : {}),
         };
-        this.logger = console;
     }
     /**
      * Set the OpenClaw client
@@ -43,19 +42,19 @@ export class OpenClawHooksManager {
      */
     async initialize() {
         if (this.initialized) {
-            this.logger.warn('[OpenClawHooks] Already initialized');
+            frameworkLogger.log('openclaw-hooks', 'Already initialized', 'warning', {});
             return;
         }
         if (!this.config.enabled) {
-            this.logger.info('[OpenClawHooks] Hooks disabled in configuration');
+            frameworkLogger.log('openclaw-hooks', 'Hooks disabled in configuration', 'info', {});
             return;
         }
-        this.logger.info('[OpenClawHooks] Initializing 0xRay tool hooks...');
+        frameworkLogger.log('openclaw-hooks', 'Initializing 0xRay tool hooks...', 'info', {});
         // Register with 0xRay's event system
         // The integration should call registerToolBefore and registerToolAfter
         // to connect to 0xRay's actual tool execution events
         this.initialized = true;
-        this.logger.info('[OpenClawHooks] Hooks initialized successfully');
+        frameworkLogger.log('openclaw-hooks', 'Hooks initialized successfully', 'info', {});
     }
     /**
      * Register a callback for tool.before events
@@ -121,13 +120,13 @@ export class OpenClawHooksManager {
                     await callback(event);
                 }
                 catch (error) {
-                    this.logger.error('[OpenClawHooks] Callback error in tool.before:', error);
+                    frameworkLogger.log('openclaw-hooks', 'Callback error in tool.before:', 'error', { error });
                 }
             }
-            this.logger.debug(`[OpenClawHooks] tool.before: ${event.toolName}`);
+            frameworkLogger.log('openclaw-hooks', `tool.before: ${event.toolName}`, 'debug', {});
         }
         catch (error) {
-            this.logger.error('[OpenClawHooks] Error handling tool.before:', error);
+            frameworkLogger.log('openclaw-hooks', 'Error handling tool.before:', 'error', { error });
         }
     }
     /**
@@ -171,13 +170,13 @@ export class OpenClawHooksManager {
                     await callback(event);
                 }
                 catch (error) {
-                    this.logger.error('[OpenClawHooks] Callback error in tool.after:', error);
+                    frameworkLogger.log('openclaw-hooks', 'Callback error in tool.after:', 'error', { error });
                 }
             }
-            this.logger.debug(`[OpenClawHooks] tool.after: ${event.toolName} (${event.error ? 'error' : 'success'})`);
+            frameworkLogger.log('openclaw-hooks', `tool.after: ${event.toolName} (${event.error ? 'error' : 'success'})`, 'debug', {});
         }
         catch (error) {
-            this.logger.error('[OpenClawHooks] Error handling tool.after:', error);
+            frameworkLogger.log('openclaw-hooks', 'Error handling tool.after:', 'error', { error });
         }
     }
     /**
@@ -187,10 +186,10 @@ export class OpenClawHooksManager {
         if (this.eventQueue.length >= this.maxQueueSize) {
             // Remove oldest event to make room
             this.eventQueue.shift();
-            this.logger.warn('[OpenClawHooks] Event queue full, dropping oldest event');
+            frameworkLogger.log('openclaw-hooks', 'Event queue full, dropping oldest event', 'warning', {});
         }
         this.eventQueue.push({ type, event });
-        this.logger.debug(`[OpenClawHooks] Queued ${type} event (queue size: ${this.eventQueue.length})`);
+        frameworkLogger.log('openclaw-hooks', `Queued ${type} event (queue size: ${this.eventQueue.length})`, 'debug', {});
     }
     /**
      * Flush queued events to OpenClaw Gateway
@@ -213,12 +212,12 @@ export class OpenClawHooksManager {
                     }
                 }
                 catch (error) {
-                    this.logger.error(`[OpenClawHooks] Failed to send queued ${item.type} event:`, error);
+                    frameworkLogger.log('openclaw-hooks', `Failed to send queued ${item.type} event:`, 'error', { error });
                     // Re-queue failed events
                     this.eventQueue.push(item);
                 }
             }
-            this.logger.info(`[OpenClawHooks] Flushed ${queue.length} queued events`);
+            frameworkLogger.log('openclaw-hooks', `Flushed ${queue.length} queued events`, 'info', {});
         }
         finally {
             this.isFlushing = false;
@@ -235,7 +234,7 @@ export class OpenClawHooksManager {
      */
     async handleReconnect() {
         if (this.eventQueue.length > 0) {
-            this.logger.info(`[OpenClawHooks] Client reconnected, flushing ${this.eventQueue.length} queued events...`);
+            frameworkLogger.log('openclaw-hooks', `Client reconnected, flushing ${this.eventQueue.length} queued events...`, 'info', {});
             await this.flushEventQueue();
         }
     }
@@ -248,7 +247,7 @@ export class OpenClawHooksManager {
         this.eventQueue.length = 0;
         this.initialized = false;
         this.client = null;
-        this.logger.info(`[OpenClawHooks] Hooks shutdown complete (${queuedCount} queued events dropped)`);
+        frameworkLogger.log('openclaw-hooks', `Hooks shutdown complete (${queuedCount} queued events dropped)`, 'info', {});
     }
     /**
      * Check if hooks are initialized

package/dist/integrations/plugins/plugin-registry.js

@@ -462,10 +462,10 @@ export class PluginRegistry extends EventEmitter {
                     this.debounceReload(pluginName);
                 }
             });
-            frameworkLogger.log("plugin-registry", "hot-reload-started", "info", { pluginsDir: this.pluginsDir }).catch(() => { });
+            frameworkLogger.log("plugin-registry", "hot-reload-started", "info", { pluginsDir: this.pluginsDir });
         }
         catch (error) {
-            frameworkLogger.log("plugin-registry", "hot-reload-failed", "error", { error: error instanceof Error ? error.message : String(error) }).catch(() => { });
+            frameworkLogger.log("plugin-registry", "hot-reload-failed", "error", { error: error instanceof Error ? error.message : String(error) });
         }
     }
     /**
@@ -479,7 +479,7 @@ export class PluginRegistry extends EventEmitter {
         const timeout = setTimeout(() => {
             this.reloadDebounce.delete(pluginName);
             this.hotReloadPlugin(pluginName).catch((error) => {
-                frameworkLogger.log("plugin-registry", "hot-reload-error", "error", { pluginName, error: error instanceof Error ? error.message : String(error) }).catch(() => { });
+                frameworkLogger.log("plugin-registry", "hot-reload-error", "error", { pluginName, error: error instanceof Error ? error.message : String(error) });
             });
         }, 1000);
         this.reloadDebounce.set(pluginName, timeout);
@@ -506,7 +506,7 @@ export class PluginRegistry extends EventEmitter {
                 await newPlugin.restart();
             }
             this.emitEvent("plugin-reloaded", { name: pluginName, phase: "loaded" });
-            await frameworkLogger.log("plugin-registry", "plugin-hot-reloaded", "info", { name: pluginName }).catch(() => { });
+            await frameworkLogger.log("plugin-registry", "plugin-hot-reloaded", "info", { name: pluginName });
         }
     }
     /**
@@ -529,7 +529,7 @@ export class PluginRegistry extends EventEmitter {
         results.forEach((result, index) => {
             if (result.status === "rejected") {
                 const pluginNames = Array.from(this.plugins.keys());
-                frameworkLogger.log("plugin-registry", "plugin-shutdown-error", "error", { name: pluginNames[index], error: result.reason }).catch(() => { });
+                frameworkLogger.log("plugin-registry", "plugin-shutdown-error", "error", { name: pluginNames[index], error: result.reason });
             }
         });
         this.plugins.clear();

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

@@ -4,14 +4,12 @@
  * Converts architect-tools.ts functions into MCP server tools
  * Provides contextual analysis capabilities via MCP protocol
  */
-declare class XrayArchitectToolsServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
     constructor();
-    private setupToolHandlers;
     private contextAnalysis;
     private codebaseStructure;
     private dependencyAnalysis;
     private architectureAssessment;
-    run(): Promise<void>;
 }
 export default XrayArchitectToolsServer;