if verification_passed and deployment_failed:
    # Gap detected: verification missed something reality caught
    gap_detected = True
    failure_case = deployment_failure_details
    observer_results = get_all_observer_results()
else:
    # No gap: either verification caught it or deployment succeeded
    gap_detected = False

def analyze_gap(failure_case, observer_results, system_state):
    """Determine what domain no observer covers"""
    
    # Extract failure characteristics
    failure_type = classify_failure(failure_case)
    failure_domain = extract_domain(failure_case)
    
    # Check which observers should have caught it
    responsible_observers = []
    for observer in observer_results:
        if observer.domain_overlaps(failure_domain):
            responsible_observers.append(observer)
    
    # If observers exist but failed, it's their bug
    if responsible_observers:
        return {
            'type': 'observer_bug',
            'observers': responsible_observers,
            'action': 'fix_existing_observers'
        }
    
    # If no observers overlap, it's a gap
    else:
        missing_domain = identify_missing_domain(
            failure_case,
            existing_domains=[o.domain for o in observer_results]
        )
        return {
            'type': 'coverage_gap',
            'missing_domain': missing_domain,
            'action': 'synthesize_new_observer'
        }

def synthesize_observer(missing_domain):
    """Generate new observer code for the missing domain"""
    
    # Generate observer metadata
    observer_metadata = {
        'name': generate_name(missing_domain),
        'domain': missing_domain,
        'checks': infer_checks(missing_domain),
        'detection_methods': infer_detection_methods(missing_domain)
    }
    
    # Generate observer class code
    observer_code = generate_observer_class(
        name=observer_metadata['name'],
        domain=observer_metadata['domain'],
        checks=observer_metadata['checks'],
        methods=observer_metadata['detection_methods']
    )
    
    # Generate test cases
    test_cases = generate_tests(
        observer_code=observer_code,
        failure_case=original_failure  # Should catch this
    )
    
    # Verify generated observer
    if test_observer(observer_code, test_cases):
        return {
            'observer_code': observer_code,
            'tests': test_cases,
            'metadata': observer_metadata,
            'status': 'ready'
        }
    else:
        return {
            'status': 'synthesis_failed',
            'error': 'generated observer failed tests'
        }

# Input: missing_domain = "layer_order_temporal_sequence"

# Generated metadata:
{
    'name': 'LayerOrderObserver',
    'domain': 'temporal_sequence',
    'checks': [
        'drawing_sequence_validation',
        'depth_hierarchy_verification',
        'z_index_consistency',
        'coverage_analysis'
    ]
}

# Generated code:
class LayerOrderObserver:
    def __init__(self):
        self.name = "Layer Order Observer"
        self.domain = "temporal_sequence"
    
    def verify(self, elements):
        issues = []
        
        # Check drawing order
        for i, elem in enumerate(elements):
            if self._is_background(elem):
                # Check if foreground drawn before this background
                for j in range(i):
                    earlier = elements[j]
                    if self._is_foreground(earlier):
                        if self._overlaps(elem, earlier):
                            issues.append({
                                'type': 'z_order_violation',
                                'elem1': elem,
                                'elem2': earlier
                            })
        
        return {'passed': len(issues) == 0, 'issues': issues}

def integrate_observer(new_observer, existing_network):
    """Add new observer to the network"""
    
    # Verify no conflicts with existing observers
    for existing in existing_network.observers:
        if domain_conflict(new_observer.domain, existing.domain):
            # Merge or specialize
            return merge_observers(new_observer, existing)
    
    # Add to network
    network_id = len(existing_network.observers) + 1
    new_observer.set_id(network_id)
    existing_network.observers.append(new_observer)
    
    # Update network topology
    existing_network.update_topology()
    
    # Run integration tests
    if test_network(existing_network):
        return {
            'status': 'integrated',
            'network': existing_network,
            'observer_id': network_id
        }
    else:
        # Rollback
        existing_network.observers.pop()
        return {
            'status': 'integration_failed',
            'error': 'network tests failed'
        }

# Before
observers = [Observer1, Observer2, ..., Observer7]

# After auto-discovery
observers = [Observer1, Observer2, ..., Observer7, Observer8_AutoGenerated]

# All future creations checked by 8 observers instead of 7

class AutoObserverDiscoveryEngine:
    """Automatically discovers and synthesizes new observers from failures"""
    
    def __init__(self, observer_network):
        self.network = observer_network
        self.failure_history = []
        self.discovered_observers = []
    
    def process_failure(self, failure_case, verification_results, deployment_results):
        """Main entry point: failure detected, process it"""
        
        # Phase 1: Detect gap
        gap = self.detect_gap(verification_results, deployment_results)
        if not gap['detected']:
            return {'action': 'no_gap', 'result': 'verification_or_deployment_error'}
        
        # Phase 2: Analyze gap
        analysis = self.analyze_gap(
            failure_case=failure_case,
            observer_results=verification_results,
            system_state=self.network.get_state()
        )
        
        if analysis['type'] == 'observer_bug':
            # Existing observer failed - fix it
            return self.fix_observer_bug(analysis)
        
        # Phase 3: Synthesize new observer
        new_observer = self.synthesize_observer(analysis['missing_domain'])
        if new_observer['status'] != 'ready':
            return {'action': 'synthesis_failed', 'error': new_observer['error']}
        
        # Phase 4: Integrate
        integration = self.integrate_observer(
            new_observer=new_observer['observer_code'],
            network=self.network
        )
        if integration['status'] != 'integrated':
            return {'action': 'integration_failed', 'error': integration['error']}
        
        # Phase 5: Deploy
        self.deploy_expanded_network(integration['network'])
        
        # Record discovery
        self.discovered_observers.append({
            'observer': new_observer,
            'failure_case': failure_case,
            'timestamp': now(),
            'observer_id': integration['observer_id']
        })
        
        return {
            'action': 'observer_discovered',
            'observer_id': integration['observer_id'],
            'observer_name': new_observer['metadata']['name'],
            'network_size': len(self.network.observers)
        }
    
    def detect_gap(self, verification_results, deployment_results):
        """Phase 1: Detect if gap exists"""
        verification_passed = all(r['passed'] for r in verification_results)
        deployment_passed = deployment_results['passed']
        
        if verification_passed and not deployment_passed:
            return {
                'detected': True,
                'reason': 'verification_missed_real_failure',
                'failure_details': deployment_results['failure']
            }
        else:
            return {'detected': False}
    
    def analyze_gap(self, failure_case, observer_results, system_state):
        """Phase 2: Analyze what domain is missing"""
        
        # Classify failure
        failure_taxonomy = self.classify_failure(failure_case)
        
        # Extract domain
        failure_domain = self.extract_domain(failure_taxonomy)
        
        # Check coverage
        covered_domains = [obs['domain'] for obs in observer_results]
        
        # Find gap
        if failure_domain not in covered_domains:
            # Pure gap - no observer covers this
            return {
                'type': 'coverage_gap',
                'missing_domain': failure_domain,
                'action': 'synthesize_new_observer',
                'confidence': self.calculate_confidence(failure_case, covered_domains)
            }
        else:
            # Observer exists but failed - it's buggy
            responsible = [obs for obs in observer_results if obs['domain'] == failure_domain]
            return {
                'type': 'observer_bug',
                'observers': responsible,
                'action': 'fix_existing_observers',
                'bug_details': self.diagnose_bug(responsible, failure_case)
            }
    
    def classify_failure(self, failure_case):
        """Classify failure into taxonomy"""
        failure_type = failure_case['type']
        
        taxonomy = {
            'visual': ['color', 'position', 'size', 'visibility', 'z-order'],
            'structural': ['topology', 'connectivity', 'hierarchy'],
            'temporal': ['timing', 'sequence', 'synchronization'],
            'logical': ['correctness', 'consistency', 'completeness'],
            'semantic': ['meaning', 'intent', 'context']
        }
        
        # Classify failure into taxonomy
        for category, subcategories in taxonomy.items():
            for subcategory in subcategories:
                if subcategory in failure_case['description'].lower():
                    return {
                        'category': category,
                        'subcategory': subcategory,
                        'domain': f"{category}_{subcategory}"
                    }
        
        # Unknown - create new category
        return {
            'category': 'unknown',
            'subcategory': 'new',
            'domain': self.infer_domain(failure_case)
        }
    
    def extract_domain(self, taxonomy):
        """Extract domain specification from taxonomy"""
        return taxonomy['domain']
    
    def synthesize_observer(self, missing_domain):
        """Phase 3: Generate new observer code"""
        
        # Generate observer specification
        spec = self.generate_observer_spec(missing_domain)
        
        # Generate code from spec
        code = self.generate_code(spec)
        
        # Generate tests
        tests = self.generate_tests(spec)
        
        # Verify generated observer
        if self.test_observer(code, tests):
            return {
                'status': 'ready',
                'observer_code': code,
                'tests': tests,
                'metadata': spec
            }
        else:
            return {
                'status': 'synthesis_failed',
                'error': 'generated observer failed validation'
            }
    
    def generate_observer_spec(self, domain):
        """Generate specification for observer in this domain"""
        
        # Domain → Name
        name = self.domain_to_name(domain)
        
        # Domain → Checks
        checks = self.domain_to_checks(domain)
        
        # Domain → Detection methods
        methods = self.domain_to_methods(domain)
        
        return {
            'name': name,
            'domain': domain,
            'checks': checks,
            'methods': methods,
            'template': self.select_template(domain)
        }
    
    def generate_code(self, spec):
        """Generate Python class code from specification"""
        
        template = self.get_template(spec['template'])
        
        code = template.render(
            name=spec['name'],
            domain=spec['domain'],
            checks=spec['checks'],
            methods=spec['methods']
        )
        
        return code
    
    def generate_tests(self, spec):
        """Generate test cases for the observer"""
        
        tests = []
        
        # Test 1: Should catch original failure
        tests.append({
            'name': 'test_catches_original_failure',
            'input': self.failure_history[-1]['failure_case'],
            'expected': {'passed': False, 'issues': [...]},
        })
        
        # Test 2: Should pass on valid cases
        tests.append({
            'name': 'test_passes_valid_cases',
            'input': self.generate_valid_case(spec['domain']),
            'expected': {'passed': True, 'issues': []},
        })
        
        # Test 3: Edge cases
        for edge_case in self.generate_edge_cases(spec['domain']):
            tests.append({
                'name': f'test_edge_case_{edge_case["name"]}',
                'input': edge_case['input'],
                'expected': edge_case['expected']
            })
        
        return tests
    
    def test_observer(self, code, tests):
        """Run tests on generated observer"""
        
        # Execute code (safely sandboxed)
        observer_class = self.safe_exec(code)
        observer = observer_class()
        
        # Run tests
        for test in tests:
            result = observer.verify(test['input'])
            if result != test['expected']:
                return False
        
        return True
    
    def integrate_observer(self, new_observer, network):
        """Phase 4: Add observer to network"""
        
        # Check conflicts
        for existing in network.observers:
            if self.domain_overlaps(new_observer.domain, existing.domain):
                # Merge or specialize
                return self.handle_conflict(new_observer, existing, network)
        
        # Assign ID
        observer_id = len(network.observers) + 1
        new_observer.set_id(observer_id)
        
        # Add to network
        network.observers.append(new_observer)
        
        # Test integration
        if self.test_network_integration(network):
            return {
                'status': 'integrated',
                'network': network,
                'observer_id': observer_id
            }
        else:
            # Rollback
            network.observers.pop()
            return {
                'status': 'integration_failed',
                'error': 'network tests failed after integration'
            }
    
    def deploy_expanded_network(self, network):
        """Phase 5: Deploy expanded network"""
        
        # Update network reference
        self.network = network
        
        # Persist to disk
        self.save_network(network)
        
        # Log discovery
        self.log_discovery(network.observers[-1])
        
        return {'status': 'deployed'}
    
    def domain_to_name(self, domain):
        """Convert domain to observer name"""
        words = domain.split('_')
        name = ''.join(w.capitalize() for w in words) + 'Observer'
        return name
    
    def domain_to_checks(self, domain):
        """Infer checks from domain"""
        # Domain-specific logic
        checks_map = {
            'temporal_sequence': ['drawing_order', 'z_index', 'depth_hierarchy'],
            'spatial_overlap': ['collision_detection', 'boundary_checking'],
            'semantic_consistency': ['pattern_matching', 'rule_verification'],
            # ... more domains
        }
        return checks_map.get(domain, ['generic_validation'])
    
    def domain_to_methods(self, domain):
        """Infer detection methods from domain"""
        # Generate method signatures
        methods = []
        for check in self.domain_to_checks(domain):
            methods.append({
                'name': f'check_{check}',
                'signature': f'def check_{check}(self, elements):',
                'body': self.generate_method_body(check)
            })
        return methods

# Initialize
network = ObserverNetwork([Observer1(), Observer2(), ..., Observer7()])
discovery_engine = AutoObserverDiscoveryEngine(network)

# Create something
svg = create_svg()

# Verify with current network
verification_results = network.verify(svg)

# Deploy
deploy_results = deploy(svg)

# If failure despite verification passing
if verification_results.passed and not deploy_results.passed:
    # Auto-discover new observer
    result = discovery_engine.process_failure(
        failure_case=deploy_results.failure,
        verification_results=verification_results,
        deployment_results=deploy_results
    )
    
    if result['action'] == 'observer_discovered':
        print(f"✓ Discovered Observer #{result['observer_id']}: {result['observer_name']}")
        print(f"✓ Network expanded to {result['network_size']} observers")

# Failure case
failure = {
    'type': 'visual_obscured',
    'description': 'Title text covered by fusion panel',
    'details': {
        'element': 'title text',
        'drawn_at': 'position 4',
        'covered_by': 'fusion panel',
        'covered_at': 'position 5',
        'reason': 'later-drawn element overlaps earlier'
    }
}

# Verification results (7 observers, all passed)
verification = [
    {'observer': 'SpacingChecker', 'passed': True},
    {'observer': 'OverlapDetector', 'passed': True},  # Detected overlap but not z-order issue
    {'observer': 'AestheticEvaluator', 'passed': True},
    {'observer': 'ConsistencyVerifier', 'passed': True},
    {'observer': 'AccessibilityAuditor', 'passed': True},
    {'observer': 'MathValidator', 'passed': True},
    {'observer': 'PatternAnalyzer', 'passed': True}
]

# Deployment failed
deployment = {
    'passed': False,
    'failure': failure
}

# Run auto-discovery
result = discovery_engine.process_failure(failure, verification, deployment)

# Output:
{
    'action': 'observer_discovered',
    'observer_id': 8,
    'observer_name': 'LayerOrderObserver',
    'network_size': 8,
    'synthesis_details': {
        'detected_gap': 'temporal_sequence',
        'generated_checks': ['drawing_order', 'z_index', 'depth_hierarchy'],
        'test_results': 'all_passed',
        'integration_status': 'successful'
    }
}