🌱 BarnOS Development Roadmap

pub enum MissionState {
    Created,
    Queued,
    Running,
    Paused,
    Blocked,
    Evaluating,
    Completed,
    Failed,
    Cancelled,
}

// Enforced transitions:
//   Created  → Queued  → Running → Evaluating → Completed
//                          Running → Paused  | Blocked | Failed
//                          Failed  → Queued  (retry)
//                          Cancelled → Queued (re-queue)

impl MissionState {
    pub fn is_terminal(&self) -> bool {
        matches!(self, Self::Completed | Self::Failed | Self::Cancelled)
    }

    pub fn can_transition_to(&self, target: &MissionState) -> bool {
        matches!(
            (self, target),
            (Self::Created,    Self::Queued)
          | (Self::Queued,     Self::Running)
          | (Self::Running,    Self::Paused)
          | (Self::Running,    Self::Blocked)
          | (Self::Running,    Self::Evaluating)
          | (Self::Running,    Self::Failed)
          | (Self::Evaluating, Self::Completed)
          | (Self::Evaluating, Self::Failed)
          | (Self::Failed,     Self::Queued)      // retry
          | (Self::Cancelled,  Self::Queued)      // re-queue
        )
    }
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
pub enum AuthorityLevel {
    Observer    = 0,   // Read-only access
    Contributor = 1,   // Can submit work
    Operator    = 2,   // Can execute missions
    Architect   = 3,   // Can modify structure
    Admin       = 4,   // Full control
}

pub enum TrustDecision {
    Allowed,
    Denied(String),
    RequiresApproval {
        reason:             String,
        authority_required: AuthorityLevel,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Capability {
    ReadKb,
    ReadCosmos          { containers:    Vec<String> },
    WriteKb             { partitions:    Vec<String> },
    PostSlack           { channels:      Vec<String> },
    GenerateDocuments,
    ExecuteTool         { tools:         Vec<String> },
    CreateMission,
    ManageMission       { mission_ids:   Vec<String> },
    WriteRepo           { repos:         Vec<String> },
    CreatePullRequest   { repos:         Vec<String> },
    ModifyConfig        { scopes:        Vec<String> },
    ManageAgents,
    ApproveActions      { max_authority: u8 },
}

/// Mission — matches TS KernelMission interface exactly.
/// Cosmos container: kernel-missions (partition key: /id)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Mission {
    pub id:                 String,                      // "msn-{uuid12}"
    pub name:               String,
    pub description:        String,
    pub state:              MissionState,
    pub agent_id:           String,
    pub owner_id:           String,
    pub project_id:         Option<String>,
    pub spec:               MissionSpec,                  // objective, tools, timeout, strategy
    pub steps:              Vec<MissionStep>,             // each step can override agent_id
    pub outcome:            Option<MissionOutcome>,
    pub tool_call_log:      Vec<ToolCallRecord>,
    pub current_step_index: usize,
    pub priority:           MissionPriority,             // Low | Normal | High | Critical
    pub retry_policy:       RetryPolicy,
    pub started_at:         Option<DateTime<Utc>>,
    pub completed_at:       Option<DateTime<Utc>>,
    pub created_at:         DateTime<Utc>,
    pub updated_at:         DateTime<Utc>,
}

pub enum MissionStrategy {
    Sequential,    // Steps run one after another
    Parallel,      // All steps run concurrently
    FanOutMerge,   // Fan out to swarm, merge results
}

pub struct MissionSpec {
    pub objective:         String,
    pub tools:             Vec<String>,
    pub timeout_secs:      u64,              // default: 600
    pub max_retries:       u32,              // default: 1
    pub strategy:          MissionStrategy,  // default: Sequential
    pub knowledge_capture: bool,             // auto-extract to KB on completion
    pub kb_partition:      Option<String>,   // target KB partition
}

//! barn-kernel/src/main.rs
//!
//! Barn Platform Kernel — mission-driven agent runtime.
//! Runs as a sidecar in workspace pods or standalone daemon.

mod config;
mod engine;
mod mcp;        // JSON-RPC 2.0 server      — DONE
mod metrics;    // Health + Prometheus       — DONE
mod mission;   // Controller + scheduler    — DONE
mod store;     // CosmosStore backend       — DONE
mod trace;     // OpenTelemetry tracing     — DONE

// Future phases (K3-K6) — empty modules for now
mod swarm;     // Stage 3: Cross-domain agent coordination
mod events;    // Stage 2: Event bus, drift detection signals
mod trust;     // Stage 1: K1-K6 alignment (partially implemented)

use config::KernelConfig;
use mission::MissionController;
use store::CosmosStore;
use trust::{ApprovalManager, AuditLogger};
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let config = KernelConfig::from_env();

    // Initialize trust components
    let approval_manager = Arc::new(ApprovalManager::new(config.approval_ttl_secs));
    let audit_logger     = Arc::new(AuditLogger::new(config.audit_buffer_size, config.clone()));

    // Initialize persistence + mission controller
    let cosmos_store: Arc<dyn barn_core::traits::store::KernelStore> =
        Arc::new(CosmosStore::new(config.clone()));
    let mission_ctrl = Arc::new(MissionController::new(cosmos_store));

    // Hydrate missions from Cosmos (warm cache)
    mission_ctrl.hydrate().await?;

    // Start MCP server, health server, mission scheduler...
    info!("Barn Kernel ready");
    tokio::signal::ctrl_c().await?;
}