class ReputationNode:
    """Reputation via series push"""
    
    def __init__(self, node_id):
        self.node_id = node_id
        
        # ONLY series
        self.series = [
            {'t': time.time(), 'event': 'initialized'}
        ]
    
    def record_action(self, action_type, **details):
        """Record reputation-relevant action"""
        # Append to series (not mutation!)
        self._append_series(action_type, **details)
        
        # Push chunks to BT periodically
        if len(self.series) % 10 == 0:
            self._push_recent_chunks_to_bt()
    
    def _derive_reputation(self):
        """Derive reputation from series (computed on demand)"""
        positive = 0
        negative = 0
        
        for entry in self.series:
            if entry['event'] in ['ecosystem_improved', 'dispute_resolved', 'consensus_match']:
                positive += 1
            elif entry['event'] in ['ecosystem_degraded', 'dispute_failed', 'consensus_mismatch']:
                negative += 1
        
        total = positive + negative
        if total == 0:
            return 0.5  # Neutral
        
        return positive / total

def query_reputation(self, target_node_id):
    """
    Query another node's reputation
    Intent-based, not request
    """
    # Declare intent to DHT
    dht.broadcast_intent({
        'from': self.address,
        'intent': 'want_reputation_chunks',
        'target_node': target_node_id,
        'chunk_types': ['ecosystem', 'dispute', 'consensus']
    })
    
    # Append declaration to MY series
    self._append_series('declared_reputation_query',
                      target=target_node_id,
                      timestamp=time.time())
    
    # Wait for responses (YES/NO/SILENCE)
    # Each response appended to series

❌ reputation = get_reputation(node_id)  # Request
❌ score = node.reputation_score  # Stored state

✅ dht.broadcast_intent("want_reputation_chunks", node_id)
✅ responses = collect_responses()  # YES/NO/SILENCE
✅ reputation = derive_from_chunks(responses['yes'])

class BTNodeWithReputation:
    """BT node stores reputation chunks"""
    
    def receive_reputation_intent(self, intent):
        """Reputation query received"""
        target_node = intent['target_node']
        
        # Do I have reputation chunks for this node?
        my_chunks = self._get_chunks_for_node(target_node)
        
        if not my_chunks:
            # SILENCE (don't have chunks)
            return None
        
        # Check rate limiters
        limiters = self._compute_rate_limiters()
        
        if limiters['w_tracking'] < 0.3:
            # NO (have chunks but rate limited)
            return {
                'response': 'no',
                'reason': 'rate_limited',
                'chunks_available': len(my_chunks)
            }
        
        # YES (share chunks)
        return {
            'response': 'yes',
            'chunks': my_chunks,
            'total_events': sum(len(c['events']) for c in my_chunks)
        }

def derive_multi_perspective_reputation(self, target_node, responses):
    """Derive reputation from multiple chunk sources"""
    
    all_chunks = []
    
    # Collect YES responses
    for r in responses['yes']:
        all_chunks.extend(r['chunks'])
    
    # NO responses tell us chunks exist elsewhere
    chunks_elsewhere = sum(r.get('chunks_available', 0) 
                          for r in responses['no'])
    
    # SILENCE tells us coverage
    nodes_without_data = len(responses['silence'])
    
    # Combine all events from chunks
    all_events = []
    for chunk in all_chunks:
        all_events.extend(chunk['events'])
    
    # Count event types
    positive = sum(1 for e in all_events 
                  if e['event'] in ['ecosystem_improved', 
                                   'dispute_resolved',
                                   'consensus_match'])
    
    negative = sum(1 for e in all_events
                  if e['event'] in ['ecosystem_degraded',
                                   'dispute_failed', 
                                   'consensus_mismatch'])
    
    total = positive + negative
    if total == 0:
        return {
            'reputation': 0.5,
            'confidence': 'low',
            'sources': 0
        }
    
    reputation = positive / total
    
    # Metadata from all responses
    metadata = {
        'reputation': reputation,
        'total_events': total,
        'positive_events': positive,
        'negative_events': negative,
        'chunks_fetched': len(all_chunks),
        'bt_nodes_responded': len(responses['yes']),
        'bt_nodes_rate_limited': len(responses['no']),
        'bt_nodes_no_data': nodes_without_data,
        'confidence': 'high' if len(responses['yes']) >= 2 else 'medium'
    }
    
    return metadata

class ReputationChunkPushing:
    """Push reputation events to BT network"""
    
    def push_reputation_chunks(self):
        """Push recent reputation events as chunks"""
        # Filter series for reputation-relevant events
        rep_events = [
            e for e in self.series
            if e.get('event') in [
                'ecosystem_improved',
                'ecosystem_degraded',
                'dispute_resolved',
                'dispute_failed',
                'consensus_match',
                'consensus_mismatch',
                'community_feedback'
            ]
        ]
        
        # Chunk events (10 events per chunk)
        chunks = []
        for i in range(0, len(rep_events), 10):
            chunk = {
                'chunk_id': f'rep_{self.node_id}_{i}',
                'node_id': self.node_id,
                'chunk_type': 'reputation',
                'events': rep_events[i:i+10],
                'start_time': rep_events[i]['t'],
                'end_time': rep_events[min(i+9, len(rep_events)-1)]['t']
            }
            chunks.append(chunk)
        
        # Push each chunk via intent
        for chunk in chunks:
            dht.broadcast_intent({
                'from': self.address,
                'intent': 'store_chunk',
                'chunk_id': chunk['chunk_id'],
                'chunk_type': 'reputation',
                'data': chunk
            })
            
            # BT nodes decide via rate limiters
            # YES: Store it
            # NO: Rate limited
            # SILENCE: Don't want to store

def compare_candidates(self, candidates):
    """Compare by track record, not capital"""
    
    scores = []
    
    for candidate in candidates:
        # Fetch reputation via intent
        dht.broadcast_intent({
            'intent': 'want_reputation_chunks',
            'target_node': candidate.node_id
        })
        
        responses = self._collect_responses()
        
        # Derive reputation from chunks
        rep_data = self.derive_multi_perspective_reputation(
            candidate.node_id,
            responses
        )
        
        # Score = reputation (not capital!)
        score = rep_data['reputation']
        
        # Capital can amplify but doesn't dominate
        if candidate.stake > 0:
            score *= (1 + 0.1 * log(candidate.stake))
        
        scores.append({
            'candidate': candidate,
            'reputation': rep_data['reputation'],
            'score': score,
            'confidence': rep_data['confidence']
        })
    
    # Best track record wins
    best = max(scores, key=lambda s: s['score'])
    
    return best

def handle_poor_performance(self, node):
    """Natural consequences, not arbitrary punishment"""
    
    # Bad performance appended to series
    node._append_series('ecosystem_degraded',
                       territory='forest_A',
                       health_delta=-15)
    
    # Push updated chunks to BT
    node._push_reputation_chunks()
    
    # Others fetch updated reputation
    # (When they query via intent)
    
    # Natural consequence: Lower reputation
    # → Less likely selected for future roles
    # → Economic incentive to improve
    
    # NO slashing
    # NO arbitrary punishment
    # Just natural market response to track record

class ReputationStake:
    """Stake amplifies reputation, doesn't replace it"""
    
    def calculate_selection_weight(self, candidate):
        """Weight = reputation + stake amplifier"""
        
        # Fetch reputation via intent
        rep_data = self._fetch_reputation(candidate.node_id)
        
        base_reputation = rep_data['reputation']  # 0.0 to 1.0
        
        # Stake amplifies (doesn't replace)
        if candidate.stake_eth > 0:
            stake_multiplier = 1 + 0.1 * math.log(candidate.stake_eth)
        else:
            stake_multiplier = 1.0
        
        weight = base_reputation * stake_multiplier
        
        return {
            'weight': weight,
            'reputation': base_reputation,
            'stake': candidate.stake_eth,
            'multiplier': stake_multiplier
        }

def build_reputation_timeline():
    """How to build high reputation via intents"""
    
    timeline = {
        'month_1': {
            'actions': [
                'Perform first actions',
                'Record in series',
                'Push chunks to BT'
            ],
            'reputation': 0.5,  # Neutral
            'status': 'Building track record'
        },
        
        'month_3': {
            'actions': [
                'Consistent positive actions',
                'Regular chunk updates',
                'Multi-node verification'
            ],
            'reputation': 0.6,
            'status': 'Track record emerging'
        },
        
        'month_6': {
            'actions': [
                'Sustained performance',
                'Community validation',
                'Cross-node reputation'
            ],
            'reputation': 0.7,
            'status': 'Good reputation'
        },
        
        'year_1': {
            'actions': [
                'Long-term consistency',
                'Multiple domains',
                'High confidence'
            ],
            'reputation': 0.8,
            'status': 'High reputation'
        },
        
        'year_2+': {
            'actions': [
                'Elite track record',
                'Wide recognition',
                'Priority selection'
            ],
            'reputation': 0.9+,
            'status': 'Elite reputation'
        }
    }
    
    return timeline

def select_best_candidate(candidates, skill_type):
    """
    Select best candidate via intent queries
    No "Ethos" system needed - just use Post 874 paradigm
    """
    best = None
    best_weight = 0
    
    for candidate in candidates:
        # Query reputation via intent (Post 874 paradigm)
        dht.broadcast_intent({
            'intent': 'want_reputation_chunks',
            'target_node': candidate.node_id,
            'skill_type': skill_type
        })
        
        # Collect responses (YES/NO/SILENCE)
        responses = wait_for_responses()
        
        # Derive reputation from chunks
        rep_data = derive_multi_perspective_reputation(
            candidate.node_id,
            responses
        )
        
        # Calculate weight (reputation + stake)
        weight = rep_data['reputation']
        if candidate.stake_eth > 0:
            weight *= (1 + 0.1 * math.log(candidate.stake_eth))
        
        if weight > best_weight:
            best = candidate
            best_weight = weight
    
    return best

_append_series('ecosystem_improved', delta=+10)
→ Push chunks to BT via intent

dht.broadcast_intent("want_reputation_chunks", node_id)
→ YES/NO/SILENCE responses
→ Derive from multiple sources

YES: Chunks provided
NO: Have chunks but rate limited
SILENCE: Don't have chunks
→ All inform confidence

weight = reputation * stake_multiplier
→ Reputation dominates
→ Stake amplifies (doesn't replace)

Good actions → high rep → selected more
Bad actions → low rep → selected less
NO punishment needed