0xray 2.0.0

package/dist/services/inference-tuner.js

@@ -0,0 +1,301 @@
+/**
+ * Inference Tuner - Autonomous Learning Service
+ *
+ * Implements the autonomous inference improvement loop:
+ * 1. Collects routing outcomes and pattern metrics
+ * 2. Analyzes performance and detects drift
+ * 3. Generates refinement reports
+ * 4. Updates configuration automatically
+ *
+ * @module services
+ * @version 1.0.0
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { routingOutcomeTracker } from "../delegation/analytics/outcome-tracker.js";
+import { patternPerformanceTracker } from "../analytics/pattern-performance-tracker.js";
+import { routingPerformanceAnalyzer } from "../analytics/routing-performance-analyzer.js";
+import { promptPatternAnalyzer } from "../analytics/prompt-pattern-analyzer.js";
+import { routingRefiner } from "../analytics/routing-refiner.js";
+import { getAdaptiveKernel } from "../core/adaptive-kernel.js";
+import { frameworkLogger } from "../core/framework-logger.js";
+const DEFAULT_CONFIG = {
+    autoUpdateMappings: true,
+    autoUpdateThresholds: true,
+    minConfidenceThreshold: 0.7,
+    minSuccessRateForAutoAdd: 0.8,
+    learningIntervalMs: 60000,
+    maxMappingsToAdd: 5,
+};
+export class InferenceTuner {
+    config;
+    lastTuningTime = 0;
+    tuningInProgress = false;
+    tuningInterval = null;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Start autonomous tuning
+     */
+    start() {
+        if (this.tuningInterval) {
+            return;
+        }
+        frameworkLogger.log("inference-tuner", "starting", "info", { config: this.config });
+        this.tuningInterval = setInterval(() => {
+            this.runTuningCycle().catch((err) => {
+                frameworkLogger.log("inference-tuner", "tuning-error", "error", { error: String(err) });
+            });
+        }, this.config.learningIntervalMs);
+        this.runTuningCycle().catch((e) => frameworkLogger.log("inference-tuner", "initial-tuning-error", "error", { error: e }));
+    }
+    /**
+     * Stop autonomous tuning
+     */
+    stop() {
+        if (this.tuningInterval) {
+            clearInterval(this.tuningInterval);
+            this.tuningInterval = null;
+            frameworkLogger.log("inference-tuner", "stopped", "info", {});
+        }
+    }
+    /**
+     * Run a single tuning cycle
+     */
+    async runTuningCycle() {
+        if (this.tuningInProgress) {
+            return;
+        }
+        this.tuningInProgress = true;
+        try {
+            routingOutcomeTracker.reloadFromDisk();
+            patternPerformanceTracker.loadFromDisk();
+            const outcomes = routingOutcomeTracker.getOutcomes();
+            const patterns = patternPerformanceTracker.getAllPatternMetrics();
+            if (outcomes.length < 5 && patterns.length < 3) {
+                frameworkLogger.log("inference-tuner", "skipping-insufficient-data", "debug", { outcomes: outcomes.length, patterns: patterns.length });
+                return;
+            }
+            frameworkLogger.log("inference-tuner", "tuning-cycle-start", "info", { outcomes: outcomes.length, patterns: patterns.length });
+            const results = await this.performTuning(outcomes, patterns);
+            if (results.mappingsUpdated) {
+                frameworkLogger.log("inference-tuner", "tuning-cycle-complete", "info", { mappingsAdded: results.mappingsAdded });
+            }
+            this.lastTuningTime = Date.now();
+        }
+        finally {
+            this.tuningInProgress = false;
+        }
+    }
+    /**
+     * Perform the actual tuning work
+     */
+    async performTuning(outcomes, patterns) {
+        const result = {
+            mappingsAdded: 0,
+            mappingsModified: 0,
+            thresholdsUpdated: false,
+            mappingsUpdated: false,
+        };
+        try {
+            const perfReport = routingPerformanceAnalyzer.generatePerformanceReport();
+            const promptAnalysis = promptPatternAnalyzer.analyzePromptPatterns();
+            const kernel = getAdaptiveKernel();
+            kernel.triggerLearning(outcomes.map(o => ({
+                taskId: o.taskId,
+                taskDescription: o.taskDescription,
+                routedAgent: o.routedAgent,
+                routedSkill: o.routedSkill,
+                confidence: o.confidence,
+                success: o.success ?? true
+            })), []);
+            if (this.config.autoUpdateMappings) {
+                const newMappings = this.suggestMappingsFromPatterns(patterns, outcomes);
+                for (const mapping of newMappings.slice(0, this.config.maxMappingsToAdd)) {
+                    const added = this.addKeywordMapping(mapping.keyword, mapping.agent, mapping.skill, mapping.confidence);
+                    if (added) {
+                        result.mappingsAdded++;
+                    }
+                }
+                result.mappingsUpdated = result.mappingsAdded > 0;
+            }
+            // Apply routing refiner suggestions
+            try {
+                const refinerReport = routingRefiner.generateRefinementReport();
+                const configUpdate = refinerReport.configurationUpdate;
+                if (configUpdate.newMappings.length > 0) {
+                    for (const suggestion of configUpdate.newMappings.slice(0, this.config.maxMappingsToAdd)) {
+                        const added = this.addKeywordMapping(suggestion.keyword, suggestion.targetAgent, suggestion.targetSkill, suggestion.suggestedConfidence);
+                        if (added) {
+                            result.mappingsAdded++;
+                        }
+                    }
+                    result.mappingsUpdated = result.mappingsUpdated || result.mappingsAdded > 0;
+                }
+            }
+            catch (refinerError) {
+                frameworkLogger.log("inference-tuner", "refiner-error", "warning", { error: String(refinerError) });
+            }
+        }
+        catch (error) {
+            frameworkLogger.log("inference-tuner", "tuning-error", "error", { error: String(error) });
+        }
+        return result;
+    }
+    /**
+     * Suggest new mappings based on patterns and outcomes
+     */
+    suggestMappingsFromPatterns(patterns, outcomes) {
+        const suggestions = [];
+        for (const pattern of patterns) {
+            if (pattern.totalUsages >= 3 && pattern.successRate >= this.config.minSuccessRateForAutoAdd) {
+                const parts = pattern.patternId.split(":");
+                const agent = parts[0] ?? "";
+                const skill = parts.length > 1 ? (parts[1] ?? parts[0] ?? "") : "";
+                if (!agent || !skill)
+                    continue;
+                const matchingOutcome = outcomes.find(o => o.routedAgent === agent);
+                if (matchingOutcome) {
+                    const words = matchingOutcome.taskDescription.toLowerCase().split(/\s+/);
+                    const significantWords = words.filter(w => w.length > 4 && !["the", "this", "that", "with", "from"].includes(w));
+                    if (significantWords.length > 0) {
+                        const keyword = significantWords[0] ?? "";
+                        if (keyword) {
+                            suggestions.push({
+                                keyword,
+                                agent,
+                                skill,
+                                confidence: Math.min(pattern.avgConfidence, 0.9),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return suggestions;
+    }
+    /**
+     * Resolve the path to the routing-mappings.json file.
+     * Checks multiple known locations and returns the first one found.
+     */
+    resolveMappingsPath() {
+        const candidates = [
+            path.resolve(process.cwd(), ".strray/routing-mappings.json"),
+            path.resolve(process.cwd(), "xray/routing-mappings.json"),
+            path.resolve(process.cwd(), ".opencode/strray/routing-mappings.json"),
+            path.resolve(process.cwd(), "routing-mappings.json"),
+        ];
+        for (const p of candidates) {
+            if (fs.existsSync(p))
+                return p;
+        }
+        return candidates[0] ?? null; // Default to primary location even if it doesn't exist yet
+    }
+    /**
+     * Load current routing mappings from disk.
+     */
+    loadMappings() {
+        const mappingsPath = this.resolveMappingsPath();
+        try {
+            if (mappingsPath && fs.existsSync(mappingsPath)) {
+                const data = fs.readFileSync(mappingsPath, "utf-8");
+                return JSON.parse(data);
+            }
+        }
+        catch {
+            // Fall through to empty array
+        }
+        return [];
+    }
+    /**
+     * Save routing mappings to disk.
+     */
+    saveMappings(mappings) {
+        const mappingsPath = this.resolveMappingsPath();
+        if (!mappingsPath)
+            return false;
+        try {
+            const dir = path.dirname(mappingsPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(mappingsPath, JSON.stringify(mappings, null, 2));
+            return true;
+        }
+        catch (error) {
+            frameworkLogger.log("inference-tuner", "mappings-save-error", "error", { error: String(error), path: mappingsPath });
+            return false;
+        }
+    }
+    /**
+     * Add a keyword mapping to the routing-mappings.json file.
+     *
+     * Checks for conflicts (keyword already mapped to a different agent)
+     * before adding. If the keyword already exists for the same agent,
+     * updates the confidence if the new value is higher.
+     */
+    addKeywordMapping(keyword, agent, skill, confidence) {
+        if (!keyword || keyword.length < 3)
+            return false;
+        if (!agent || !skill)
+            return false;
+        if (confidence < this.config.minConfidenceThreshold)
+            return false;
+        const mappings = this.loadMappings();
+        const normalizedKeyword = keyword.toLowerCase();
+        // Check if this keyword is already mapped to a DIFFERENT agent (conflict)
+        for (const mapping of mappings) {
+            if (mapping.keywords.some(k => k === normalizedKeyword)) {
+                if (mapping.agent !== agent) {
+                    // Conflict: keyword already belongs to another agent. Skip.
+                    frameworkLogger.log("inference-tuner", "mapping-conflict", "debug", { keyword: normalizedKeyword, existingAgent: mapping.agent, newAgent: agent });
+                    return false;
+                }
+                // Same agent — boost confidence if higher
+                if (confidence > mapping.confidence) {
+                    mapping.confidence = confidence;
+                    const saved = this.saveMappings(mappings);
+                    frameworkLogger.log("inference-tuner", "mapping-confidence-updated", "info", { keyword: normalizedKeyword, agent, oldConfidence: mapping.confidence, newConfidence: confidence });
+                    return saved;
+                }
+                return false; // Already exists with >= confidence
+            }
+        }
+        // Find existing mapping for this agent/skill combo to add keyword to
+        const existingMapping = mappings.find(m => m.agent === agent && m.skill === skill);
+        if (existingMapping) {
+            if (!existingMapping.keywords.includes(normalizedKeyword)) {
+                existingMapping.keywords.push(normalizedKeyword);
+                const saved = this.saveMappings(mappings);
+                frameworkLogger.log("inference-tuner", "keyword-added-to-mapping", "info", { keyword: normalizedKeyword, agent, skill });
+                return saved;
+            }
+            return false;
+        }
+        // Create a new mapping entry
+        mappings.push({
+            keywords: [normalizedKeyword],
+            skill,
+            agent,
+            confidence,
+        });
+        const saved = this.saveMappings(mappings);
+        if (saved) {
+            frameworkLogger.log("inference-tuner", "new-mapping-created", "info", { keyword: normalizedKeyword, agent, skill, confidence });
+        }
+        return saved;
+    }
+    /**
+     * Get tuning status
+     */
+    getStatus() {
+        return {
+            running: this.tuningInterval !== null,
+            lastTuningTime: this.lastTuningTime,
+            config: this.config,
+        };
+    }
+}
+// Singleton instance
+export const inferenceTuner = new InferenceTuner();

package/dist/session/index.js

@@ -0,0 +1,3 @@
+export { SessionCleanupManager, createSessionCleanupManager } from "./session-cleanup-manager.js";
+export { SessionMonitor, createSessionMonitor } from "./session-monitor.js";
+export { SessionStateManager, createSessionStateManager } from "./session-state-manager.js";

package/dist/session/session-cleanup-manager.js

@@ -0,0 +1,366 @@
+/**
+ * Session Cleanup Manager
+ *
+ * Manages automatic cleanup of sessions with TTL-based expiration,
+ * idle session detection, and manual cleanup utilities.
+ *
+ * @version 1.0.0
+ * @since 2026-01-07
+ */
+import { frameworkLogger } from "../core/framework-logger.js";
+export class SessionCleanupManager {
+    stateManager;
+    config;
+    cleanupInterval;
+    _sessionMetadata;
+    _metadataLoaded = false;
+    sessionMonitor;
+    constructor(stateManager, config = {}, sessionMonitor) {
+        this.stateManager = stateManager;
+        this.sessionMonitor = sessionMonitor;
+        this.config = {
+            ttlMs: 24 * 60 * 60 * 1000,
+            idleTimeoutMs: 2 * 60 * 60 * 1000,
+            maxSessions: 100,
+            cleanupIntervalMs: 5 * 60 * 1000,
+            enableAutoCleanup: true,
+            ...config,
+        };
+        this.initialize();
+    }
+    /**
+     * Lazy-loaded session metadata - loads from state manager on first access
+     */
+    get sessionMetadata() {
+        if (!this._metadataLoaded) {
+            this.loadSessionMetadata();
+            this._metadataLoaded = true;
+        }
+        return this._sessionMetadata;
+    }
+    set sessionMetadata(value) {
+        this._sessionMetadata = value;
+        this._metadataLoaded = true;
+    }
+    /**
+     * Initialize cleanup manager and start auto-cleanup if enabled
+     */
+    initialize() {
+        frameworkLogger.log("session-cleanup", "initialize", "info", {
+            enableAutoCleanup: this.config.enableAutoCleanup,
+            ttlMs: this.config.ttlMs,
+            idleTimeoutMs: this.config.idleTimeoutMs,
+            maxSessions: this.config.maxSessions,
+        });
+        this.loadSessionMetadata();
+        frameworkLogger.log("session-cleanup", "initialize", "success", {
+            autoCleanupEnabled: this.config.enableAutoCleanup,
+            note: "auto-cleanup timer deferred to explicit start() call",
+        });
+    }
+    start() {
+        if (this.cleanupInterval)
+            return;
+        if (this.config.enableAutoCleanup) {
+            this.startAutoCleanup();
+        }
+    }
+    /**
+     * Register a new session for cleanup tracking
+     */
+    registerSession(sessionId, ttlMs) {
+        const metadata = {
+            sessionId,
+            createdAt: Date.now(),
+            lastActivity: Date.now(),
+            ttlMs: ttlMs || this.config.ttlMs,
+            isActive: true,
+            agentCount: 0,
+            memoryUsage: 0,
+        };
+        this.sessionMetadata.set(sessionId, metadata);
+        this.persistSessionMetadata(sessionId, metadata);
+        frameworkLogger.log("session-cleanup", "register-session", "info", {
+            sessionId,
+            ttlMs: ttlMs || this.config.ttlMs,
+        });
+    }
+    updateActivity(sessionId) {
+        const metadata = this.sessionMetadata.get(sessionId);
+        if (metadata) {
+            metadata.lastActivity = Date.now();
+            this.persistSessionMetadata(sessionId, metadata);
+        }
+    }
+    updateMetadata(sessionId, updates) {
+        const metadata = this.sessionMetadata.get(sessionId);
+        if (metadata) {
+            Object.assign(metadata, updates);
+            this.persistSessionMetadata(sessionId, metadata);
+        }
+    }
+    /**
+     * Check if session should be cleaned up
+     */
+    shouldCleanup(sessionId) {
+        const metadata = this.sessionMetadata.get(sessionId);
+        if (!metadata)
+            return false;
+        const now = Date.now();
+        if (now - metadata.createdAt > metadata.ttlMs) {
+            return true;
+        }
+        if (now - metadata.lastActivity > this.config.idleTimeoutMs) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Perform cleanup of expired/idle sessions
+     */
+    async performCleanup() {
+        const jobId = `session-cleanup-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+        const result = {
+            sessionsCleaned: 0,
+            sessionsExpired: 0,
+            sessionsIdle: 0,
+            errors: [],
+        };
+        const sessionsToCleanup = [];
+        for (const [sessionId, metadata] of this.sessionMetadata) {
+            if (!metadata.isActive)
+                continue;
+            const now = Date.now();
+            if (now - metadata.createdAt > metadata.ttlMs) {
+                sessionsToCleanup.push(sessionId);
+                result.sessionsExpired++;
+            }
+            else if (now - metadata.lastActivity > this.config.idleTimeoutMs) {
+                sessionsToCleanup.push(sessionId);
+                result.sessionsIdle++;
+            }
+        }
+        if (this.sessionMetadata.size > this.config.maxSessions) {
+            const sortedSessions = Array.from(this.sessionMetadata.entries())
+                .filter(([_, metadata]) => metadata.isActive)
+                .sort((a, b) => a[1].lastActivity - b[1].lastActivity);
+            const excessCount = sortedSessions.length - this.config.maxSessions;
+            for (let i = 0; i < excessCount && i < sortedSessions.length; i++) {
+                const session = sortedSessions[i];
+                if (session) {
+                    sessionsToCleanup.push(session[0]);
+                }
+            }
+        }
+        for (const sessionId of sessionsToCleanup) {
+            try {
+                await this.cleanupSession(sessionId);
+                result.sessionsCleaned++;
+            }
+            catch (error) {
+                result.errors.push(`Failed to cleanup session ${sessionId}: ${error}`);
+            }
+        }
+        if (result.sessionsCleaned > 0) {
+            frameworkLogger.log("session-cleanup", "perform-cleanup", "info", {
+                jobId,
+                sessionsCleaned: result.sessionsCleaned,
+                sessionsExpired: result.sessionsExpired,
+                sessionsIdle: result.sessionsIdle,
+                errors: result.errors.length,
+            });
+        }
+        return result;
+    }
+    /**
+     * Manually cleanup a specific session
+     */
+    async manualCleanup(sessionId, reason) {
+        try {
+            const metadata = this.sessionMetadata.get(sessionId);
+            if (metadata) {
+                metadata.cleanupReason = reason || "manual";
+                this.persistSessionMetadata(sessionId, metadata);
+            }
+            await this.cleanupSession(sessionId);
+            frameworkLogger.log("session-cleanup", "manual-cleanup", "success", {
+                sessionId,
+                reason: reason || "manual",
+            });
+            return true;
+        }
+        catch (error) {
+            frameworkLogger.log("session-cleanup", "manual-cleanup-failed", "error", {
+                sessionId,
+                error,
+            });
+            return false;
+        }
+    }
+    /**
+     * Cleanup all sessions (emergency cleanup)
+     */
+    async emergencyCleanup() {
+        const result = {
+            sessionsCleaned: 0,
+            sessionsExpired: 0,
+            sessionsIdle: 0,
+            errors: [],
+        };
+        for (const sessionId of this.sessionMetadata.keys()) {
+            try {
+                await this.cleanupSession(sessionId);
+                result.sessionsCleaned++;
+            }
+            catch (error) {
+                result.errors.push(`Failed to cleanup session ${sessionId}: ${error}`);
+            }
+        }
+        frameworkLogger.log("session-cleanup", "emergency-cleanup", "info", {
+            sessionsCleaned: result.sessionsCleaned,
+            errors: result.errors.length,
+        });
+        return result;
+    }
+    /**
+     * Get cleanup statistics
+     */
+    getCleanupStats() {
+        const now = Date.now();
+        let expiredCount = 0;
+        let idleCount = 0;
+        for (const metadata of this.sessionMetadata.values()) {
+            if (!metadata.isActive)
+                continue;
+            if (now - metadata.createdAt > metadata.ttlMs) {
+                expiredCount++;
+            }
+            else if (now - metadata.lastActivity > this.config.idleTimeoutMs) {
+                idleCount++;
+            }
+        }
+        return {
+            totalSessions: this.sessionMetadata.size,
+            activeSessions: Array.from(this.sessionMetadata.values()).filter((m) => m.isActive).length,
+            expiredSessions: expiredCount,
+            idleSessions: idleCount,
+            nextCleanup: this.cleanupInterval
+                ? Date.now() + this.config.cleanupIntervalMs
+                : 0,
+        };
+    }
+    /**
+     * Get session metadata
+     */
+    getSessionMetadata(sessionId) {
+        return this.sessionMetadata.get(sessionId);
+    }
+    /**
+     * List all sessions with metadata
+     */
+    listSessions() {
+        return Array.from(this.sessionMetadata.values());
+    }
+    /**
+     * Start automatic cleanup interval
+     */
+    startAutoCleanup() {
+        this.cleanupInterval = setInterval(async () => {
+            try {
+                await this.performCleanup();
+            }
+            catch (error) {
+                frameworkLogger.log("session-cleanup", "auto-cleanup-failed", "error", {
+                    error,
+                });
+            }
+        }, this.config.cleanupIntervalMs);
+        frameworkLogger.log("session-cleanup", "start-auto-cleanup", "info", {
+            cleanupIntervalMs: this.config.cleanupIntervalMs,
+        });
+    }
+    /**
+     * Stop automatic cleanup
+     */
+    stopAutoCleanup() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = undefined;
+            frameworkLogger.log("session-cleanup", "stop-auto-cleanup", "info");
+        }
+    }
+    /**
+     * Load session metadata from state manager (lazy loading)
+     */
+    loadSessionMetadata() {
+        try {
+            const storedMetadata = this.stateManager.get("cleanup:session_metadata");
+            this._sessionMetadata = new Map();
+            if (storedMetadata &&
+                typeof storedMetadata === "object" &&
+                !Array.isArray(storedMetadata)) {
+                for (const [sessionId, metadata] of Object.entries(storedMetadata)) {
+                    if (metadata && typeof metadata === "object" && metadata.sessionId) {
+                        this._sessionMetadata.set(sessionId, metadata);
+                    }
+                }
+                frameworkLogger.log("session-cleanup", "load-metadata", "info", {
+                    sessionsLoaded: this._sessionMetadata.size,
+                });
+            }
+            else if (storedMetadata) {
+                frameworkLogger.log("session-cleanup", "corrupted-metadata-detected", "warning", { warning: "Corrupted session metadata detected, skipping load" });
+            }
+        }
+        catch (error) {
+            frameworkLogger.log("session-cleanup", "metadata-load-failed", "error", {
+                error,
+            });
+        }
+    }
+    /**
+     * Persist session metadata to state manager
+     */
+    persistSessionMetadata(sessionId, metadata) {
+        const allMetadata = Object.fromEntries(this.sessionMetadata);
+        this.stateManager.set("cleanup:session_metadata", allMetadata);
+    }
+    /**
+     * Cleanup a specific session
+     */
+    async cleanupSession(sessionId) {
+        const metadata = this.sessionMetadata.get(sessionId);
+        if (!metadata)
+            return;
+        metadata.isActive = false;
+        this.persistSessionMetadata(sessionId, metadata);
+        // Skip session coordinator cleanup in test environment to avoid dependency issues
+        // const sessionCoordinator = this.stateManager.get(
+        //   "delegation:session_coordinator",
+        // ) as SessionCoordinator;
+        // if (sessionCoordinator) {
+        //   sessionCoordinator.cleanupSession(sessionId);
+        // }
+        // Notify session monitor to unregister the session
+        if (this.sessionMonitor) {
+            this.sessionMonitor.unregisterSession(sessionId);
+        }
+        this.stateManager.clear(`session:${sessionId}`);
+        this.sessionMetadata.delete(sessionId);
+        this.persistSessionMetadata(sessionId, metadata);
+        frameworkLogger.log("session-cleanup", "cleanup-session", "info", {
+            sessionId,
+            cleanupReason: metadata.cleanupReason,
+        });
+    }
+    /**
+     * Shutdown cleanup manager
+     */
+    shutdown() {
+        this.stopAutoCleanup();
+        frameworkLogger.log("session-cleanup", "shutdown", "info");
+    }
+}
+export const createSessionCleanupManager = (stateManager, config, sessionMonitor) => {
+    return new SessionCleanupManager(stateManager, config, sessionMonitor);
+};