/// Task type for dependency relationships
#[derive(AnchorSerialize, AnchorDeserialize, Clone, Copy, PartialEq, Eq, Default, InitSpace)]
#[repr(u8)]
pub enum DependencyType {
    /// No dependency - standalone task
    #[default]
    None = 0,
    /// Hard dependency - task cannot execute until parent is confirmed
    Hard = 1,
    /// Soft dependency - task can speculatively execute before parent confirms
    Soft = 2,
}

/// Task account (V2 - with dependency support)
/// PDA seeds: ["task", creator, task_id]
#[account]
#[derive(InitSpace)]
pub struct Task {
    // === Existing fields (unchanged) ===
    /// Unique task identifier
    pub task_id: [u8; 32],
    /// Task creator (paying party)
    pub creator: Pubkey,
    /// Required capability bitmask
    pub required_capabilities: u64,
    /// Task description or instruction hash
    pub description: [u8; 64],
    /// Constraint hash for private task verification
    pub constraint_hash: [u8; 32],
    /// Reward amount in lamports
    pub reward_amount: u64,
    /// Maximum workers allowed
    pub max_workers: u8,
    /// Current worker count
    pub current_workers: u8,
    /// Task status
    pub status: TaskStatus,
    /// Task type
    pub task_type: TaskType,
    /// Creation timestamp
    pub created_at: i64,
    /// Deadline timestamp (0 = no deadline)
    pub deadline: i64,
    /// Completion timestamp
    pub completed_at: i64,
    /// Escrow account for reward
    pub escrow: Pubkey,
    /// Result data or pointer
    pub result: [u8; 64],
    /// Number of completions (for collaborative tasks)
    pub completions: u8,
    /// Required completions
    pub required_completions: u8,
    /// Bump seed
    pub bump: u8,
    
    // === New dependency fields ===
    /// Parent task this task depends on (Pubkey::default() if none)
    pub depends_on: Pubkey,
    /// Type of dependency relationship
    pub dependency_type: DependencyType,
    /// Depth in the dependency chain (0 = root task, 1 = direct child, etc.)
    pub dependency_depth: u8,
    
    // === Updated reserved (reduced to accommodate new fields) ===
    /// Reserved for future use
    pub _reserved: [u8; 28],
}

impl Task {
    /// Account size calculation
    /// Note: Using manual calculation for backward compatibility
    pub const SIZE: usize = 8 +   // discriminator
        32 +  // task_id
        32 +  // creator
        8 +   // required_capabilities
        64 +  // description
        32 +  // constraint_hash
        8 +   // reward_amount
        1 +   // max_workers
        1 +   // current_workers
        1 +   // status
        1 +   // task_type
        8 +   // created_at
        8 +   // deadline
        8 +   // completed_at
        32 +  // escrow
        64 +  // result
        1 +   // completions
        1 +   // required_completions
        1 +   // bump
        // New fields
        32 +  // depends_on
        1 +   // dependency_type
        1 +   // dependency_depth
        28;   // _reserved (reduced from 32)
    
    /// Maximum allowed dependency depth
    pub const MAX_DEPENDENCY_DEPTH: u8 = 20;
    
    /// Check if task has a dependency
    pub fn has_dependency(&self) -> bool {
        self.depends_on != Pubkey::default() && 
        self.dependency_type != DependencyType::None
    }
    
    /// Check if task allows speculative execution
    pub fn allows_speculation(&self) -> bool {
        self.dependency_type == DependencyType::Soft
    }
}

seeds = [b"task", creator.key().as_ref(), task_id.as_ref()]

/// Status of a speculative commitment
#[derive(AnchorSerialize, AnchorDeserialize, Clone, Copy, PartialEq, Eq, Default, InitSpace)]
#[repr(u8)]
pub enum CommitmentStatus {
    /// Commitment is pending - execution claimed but not confirmed
    #[default]
    Pending = 0,
    /// Commitment is confirmed - proof verified on-chain
    Confirmed = 1,
    /// Commitment is voided - rolled back due to ancestor failure
    Voided = 2,
    /// Commitment expired - not confirmed within timeout
    Expired = 3,
}

/// Speculative commitment account
/// Records an agent's commitment to speculatively execute a task
/// 
/// PDA seeds: ["spec_commitment", task, worker]
#[account]
#[derive(InitSpace)]
pub struct SpeculativeCommitment {
    // === Identity ===
    /// The task being speculatively executed
    pub task: Pubkey,
    /// The worker agent making the commitment
    pub worker: Pubkey,
    /// The worker's agent registration
    pub worker_agent: Pubkey,
    
    // === Dependency chain ===
    /// Parent commitment this depends on (Pubkey::default() if root)
    pub parent_commitment: Pubkey,
    /// The task this commitment's task depends on
    pub depends_on_task: Pubkey,
    /// Depth in the speculation chain (0 = first speculative task)
    pub speculation_depth: u8,
    
    // === Commitment data ===
    /// Hash of the speculative result (commitment to output)
    pub result_hash: [u8; 32],
    /// Hash of the input state used for speculation
    pub input_state_hash: [u8; 32],
    /// Estimated computation cost (for slash distribution)
    pub compute_cost_estimate: u64,
    
    // === Timestamps ===
    /// When the commitment was created
    pub created_at: i64,
    /// When the commitment expires if not confirmed
    pub expires_at: i64,
    /// When the commitment was confirmed (0 if not yet)
    pub confirmed_at: i64,
    /// When the commitment was voided (0 if not)
    pub voided_at: i64,
    
    // === State ===
    /// Current status of the commitment
    pub status: CommitmentStatus,
    /// Associated speculation bond (if any)
    pub bond: Pubkey,
    /// Amount of stake locked for this commitment
    pub staked_amount: u64,
    
    // === PDA ===
    /// Bump seed for PDA
    pub bump: u8,
    
    /// Reserved for future use
    pub _reserved: [u8; 32],
}

impl SpeculativeCommitment {
    /// Account size calculation
    pub const SIZE: usize = 8 +   // discriminator
        32 +  // task
        32 +  // worker
        32 +  // worker_agent
        32 +  // parent_commitment
        32 +  // depends_on_task
        1 +   // speculation_depth
        32 +  // result_hash
        32 +  // input_state_hash
        8 +   // compute_cost_estimate
        8 +   // created_at
        8 +   // expires_at
        8 +   // confirmed_at
        8 +   // voided_at
        1 +   // status
        32 +  // bond
        8 +   // staked_amount
        1 +   // bump
        32;   // _reserved
    
    /// Default commitment timeout (24 hours)
    pub const DEFAULT_EXPIRY_DURATION: i64 = 24 * 60 * 60;
    
    /// Maximum speculation depth allowed
    pub const MAX_SPECULATION_DEPTH: u8 = 20;
    
    /// Check if commitment can be confirmed
    pub fn can_confirm(&self, clock: &Clock) -> bool {
        self.status == CommitmentStatus::Pending &&
        clock.unix_timestamp < self.expires_at
    }
    
    /// Check if commitment is expired
    pub fn is_expired(&self, clock: &Clock) -> bool {
        self.status == CommitmentStatus::Pending &&
        clock.unix_timestamp >= self.expires_at
    }
    
    /// Check if commitment is active (pending and not expired)
    pub fn is_active(&self, clock: &Clock) -> bool {
        self.status == CommitmentStatus::Pending &&
        clock.unix_timestamp < self.expires_at
    }
}

impl Default for SpeculativeCommitment {
    fn default() -> Self {
        Self {
            task: Pubkey::default(),
            worker: Pubkey::default(),
            worker_agent: Pubkey::default(),
            parent_commitment: Pubkey::default(),
            depends_on_task: Pubkey::default(),
            speculation_depth: 0,
            result_hash: [0u8; 32],
            input_state_hash: [0u8; 32],
            compute_cost_estimate: 0,
            created_at: 0,
            expires_at: 0,
            confirmed_at: 0,
            voided_at: 0,
            status: CommitmentStatus::default(),
            bond: Pubkey::default(),
            staked_amount: 0,
            bump: 0,
            _reserved: [0u8; 32],
        }
    }
}

seeds = [b"spec_commitment", task.key().as_ref(), worker.key().as_ref()]

/// Status of a speculation bond
#[derive(AnchorSerialize, AnchorDeserialize, Clone, Copy, PartialEq, Eq, Default, InitSpace)]
#[repr(u8)]
pub enum BondStatus {
    /// Bond is active and available for locking
    #[default]
    Active = 0,
    /// Bond is partially or fully locked in commitments
    Locked = 1,
    /// Bond is being withdrawn (cooldown period)
    Withdrawing = 2,
    /// Bond has been slashed
    Slashed = 3,
}

/// Speculation bond account
/// Holds stake that backs speculative commitments
/// 
/// PDA seeds: ["spec_bond", agent]
#[account]
#[derive(InitSpace)]
pub struct SpeculationBond {
    // === Identity ===
    /// The agent this bond belongs to
    pub agent: Pubkey,
    /// The agent's authority (signer for operations)
    pub authority: Pubkey,
    
    // === Balances ===
    /// Total amount deposited into the bond
    pub total_deposited: u64,
    /// Amount currently available (not locked)
    pub available_balance: u64,
    /// Amount currently locked in active commitments
    pub locked_balance: u64,
    /// Amount pending withdrawal (in cooldown)
    pub pending_withdrawal: u64,
    
    // === Lock tracking ===
    /// Number of active commitment locks
    pub active_locks: u16,
    /// Maximum concurrent locks allowed
    pub max_locks: u16,
    
    // === Withdrawal state ===
    /// Timestamp when withdrawal cooldown ends (0 if not withdrawing)
    pub withdrawal_available_at: i64,
    /// Amount requested for withdrawal
    pub withdrawal_amount: u64,
    
    // === Slash history ===
    /// Total amount slashed historically
    pub total_slashed: u64,
    /// Number of times this bond has been slashed
    pub slash_count: u16,
    /// Timestamp of last slash (for cooldown)
    pub last_slash_at: i64,
    /// Cooldown end timestamp after slash (cannot speculate until then)
    pub slash_cooldown_until: i64,
    
    // === Timestamps ===
    /// When the bond was created
    pub created_at: i64,
    /// Last activity timestamp
    pub last_activity: i64,
    
    // === State ===
    /// Current bond status
    pub status: BondStatus,
    /// Bump seed for PDA
    pub bump: u8,
    
    /// Reserved for future use
    pub _reserved: [u8; 30],
}

impl SpeculationBond {
    /// Account size calculation
    pub const SIZE: usize = 8 +   // discriminator
        32 +  // agent
        32 +  // authority
        8 +   // total_deposited
        8 +   // available_balance
        8 +   // locked_balance
        8 +   // pending_withdrawal
        2 +   // active_locks
        2 +   // max_locks
        8 +   // withdrawal_available_at
        8 +   // withdrawal_amount
        8 +   // total_slashed
        2 +   // slash_count
        8 +   // last_slash_at
        8 +   // slash_cooldown_until
        8 +   // created_at
        8 +   // last_activity
        1 +   // status
        1 +   // bump
        30;   // _reserved
    
    /// Minimum bond deposit
    pub const MIN_DEPOSIT: u64 = 1_000_000; // 0.001 SOL
    
    /// Maximum deposit per bond
    pub const MAX_DEPOSIT: u64 = 1_000_000_000_000; // 1000 SOL
    
    /// Withdrawal cooldown period (1 hour)
    pub const WITHDRAWAL_COOLDOWN: i64 = 60 * 60;
    
    /// Slash cooldown period (5 minutes)
    pub const SLASH_COOLDOWN: i64 = 5 * 60;
    
    /// Default max concurrent locks
    pub const DEFAULT_MAX_LOCKS: u16 = 100;
    
    /// Base bond amount for speculation (exponential: base * 2^depth)
    pub const BASE_SPECULATION_BOND: u64 = 100_000; // 0.0001 SOL
    
    /// Calculate required bond for a given speculation depth
    /// Formula: base_bond × 2^depth
    pub fn calculate_required_bond(depth: u8) -> Result<u64, CoordinationError> {
        if depth > SpeculativeCommitment::MAX_SPECULATION_DEPTH {
            return Err(CoordinationError::SpeculationDepthExceeded);
        }
        
        let multiplier = 1u64
            .checked_shl(depth as u32)
            .ok_or(CoordinationError::ArithmeticOverflow)?;
        
        Self::BASE_SPECULATION_BOND
            .checked_mul(multiplier)
            .ok_or(CoordinationError::ArithmeticOverflow)
    }
    
    /// Check if bond can support a lock of the given amount
    pub fn can_lock(&self, amount: u64, clock: &Clock) -> bool {
        self.status == BondStatus::Active &&
        self.available_balance >= amount &&
        self.active_locks < self.max_locks &&
        clock.unix_timestamp >= self.slash_cooldown_until
    }
    
    /// Check if bond is in slash cooldown
    pub fn is_in_cooldown(&self, clock: &Clock) -> bool {
        clock.unix_timestamp < self.slash_cooldown_until
    }
}

impl Default for SpeculationBond {
    fn default() -> Self {
        Self {
            agent: Pubkey::default(),
            authority: Pubkey::default(),
            total_deposited: 0,
            available_balance: 0,
            locked_balance: 0,
            pending_withdrawal: 0,
            active_locks: 0,
            max_locks: Self::DEFAULT_MAX_LOCKS,
            withdrawal_available_at: 0,
            withdrawal_amount: 0,
            total_slashed: 0,
            slash_count: 0,
            last_slash_at: 0,
            slash_cooldown_until: 0,
            created_at: 0,
            last_activity: 0,
            status: BondStatus::default(),
            bump: 0,
            _reserved: [0u8; 30],
        }
    }
}

seeds = [b"spec_bond", agent.key().as_ref()]

/// Individual lock record linking a bond to a commitment
/// 
/// PDA seeds: ["bond_lock", bond, commitment]
#[account]
#[derive(InitSpace)]
pub struct BondLock {
    /// The speculation bond this lock is against
    pub bond: Pubkey,
    /// The speculative commitment this lock secures
    pub commitment: Pubkey,
    /// Amount locked
    pub amount: u64,
    /// When the lock was created
    pub created_at: i64,
    /// When the lock was released (0 if still active)
    pub released_at: i64,
    /// Whether the lock is active
    pub is_active: bool,
    /// Bump seed for PDA
    pub bump: u8,
}

impl BondLock {
    pub const SIZE: usize = 8 +   // discriminator
        32 +  // bond
        32 +  // commitment
        8 +   // amount
        8 +   // created_at
        8 +   // released_at
        1 +   // is_active
        1;    // bump
}

impl Default for BondLock {
    fn default() -> Self {
        Self {
            bond: Pubkey::default(),
            commitment: Pubkey::default(),
            amount: 0,
            created_at: 0,
            released_at: 0,
            is_active: false,
            bump: 0,
        }
    }
}

seeds = [b"bond_lock", bond.key().as_ref(), commitment.key().as_ref()]

/// Add to existing ProtocolConfig struct
impl ProtocolConfig {
    // ... existing fields ...
    
    // === Speculation configuration (add to struct) ===
    /// Whether speculation is enabled protocol-wide
    pub speculation_enabled: bool,
    /// Base bond amount for speculation (lamports)
    pub speculation_base_bond: u64,
    /// Maximum speculation depth allowed
    pub max_speculation_depth: u8,
    /// Slash percentage on failed speculation (0-100)
    pub speculation_slash_percentage: u8,
    /// Commitment expiry duration (seconds)
    pub commitment_expiry_duration: i64,
    /// Slash cooldown duration (seconds)
    pub slash_cooldown_duration: i64,
    /// Treasury share of slashed funds (percentage, 0-100)
    pub slash_treasury_share: u8,
}

// Add these constants
impl ProtocolConfig {
    pub const DEFAULT_SPECULATION_BASE_BOND: u64 = 100_000; // 0.0001 SOL
    pub const DEFAULT_MAX_SPECULATION_DEPTH: u8 = 10;
    pub const DEFAULT_SPECULATION_SLASH_PERCENTAGE: u8 = 10;
    pub const DEFAULT_COMMITMENT_EXPIRY: i64 = 24 * 60 * 60; // 24 hours
    pub const DEFAULT_SLASH_COOLDOWN: i64 = 5 * 60; // 5 minutes
    pub const DEFAULT_SLASH_TREASURY_SHARE: u8 = 50; // 50%
}

#[derive(Accounts)]
#[instruction(task_id: [u8; 32])]
pub struct CreateDependentTask<'info> {
    /// The new task to create
    #[account(
        init,
        payer = creator,
        space = Task::SIZE,
        seeds = [b"task", creator.key().as_ref(), task_id.as_ref()],
        bump
    )]
    pub task: Account<'info, Task>,

    /// Escrow for the new task's reward
    #[account(
        init,
        payer = creator,
        space = TaskEscrow::SIZE,
        seeds = [b"escrow", task.key().as_ref()],
        bump
    )]
    pub escrow: Account<'info, TaskEscrow>,

    /// The parent task this new task depends on
    #[account(
        constraint = parent_task.status != TaskStatus::Cancelled @ CoordinationError::ParentTaskCancelled,
        constraint = parent_task.status != TaskStatus::Disputed @ CoordinationError::ParentTaskDisputed,
    )]
    pub parent_task: Account<'info, Task>,

    /// Protocol configuration
    #[account(
        mut,
        seeds = [b"protocol"],
        bump = protocol_config.bump
    )]
    pub protocol_config: Account<'info, ProtocolConfig>,

    /// Creator's agent registration for rate limiting
    #[account(
        mut,
        seeds = [b"agent", creator_agent.agent_id.as_ref()],
        bump = creator_agent.bump,
        has_one = authority @ CoordinationError::UnauthorizedAgent
    )]
    pub creator_agent: Account<'info, AgentRegistration>,

    /// The authority that owns the creator_agent
    pub authority: Signer<'info>,

    /// Task creator (payer)
    #[account(mut)]
    pub creator: Signer<'info>,

    pub system_program: Program<'info, System>,
}

#[derive(AnchorSerialize, AnchorDeserialize)]
pub struct CreateDependentTaskArgs {
    /// Unique task identifier
    pub task_id: [u8; 32],
    /// Required capability bitmask
    pub required_capabilities: u64,
    /// Task description or instruction hash
    pub description: [u8; 64],
    /// Reward amount in lamports
    pub reward_amount: u64,
    /// Maximum workers allowed
    pub max_workers: u8,
    /// Deadline timestamp (0 = no deadline)
    pub deadline: i64,
    /// Task type (0=Exclusive, 1=Collaborative, 2=Competitive)
    pub task_type: u8,
    /// Constraint hash for private task verification
    pub constraint_hash: Option<[u8; 32]>,
    /// Dependency type (1=Hard, 2=Soft)
    pub dependency_type: u8,
}

pub fn handler(
    ctx: Context<CreateDependentTask>,
    args: CreateDependentTaskArgs,
) -> Result<()> {
    // 1. Validate inputs
    require!(args.max_workers > 0, CoordinationError::InvalidInput);
    require!(args.task_type <= 2, CoordinationError::InvalidTaskType);
    require!(
        args.dependency_type == 1 || args.dependency_type == 2,
        CoordinationError::InvalidDependencyType
    );
    
    let clock = Clock::get()?;
    let config = &ctx.accounts.protocol_config;
    
    check_version_compatible(config)?;
    
    // 2. Validate deadline if set
    if args.deadline > 0 {
        require!(
            args.deadline > clock.unix_timestamp,
            CoordinationError::InvalidInput
        );
    }
    
    // 3. Calculate and validate dependency depth
    let parent_task = &ctx.accounts.parent_task;
    let new_depth = parent_task.dependency_depth
        .checked_add(1)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    
    require!(
        new_depth <= Task::MAX_DEPENDENCY_DEPTH,
        CoordinationError::DependencyDepthExceeded
    );
    
    // 4. Apply rate limiting (same as create_task)
    apply_rate_limits(&mut ctx.accounts.creator_agent, config, &clock)?;
    
    // 5. Transfer reward to escrow
    if args.reward_amount > 0 {
        system_program::transfer(
            CpiContext::new(
                ctx.accounts.system_program.to_account_info(),
                system_program::Transfer {
                    from: ctx.accounts.creator.to_account_info(),
                    to: ctx.accounts.escrow.to_account_info(),
                },
            ),
            args.reward_amount,
        )?;
    }
    
    // 6. Initialize task with dependency fields
    let task = &mut ctx.accounts.task;
    task.task_id = args.task_id;
    task.creator = ctx.accounts.creator.key();
    task.required_capabilities = args.required_capabilities;
    task.description = args.description;
    task.constraint_hash = args.constraint_hash.unwrap_or([0u8; 32]);
    task.reward_amount = args.reward_amount;
    task.max_workers = args.max_workers;
    task.current_workers = 0;
    task.status = TaskStatus::Open;
    task.task_type = TaskType::try_from(args.task_type)?;
    task.created_at = clock.unix_timestamp;
    task.deadline = args.deadline;
    task.completed_at = 0;
    task.escrow = ctx.accounts.escrow.key();
    task.result = [0u8; 64];
    task.completions = 0;
    task.required_completions = if args.task_type == 1 { args.max_workers } else { 1 };
    task.bump = ctx.bumps.task;
    
    // Set dependency fields
    task.depends_on = parent_task.key();
    task.dependency_type = DependencyType::try_from(args.dependency_type)?;
    task.dependency_depth = new_depth;
    
    // 7. Initialize escrow
    let escrow = &mut ctx.accounts.escrow;
    escrow.task = task.key();
    escrow.amount = args.reward_amount;
    escrow.distributed = 0;
    escrow.is_closed = false;
    escrow.bump = ctx.bumps.escrow;
    
    // 8. Update protocol stats
    let protocol_config = &mut ctx.accounts.protocol_config;
    protocol_config.total_tasks = protocol_config
        .total_tasks
        .checked_add(1)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    
    // 9. Emit event
    emit!(DependentTaskCreated {
        task_id: args.task_id,
        creator: task.creator,
        parent_task: parent_task.key(),
        parent_task_id: parent_task.task_id,
        dependency_type: args.dependency_type,
        dependency_depth: new_depth,
        required_capabilities: args.required_capabilities,
        reward_amount: args.reward_amount,
        task_type: args.task_type,
        deadline: args.deadline,
        timestamp: clock.unix_timestamp,
    });
    
    Ok(())
}

#[derive(Accounts)]
pub struct CreateSpeculativeCommitment<'info> {
    /// The speculative commitment to create
    #[account(
        init,
        payer = worker,
        space = SpeculativeCommitment::SIZE,
        seeds = [b"spec_commitment", task.key().as_ref(), worker.key().as_ref()],
        bump
    )]
    pub commitment: Account<'info, SpeculativeCommitment>,

    /// The task being speculatively executed
    #[account(
        constraint = task.status == TaskStatus::InProgress @ CoordinationError::TaskNotInProgress,
        constraint = task.dependency_type == DependencyType::Soft @ CoordinationError::TaskNotSpeculatable,
    )]
    pub task: Account<'info, Task>,

    /// The task this task depends on
    #[account(
        constraint = parent_task.key() == task.depends_on @ CoordinationError::InvalidParentTask,
    )]
    pub parent_task: Account<'info, Task>,

    /// Parent commitment (optional - Pubkey::default() if parent has no commitment)
    /// CHECK: Validated in handler if not default
    pub parent_commitment: UncheckedAccount<'info>,

    /// The worker's task claim (proves they have claimed this task)
    #[account(
        seeds = [b"claim", task.key().as_ref(), worker_agent.key().as_ref()],
        bump = task_claim.bump,
        constraint = task_claim.worker == worker_agent.key() @ CoordinationError::NotClaimed,
        constraint = !task_claim.is_completed @ CoordinationError::ClaimAlreadyCompleted,
    )]
    pub task_claim: Account<'info, TaskClaim>,

    /// The worker's agent registration
    #[account(
        seeds = [b"agent", worker_agent.agent_id.as_ref()],
        bump = worker_agent.bump,
        has_one = authority @ CoordinationError::UnauthorizedAgent,
    )]
    pub worker_agent: Account<'info, AgentRegistration>,

    /// The worker's speculation bond
    #[account(
        mut,
        seeds = [b"spec_bond", worker_agent.key().as_ref()],
        bump = bond.bump,
        constraint = bond.agent == worker_agent.key() @ CoordinationError::InvalidBond,
    )]
    pub bond: Account<'info, SpeculationBond>,

    /// Bond lock account for this commitment
    #[account(
        init,
        payer = worker,
        space = BondLock::SIZE,
        seeds = [b"bond_lock", bond.key().as_ref(), commitment.key().as_ref()],
        bump
    )]
    pub bond_lock: Account<'info, BondLock>,

    /// Protocol configuration
    #[account(
        seeds = [b"protocol"],
        bump = protocol_config.bump,
        constraint = protocol_config.speculation_enabled @ CoordinationError::SpeculationDisabled,
    )]
    pub protocol_config: Account<'info, ProtocolConfig>,

    /// Worker's authority (signer)
    pub authority: Signer<'info>,

    /// Worker (payer for account creation)
    #[account(mut)]
    pub worker: Signer<'info>,

    pub system_program: Program<'info, System>,
}

#[derive(AnchorSerialize, AnchorDeserialize)]
pub struct CreateSpeculativeCommitmentArgs {
    /// Hash of the speculative result
    pub result_hash: [u8; 32],
    /// Hash of the input state used
    pub input_state_hash: [u8; 32],
    /// Estimated computation cost (lamports)
    pub compute_cost_estimate: u64,
    /// Custom expiry duration (0 = use default)
    pub expiry_duration: i64,
}

pub fn handler(
    ctx: Context<CreateSpeculativeCommitment>,
    args: CreateSpeculativeCommitmentArgs,
) -> Result<()> {
    let clock = Clock::get()?;
    let config = &ctx.accounts.protocol_config;
    let task = &ctx.accounts.task;
    let bond = &mut ctx.accounts.bond;
    
    // 1. Calculate speculation depth
    let speculation_depth = if ctx.accounts.parent_commitment.key() == Pubkey::default() {
        0u8
    } else {
        // Validate and deserialize parent commitment
        let parent_data = ctx.accounts.parent_commitment.try_borrow_data()?;
        let parent_commitment = SpeculativeCommitment::try_deserialize(&mut &parent_data[..])?;
        
        require!(
            parent_commitment.task == task.depends_on,
            CoordinationError::InvalidParentCommitment
        );
        require!(
            parent_commitment.status == CommitmentStatus::Pending ||
            parent_commitment.status == CommitmentStatus::Confirmed,
            CoordinationError::ParentCommitmentInvalid
        );
        
        parent_commitment.speculation_depth
            .checked_add(1)
            .ok_or(CoordinationError::ArithmeticOverflow)?
    };
    
    require!(
        speculation_depth <= config.max_speculation_depth,
        CoordinationError::SpeculationDepthExceeded
    );
    
    // 2. Calculate required bond using exponential formula
    let required_bond = SpeculationBond::calculate_required_bond(speculation_depth)?;
    
    // 3. Verify bond has sufficient available balance
    require!(
        bond.can_lock(required_bond, &clock),
        CoordinationError::InsufficientBondBalance
    );
    
    // 4. Lock the bond
    bond.available_balance = bond.available_balance
        .checked_sub(required_bond)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    bond.locked_balance = bond.locked_balance
        .checked_add(required_bond)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    bond.active_locks = bond.active_locks
        .checked_add(1)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    bond.last_activity = clock.unix_timestamp;
    
    if bond.available_balance == 0 {
        bond.status = BondStatus::Locked;
    }
    
    // 5. Initialize bond lock
    let bond_lock = &mut ctx.accounts.bond_lock;
    bond_lock.bond = ctx.accounts.bond.key();
    bond_lock.commitment = ctx.accounts.commitment.key();
    bond_lock.amount = required_bond;
    bond_lock.created_at = clock.unix_timestamp;
    bond_lock.released_at = 0;
    bond_lock.is_active = true;
    bond_lock.bump = ctx.bumps.bond_lock;
    
    // 6. Calculate expiry
    let expiry_duration = if args.expiry_duration > 0 {
        args.expiry_duration
    } else {
        config.commitment_expiry_duration
    };
    let expires_at = clock.unix_timestamp
        .checked_add(expiry_duration)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    
    // 7. Initialize commitment
    let commitment = &mut ctx.accounts.commitment;
    commitment.task = task.key();
    commitment.worker = ctx.accounts.worker.key();
    commitment.worker_agent = ctx.accounts.worker_agent.key();
    commitment.parent_commitment = ctx.accounts.parent_commitment.key();
    commitment.depends_on_task = task.depends_on;
    commitment.speculation_depth = speculation_depth;
    commitment.result_hash = args.result_hash;
    commitment.input_state_hash = args.input_state_hash;
    commitment.compute_cost_estimate = args.compute_cost_estimate;
    commitment.created_at = clock.unix_timestamp;
    commitment.expires_at = expires_at;
    commitment.confirmed_at = 0;
    commitment.voided_at = 0;
    commitment.status = CommitmentStatus::Pending;
    commitment.bond = ctx.accounts.bond.key();
    commitment.staked_amount = required_bond;
    commitment.bump = ctx.bumps.commitment;
    
    // 8. Emit event
    emit!(SpeculativeCommitmentCreated {
        commitment: commitment.key(),
        task: task.key(),
        task_id: task.task_id,
        worker: commitment.worker,
        worker_agent: commitment.worker_agent,
        parent_commitment: commitment.parent_commitment,
        speculation_depth,
        result_hash: args.result_hash,
        staked_amount: required_bond,
        expires_at,
        timestamp: clock.unix_timestamp,
    });
    
    Ok(())
}

#[derive(Accounts)]
pub struct ConfirmSpeculativeCommitment<'info> {
    /// The commitment to confirm
    #[account(
        mut,
        seeds = [b"spec_commitment", task.key().as_ref(), commitment.worker.as_ref()],
        bump = commitment.bump,
        constraint = commitment.status == CommitmentStatus::Pending @ CoordinationError::CommitmentNotPending,
    )]
    pub commitment: Account<'info, SpeculativeCommitment>,

    /// The task associated with this commitment
    #[account(
        constraint = task.key() == commitment.task @ CoordinationError::InvalidTask,
        constraint = task.status == TaskStatus::Completed @ CoordinationError::TaskNotCompleted,
    )]
    pub task: Account<'info, Task>,

    /// The parent task (must be completed for confirmation)
    #[account(
        constraint = parent_task.key() == commitment.depends_on_task @ CoordinationError::InvalidParentTask,
        constraint = parent_task.status == TaskStatus::Completed @ CoordinationError::ParentTaskNotCompleted,
    )]
    pub parent_task: Account<'info, Task>,

    /// The worker's speculation bond
    #[account(
        mut,
        seeds = [b"spec_bond", commitment.worker_agent.as_ref()],
        bump = bond.bump,
    )]
    pub bond: Account<'info, SpeculationBond>,

    /// The bond lock for this commitment
    #[account(
        mut,
        seeds = [b"bond_lock", bond.key().as_ref(), commitment.key().as_ref()],
        bump = bond_lock.bump,
        constraint = bond_lock.is_active @ CoordinationError::BondLockNotActive,
    )]
    pub bond_lock: Account<'info, BondLock>,

    /// Worker's authority or permissionless confirmer
    pub authority: Signer<'info>,
}

// No additional args needed - confirmation is based on on-chain state

pub fn handler(ctx: Context<ConfirmSpeculativeCommitment>) -> Result<()> {
    let clock = Clock::get()?;
    let commitment = &mut ctx.accounts.commitment;
    let bond = &mut ctx.accounts.bond;
    let bond_lock = &mut ctx.accounts.bond_lock;
    
    // 1. Verify commitment hasn't expired
    require!(
        commitment.can_confirm(&clock),
        CoordinationError::CommitmentExpired
    );
    
    // 2. Update commitment status
    commitment.status = CommitmentStatus::Confirmed;
    commitment.confirmed_at = clock.unix_timestamp;
    
    // 3. Release bond lock
    let locked_amount = bond_lock.amount;
    bond_lock.is_active = false;
    bond_lock.released_at = clock.unix_timestamp;
    
    // 4. Update bond balances
    bond.locked_balance = bond.locked_balance
        .checked_sub(locked_amount)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    bond.available_balance = bond.available_balance
        .checked_add(locked_amount)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    bond.active_locks = bond.active_locks
        .checked_sub(1)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    bond.last_activity = clock.unix_timestamp;
    
    if bond.status == BondStatus::Locked && bond.locked_balance == 0 {
        bond.status = BondStatus::Active;
    }
    
    // 5. Emit event
    emit!(SpeculativeCommitmentConfirmed {
        commitment: ctx.accounts.commitment.key(),
        task: commitment.task,
        worker: commitment.worker,
        speculation_depth: commitment.speculation_depth,
        staked_amount: locked_amount,
        confirmed_at: clock.unix_timestamp,
    });
    
    Ok(())
}

#[derive(Accounts)]
pub struct VoidSpeculativeCommitment<'info> {
    /// The commitment to void
    #[account(
        mut,
        seeds = [b"spec_commitment", commitment.task.as_ref(), commitment.worker.as_ref()],
        bump = commitment.bump,
        constraint = commitment.status == CommitmentStatus::Pending @ CoordinationError::CommitmentNotPending,
    )]
    pub commitment: Account<'info, SpeculativeCommitment>,

    /// The failed parent commitment or task that caused the void
    /// CHECK: Validated in handler
    pub failed_ancestor: UncheckedAccount<'info>,

    /// The worker's speculation bond
    #[account(
        mut,
        seeds = [b"spec_bond", commitment.worker_agent.as_ref()],
        bump = bond.bump,
    )]
    pub bond: Account<'info, SpeculationBond>,

    /// The bond lock for this commitment
    #[account(
        mut,
        seeds = [b"bond_lock", bond.key().as_ref(), commitment.key().as_ref()],
        bump = bond_lock.bump,
        constraint = bond_lock.is_active @ CoordinationError::BondLockNotActive,
    )]
    pub bond_lock: Account<'info, BondLock>,

    /// Protocol config for slash parameters
    #[account(
        seeds = [b"protocol"],
        bump = protocol_config.bump,
    )]
    pub protocol_config: Account<'info, ProtocolConfig>,

    /// Protocol treasury for slash distribution
    /// CHECK: Validated against protocol_config
    #[account(
        mut,
        constraint = treasury.key() == protocol_config.treasury @ CoordinationError::InvalidTreasury,
    )]
    pub treasury: UncheckedAccount<'info>,

    /// Anyone can call void if ancestor has failed
    pub authority: Signer<'info>,

    pub system_program: Program<'info, System>,
}

#[derive(AnchorSerialize, AnchorDeserialize)]
pub struct VoidSpeculativeCommitmentArgs {
    /// Reason for voiding (for logging)
    pub reason: VoidReason,
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone, Copy)]
#[repr(u8)]
pub enum VoidReason {
    /// Parent commitment was voided
    ParentVoided = 0,
    /// Parent task was cancelled
    ParentCancelled = 1,
    /// Parent task failed dispute
    ParentDisputed = 2,
    /// Commitment expired without confirmation
    Expired = 3,
}

pub fn handler(
    ctx: Context<VoidSpeculativeCommitment>,
    args: VoidSpeculativeCommitmentArgs,
) -> Result<()> {
    let clock = Clock::get()?;
    let commitment = &mut ctx.accounts.commitment;
    let bond = &mut ctx.accounts.bond;
    let bond_lock = &mut ctx.accounts.bond_lock;
    let config = &ctx.accounts.protocol_config;
    
    // 1. Validate void reason based on ancestor state
    let is_valid_void = match args.reason {
        VoidReason::Expired => commitment.is_expired(&clock),
        VoidReason::ParentVoided | VoidReason::ParentCancelled | VoidReason::ParentDisputed => {
            // Validate ancestor state
            validate_ancestor_failure(&ctx.accounts.failed_ancestor, &commitment)?
        }
    };
    
    require!(is_valid_void, CoordinationError::InvalidVoidReason);
    
    // 2. Calculate slash amount
    let locked_amount = bond_lock.amount;
    let slash_amount = locked_amount
        .checked_mul(config.speculation_slash_percentage as u64)
        .ok_or(CoordinationError::ArithmeticOverflow)?
        .checked_div(100)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    
    let return_amount = locked_amount
        .checked_sub(slash_amount)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    
    // 3. Update commitment status
    commitment.status = CommitmentStatus::Voided;
    commitment.voided_at = clock.unix_timestamp;
    
    // 4. Release bond lock (partial - after slash)
    bond_lock.is_active = false;
    bond_lock.released_at = clock.unix_timestamp;
    
    // 5. Update bond balances with slash
    bond.locked_balance = bond.locked_balance
        .checked_sub(locked_amount)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    bond.available_balance = bond.available_balance
        .checked_add(return_amount)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    bond.total_slashed = bond.total_slashed
        .checked_add(slash_amount)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    bond.slash_count = bond.slash_count
        .checked_add(1)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    bond.last_slash_at = clock.unix_timestamp;
    bond.slash_cooldown_until = clock.unix_timestamp
        .checked_add(config.slash_cooldown_duration)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    bond.active_locks = bond.active_locks
        .checked_sub(1)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    bond.last_activity = clock.unix_timestamp;
    
    if bond.locked_balance == 0 && bond.status == BondStatus::Locked {
        bond.status = BondStatus::Active;
    }
    
    // 6. Distribute slashed funds
    let treasury_share = slash_amount
        .checked_mul(config.slash_treasury_share as u64)
        .ok_or(CoordinationError::ArithmeticOverflow)?
        .checked_div(100)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    
    // Transfer treasury share (remaining can go to affected downstream in separate ix)
    if treasury_share > 0 {
        **ctx.accounts.bond.to_account_info().try_borrow_mut_lamports()? -= treasury_share;
        **ctx.accounts.treasury.try_borrow_mut_lamports()? += treasury_share;
    }
    
    // 7. Emit event
    emit!(SpeculativeCommitmentVoided {
        commitment: ctx.accounts.commitment.key(),
        task: commitment.task,
        worker: commitment.worker,
        reason: args.reason as u8,
        slashed_amount: slash_amount,
        returned_amount: return_amount,
        treasury_share,
        voided_at: clock.unix_timestamp,
    });
    
    Ok(())
}

#[derive(Accounts)]
pub struct DepositSpeculationBond<'info> {
    /// The bond to deposit into (creates if doesn't exist)
    #[account(
        init_if_needed,
        payer = depositor,
        space = SpeculationBond::SIZE,
        seeds = [b"spec_bond", agent.key().as_ref()],
        bump
    )]
    pub bond: Account<'info, SpeculationBond>,

    /// The agent this bond belongs to
    #[account(
        seeds = [b"agent", agent.agent_id.as_ref()],
        bump = agent.bump,
        has_one = authority @ CoordinationError::UnauthorizedAgent,
    )]
    pub agent: Account<'info, AgentRegistration>,

    /// Agent's authority
    pub authority: Signer<'info>,

    /// Depositor (payer)
    #[account(mut)]
    pub depositor: Signer<'info>,

    pub system_program: Program<'info, System>,
}

#[derive(AnchorSerialize, AnchorDeserialize)]
pub struct DepositSpeculationBondArgs {
    /// Amount to deposit in lamports
    pub amount: u64,
}

pub fn handler(
    ctx: Context<DepositSpeculationBond>,
    args: DepositSpeculationBondArgs,
) -> Result<()> {
    let clock = Clock::get()?;
    let bond = &mut ctx.accounts.bond;
    
    // 1. Validate deposit amount
    require!(
        args.amount >= SpeculationBond::MIN_DEPOSIT,
        CoordinationError::DepositTooSmall
    );
    
    let new_total = bond.total_deposited
        .checked_add(args.amount)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    
    require!(
        new_total <= SpeculationBond::MAX_DEPOSIT,
        CoordinationError::DepositExceedsMax
    );
    
    // 2. Initialize if new bond
    if bond.created_at == 0 {
        bond.agent = ctx.accounts.agent.key();
        bond.authority = ctx.accounts.authority.key();
        bond.created_at = clock.unix_timestamp;
        bond.status = BondStatus::Active;
        bond.max_locks = SpeculationBond::DEFAULT_MAX_LOCKS;
        bond.bump = ctx.bumps.bond;
    }
    
    // 3. Transfer funds
    system_program::transfer(
        CpiContext::new(
            ctx.accounts.system_program.to_account_info(),
            system_program::Transfer {
                from: ctx.accounts.depositor.to_account_info(),
                to: ctx.accounts.bond.to_account_info(),
            },
        ),
        args.amount,
    )?;
    
    // 4. Update balances
    bond.total_deposited = new_total;
    bond.available_balance = bond.available_balance
        .checked_add(args.amount)
        .ok_or(CoordinationError::ArithmeticOverflow)?;
    bond.last_activity = clock.unix_timestamp;
    
    // 5. Emit event
    emit!(SpeculationBondDeposited {
        bond: ctx.accounts.bond.key(),
        agent: bond.agent,
        depositor: ctx.accounts.depositor.key(),
        amount: args.amount,
        new_total: bond.total_deposited,
        new_available: bond.available_balance,
        timestamp: clock.unix_timestamp,
    });
    
    Ok(())
}

#[derive(Accounts)]
pub struct WithdrawSpeculationBond<'info> {
    /// The bond to withdraw from
    #[account(
        mut,
        seeds = [b"spec_bond", agent.key().as_ref()],
        bump = bond.bump,
        constraint = bond.agent == agent.key() @ CoordinationError::InvalidBond,
        constraint = bond.status != BondStatus::Slashed @ CoordinationError::BondSlashed,
    )]
    pub bond: Account<'info, SpeculationBond>,

    /// The agent this bond belongs to
    #[account(
        seeds = [b"agent", agent.agent_id.as_ref()],
        bump = agent.bump,
        has_one = authority @ CoordinationError::UnauthorizedAgent,
    )]
    pub agent: Account<'info, AgentRegistration>,

    /// Agent's authority
    pub authority: Signer<'info>,

    /// Recipient of withdrawn funds
    /// CHECK: Can be any account
    #[account(mut)]
    pub recipient: UncheckedAccount<'info>,

    pub system_program: Program<'info, System>,
}