@dcyfr/ai 1.0.4 → 2.1.0

package/dist/ai/src/delegation/liability-firebreak.js

@@ -0,0 +1,643 @@
+/**
+ * Liability Firebreak Enforcement for DCYFR Delegation Framework
+ * TLP:AMBER - Internal Use Only
+ *
+ * Implements accountability boundaries in delegation chains to prevent
+ * unlimited delegation and ensure clear liability assignment. Includes
+ * manual override capabilities and escalation procedures.
+ *
+ * Key accountability mechanisms:
+ * - Delegation chain depth limits with liability boundaries
+ * - Responsibility tracking through chain hierarchy
+ * - Manual override and emergency escalation procedures
+ * - Liability assignment and audit trail maintenance
+ *
+ * @module delegation/liability-firebreak
+ * @version 1.0.0
+ * @date 2026-02-14
+ */
+/**
+ * Liability Firebreak Enforcement Engine
+ */
+export class LiabilityFirebreakEnforcer {
+    config;
+    overrideRequests;
+    chainAccountability;
+    stats;
+    constructor(config = {}) {
+        this.config = {
+            depth_thresholds: {
+                supervisor: config.depth_thresholds?.supervisor || 3,
+                manager: config.depth_thresholds?.manager || 5,
+                executive: config.depth_thresholds?.executive || 7,
+            },
+            liability_thresholds: {
+                high_value_limit: config.liability_thresholds?.high_value_limit || 100000,
+                critical_system_approval: config.liability_thresholds?.critical_system_approval ?? true,
+                external_delegation_approval: config.liability_thresholds?.external_delegation_approval ?? true,
+            },
+            emergency_procedures: {
+                max_emergency_depth: config.emergency_procedures?.max_emergency_depth || 10,
+                emergency_contacts: config.emergency_procedures?.emergency_contacts || [
+                    { authority: 'supervisor', contact_id: 'supervisor@dcyfr.ai', response_time_sla_minutes: 30 },
+                    { authority: 'manager', contact_id: 'manager@dcyfr.ai', response_time_sla_minutes: 60 },
+                    { authority: 'executive', contact_id: 'executive@dcyfr.ai', response_time_sla_minutes: 120 },
+                ],
+            },
+        };
+        this.overrideRequests = new Map();
+        this.chainAccountability = new Map();
+        // Initialize statistics
+        this.stats = {
+            total_validations: 0,
+            firebreaks_passed: 0,
+            firebreaks_blocked: 0,
+            block_reasons: {},
+            liability_distribution: {
+                full: 0,
+                shared: 0,
+                limited: 0,
+                none: 0,
+            },
+        };
+    }
+    /**
+     * Enforce liability firebreaks for delegation
+     */
+    enforceFirebreaks(primaryAgent, secondaryAgent, context) {
+        // Use default values for missing context properties
+        // Empty array means single delegation (1 hop)
+        const hasChainAgents = context.chain_agents && context.chain_agents.length > 0;
+        const defaultChainAgents = hasChainAgents
+            ? context.chain_agents
+            : []; // Empty means single delegation
+        const validationContext = {
+            delegation_depth: Math.max(context.delegation_depth || 1, 1),
+            estimated_value: Math.max(context.estimated_value || 0, 0),
+            involves_critical_systems: context.involves_critical_systems || false,
+            is_external_delegation: context.is_external_delegation || false,
+            chain_agents: defaultChainAgents,
+        };
+        this.stats.total_validations++;
+        const blockingFirebreaks = [];
+        let requiredAuthority = 'agent';
+        let liabilityLevel = this.assignLiabilityLevel(validationContext);
+        // Check depth firebreaks
+        const depthCheck = this.checkDepthLimits(validationContext.delegation_depth);
+        if (!depthCheck.allowed) {
+            blockingFirebreaks.push('delegation_depth_exceeded');
+            requiredAuthority = this.getAuthorityForDepth(validationContext.delegation_depth);
+        }
+        // Check value firebreaks  
+        if (validationContext.estimated_value > this.config.liability_thresholds.high_value_limit) {
+            blockingFirebreaks.push('high_value_delegation');
+            requiredAuthority = this.escalateAuthority(requiredAuthority, 'manager');
+            liabilityLevel = 'full';
+        }
+        // Check critical system firebreaks
+        if (validationContext.involves_critical_systems && this.config.liability_thresholds.critical_system_approval) {
+            blockingFirebreaks.push('critical_system_delegation');
+            requiredAuthority = this.escalateAuthority(requiredAuthority, 'manager');
+            liabilityLevel = 'full';
+        }
+        // Check external delegation firebreaks
+        if (validationContext.is_external_delegation && this.config.liability_thresholds.external_delegation_approval) {
+            blockingFirebreaks.push('external_delegation');
+            requiredAuthority = this.escalateAuthority(requiredAuthority, 'executive');
+            liabilityLevel = 'full';
+        }
+        const firebreaksPassed = blockingFirebreaks.length === 0;
+        if (!firebreaksPassed) {
+            this.stats.firebreaks_blocked++;
+            this.stats.block_reasons = this.stats.block_reasons || {};
+            blockingFirebreaks.forEach(reason => {
+                this.stats.block_reasons[reason] = (this.stats.block_reasons[reason] || 0) + 1;
+            });
+        }
+        else {
+            this.stats.firebreaks_passed++;
+        }
+        // Update liability distribution
+        this.stats.liability_distribution = this.stats.liability_distribution || {};
+        this.stats.liability_distribution[liabilityLevel] = (this.stats.liability_distribution[liabilityLevel] || 0) + 1;
+        const result = {
+            firebreaks_passed: firebreaksPassed,
+            blocking_firebreaks: blockingFirebreaks,
+            liability_level: liabilityLevel,
+            chain_length: validationContext.chain_agents.length || 1, // Default to 1 for empty
+            manual_override_available: !firebreaksPassed,
+            required_authority: requiredAuthority,
+            validation_timestamp: new Date().toISOString(),
+        };
+        console.log(`🔥 Firebreak enforcement: ${firebreaksPassed ? 'PASS' : 'BLOCK'} - ${primaryAgent} -> ${secondaryAgent} (Depth: ${validationContext.delegation_depth}, Liability: ${liabilityLevel})`);
+        return result;
+    }
+    /**
+     * Assign liability level based on delegation context
+     */
+    assignLiabilityLevel(context) {
+        // Simple liability assignment based on delegation characteristics
+        if (context.delegation_depth <= 1 && context.estimated_value < 100) {
+            return 'none';
+        }
+        if (context.involves_critical_systems || context.estimated_value > 50000) {
+            return 'full';
+        }
+        if (context.delegation_depth > 3 && context.estimated_value > 500) {
+            return 'shared';
+        }
+        return 'limited';
+    }
+    /**
+     * Check depth limits
+     */
+    checkDepthLimits(depth) {
+        // Block if depth EXCEEDS supervisor threshold (not equal to)
+        const requiresApproval = depth > this.config.depth_thresholds.supervisor;
+        return { allowed: !requiresApproval };
+    }
+    /**
+     * Get required authority for given depth
+     */
+    getAuthorityForDepth(depth) {
+        // Depths beyond executive threshold require emergency authority
+        if (depth > this.config.depth_thresholds.executive)
+            return 'emergency';
+        if (depth > this.config.depth_thresholds.manager)
+            return 'manager';
+        if (depth > this.config.depth_thresholds.supervisor)
+            return 'supervisor';
+        // At or below supervisor threshold requires agent only
+        return 'agent';
+    }
+    /**
+     * Escalate authority level
+     */
+    escalateAuthority(current, required) {
+        const levels = ['agent', 'supervisor', 'manager', 'executive', 'emergency'];
+        const currentIndex = levels.indexOf(current);
+        const requiredIndex = levels.indexOf(required);
+        return levels[Math.max(currentIndex, requiredIndex)];
+    }
+    /**
+     * Process emergency escalation
+     */
+    async processEmergencyEscalation(escalationData) {
+        const escalation_id = `escalation_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+        // Find appropriate emergency contact
+        const emergencyContact = this.config.emergency_procedures.emergency_contacts
+            .find(contact => contact.authority === 'supervisor') ||
+            this.config.emergency_procedures.emergency_contacts[0];
+        const result = {
+            escalation_id,
+            status: 'escalated',
+            agent_id: escalationData.agent_id,
+            emergency_level: escalationData.emergency_level,
+            emergency_contact_notified: true,
+            emergency_contact: emergencyContact?.contact_id || 'emergency@dcyfr.ai',
+            bypass_granted: false, // Manual approval required
+            approval_required: true,
+            escalation_timestamp: new Date().toISOString(),
+        };
+        return result;
+    }
+    /**
+     * Get pending override requests
+     */
+    /**
+     * Calculate chain accountability and tracking
+     */
+    calculateChainAccountability(contract) {
+        const chain_id = contract.contract_id; // Simplified - no parent contract tracking
+        let depth = 1;
+        const boundaries_hit = [];
+        // Calculate depth from chain history
+        if (contract.metadata?.delegation_depth) {
+            depth = contract.metadata.delegation_depth;
+        }
+        // Get existing chain accountability
+        const existing_chain = this.chainAccountability.get(chain_id) || [];
+        // Check boundaries
+        if (depth >= this.config.depth_thresholds.supervisor) {
+            boundaries_hit.push('supervisor_review_required');
+        }
+        if (depth >= this.config.depth_thresholds.manager) {
+            boundaries_hit.push('manager_approval_required');
+        }
+        if (depth >= this.config.depth_thresholds.executive) {
+            boundaries_hit.push('executive_authorization_required');
+        }
+        // Build liability distribution
+        const liability_distribution = existing_chain.map(entry => ({
+            agent_id: entry.agent_id,
+            liability_level: entry.liability_level,
+            scope: this.getScopeForAgent(entry.agent_id, contract),
+        }));
+        // Add current delegation
+        liability_distribution.push({
+            agent_id: contract.delegatee_agent_id,
+            liability_level: 'shared', // Simplified for old method compatibility
+            scope: contract.permission_token?.scopes || ['unknown'],
+        });
+        return {
+            depth,
+            max_depth: this.config.emergency_procedures.max_emergency_depth,
+            liability_distribution,
+            boundaries_hit,
+        };
+    }
+    /**
+     * Check depth-based firebreaks
+     */
+    checkDepthFirebreaks(depth) {
+        if (depth > this.config.emergency_procedures.max_emergency_depth) {
+            return {
+                allowed: false,
+                action: 'terminate_chain',
+                reason: `Delegation chain exceeds maximum emergency depth (${this.config.emergency_procedures.max_emergency_depth})`,
+            };
+        }
+        if (depth >= this.config.depth_thresholds.executive) {
+            return {
+                allowed: false,
+                action: 'escalate',
+                reason: 'Delegation chain requires executive authorization',
+                required_authority: 'executive',
+            };
+        }
+        if (depth >= this.config.depth_thresholds.manager) {
+            return {
+                allowed: false,
+                action: 'require_approval',
+                reason: 'Delegation chain requires manager approval',
+                required_authority: 'manager',
+            };
+        }
+        if (depth >= this.config.depth_thresholds.supervisor) {
+            return {
+                allowed: false,
+                action: 'require_approval',
+                reason: 'Delegation chain requires supervisor review',
+                required_authority: 'supervisor',
+            };
+        }
+        return { allowed: true, action: 'allow', reason: 'Depth within acceptable limits' };
+    }
+    /**
+     * Check liability-based firebreaks
+     */
+    checkLiabilityFirebreaks(contract) {
+        let required_authority;
+        let action = 'allow';
+        let reason = 'Liability checks passed';
+        let liability_level = 'limited';
+        // Check for high-value operations
+        if (contract.metadata && typeof contract.metadata?.estimated_value === 'number' &&
+            contract.metadata.estimated_value > this.config.liability_thresholds.high_value_limit) {
+            required_authority = 'manager';
+            action = 'require_approval';
+            reason = `High-value operation (${contract.metadata.estimated_value}) requires manager approval`;
+            liability_level = 'full';
+        }
+        // Check for critical system access
+        if (this.config.liability_thresholds.critical_system_approval && contract.permission_token?.scopes?.some(scope => scope.includes('production') || scope.includes('critical') || scope.includes('system'))) {
+            required_authority = required_authority === 'manager' ? 'manager' : 'supervisor';
+            action = 'require_approval';
+            reason = 'Critical system access requires approval';
+            liability_level = 'full';
+        }
+        // Check for external delegation
+        if (this.config.liability_thresholds.external_delegation_approval &&
+            (contract.delegatee_agent_id.includes('external') ||
+                contract.delegatee_agent_id.includes('third-party'))) {
+            required_authority = 'manager';
+            action = 'escalate';
+            reason = 'External delegation requires manager escalation';
+            liability_level = 'shared';
+        }
+        return {
+            allowed: !required_authority,
+            action,
+            reason,
+            required_authority,
+            liability_level,
+        };
+    }
+    /**
+     * Check for active manual overrides
+     */
+    checkActiveOverrides(contract_id) {
+        for (const [_, override] of this.overrideRequests) {
+            if (override.contract_id === contract_id &&
+                override.status === 'approved' &&
+                override.expires_at &&
+                new Date(override.expires_at) > new Date()) {
+                return override;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get scope for agent in contract context
+     */
+    getScopeForAgent(agent_id, contract) {
+        // For now, return contract scopes - in production this would query agent capabilities
+        return contract.permission_token?.scopes || ['read'];
+    }
+    /**
+     * Build escalation path for required authority
+     */
+    buildEscalationPath(required_authority) {
+        if (!required_authority)
+            return [];
+        const path = [];
+        const contacts = this.config.emergency_procedures.emergency_contacts;
+        switch (required_authority) {
+            case 'supervisor':
+                path.push({
+                    level: 'supervisor',
+                    contact_method: contacts.find(c => c.authority === 'supervisor')?.contact_id,
+                });
+                break;
+            case 'manager':
+                path.push({ level: 'supervisor', contact_method: contacts.find(c => c.authority === 'supervisor')?.contact_id }, { level: 'manager', contact_method: contacts.find(c => c.authority === 'manager')?.contact_id });
+                break;
+            case 'executive':
+                path.push({ level: 'supervisor', contact_method: contacts.find(c => c.authority === 'supervisor')?.contact_id }, { level: 'manager', contact_method: contacts.find(c => c.authority === 'manager')?.contact_id }, { level: 'executive', contact_method: contacts.find(c => c.authority === 'executive')?.contact_id });
+                break;
+        }
+        return path;
+    }
+    /**
+     * Request manual override for blocked delegation
+     */
+    /** Normalize positional or object-based requestOverride params into a canonical shape */
+    normalizeOverrideParams(contractIdOrRequest, requesting_agent_id, authority, justification, business_impact, urgency) {
+        if (typeof contractIdOrRequest === 'object') {
+            const req = contractIdOrRequest;
+            return {
+                reqAgent: req.requesting_agent || req.requesting_agent_id || 'unknown',
+                reqAuthority: req.authority_level || req.authority || 'agent',
+                reqJustification: req.justification || req.reason || '',
+                reqReason: req.reason,
+                reqContext: req.context,
+                reqExpiresAt: req.expires_at,
+                reqBusinessImpact: req.business_impact,
+                reqUrgency: req.urgency,
+                reqContractId: req.contract_id,
+                reqTargetAgent: req.target_agent,
+            };
+        }
+        return {
+            reqAgent: requesting_agent_id || 'unknown',
+            reqAuthority: authority || 'agent',
+            reqJustification: justification || '',
+            reqBusinessImpact: business_impact,
+            reqUrgency: urgency,
+            reqContractId: contractIdOrRequest,
+        };
+    }
+    /** Determine required override authority based on delegation context */
+    determineRequiredAuthority(context) {
+        let required = 'agent';
+        if (!context)
+            return required;
+        if (context.is_external_delegation)
+            required = this.escalateAuthority(required, 'executive');
+        if (context.involves_critical_systems)
+            required = this.escalateAuthority(required, 'manager');
+        if (context.estimated_value > this.config.liability_thresholds.high_value_limit)
+            required = this.escalateAuthority(required, 'manager');
+        if (context.delegation_depth > this.config.depth_thresholds.executive)
+            required = this.escalateAuthority(required, 'emergency');
+        else if (context.delegation_depth > this.config.depth_thresholds.manager)
+            required = this.escalateAuthority(required, 'manager');
+        else if (context.delegation_depth > this.config.depth_thresholds.supervisor)
+            required = this.escalateAuthority(required, 'supervisor');
+        return required;
+    }
+    async requestOverride(contractIdOrRequest, requesting_agent_id, authority, justification, business_impact, urgency) {
+        const override_id = `override_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+        const { reqAgent, reqAuthority, reqJustification, reqReason, reqContext, reqExpiresAt: initExpiresAt, reqBusinessImpact, reqUrgency, reqContractId, reqTargetAgent } = this.normalizeOverrideParams(contractIdOrRequest, requesting_agent_id, authority, justification, business_impact, urgency);
+        let reqExpiresAt = initExpiresAt;
+        const requiredAuthority = this.determineRequiredAuthority(reqContext);
+        // Check if requesting authority is sufficient
+        const authority_levels = ['agent', 'supervisor', 'manager', 'executive', 'emergency'];
+        const requestedLevel = authority_levels.indexOf(reqAuthority);
+        const requiredLevel = authority_levels.indexOf(requiredAuthority);
+        if (requiredLevel > requestedLevel) {
+            // Insufficient authority - reject
+            const rejected = {
+                override_id,
+                authority: reqAuthority,
+                authority_level: reqAuthority,
+                requesting_agent_id: reqAgent,
+                requesting_agent: reqAgent,
+                target_agent: reqTargetAgent,
+                contract_id: reqContractId,
+                justification: reqJustification,
+                reason: reqReason,
+                context: reqContext,
+                business_impact: reqBusinessImpact,
+                urgency: reqUrgency,
+                status: 'rejected',
+                expires_at: reqExpiresAt,
+                created_at: new Date().toISOString(),
+                rejection_reason: `Insufficient authority level: ${reqAuthority}. Required: ${requiredAuthority}`,
+                required_approvals: [requiredAuthority],
+                auto_approved: false,
+            };
+            this.overrideRequests.set(override_id, rejected);
+            return rejected;
+        }
+        // Calculate expiry if not provided
+        if (!reqExpiresAt) {
+            const expiresDate = new Date();
+            switch (reqUrgency) {
+                case 'emergency':
+                    expiresDate.setHours(expiresDate.getHours() + 1);
+                    break;
+                case 'urgent':
+                    expiresDate.setHours(expiresDate.getHours() + 4);
+                    break;
+                default:
+                    expiresDate.setHours(expiresDate.getHours() + 24);
+            }
+            reqExpiresAt = expiresDate.toISOString();
+        }
+        const override = {
+            override_id,
+            authority: reqAuthority,
+            authority_level: reqAuthority,
+            requesting_agent_id: reqAgent,
+            requesting_agent: reqAgent,
+            target_agent: reqTargetAgent,
+            contract_id: reqContractId,
+            justification: reqJustification,
+            reason: reqReason,
+            context: reqContext,
+            business_impact: reqBusinessImpact,
+            urgency: reqUrgency,
+            status: 'pending',
+            expires_at: reqExpiresAt,
+            created_at: new Date().toISOString(),
+            required_approvals: requiredAuthority !== 'agent' ? [requiredAuthority] : undefined,
+            auto_approved: false,
+        };
+        this.overrideRequests.set(override_id, override);
+        // Emit override request event for monitoring
+        console.log(`🔥 Firebreak Override Requested: ${override_id} (${reqAuthority}) - ${reqJustification}`);
+        return override;
+    }
+    /**
+     * Approve manual override
+     */
+    async approveOverride(override_id, approving_authority, approver_clearance) {
+        const override = this.overrideRequests.get(override_id);
+        if (!override) {
+            throw new Error(`Override request not found: ${override_id}`);
+        }
+        if (override.status !== 'pending') {
+            throw new Error(`Override request ${override_id} is not pending (current status: ${override.status})`);
+        }
+        if (!override.expires_at || new Date(override.expires_at) <= new Date()) {
+            override.status = 'expired';
+            this.overrideRequests.set(override_id, override);
+            throw new Error(`Override request ${override_id} has expired`);
+        }
+        // Check if approver has sufficient authority
+        const authority_levels = ['agent', 'supervisor', 'manager', 'executive', 'emergency'];
+        const required_level = authority_levels.indexOf(override.authority || 'agent');
+        const approver_level = authority_levels.indexOf(approver_clearance);
+        if (approver_level < required_level) {
+            throw new Error(`Insufficient authority: ${approver_clearance} cannot approve ${override.authority} level override`);
+        }
+        // Approve the override
+        override.status = 'approved';
+        override.approved_by = approving_authority;
+        override.approved_at = new Date().toISOString();
+        this.overrideRequests.set(override_id, override);
+        console.log(`✅ Firebreak Override Approved: ${override_id} by ${approving_authority}`);
+        return override;
+    }
+    /**
+     * Emergency escalation bypass (highest authority override)
+     */
+    async emergencyEscalation(contract_id, emergency_contact, justification) {
+        const override = await this.requestOverride(contract_id, emergency_contact, 'emergency', `EMERGENCY ESCALATION: ${justification}`, 'critical', 'emergency');
+        // Security hardening: emergency escalations are no longer auto-approved.
+        // Explicit human/operator approval must call approveOverride() separately.
+        return override;
+    }
+    /**
+     * Get liability firebreak statistics
+     */
+    getFirebreakStatistics() {
+        // This would be implemented with proper metrics tracking in production
+        return {
+            total_evaluations: 0,
+            blocked_delegations: 0,
+            escalations_required: 0,
+            overrides_requested: this.overrideRequests.size,
+            overrides_approved: Array.from(this.overrideRequests.values()).filter(o => o.status === 'approved').length,
+            chain_depth_violations: 0,
+            liability_threshold_violations: 0,
+        };
+    }
+    /**
+     * Get pending override requests
+     */
+    getPendingOverrides() {
+        return Array.from(this.overrideRequests.values())
+            .filter(override => override.status === 'pending')
+            .sort((a, b) => {
+            // Sort by urgency and business impact
+            const urgencyOrder = { emergency: 3, urgent: 2, routine: 1 };
+            const impactOrder = { critical: 4, high: 3, medium: 2, low: 1 };
+            const aScore = (urgencyOrder[a.urgency || 'routine'] ?? 0) * 10 + (impactOrder[a.business_impact || 'low'] ?? 0);
+            const bScore = (urgencyOrder[b.urgency || 'routine'] ?? 0) * 10 + (impactOrder[b.business_impact || 'low'] ?? 0);
+            return bScore - aScore; // Descending order (highest priority first)
+        });
+    }
+    /**
+     * Update chain accountability tracking
+     */
+    updateChainAccountability(chain_id, agent_id, liability_level, depth) {
+        const existing = this.chainAccountability.get(chain_id) || [];
+        existing.push({ agent_id, liability_level, depth });
+        this.chainAccountability.set(chain_id, existing);
+    }
+    /**
+     * Clean up expired override requests
+     */
+    cleanupExpiredOverrides() {
+        let cleaned = 0;
+        const now = new Date();
+        for (const [override_id, override] of this.overrideRequests) {
+            if (override.expires_at && new Date(override.expires_at) <= now && override.status === 'pending') {
+                override.status = 'expired';
+                this.overrideRequests.set(override_id, override);
+                cleaned++;
+            }
+        }
+        return cleaned;
+    }
+    /**
+     * Evaluate a contract for firebreak requirements
+     * Wrapper method for test compatibility - converts contract to context and calls enforceFirebreaks
+     */
+    evaluateContract(contract) {
+        // Extract delegation context from contract
+        const isSensitive = contract.metadata?.operation_type === 'destructive' ||
+            contract.metadata?.environment === 'production' ||
+            contract.priority >= 8;
+        const context = {
+            delegation_depth: 1, // Default depth
+            estimated_value: isSensitive ? 100000 : (contract.metadata?.estimated_value || 0),
+            involves_critical_systems: isSensitive || contract.metadata?.involves_critical_systems || false,
+            is_external_delegation: contract.metadata?.is_external_delegation || false,
+            chain_agents: [
+                contract.delegator?.agent_id || contract.delegator_agent_id,
+                contract.delegatee?.agent_id || contract.delegatee_agent_id,
+            ],
+        };
+        const result = this.enforceFirebreaks(contract.delegator?.agent_id || contract.delegator_agent_id, contract.delegatee?.agent_id || contract.delegatee_agent_id, context);
+        // Determine risk level
+        const riskLevel = isSensitive ? 'high' :
+            contract.priority >= 5 ? 'medium' : 'low';
+        return {
+            requires_firebreak: !result.firebreaks_passed,
+            risk_level: riskLevel,
+            firebreak_conditions: result.blocking_firebreaks.length > 0 ? result.blocking_firebreaks : undefined,
+            reason: result.blocking_firebreaks.length > 0
+                ? `Firebreak required: ${result.blocking_firebreaks.join(', ')}`
+                : undefined,
+        };
+    }
+    /**
+     * Get firebreak enforcement statistics
+     */
+    getStats() {
+        // Calculate override request summary
+        const overrideValues = Array.from(this.overrideRequests.values());
+        const override_requests_summary = {
+            total: overrideValues.length,
+            pending: overrideValues.filter(o => o.status === 'pending').length,
+            approved: overrideValues.filter(o => o.status === 'approved').length,
+            rejected: overrideValues.filter(o => o.status === 'denied' || o.status === 'rejected').length,
+            expired: overrideValues.filter(o => o.status === 'expired').length,
+        };
+        return {
+            ...this.stats,
+            total_validations: this.stats.total_validations,
+            firebreaks_passed: this.stats.firebreaks_passed,
+            firebreaks_blocked: this.stats.firebreaks_blocked,
+            block_reasons: this.stats.block_reasons,
+            block_reason_distribution: this.stats.block_reasons,
+            liability_distribution: this.stats.liability_distribution,
+            pending_overrides: this.overrideRequests.size,
+            override_requests_summary,
+        };
+    }
+}
+//# sourceMappingURL=liability-firebreak.js.map