Struct Obligation 

pub struct Obligation {
    pub id: ObligationId,
    pub obligation_type: ObligationType,
    pub agent: String<32>,
    pub action: String<64>,
    pub object: Option<String<64>>,
    pub state: ObligationState,
    pub created_at: u64,
    pub deadline_ns: Option<u64>,
    pub last_updated: u64,
    pub source: Option<String<128>>,
    pub priority: u8,
}

A tracked obligation in the world state.

Fields

id: ObligationId

obligation_type: ObligationType

SDL modality.

agent: String<32>

The agent bearing the obligation.

action: String<64>

The action the obligation concerns.

object: Option<String<64>>

Optional object/patient of the action.

state: ObligationState

Current lifecycle state.

created_at: u64

Logical time when obligation was created (nanoseconds or counter).

deadline_ns: Option<u64>

Deadline for satisfaction. None = no deadline (permanent).

last_updated: u64

Logical time of last state transition.

source: Option<String<128>>

Policy source citation.

priority: u8

Priority (higher = more urgent). Used for escalation ordering.

Implementations

impl Obligation

pub fn new( id: &str, obligation_type: ObligationType, agent: &str, action: &str, deadline_ns: Option<u64>, created_at: u64, ) -> Obligation

Examples found in repository

examples/comparison_opa.rs (lines 73-80)

fn main() {
    println!("=== URGE side of the OPA comparison ===\n");
    println!("policy expression: {POLICY}\n");

    let pipeline = GovernancePipeline::new(PipelineConfig::healthcare());

    // Case 1: everything in order — same PERMIT OPA gives.
    evaluate(&pipeline, true, true);

    // Case 2: review missing. OPA says deny. URGE says deny AND reports the
    // cross-paradigm finding: the temporal constraint is violated while the
    // deontic obligation is active — a contradiction, not just a false.
    evaluate(&pipeline, true, false);

    // Part 2 — what OPA has no vocabulary for at all: the review is an
    // obligation with a deadline, tracked across time.
    println!("=== Obligation lifecycle (no OPA equivalent) ===\n");
    let mut mgr = ObligationManager::new();
    mgr.register(
        Obligation::new(
            "review-P123",
            ObligationType::Obligatory,
            "payment-agent",
            "complete_review",
            Some(1000), // deadline at t=1000
            0,
        ),
        0,
    );
    println!("t=0     obligation registered: complete_review, deadline t=1000");
    println!(
        "        active={} violated={}",
        mgr.active_count(),
        mgr.violated_count()
    );

    let violations = mgr.process(ObligationEvent::TimeTick { now: 2000 });
    println!("t=2000  time tick — deadline exceeded, review never happened");
    for v in &violations {
        println!("        VIOLATION EVENT: {v:?}");
    }
    println!(
        "        active={} violated={}",
        mgr.active_count(),
        mgr.violated_count()
    );
}

pub fn activate(&mut self, now: u64)

Transition to Active.

pub fn satisfy(&mut self, now: u64)

Mark as satisfied (action performed).

pub fn check_deadline(&mut self, now: u64) -> bool

Check deadline and transition to Violated if exceeded. Returns true if a violation was newly detected.

pub fn waive(&mut self, now: u64)

Waive this obligation.

pub fn summary(&self) -> String<128>

Human-readable summary for audit logs.

Trait Implementations

impl Clone for Obligation

fn clone(&self) -> Obligation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Obligation

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

Formats the value using the given formatter.