ARM Agents

// Temporal workflow — checkpoint on every state transition
#[workflow]
async fn agent_task(ctx: WorkflowCtx, task: A2ATask) -> Result<TaskResult> {
    let plan = ctx.activity(plan_action, &task).await?;     // checkpoint 1
    let approved = ctx.activity(bft_consensus, &plan).await?; // checkpoint 2
    
    if !approved.quorum_met {
        ctx.activity(escalate_hitl, &plan).await?;           // checkpoint 3
        return Ok(TaskResult::InputRequired);
    }
    
    let result = ctx.activity(execute_sandboxed, &plan).await?; // checkpoint 4
    ctx.activity(log_truth_ledger, &result).await?;             // checkpoint 5
    Ok(TaskResult::Done(result))
}

// BFT consensus for high-stakes plan approval
async fn bft_consensus(plan: &AgentPlan) -> ConsensusResult {
    let models = [Model::Primary, Model::Secondary, Model::Auditor];
    let votes: Vec<Vote> = join_all(
        models.iter().map(|m| evaluate_plan(m, plan))
    ).await;
    
    let approvals = votes.iter().filter(|v| v.approved).count();
    ConsensusResult {
        quorum_met: approvals >= 2,  // 2-of-3 agreement
        votes,
        confidence: votes.iter().map(|v| v.confidence).sum::<f64>() / 3.0,
    }
}

// Dead-Man's Switch — kills runaway agents
struct DeadManSwitch {
    max_steps: u32,
    max_tokens: u64,
    max_wall_time: Duration,
    repetition_window: u32,
}

impl DeadManSwitch {
    fn check(&self, ctx: &AgentContext) -> SwitchResult {
        if ctx.steps > self.max_steps { return SwitchResult::Kill("Step limit") }
        if ctx.tokens_burned > self.max_tokens { return SwitchResult::Kill("Token limit") }
        if ctx.elapsed() > self.max_wall_time { return SwitchResult::Kill("Timeout") }
        if ctx.action_entropy() < 0.1 { return SwitchResult::Kill("Loop detected") }
        SwitchResult::Continue
    }
}

// Wasm sandbox configuration per tool
{
  "tool": "web_search",
  "sandbox": {
    "memory_limit_mb": 64,
    "cpu_time_limit_ms": 5000,
    "permissions": {
      "network": ["GET https://*.googleapis.com/*"],
      "filesystem": "none",
      "env_vars": "none"
    },
    "syscalls": ["clock_gettime", "random_get"],
    "output_schema": { "type": "array", "items": "SearchResult" }
  }
}

// Circuit breaker state machine
enum CircuitState { Closed, Open(Instant), HalfOpen }

impl CircuitBreaker {
    async fn call<F, T>(&mut self, f: F) -> Result<T>
    where F: Future<Output = Result<T>> {
        match self.state {
            CircuitState::Open(until) if Instant::now() < until => {
                Err(Error::CircuitOpen)
            }
            CircuitState::Open(_) => {
                self.state = CircuitState::HalfOpen;
                self.try_call(f).await
            }
            _ => self.try_call(f).await,
        }
    }
}

// Graceful degradation with confidence thresholds
async fn execute_with_fallback(task: &Task) -> Result<Output> {
    let ai_result = ai_engine.reason(task).await;
    
    match ai_result.confidence {
        c if c > 0.85 => Ok(ai_result.output),
        c if c > 0.60 => {
            log_truth_ledger("low_confidence", &ai_result);
            escalate_hitl(task, &ai_result).await
        }
        _ => {
            log_truth_ledger("fallback_triggered", &ai_result);
            deterministic_fallback(task).await  // Safe, tested path
        }
    }
}