0xray 4.0.12 → 4.0.13

package/dist/postprocessor/metamorphosis/SelfProposalEngine.js

@@ -1,472 +0,0 @@
-/**
- * SelfProposalEngine — Phase 2.2
- *
- * Concrete MetamorphosisEngine that reads activity.log, parses structured
- * log entries, detects semantic patterns, generates governance proposals
- * (type: 'metamorphosis'), and submits them through the full 3-agent +
- * Dynamo governance pipeline.
- *
- * Safety constraints:
- * - Max proposals per hour (default 1, configurable)
- * - Circuit breaker: after N consecutive failures, halt for cooldown (default 3/24h)
- * - Only proposes changes to whitelisted targets
- * - All proposals go through full governance with metamorphosisThreshold (default 0.7)
- * - Detection thresholds are configurable (not hard-coded)
- *
- * Coupling note: currently triggered by PostProcessor.onPhase(). A future
- * refactor should extract log-reading into a dedicated LogReader that can
- * run on its own schedule or fs.watch, decoupling from PostProcessor lifecycle.
- */
-import { promises as fs, existsSync } from 'fs';
-import { join } from 'path';
-import { frameworkLogger } from '../../core/framework-logger.js';
-import { handleGovernRequest } from '../../nucleus/govern-http.js';
-const DEFAULT_CONFIG = {
-    maxProposalsPerHour: 1,
-    circuitBreakerThreshold: 3,
-    circuitBreakerCooldownHours: 24,
-    activityLogPath: 'logs/framework/activity.log',
-    whitelistedTargets: ['config/', 'features.json', 'src/processors/'],
-    maxLogLines: 100,
-    errorThreshold: 5,
-    warningThreshold: 10,
-    governanceRejectionThreshold: 3,
-    proposalConfidence: 0.7,
-    metamorphosisThreshold: 0.7,
-    projectRoot: process.cwd(),
-};
-const LOG_LINE_PATTERN = /^(\d{4}-\d{2}-\d{2}T[^ ]+)\s+(?:\[([^\]]*)\]\s+)?(?:\[([^\]]*)\]\s+)?\[([^\]]*)\]\s+(\S+)\s+-\s+(\w+)(?:\s+\|(.+))?$/;
-function parseLogEntry(line) {
-    const match = line.match(LOG_LINE_PATTERN);
-    if (!match) {
-        // Fallback: try JSON parse for entangled log entries
-        try {
-            const json = JSON.parse(line);
-            if (json && typeof json === 'object' && json.action) {
-                return {
-                    timestamp: json.timestamp ? new Date(json.timestamp).toISOString() : new Date().toISOString(),
-                    component: json.component || 'unknown',
-                    action: json.action,
-                    status: (json.status || json.level || 'info').toLowerCase(),
-                    details: json.details || json,
-                    raw: line,
-                };
-            }
-        }
-        catch { }
-        return null;
-    }
-    const [, timestamp, , , component, action, status, detailsStr] = match;
-    let details;
-    if (detailsStr) {
-        try {
-            details = JSON.parse(detailsStr.trim());
-        }
-        catch {
-            details = { rawDetails: detailsStr.trim() };
-        }
-    }
-    const entry = {
-        timestamp: timestamp ?? new Date().toISOString(),
-        component: component || 'unknown',
-        action: action ?? 'unknown',
-        status: (status ?? 'info').toLowerCase(),
-        raw: line,
-    };
-    if (details !== undefined) {
-        entry.details = details;
-    }
-    return entry;
-}
-export class SelfProposalEngine {
-    name = 'self-proposal';
-    config;
-    proposalHistory = [];
-    consecutiveFailures = 0;
-    circuitBreakerUntil = 0;
-    constructor(config) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    async onPhase(phase, context) {
-        if (phase !== 'monitoring-complete' && phase !== 'post-process-complete') {
-            return;
-        }
-        await frameworkLogger.log('self-proposal', 'phase-hook', 'info', {
-            phase,
-            message: 'Self-proposal engine triggered by phase',
-        });
-        if (this.isCircuitBreakerActive()) {
-            await frameworkLogger.log('self-proposal', 'circuit-breaker-active', 'warning', {
-                message: `Circuit breaker active until ${new Date(this.circuitBreakerUntil).toISOString()}`,
-                consecutiveFailures: this.consecutiveFailures,
-            });
-            return;
-        }
-        if (this.isRateLimited()) {
-            await frameworkLogger.log('self-proposal', 'rate-limited', 'info', {
-                message: 'Max proposals per hour reached',
-            });
-            return;
-        }
-        await this.evaluateAndPropose();
-    }
-    async onProposal(proposal) {
-        await frameworkLogger.log('self-proposal', 'external-proposal', 'info', {
-            proposalId: proposal.id,
-            type: proposal.type,
-            target: proposal.target,
-            impact: proposal.impact,
-        });
-    }
-    isCircuitBreakerActive() {
-        if (this.consecutiveFailures >= this.config.circuitBreakerThreshold) {
-            if (Date.now() < this.circuitBreakerUntil) {
-                return true;
-            }
-            this.consecutiveFailures = 0;
-            this.circuitBreakerUntil = 0;
-        }
-        return false;
-    }
-    isRateLimited() {
-        const oneHourAgo = Date.now() - 60 * 60 * 1000;
-        const recentProposals = this.proposalHistory.filter(a => a.timestamp > oneHourAgo);
-        return recentProposals.length >= this.config.maxProposalsPerHour;
-    }
-    getMetrics() {
-        const oneHourAgo = Date.now() - 60 * 60 * 1000;
-        const recentProposals = this.proposalHistory.filter(a => a.timestamp > oneHourAgo);
-        return {
-            totalProposals: this.proposalHistory.length,
-            recentProposals: recentProposals.length,
-            consecutiveFailures: this.consecutiveFailures,
-            circuitBreakerActive: this.isCircuitBreakerActive(),
-            circuitBreakerUntil: this.circuitBreakerUntil,
-            successRate: this.proposalHistory.length > 0
-                ? this.proposalHistory.filter(a => a.result === 'approved').length / this.proposalHistory.length
-                : 0,
-        };
-    }
-    async evaluateAndPropose() {
-        let logEntries = [];
-        try {
-            const logContent = await fs.readFile(this.config.activityLogPath, 'utf-8');
-            const lines = logContent.trim().split('\n');
-            logEntries = lines.slice(-this.config.maxLogLines).filter(line => line.trim().length > 0);
-        }
-        catch {
-            await frameworkLogger.log('self-proposal', 'log-read-error', 'warning', {
-                path: this.config.activityLogPath,
-                message: 'Activity log not found or unreadable — skipping self-proposal',
-            });
-            return;
-        }
-        const patterns = this.detectPatterns(logEntries);
-        if (patterns.length === 0) {
-            await frameworkLogger.log('self-proposal', 'no-patterns', 'info', {
-                message: 'No actionable patterns detected in activity log',
-            });
-            return;
-        }
-        for (const pattern of patterns) {
-            await this.submitProposal(pattern);
-        }
-    }
-    /**
-     * Detect actionable patterns from parsed activity log entries.
-     * Uses structured parsing instead of raw string matching to handle
-     * the actual xray log format:
-     *   ISO_TIMESTAMP [jobId] [traceId.spanId] [component] action - STATUS | {details}
-     */
-    detectPatterns(entries) {
-        const parsed = entries.map(parseLogEntry).filter((e) => e !== null);
-        const proposals = [];
-        const errorEntries = parsed.filter(e => e.status === 'error');
-        const warningEntries = parsed.filter(e => e.status === 'warning');
-        const rejectedEntries = parsed.filter(e => e.component === 'governance' && (e.status === 'rejected' || e.details?.decision === 'reject'));
-        if (errorEntries.length >= this.config.errorThreshold) {
-            const components = [...new Set(errorEntries.map(e => e.component))];
-            proposals.push({
-                id: `meta-errors-${Date.now()}`,
-                type: 'modify',
-                target: 'config/error-handling',
-                description: `Elevated error rate: ${errorEntries.length} errors in last ${this.config.maxLogLines} entries. Components: ${components.join(', ')}. Propose adjusting error handling thresholds.`,
-                rationale: `High error count (${errorEntries.length}) across ${components.length} component(s) indicates a systemic issue. Affected components: ${components.join(', ')}. Governance review recommended for self-optimization.`,
-                impact: 'medium',
-            });
-        }
-        if (warningEntries.length >= this.config.warningThreshold) {
-            const components = [...new Set(warningEntries.map(e => e.component))];
-            proposals.push({
-                id: `meta-warnings-${Date.now()}`,
-                type: 'modify',
-                target: 'config/monitoring',
-                description: `Elevated warning rate: ${warningEntries.length} warnings in last ${this.config.maxLogLines} entries. Components: ${components.join(', ')}. Propose adjusting monitoring sensitivity.`,
-                rationale: `Frequent warnings (${warningEntries.length}) across ${components.length} component(s) may indicate configuration drift. Affected: ${components.join(', ')}.`,
-                impact: 'low',
-            });
-        }
-        if (rejectedEntries.length >= this.config.governanceRejectionThreshold) {
-            proposals.push({
-                id: `meta-governance-rejections-${Date.now()}`,
-                type: 'modify',
-                target: 'config/governance',
-                description: `Repeated governance rejections: ${rejectedEntries.length} in last ${this.config.maxLogLines} entries. Propose reviewing governance thresholds or submission patterns.`,
-                rationale: `${rejectedEntries.length} governance rejections suggest a pattern mismatch between proposals and governance criteria. Review recommended.`,
-                impact: 'medium',
-            });
-        }
-        return proposals.filter(p => this.config.whitelistedTargets.some(t => p.target.startsWith(t)));
-    }
-    /**
-     * Apply an approved self-evolution proposal by recording the change
-     * in a state file within the first matching whitelisted target directory.
-     * Returns true if the change was written and verified, false otherwise.
-     */
-    async applySelfProposal(pattern, score, decision) {
-        const matchedTarget = this.config.whitelistedTargets.find(t => pattern.target.startsWith(t));
-        if (!matchedTarget) {
-            await frameworkLogger.log('self-proposal', 'apply-no-matching-target', 'warning', {
-                proposalId: pattern.id,
-                target: pattern.target,
-                message: 'No whitelisted target matches this proposal — skipping apply',
-            });
-            return false;
-        }
-        const root = this.config.projectRoot;
-        const stateDir = join(root, matchedTarget);
-        const statePath = join(stateDir, 'self-evolution-state.json');
-        let applied = [];
-        try {
-            const content = await fs.readFile(statePath, 'utf-8');
-            const parsed = JSON.parse(content);
-            if (Array.isArray(parsed.applied))
-                applied = parsed.applied;
-        }
-        catch { }
-        applied.push({
-            proposalId: pattern.id,
-            target: pattern.target,
-            type: pattern.type,
-            description: pattern.description,
-            rationale: pattern.rationale,
-            impact: pattern.impact,
-            metamorphosisScore: score,
-            decision: decision,
-            appliedAt: new Date().toISOString(),
-        });
-        try {
-            await fs.mkdir(stateDir, { recursive: true });
-            // Backup existing state file before overwriting
-            const backupDir = join(root, '.xray', 'metamorphosis', 'backups');
-            let backupPath = null;
-            if (existsSync(statePath)) {
-                await fs.mkdir(backupDir, { recursive: true });
-                backupPath = join(backupDir, `self-evolution-state-${Date.now()}.json`);
-                await fs.copyFile(statePath, backupPath);
-                await frameworkLogger.log('self-proposal', 'backup-created', 'info', {
-                    proposalId: pattern.id,
-                    backupPath,
-                });
-            }
-            try {
-                await fs.writeFile(statePath, JSON.stringify({ applied }, null, 2), 'utf-8');
-            }
-            catch (writeError) {
-                // Restore from backup on write failure
-                if (backupPath && existsSync(backupPath)) {
-                    await fs.copyFile(backupPath, statePath);
-                    await frameworkLogger.log('self-proposal', 'restored-from-backup', 'warning', {
-                        proposalId: pattern.id,
-                        backupPath,
-                        error: writeError instanceof Error ? writeError.message : String(writeError),
-                    });
-                }
-                await frameworkLogger.log('self-proposal', 'apply-write-error', 'error', {
-                    proposalId: pattern.id,
-                    path: statePath,
-                    error: writeError instanceof Error ? writeError.message : String(writeError),
-                });
-                return false;
-            }
-        }
-        catch (writeError) {
-            await frameworkLogger.log('self-proposal', 'apply-mkdir-error', 'error', {
-                proposalId: pattern.id,
-                error: writeError instanceof Error ? writeError.message : String(writeError),
-            });
-            return false;
-        }
-        try {
-            const verify = await fs.readFile(statePath, 'utf-8');
-            const parsed = JSON.parse(verify);
-            const found = Array.isArray(parsed.applied) && parsed.applied.some((a) => a.proposalId === pattern.id);
-            if (!found) {
-                await frameworkLogger.log('self-proposal', 'apply-verify-failed', 'error', {
-                    proposalId: pattern.id,
-                    message: 'Applied change not found in state file after write — verification failed',
-                });
-            }
-            return found;
-        }
-        catch (verifyError) {
-            await frameworkLogger.log('self-proposal', 'apply-verify-error', 'error', {
-                proposalId: pattern.id,
-                error: verifyError instanceof Error ? verifyError.message : String(verifyError),
-            });
-            return false;
-        }
-    }
-    async submitProposal(pattern) {
-        const governanceRequest = {
-            proposals: [{
-                    id: pattern.id,
-                    type: 'metamorphosis',
-                    title: `Self-proposal: ${pattern.description.slice(0, 80)}`,
-                    description: pattern.description,
-                    evidence: [pattern.rationale],
-                    source: 'metamorphosis',
-                    confidence: this.config.proposalConfidence,
-                    tags: ['0xray'],
-                }],
-            context: {
-                project: 'xray-self',
-                phase: 'self-evolution',
-                source: 'self-proposal-engine',
-                tags: ['0xray'],
-            },
-            options: {
-                requireExternalDynamo: true,
-                metamorphosisThreshold: this.config.metamorphosisThreshold,
-            },
-        };
-        await frameworkLogger.log('self-proposal', 'submitting', 'info', {
-            proposalId: pattern.id,
-            target: pattern.target,
-            impact: pattern.impact,
-        });
-        try {
-            const response = await handleGovernRequest(governanceRequest);
-            const result = response.results[0];
-            if (!result) {
-                await frameworkLogger.log('self-proposal', 'no-result', 'warning', {
-                    proposalId: pattern.id,
-                    message: 'Governance returned no results',
-                });
-                return;
-            }
-            const decision = result.finalDecision;
-            const attempt = {
-                timestamp: Date.now(),
-                result: decision === 'approve' ? 'approved' : decision === 'reject' ? 'rejected' : 'needs_revision',
-            };
-            if (result.metamorphosisScore !== undefined) {
-                attempt.metamorphosisScore = result.metamorphosisScore;
-            }
-            this.proposalHistory.push(attempt);
-            if (decision === 'approve' && (result.metamorphosisScore ?? 0) >= this.config.metamorphosisThreshold) {
-                this.consecutiveFailures = 0;
-                await frameworkLogger.log('self-proposal', 'approved', 'success', {
-                    proposalId: pattern.id,
-                    metamorphosisScore: result.metamorphosisScore,
-                    finalDecision: decision,
-                    averageConfidence: result.averageConfidence,
-                    voteSummary: result.votes ? result.votes.map((v) => ({ server: v.server, decision: v.decision })) : undefined,
-                    message: 'Self-evolution proposal approved by governance — applying change',
-                    tags: ['0xray'],
-                });
-                const applied = await this.applySelfProposal(pattern, result.metamorphosisScore, decision);
-                if (applied) {
-                    await frameworkLogger.log('self-proposal', 'applied', 'success', {
-                        proposalId: pattern.id,
-                        target: pattern.target,
-                        metamorphosisScore: result.metamorphosisScore,
-                        decision,
-                        message: 'Self-evolution change applied and verified',
-                        tags: ['0xray'],
-                    });
-                    await this.audit0xrayProposalTraceability(pattern.id, decision, result.metamorphosisScore);
-                }
-                else {
-                    this.consecutiveFailures++;
-                    if (this.consecutiveFailures >= this.config.circuitBreakerThreshold) {
-                        this.circuitBreakerUntil = Date.now() + this.config.circuitBreakerCooldownHours * 60 * 60 * 1000;
-                    }
-                    await frameworkLogger.log('self-proposal', 'apply-failed', 'error', {
-                        proposalId: pattern.id,
-                        target: pattern.target,
-                        consecutiveFailures: this.consecutiveFailures,
-                        message: 'Self-evolution change apply failed — circuit breaker may activate',
-                    });
-                }
-            }
-            else {
-                this.consecutiveFailures++;
-                if (this.consecutiveFailures >= this.config.circuitBreakerThreshold) {
-                    this.circuitBreakerUntil = Date.now() + this.config.circuitBreakerCooldownHours * 60 * 60 * 1000;
-                }
-                await frameworkLogger.log('self-proposal', 'not-approved', 'warning', {
-                    proposalId: pattern.id,
-                    decision: decision,
-                    metamorphosisScore: result.metamorphosisScore,
-                    consecutiveFailures: this.consecutiveFailures,
-                    circuitBreakerUntil: this.circuitBreakerUntil || 'not active',
-                });
-            }
-        }
-        catch (error) {
-            this.consecutiveFailures++;
-            await frameworkLogger.log('self-proposal', 'submission-error', 'error', {
-                proposalId: pattern.id,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    /**
-     * Post-apply audit for Term 72 (Self-Evolution Traceability).
-     * For 0xray-tagged proposals (framework self-evolution), asserts that
-     * frameworkLogger entries exist with full provenance:
-     *   - source proposal ID
-     *   - governance vote results / finalDecision / averageConfidence
-     *   - metamorphosisScore
-     * Logs the audit outcome via frameworkLogger.
-     */
-    async audit0xrayProposalTraceability(proposalId, decision, score) {
-        if (!proposalId) {
-            return;
-        }
-        try {
-            const logContent = await fs.readFile(this.config.activityLogPath, 'utf-8');
-            const lines = logContent.trim().split('\n').filter(l => l.trim().length > 0);
-            const recentLines = lines.slice(-this.config.maxLogLines);
-            // Look for entries tied to this proposalId that carry the required provenance.
-            // We expect 'approved' (with vote info) and 'applied' (with score/decision) for 0xray self-proposals.
-            const relevant = recentLines.filter(line => line.includes(proposalId) &&
-                (line.includes('approved') || line.includes('applied') || line.includes('submitting')));
-            const hasProposalId = relevant.length > 0;
-            const hasGovernanceVote = relevant.some(l => l.includes('finalDecision') || l.includes('averageConfidence') || l.includes('voteSummary'));
-            const hasMetamorphosisScore = relevant.some(l => l.includes('metamorphosisScore'));
-            const has0xrayTag = relevant.some(l => l.includes('0xray') || l.includes('"tags"') && l.includes('0xray'));
-            const auditPassed = hasProposalId && hasGovernanceVote && hasMetamorphosisScore && has0xrayTag;
-            await frameworkLogger.log('self-proposal', 'post-apply-audit', auditPassed ? 'success' : 'warning', {
-                proposalId,
-                decision,
-                metamorphosisScore: score,
-                hasProposalId,
-                hasGovernanceVote,
-                hasMetamorphosisScore,
-                has0xrayTag,
-                relevantEntryCount: relevant.length,
-                message: auditPassed
-                    ? 'Term 72 traceability audit passed: frameworkLogger entries with full provenance (proposalId, governance votes, metamorphosisScore, 0xray tag) verified for self-evolution proposal.'
-                    : 'Term 72 traceability audit warning: missing or incomplete frameworkLogger provenance for 0xray-tagged self-evolution proposal.',
-            });
-        }
-        catch (auditError) {
-            await frameworkLogger.log('self-proposal', 'post-apply-audit-error', 'error', {
-                proposalId,
-                error: auditError instanceof Error ? auditError.message : String(auditError),
-            });
-        }
-    }
-}

package/dist/postprocessor/metamorphosis/index.d.ts

@@ -1,2 +0,0 @@
-export { type MetamorphosisEngine, type MetamorphosisProposal } from '../../types/metamorphosis.js';
-export { SelfProposalEngine, type SelfProposalConfig } from './SelfProposalEngine.js';

package/dist/postprocessor/metamorphosis/index.js

@@ -1 +0,0 @@
-export { SelfProposalEngine } from './SelfProposalEngine.js';

package/dist/postprocessor/monitoring/MonitoringEngine.d.ts

@@ -1,40 +0,0 @@
-/**
- * Post-Processor Monitoring Engine
- */
-import { XrayStateManager } from "../../state/state-manager.js";
-import { SessionMonitor } from "../../session/session-monitor.js";
-import { MonitoringResult } from "../types.js";
-export interface CIStatus {
-    status: "success" | "failure" | "running";
-    failedJobs: string[];
-    totalJobs: number;
-    duration: number;
-}
-export interface PerformanceStatus {
-    status: "passed" | "failed" | "warning";
-    score: number;
-    regressions: string[];
-    duration: number;
-}
-export interface SecurityStatus {
-    status: "passed" | "failed" | "warning";
-    vulnerabilities: number;
-    criticalVulnerabilities: number;
-    scanDuration: number;
-}
-export declare class PostProcessorMonitoringEngine {
-    private stateManager;
-    private sessionMonitor?;
-    constructor(stateManager: XrayStateManager, sessionMonitor?: SessionMonitor | undefined);
-    initialize(): Promise<void>;
-    monitorDeployment(commitSha: string): Promise<MonitoringResult>;
-    private checkCIStatus;
-    private checkPerformanceStatus;
-    private checkSecurityStatus;
-    private determineOverallStatus;
-    getStatus(): Promise<{
-        monitoringEnabled: boolean;
-        activeSessions: number;
-        lastCheck: Date;
-    }>;
-}

package/dist/postprocessor/monitoring/MonitoringEngine.js

@@ -1,125 +0,0 @@
-/**
- * Post-Processor Monitoring Engine
- */
-import { frameworkLogger } from "../../core/framework-logger.js";
-export class PostProcessorMonitoringEngine {
-    stateManager;
-    sessionMonitor;
-    constructor(stateManager, sessionMonitor) {
-        this.stateManager = stateManager;
-        this.sessionMonitor = sessionMonitor;
-    }
-    async initialize() {
-        // Initialize monitoring components
-        await frameworkLogger.log("monitoring-engine", "initialized", "info");
-    }
-    async monitorDeployment(commitSha) {
-        const jobId = `monitoring-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        const startTime = Date.now();
-        // Check CI/CD status using existing github-actions-monitor
-        const ciStatus = await this.checkCIStatus(commitSha);
-        // Check performance metrics
-        const performanceStatus = await this.checkPerformanceStatus(commitSha);
-        // Check security status
-        const securityStatus = await this.checkSecurityStatus(commitSha);
-        const overallStatus = this.determineOverallStatus(ciStatus, performanceStatus, securityStatus);
-        return {
-            commitSha,
-            overallStatus,
-            timestamp: new Date(),
-            ciStatus,
-            performanceStatus,
-            securityStatus,
-            failedJobs: ciStatus.failedJobs,
-            duration: Date.now() - startTime,
-        };
-    }
-    async checkCIStatus(commitSha) {
-        // Use existing GitHub Actions monitor
-        try {
-            const { execSync } = await import("child_process");
-            const output = execSync(`node scripts/node/github-actions-monitor.cjs --commit ${commitSha}`, {
-                encoding: "utf8",
-                timeout: 30000,
-            });
-            // Parse the output to determine status
-            if (output.includes("SUCCESS") ||
-                output.includes("All workflows passed")) {
-                return { status: "success", failedJobs: [], totalJobs: 1, duration: 0 };
-            }
-            else if (output.includes("FAILURE") || output.includes("failed")) {
-                return { status: "failure", failedJobs: ["ci-pipeline"], totalJobs: 1, duration: 0 };
-            }
-            else {
-                return { status: "running", failedJobs: [], totalJobs: 1, duration: 0 };
-            }
-        }
-        catch (error) {
-            return {
-                status: "failure",
-                failedJobs: ["ci-pipeline"],
-                totalJobs: 1,
-                duration: 0,
-            };
-        }
-    }
-    async checkPerformanceStatus(_commitSha) {
-        // Check if performance tests passed
-        try {
-            const { execSync } = await import("child_process");
-            execSync("npm run test:performance", {
-                encoding: "utf8",
-                timeout: 120000,
-            });
-            return { status: "passed", score: 1.0, regressions: [], duration: 0 };
-        }
-        catch (error) {
-            return {
-                status: "failed",
-                score: 0.0,
-                regressions: ["performance-tests"],
-                duration: 0,
-            };
-        }
-    }
-    async checkSecurityStatus(_commitSha) {
-        // Check for security issues
-        try {
-            const { execSync } = await import("child_process");
-            execSync("npm run security-audit", {
-                encoding: "utf8",
-                timeout: 60000,
-            });
-            return {
-                status: "passed",
-                vulnerabilities: 0,
-                criticalVulnerabilities: 0,
-                scanDuration: 0,
-            };
-        }
-        catch (error) {
-            return {
-                status: "failed",
-                vulnerabilities: 1,
-                criticalVulnerabilities: 1,
-                scanDuration: 0,
-            };
-        }
-    }
-    determineOverallStatus(ci, performance, security) {
-        if (ci.status === "failure" || performance.status === "failed") {
-            return "failure";
-        }
-        if (ci.status === "running") {
-            return "running";
-        }
-        return "success";
-    }
-    async getStatus() {
-        return {
-            monitoringEnabled: true,
-            activeSessions: 0, // Placeholder
-            lastCheck: new Date(),
-        };
-    }
-}