0xray 2.1.2 → 2.1.3

package/dist/core/context-loader.js

@@ -268,4 +268,4 @@ export class XrayContextLoader {
  */
 export const xrayContextLoader = XrayContextLoader.getInstance();
 // Backward compat alias
-export { xrayContextLoader as strRayContextLoader, XrayContextLoader as StringRayContextLoader };
+export { xrayContextLoader as strRayContextLoader };

package/dist/core/errors.d.ts

@@ -0,0 +1,3 @@
+export declare function logAndReturn<T = never>(logger: any, component: string, message: string, error: unknown, returnValue: T): T;
+export declare function logWarning(logger: any, component: string, message: string, details?: Record<string, unknown>): void;
+export declare function logInfo(logger: any, component: string, message: string, details?: Record<string, unknown>): void;

package/dist/core/errors.js

@@ -0,0 +1,10 @@
+export function logAndReturn(logger, component, message, error, returnValue) {
+    logger.log(component, message, "error", { error: error instanceof Error ? error.message : String(error) }).catch(() => { });
+    return returnValue;
+}
+export function logWarning(logger, component, message, details) {
+    logger.log(component, message, "warning", details).catch(() => { });
+}
+export function logInfo(logger, component, message, details) {
+    logger.log(component, message, "info", details).catch(() => { });
+}

package/dist/core/features-config.js

@@ -286,7 +286,7 @@ export class FeaturesConfigLoader {
      */
     getDefaultConfig() {
         return {
-            version: "2.0.1",
+            version: "2.1.1",
             description: "0xRay Framework - Unified Feature Configuration",
             token_optimization: {
                 enabled: true,

package/dist/core/framework-logger.d.ts

@@ -43,7 +43,7 @@ export declare class JobContext {
      * Log job completion with diagnostic info
      * Enhanced with outcome and complexity accuracy tracking
      */
-    complete(success?: boolean, details?: any): Promise<void>;
+    complete(success?: boolean, details?: Record<string, unknown>): Promise<void>;
 }
 export interface FrameworkLogEntry {
     timestamp: number;
@@ -56,7 +56,7 @@ export interface FrameworkLogEntry {
     traceId?: string;
     spanId?: string;
     parentSpanId?: string;
-    details?: any;
+    details?: Record<string, unknown>;
 }
 export declare class FrameworkUsageLogger {
     private logs;
@@ -66,7 +66,7 @@ export declare class FrameworkUsageLogger {
     private flushing;
     private readonly FLUSH_INTERVAL_MS;
     private readonly MAX_BUFFER_SIZE;
-    log(component: string, action: string, status: LogStatus, details?: any, sessionId?: string, jobId?: string): Promise<void>;
+    log(component: string, action: string, status: LogStatus, details?: Record<string, unknown>, sessionId?: string, jobId?: string): Promise<void>;
     private bufferEntry;
     private flushBuffer;
     getRecentLogs(count?: number): FrameworkLogEntry[];

package/dist/core/framework-logger.js

@@ -75,21 +75,21 @@ export function withJobContext(operation, jobId) {
         if (result instanceof Promise) {
             return result.finally(async () => {
                 // Auto-complete job on operation finish
-                await jobContext.complete(true).catch(() => { });
+                await jobContext.complete(true);
                 // Restore original context
                 currentJobContext = originalContext;
             });
         }
         else {
             // Sync operation - complete immediately
-            jobContext.complete(true).catch(() => { });
+            jobContext.complete(true);
             currentJobContext = originalContext;
             return Promise.resolve(result);
         }
     }
     catch (error) {
         // Error occurred - complete job with failure
-        jobContext.complete(false, { error: String(error) }).catch(() => { });
+        jobContext.complete(false, { error: String(error) });
         currentJobContext = originalContext;
         throw error;
     }
@@ -204,7 +204,7 @@ export class FrameworkUsageLogger {
             ...(currentTraceId && { traceId: currentTraceId }),
             ...(currentSpanId && { spanId: currentSpanId }),
             ...(currentParentSpanId && { parentSpanId: currentParentSpanId }),
-            details,
+            ...(details !== undefined && { details }),
         };
         this.logs.push(entry);
         if (this.logs.length > this.maxLogs) {
@@ -212,7 +212,7 @@ export class FrameworkUsageLogger {
         }
         this.bufferEntry(entry);
     }
-    bufferEntry(entry) {
+    async bufferEntry(entry) {
         const jobIdPart = entry.jobId ? `[${entry.jobId}] ` : "";
         const tracePart = entry.traceId ? `[${entry.traceId}.${entry.spanId}] ` : "";
         const detailsPart = entry.details
@@ -226,7 +226,7 @@ export class FrameworkUsageLogger {
         const line = `${new Date(entry.timestamp).toISOString()} ${jobIdPart}${tracePart}[${entry.component}] ${entry.action} - ${entry.status.toUpperCase()}${detailsPart}\n`;
         this.buffer.push(line);
         if (this.buffer.length >= this.MAX_BUFFER_SIZE) {
-            this.flushBuffer();
+            await this.flushBuffer();
             return;
         }
         if (!this.flushTimer) {
@@ -247,17 +247,21 @@ export class FrameworkUsageLogger {
         const data = toWrite.join("");
         try {
             const cwd = process.cwd();
-            if (!cwd)
+            if (!cwd) {
+                this.flushing = false;
                 return;
+            }
             const logDir = join(cwd, "logs", "framework");
             const logFile = join(logDir, "activity.log");
             if (!existsSync(logDir)) {
                 mkdirSync(logDir, { recursive: true });
             }
-            await fs.appendFile(logFile, data).catch(() => { });
-            this.flushing = false;
+            await fs.appendFile(logFile, data);
         }
         catch {
+            // flush failure is non-fatal
+        }
+        finally {
             this.flushing = false;
         }
     }
@@ -273,3 +277,7 @@ export class FrameworkUsageLogger {
     }
 }
 export const frameworkLogger = new FrameworkUsageLogger();
+// Startup self-test: verify logger works
+if (typeof process !== "undefined" && process.env?.NODE_ENV !== "test") {
+    frameworkLogger.log("system", "logger initialized", "info").catch(() => { });
+}

package/dist/core/index.d.ts

@@ -1,5 +1,5 @@
 export { KernelOrchestrator } from "./orchestrator.js";
-export { defaultXrayConfig, defaultXrayConfig as defaultStringRayConfig } from "./xray-activation.js";
-export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, STRRAY_CONFIG_DIR_ENV, } from "./config-paths.js";
+export { defaultXrayConfig } from "./xray-activation.js";
+export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, XRAY_CONFIG_DIR_ENV, } from "./config-paths.js";
 export { formatCodexPrompt, formatMinimalCodexPrompt, getCodexConfig, findCodexPath, loadCodex, BUILTIN_CODEX, } from "./codex-formatter.js";
 export type { CodexTerm, CodexConfig, FormatOptions, FormatResult, } from "./codex-formatter.js";

package/dist/core/index.js

@@ -1,6 +1,8 @@
 export { KernelOrchestrator } from "./orchestrator.js";
-export { defaultXrayConfig, defaultXrayConfig as defaultStringRayConfig } from "./xray-activation.js"; // consumer runtime compat from prior StringRay releases (1-line min per Scope Rule)
+export { defaultXrayConfig } from "./xray-activation.js";
 // Decoupled config path resolution (Layer 1)
-export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, STRRAY_CONFIG_DIR_ENV, } from "./config-paths.js";
+export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, XRAY_CONFIG_DIR_ENV,
+// STRRAY_CONFIG_DIR_ENV (legacy export for compat shims)
+ } from "./config-paths.js";
 // Standalone codex formatter (Layer 2)
 export { formatCodexPrompt, formatMinimalCodexPrompt, getCodexConfig, findCodexPath, loadCodex, BUILTIN_CODEX, } from "./codex-formatter.js";

package/dist/core/logging-config.d.ts

@@ -1,3 +1,4 @@
+import type { LogStatus } from "./framework-logger.js";
 export interface LoggingConfig {
     enabled: boolean;
     level: "debug" | "info" | "warn" | "error";
@@ -7,4 +8,4 @@ export interface LoggingConfig {
 export declare function getLoggingConfig(): LoggingConfig;
 export declare function setLoggingConfig(config: Partial<LoggingConfig>): void;
 export declare function isLoggingEnabled(): boolean;
-export declare function shouldLog(level: string): boolean;
+export declare function shouldLog(level: LogStatus): boolean;

package/dist/core/logging-config.js

@@ -1,9 +1,9 @@
 // Default logging configuration
 const defaultLoggingConfig = {
-    enabled: process.env.STRRAY_LOGGING_ENABLED !== "false", // Default true, can be disabled
-    level: process.env.STRRAY_LOG_LEVEL || "info",
+    enabled: (process.env.XRAY_LOGGING_ENABLED) !== "false", // Default true, can be disabled
+    level: (process.env.XRAY_LOG_LEVEL) || "info",
     destinations: ["console", "file"],
-    performanceMode: process.env.STRRAY_PERFORMANCE_MODE === "true",
+    performanceMode: (process.env.XRAY_PERFORMANCE_MODE) === "true",
 };
 // Available log levels in priority order (higher index = more verbose)
 const LOG_LEVELS = ["debug", "info", "warn", "error"];
@@ -32,12 +32,12 @@ export function shouldLog(level) {
     return messageLevelIndex >= currentLevelIndex;
 }
 // Environment variable configuration
-if (process.env.STRRAY_LOGGING_ENABLED === "false") {
+if ((process.env.XRAY_LOGGING_ENABLED) === "false") {
     setLoggingConfig({ enabled: false });
 }
-if (process.env.STRRAY_LOG_LEVEL) {
-    setLoggingConfig({ level: process.env.STRRAY_LOG_LEVEL });
+if (process.env.XRAY_LOG_LEVEL) {
+    setLoggingConfig({ level: (process.env.XRAY_LOG_LEVEL) });
 }
-if (process.env.STRRAY_PERFORMANCE_MODE === "true") {
+if ((process.env.XRAY_PERFORMANCE_MODE) === "true") {
     setLoggingConfig({ performanceMode: true });
 }

package/dist/enforcement/loaders/codex-loader.js

@@ -36,7 +36,7 @@ export class CodexLoader extends BaseLoader {
         const candidates = resolveCodexPath();
         const found = candidates.find((p) => existsSync(p));
         // Fallback to primary path even if not found yet
-        return found ?? candidates[0] ?? this.resolvePath(".opencode/xray/codex.json");
+        return found ?? candidates[0] ?? this.resolvePath("xray/codex.json");
     }
     /**
      * Check if codex.json exists.

package/dist/execution/opencode-cli-invoker.js

@@ -17,7 +17,7 @@ import { getConfigDir } from "../core/config-paths.js";
 let opencodeAvailable = null;
 export async function invokeViaOpencode(agentName, prompt, projectRoot = process.cwd()) {
     // In pure MCP mode we must never reach here
-    if (process.env.STRRAY_FORCE_MCP_GOVERNANCE === "true") {
+    if ((process.env.XRAY_FORCE_MCP_GOVERNANCE) === "true") {
         throw new Error(`[PURE MCP] invokeViaOpencode called for "${agentName}" — this path is forbidden.`);
     }
     // GATE: Centralized spawn gate — blocks all agent spawning by default
@@ -79,7 +79,7 @@ export async function invokeViaOpencode(agentName, prompt, projectRoot = process
                 settled = true;
                 child.kill("SIGKILL");
                 if (trackingId) {
-                    agentSpawnGovernor.failSpawn(trackingId, new Error(`opencode ${agentName} timed out`)).catch(() => { });
+                    agentSpawnGovernor.failSpawn(trackingId, new Error(`opencode ${agentName} timed out`)).catch((err) => frameworkLogger.log("opencode-cli-invoker", "spawn-governor-error", "error", { error: String(err) }));
                 }
                 reject(new Error(`opencode ${agentName} timed out`));
             }
@@ -103,7 +103,7 @@ export async function invokeViaOpencode(agentName, prompt, projectRoot = process
             settled = true;
             if (code === 0 && stdout.trim()) {
                 if (trackingId) {
-                    await agentSpawnGovernor.completeSpawn(trackingId, true).catch(() => { });
+                    await agentSpawnGovernor.completeSpawn(trackingId, true).catch((err) => frameworkLogger.log("opencode-cli-invoker", "spawn-governor-error", "error", { error: String(err) }));
                 }
                 frameworkLogger.log("inference-cycle", "opencode-spawn-success", "info", { agentName, trackingId });
                 const textResponse = extractTextFromNdjson(stdout.trim());
@@ -117,7 +117,7 @@ export async function invokeViaOpencode(agentName, prompt, projectRoot = process
             else {
                 const error = new Error(`${agentName} exited ${code}`);
                 if (trackingId) {
-                    await agentSpawnGovernor.failSpawn(trackingId, error).catch(() => { });
+                    await agentSpawnGovernor.failSpawn(trackingId, error).catch((err) => frameworkLogger.log("opencode-cli-invoker", "spawn-governor-error", "error", { error: String(err) }));
                 }
                 frameworkLogger.log("inference-cycle", "opencode-spawn-failed", "error", { agentName, trackingId, code });
                 reject(error);
@@ -128,7 +128,7 @@ export async function invokeViaOpencode(agentName, prompt, projectRoot = process
             if (!settled) {
                 settled = true;
                 if (trackingId) {
-                    await agentSpawnGovernor.failSpawn(trackingId, err).catch(() => { });
+                    await agentSpawnGovernor.failSpawn(trackingId, err).catch((e) => frameworkLogger.log("opencode-cli-invoker", "spawn-governor-error", "error", { error: String(e) }));
                 }
                 frameworkLogger.log("inference-cycle", "opencode-spawn-error", "error", { agentName, trackingId, error: err.message });
                 reject(err);

package/dist/governance/governance-service.js

@@ -39,7 +39,7 @@ export class GovernanceService {
      */
     async govern(request) {
         const { proposals, context, options } = request;
-        const requireExternal = options?.requireExternalDynamo ?? true;
+        const requireExternal = options?.requireExternalDynamo ?? !process.env.XRAY_LOCAL_MODE;
         const timeoutMs = options?.timeoutMs ?? 90000;
         const maxAbstentionThreshold = options?.maxAbstentionThreshold ?? 1.0;
         frameworkLogger.log('governance-service', 'govern-start', 'info', {

package/dist/index.d.ts

@@ -4,13 +4,13 @@
  * This is the main entry point for the 0xRay framework.
  * It exports the core initialization function and key components.
  */
-export { XrayOrchestrator, XrayOrchestrator as StringRayOrchestrator } from "./orchestrator/orchestrator.js";
-export { XrayStateManager, XrayStateManager as StringRayStateManager } from "./state/index.js";
+export { XrayOrchestrator } from "./orchestrator/orchestrator.js";
+export { XrayStateManager } from "./state/index.js";
 export { AgentDelegator } from "./delegation/index.js";
 export { frameworkLogger } from "./core/framework-logger.js";
 export { BUILTIN_CODEX } from "./core/codex-formatter.js";
 import { defaultXrayConfig } from "./core/index.js";
-export { defaultXrayConfig, defaultXrayConfig as defaultStringRayConfig };
+export { defaultXrayConfig };
 export { OpenClawIntegration, initializeOpenClawIntegration, getOpenClawIntegration, shutdownOpenClawIntegration } from "./integrations/openclaw/index.js";
 export type { OpenClawIntegrationConfig } from "./integrations/openclaw/types.js";
 export declare function initializeXray(config?: {}): {

package/dist/index.js

@@ -4,13 +4,13 @@
  * This is the main entry point for the 0xRay framework.
  * It exports the core initialization function and key components.
  */
-export { XrayOrchestrator, XrayOrchestrator as StringRayOrchestrator } from "./orchestrator/orchestrator.js";
-export { XrayStateManager, XrayStateManager as StringRayStateManager } from "./state/index.js";
+export { XrayOrchestrator } from "./orchestrator/orchestrator.js";
+export { XrayStateManager } from "./state/index.js";
 export { AgentDelegator } from "./delegation/index.js";
 export { frameworkLogger } from "./core/framework-logger.js";
 export { BUILTIN_CODEX } from "./core/codex-formatter.js";
 import { defaultXrayConfig } from "./core/index.js";
-export { defaultXrayConfig, defaultXrayConfig as defaultStringRayConfig };
+export { defaultXrayConfig };
 export { OpenClawIntegration, initializeOpenClawIntegration, getOpenClawIntegration, shutdownOpenClawIntegration } from "./integrations/openclaw/index.js";
 // Main initialization function
 export function initializeXray(config = {}) {

package/dist/inference/inference-cycle.d.ts

@@ -75,7 +75,7 @@ export declare class InferenceCycle {
     private governProposalsInternal;
     /**
      * Pure individual knowledge-skill MCP path for governance.
-     * Used when STRRAY_FORCE_MCP_GOVERNANCE=true.
+     * Used when XRAY_FORCE_MCP_GOVERNANCE=true.
      * Each proposal is evaluated directly by the relevant skill servers using analyze_proposal.
      */
     private governProposalsWithIndividualSkills;

package/dist/inference/inference-cycle.js

@@ -328,7 +328,7 @@ export class InferenceCycle {
         try {
             let agentName = p.type === "refactor" ? "refactorer" : "code-reviewer";
             // In pure MCP mode, use real skill server names so the orchestrator dispatches to actual MCP tools
-            if (process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true') {
+            if ((process.env.XRAY_FORCE_MCP_GOVERNANCE) === 'true') {
                 agentName = p.type === "refactor" ? "refactoring-strategies" : "code-review";
             }
             await this.invokeAgentInternal(agentName, prompt);
@@ -353,11 +353,11 @@ export class InferenceCycle {
             ``,
             `1. Read the relevant source files`,
             `2. Add the missing guard, validation, or edge case handling`,
-            `3. If this is a codex rule, add the term to .opencode/xray/codex.json`,
+            `3. If this is a codex rule, add the term to xray/codex.json`,
             `4. Make minimal, surgical changes`,
         ].join("\n");
         try {
-            const agentName = process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true'
+            const agentName = (process.env.XRAY_FORCE_MCP_GOVERNANCE) === 'true'
                 ? "code-review"
                 : "code-reviewer";
             await this.invokeAgentInternal(agentName, prompt);
@@ -388,7 +388,7 @@ export class InferenceCycle {
             `3. Implement it if straightforward, otherwise describe the design`,
         ].join("\n");
         try {
-            const agentName = process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true'
+            const agentName = (process.env.XRAY_FORCE_MCP_GOVERNANCE) === 'true'
                 ? "architecture-patterns"
                 : "architect";
             await this.invokeAgentInternal(agentName, prompt);
@@ -455,7 +455,7 @@ Respond with EXACTLY one of:
     async governProposals(proposals) {
         // Primary path: Use the first-class Governance MCP (real skill servers + required Dynamo)
         // This is the clean, centralized path (governance.server.ts + GovernanceService)
-        const useGovernanceMcp = process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true' ||
+        const useGovernanceMcp = (process.env.XRAY_FORCE_MCP_GOVERNANCE) === 'true' ||
             this.isGovernanceMcpPreferred();
         if (useGovernanceMcp) {
             try {
@@ -488,7 +488,7 @@ Respond with EXACTLY one of:
                     error: err instanceof Error ? err.message : String(err),
                 });
                 // In forced pure MCP mode we must not silently fall back
-                if (process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true') {
+                if (process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true') {
                     throw err;
                 }
                 // In normal mode, fall back to legacy path with deprecation warning.
@@ -552,7 +552,7 @@ Respond with EXACTLY one of:
      */
     async governProposalsInternal(proposals) {
         // Defensive: if pure MCP mode is forced, use individual skill servers only
-        if (process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true') {
+        if ((process.env.XRAY_FORCE_MCP_GOVERNANCE) === 'true') {
             return this.governProposalsWithIndividualSkills(proposals);
         }
         const coordinator = this.getCoordinator();
@@ -633,7 +633,7 @@ Respond with EXACTLY one of:
     }
     /**
      * Pure individual knowledge-skill MCP path for governance.
-     * Used when STRRAY_FORCE_MCP_GOVERNANCE=true.
+     * Used when XRAY_FORCE_MCP_GOVERNANCE=true.
      * Each proposal is evaluated directly by the relevant skill servers using analyze_proposal.
      */
     async governProposalsWithIndividualSkills(proposals) {
@@ -801,7 +801,7 @@ Respond with EXACTLY one of:
                 responseText = JSON.stringify(result);
             }
             // In pure MCP governance mode, trust the orchestrator response (it now does real work)
-            const isPureMcp = process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true';
+            const isPureMcp = (process.env.XRAY_FORCE_MCP_GOVERNANCE) === 'true';
             const hasRealContent = /PROPOSAL:\s*\d+/i.test(responseText) ||
                 /DECISION:\s*(approve|reject|abstain)/i.test(responseText) ||
                 /Agent Outputs \(real MCP responses\):/i.test(responseText);
@@ -830,7 +830,7 @@ Respond with EXACTLY one of:
             return this.agentInvoker(agentName, prompt);
         }
         // Only fall back to OpenCode if not in forced pure MCP mode
-        if (process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true') {
+        if ((process.env.XRAY_FORCE_MCP_GOVERNANCE) === 'true') {
             throw new Error(`[PURE MCP] Orchestrator returned no usable response for agent "${agentName}" and OpenCode fallback is disabled`);
         }
         return this.invokeViaOpencode(agentName, prompt);

package/dist/integrations/base/Integration.js

@@ -315,7 +315,7 @@ export class BaseIntegration extends EventEmitter {
                 version: this.version,
                 status: this._status,
                 jobId: this.jobId,
-            }, this.jobId);
+            }, undefined, this.jobId);
         }
         catch {
             // Silent fail - logging should never break application

package/dist/integrations/base/registry.js

@@ -93,7 +93,7 @@ export class IntegrationRegistry extends EventEmitter {
             name,
             version: integration.version,
         });
-        frameworkLogger.log("integration-registry", `Registered integration: ${name} v${integration.version}`, "info", { name, version: integration.version }, this.jobId).catch(() => { });
+        frameworkLogger.log("integration-registry", `Registered integration: ${name} v${integration.version}`, "info", { name, version: integration.version });
     }
     /**
      * Unregister an integration from the registry
@@ -109,12 +109,12 @@ export class IntegrationRegistry extends EventEmitter {
         // If loaded, unload first
         if (this.loadedIntegrations.has(name)) {
             this.unload(name).catch((error) => {
-                frameworkLogger.log("integration-registry", `Error unloading integration '${name}' during unregister: ${error}`, "error", { name, error: String(error) }, this.jobId).catch(() => { });
+                frameworkLogger.log("integration-registry", `Error unloading integration '${name}' during unregister: ${error}`, "error", { name, error: String(error) });
             });
         }
         this.registeredIntegrations.delete(name);
         this.emitEvent("integration-unregistered", { name });
-        frameworkLogger.log("integration-registry", `Unregistered integration: ${name}`, "info", { name }, this.jobId).catch(() => { });
+        frameworkLogger.log("integration-registry", `Unregistered integration: ${name}`, "info", { name });
     }
     // ==========================================================================
     // Accessor Methods
@@ -184,7 +184,7 @@ export class IntegrationRegistry extends EventEmitter {
     async load(name, config) {
         // Check if already loaded
         if (this.loadedIntegrations.has(name)) {
-            frameworkLogger.log("integration-registry", `Integration '${name}' already loaded`, "warning", { name }, this.jobId).catch(() => { });
+            frameworkLogger.log("integration-registry", `Integration '${name}' already loaded`, "warning", { name });
             return;
         }
         const integration = this.registeredIntegrations.get(name);
@@ -211,7 +211,7 @@ export class IntegrationRegistry extends EventEmitter {
                 name,
                 version: integration.version,
             });
-            frameworkLogger.log("integration-registry", `Loaded integration: ${name}`, "success", { name, version: integration.version }, this.jobId).catch(() => { });
+            frameworkLogger.log("integration-registry", `Loaded integration: ${name}`, "success", { name, version: integration.version });
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -239,7 +239,7 @@ export class IntegrationRegistry extends EventEmitter {
             // Remove from loaded map
             this.loadedIntegrations.delete(name);
             this.emitEvent("integration-unloaded", { name });
-            frameworkLogger.log("integration-registry", `Unloaded integration: ${name}`, "success", { name }, this.jobId).catch(() => { });
+            frameworkLogger.log("integration-registry", `Unloaded integration: ${name}`, "success", { name });
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -250,7 +250,7 @@ export class IntegrationRegistry extends EventEmitter {
                 error: errorMessage,
                 phase: "unload",
             }, error instanceof Error ? error : undefined);
-            frameworkLogger.log("integration-registry", `Error unloading integration '${name}': ${errorMessage}`, "error", { name, error: errorMessage }, this.jobId).catch(() => { });
+            frameworkLogger.log("integration-registry", `Error unloading integration '${name}': ${errorMessage}`, "error", { name, error: errorMessage });
         }
     }
     /**
@@ -261,14 +261,14 @@ export class IntegrationRegistry extends EventEmitter {
     async loadAll(config) {
         const entries = Object.entries(config.integrations);
         const enabledEntries = entries.filter(([, entry]) => entry.enabled);
-        frameworkLogger.log("integration-registry", `Loading ${enabledEntries.length} enabled integrations...`, "info", { total: entries.length, enabled: enabledEntries.length }, this.jobId).catch(() => { });
+        frameworkLogger.log("integration-registry", `Loading ${enabledEntries.length} enabled integrations...`, "info", { total: entries.length, enabled: enabledEntries.length });
         const results = [];
         // Load all enabled integrations
         for (const [name, entry] of enabledEntries) {
             try {
                 // Check if registered
                 if (!this.registeredIntegrations.has(name)) {
-                    frameworkLogger.log("integration-registry", `Skipping '${name}': not registered`, "warning", { name }, this.jobId).catch(() => { });
+                    frameworkLogger.log("integration-registry", `Skipping '${name}': not registered`, "warning", { name });
                     results.push({ name, success: false, error: "Not registered" });
                     continue;
                 }
@@ -282,7 +282,7 @@ export class IntegrationRegistry extends EventEmitter {
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 results.push({ name, success: false, error: errorMessage });
-                frameworkLogger.log("integration-registry", `Failed to load integration '${name}': ${errorMessage}`, "error", { name, error: errorMessage }, this.jobId).catch(() => { });
+                frameworkLogger.log("integration-registry", `Failed to load integration '${name}': ${errorMessage}`, "error", { name, error: errorMessage });
             }
         }
         this.emitEvent("load-complete", {
@@ -293,14 +293,14 @@ export class IntegrationRegistry extends EventEmitter {
         });
         const succeeded = results.filter((r) => r.success).length;
         const failed = results.filter((r) => !r.success).length;
-        frameworkLogger.log("integration-registry", `Load complete: ${succeeded} succeeded, ${failed} failed`, failed > 0 ? "warning" : "success", { succeeded, failed }, this.jobId).catch(() => { });
+        frameworkLogger.log("integration-registry", `Load complete: ${succeeded} succeeded, ${failed} failed`, failed > 0 ? "warning" : "success", { succeeded, failed });
     }
     /**
      * Unload all loaded integrations
      */
     async unloadAll() {
         const loadedNames = Array.from(this.loadedIntegrations.keys());
-        frameworkLogger.log("integration-registry", `Unloading ${loadedNames.length} integrations...`, "info", { count: loadedNames.length }, this.jobId).catch(() => { });
+        frameworkLogger.log("integration-registry", `Unloading ${loadedNames.length} integrations...`, "info", { count: loadedNames.length });
         const results = [];
         // Unload all loaded integrations
         for (const name of loadedNames) {
@@ -321,7 +321,7 @@ export class IntegrationRegistry extends EventEmitter {
         });
         const succeeded = results.filter((r) => r.success).length;
         const failed = results.filter((r) => !r.success).length;
-        frameworkLogger.log("integration-registry", `Unload complete: ${succeeded} succeeded, ${failed} failed`, failed > 0 ? "warning" : "success", { succeeded, failed }, this.jobId).catch(() => { });
+        frameworkLogger.log("integration-registry", `Unload complete: ${succeeded} succeeded, ${failed} failed`, failed > 0 ? "warning" : "success", { succeeded, failed });
     }
     // ==========================================================================
     // Health and Stats Methods
@@ -427,7 +427,7 @@ export class IntegrationRegistry extends EventEmitter {
                 this.registeredIntegrations.delete(name);
             }
         }
-        frameworkLogger.log("integration-registry", "Cleared non-loaded integrations", "info", { cleared: names.length - this.loadedIntegrations.size }, this.jobId).catch(() => { });
+        frameworkLogger.log("integration-registry", "Cleared non-loaded integrations", "info", { cleared: names.length - this.loadedIntegrations.size });
     }
     /**
      * Get registry statistics
@@ -494,7 +494,7 @@ export async function discoverIntegrations(integrationsPath) {
         const path = await import("path");
         // Check if directory exists
         if (!fs.existsSync(integrationsPath)) {
-            frameworkLogger.log("integration-registry", `Integrations directory not found: ${integrationsPath}`, "warning", { path: integrationsPath }).catch(() => { });
+            frameworkLogger.log("integration-registry", `Integrations directory not found: ${integrationsPath}`, "warning", { path: integrationsPath });
             return discovered;
         }
         // Read directory contents
@@ -533,18 +533,18 @@ export async function discoverIntegrations(integrationsPath) {
                         path: indexPath,
                         module,
                     });
-                    frameworkLogger.log("integration-registry", `Discovered integration: ${name}`, "info", { name, path: indexPath }).catch(() => { });
+                    frameworkLogger.log("integration-registry", `Discovered integration: ${name}`, "info", { name, path: indexPath });
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
-                    frameworkLogger.log("integration-registry", `Failed to load integration from ${indexPath}: ${errorMessage}`, "warning", { path: indexPath, error: errorMessage }).catch(() => { });
+                    frameworkLogger.log("integration-registry", `Failed to load integration from ${indexPath}: ${errorMessage}`, "warning", { path: indexPath, error: errorMessage });
                 }
             }
         }
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        frameworkLogger.log("integration-registry", `Error during integration discovery: ${errorMessage}`, "error", { error: errorMessage }).catch(() => { });
+        frameworkLogger.log("integration-registry", `Error during integration discovery: ${errorMessage}`, "error", { error: errorMessage });
     }
     return discovered;
 }
@@ -595,7 +595,7 @@ export async function autoRegisterIntegrations(registry, integrationsPath) {
         catch (error) {
             // Skip integrations that fail to register (already registered, etc.)
             const errorMessage = error instanceof Error ? error.message : String(error);
-            frameworkLogger.log("integration-registry", `Failed to register integration '${d.name}': ${errorMessage}`, "warning", { name: d.name, error: errorMessage }).catch(() => { });
+            frameworkLogger.log("integration-registry", `Failed to register integration '${d.name}': ${errorMessage}`, "warning", { name: d.name, error: errorMessage });
         }
     }
     return registered;