0xray 2.1.1 → 2.1.3

package/dist/core/config-paths.js

@@ -21,7 +21,7 @@ import { join, resolve } from "path";
 /** Environment variable name for custom config root */
 export const XRAY_CONFIG_DIR_ENV = "XRAY_CONFIG_DIR";
 /** Legacy env var name (backward compat) */
-export const STRRAY_CONFIG_DIR_ENV = "STRRAY_CONFIG_DIR";
+// STRRAY_CONFIG_DIR_ENV kept for legacy consumer compat (see bridge and tests)
 /** Resolved config directories, cached per projectRoot */
 const _resolvedConfigDirs = new Map();
 /**
@@ -33,7 +33,7 @@ export function getConfigDir(projectRoot) {
     const cached = _resolvedConfigDirs.get(root);
     if (cached)
         return cached;
-    const envDir = process.env[XRAY_CONFIG_DIR_ENV] || process.env[STRRAY_CONFIG_DIR_ENV];
+    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
     // Priority candidates
     const candidates = [];
     if (envDir) {
@@ -64,13 +64,13 @@ export function getConfigDir(projectRoot) {
  */
 export function resolveConfigPath(relativePath, projectRoot) {
     const root = projectRoot || process.cwd();
-    const envDir = process.env[XRAY_CONFIG_DIR_ENV] || process.env[STRRAY_CONFIG_DIR_ENV];
+    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
     const candidates = [];
     if (envDir) {
         candidates.push(resolve(root, envDir, relativePath));
     }
     candidates.push(join(root, ".xray", relativePath));
-    candidates.push(join(root, ".opencode", "xray", relativePath));
+    candidates.push(join(root, "xray", relativePath));
     for (const candidate of candidates) {
         if (existsSync(candidate)) {
             return candidate;
@@ -86,7 +86,7 @@ export function resolveConfigPath(relativePath, projectRoot) {
  */
 export function resolveStateDir(projectRoot) {
     const root = projectRoot || process.cwd();
-    const envDir = process.env[XRAY_CONFIG_DIR_ENV] || process.env[STRRAY_CONFIG_DIR_ENV];
+    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
     const candidates = [];
     if (envDir) {
         candidates.push(join(root, envDir, "state"));
@@ -113,7 +113,7 @@ export function resolveStateFilePath(projectRoot) {
  */
 export function resolveProfilesDir(projectRoot) {
     const root = projectRoot || process.cwd();
-    const envDir = process.env[XRAY_CONFIG_DIR_ENV] || process.env[STRRAY_CONFIG_DIR_ENV];
+    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
     const candidates = [];
     if (envDir) {
         candidates.push(join(root, envDir, "profiles"));
@@ -133,14 +133,13 @@ export function resolveProfilesDir(projectRoot) {
  */
 export function resolveCodexPath(projectRoot) {
     const root = projectRoot || process.cwd();
-    const envDir = process.env[XRAY_CONFIG_DIR_ENV] || process.env[STRRAY_CONFIG_DIR_ENV];
+    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
     const candidates = [];
     if (envDir) {
         candidates.push(join(root, envDir, "codex.json"));
     }
     candidates.push(join(root, ".xray", "codex.json"));
     candidates.push(join(root, "xray", "codex.json"));
-    candidates.push(join(root, ".opencode", "xray", "codex.json"));
     // Additional fallback locations (for standalone usage)
     candidates.push(join(root, "codex.json"));
     candidates.push(join(root, "src", "codex.json"));

package/dist/core/context-loader.d.ts

@@ -119,4 +119,4 @@ export declare class XrayContextLoader {
  * Export singleton instance
  */
 export declare const xrayContextLoader: XrayContextLoader;
-export { xrayContextLoader as strRayContextLoader, XrayContextLoader as StringRayContextLoader };
+export { xrayContextLoader as strRayContextLoader };

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