Struct Goal 

pub struct Goal {
    pub goal_id: GoalId,
    pub level: GoalLevel,
    pub description: String,
    pub priority: u32,
    pub constraints: Vec<GoalConstraint>,
    pub dependencies: Vec<GoalId>,
    pub knowledge_context: GoalKnowledgeContext,
    pub assigned_roles: Vec<String>,
    pub assigned_agents: Vec<AgentPid>,
    pub status: GoalStatus,
    pub metadata: GoalMetadata,
}

Goal representation with knowledge graph context

Fields

goal_id: GoalId

Unique goal identifier

level: GoalLevel

Goal hierarchy level

description: String

Human-readable goal description

priority: u32

Goal priority (higher number = higher priority)

constraints: Vec<GoalConstraint>

Goal constraints and requirements

dependencies: Vec<GoalId>

Dependencies on other goals

knowledge_context: GoalKnowledgeContext

Knowledge graph concepts related to this goal

assigned_roles: Vec<String>

Agent roles that can work on this goal

assigned_agents: Vec<AgentPid>

Agents currently assigned to this goal

status: GoalStatus

Current goal status

metadata: GoalMetadata

Goal metadata and tracking

Implementations

impl Goal

pub fn new( goal_id: GoalId, level: GoalLevel, description: String, priority: u32, ) -> Self

Create a new goal

pub fn add_constraint( &mut self, constraint: GoalConstraint, ) -> GoalAlignmentResult<()>

Add a constraint to the goal

pub fn add_dependency( &mut self, dependency_goal_id: GoalId, ) -> GoalAlignmentResult<()>

Add a dependency to the goal

pub fn assign_agent(&mut self, agent_id: AgentPid) -> GoalAlignmentResult<()>

Assign an agent to the goal

pub fn unassign_agent(&mut self, agent_id: &AgentPid) -> GoalAlignmentResult<()>

Remove an agent from the goal

pub fn update_status(&mut self, status: GoalStatus) -> GoalAlignmentResult<()>

Update goal status

pub fn update_progress(&mut self, progress: f64) -> GoalAlignmentResult<()>

Update goal progress

pub fn can_start(&self, completed_goals: &HashSet<GoalId>) -> bool

Check if goal can be started (all dependencies met)

pub fn is_blocked(&self) -> bool

Check if goal is blocked

pub fn is_active(&self) -> bool

Check if goal is active

pub fn is_completed(&self) -> bool

Check if goal is completed

pub fn has_failed(&self) -> bool

Check if goal has failed

pub fn get_duration(&self) -> Option<Duration>

Get goal duration if completed

pub fn calculate_success_score(&self) -> f64

Calculate overall success score based on criteria

pub fn validate(&self) -> GoalAlignmentResult<()>

Validate the goal

Trait Implementations

impl Clone for Goal

fn clone(&self) -> Goal

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Goal

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Goal

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Goal

fn eq(&self, other: &Goal) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Goal

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Goal