Struct GovernancePipeline 

pub struct GovernancePipeline {
    pub config: PipelineConfig,
    /* private fields */
}

The complete governance pipeline (Figure 26).

Fields

config: PipelineConfig

Implementations

impl GovernancePipeline

pub fn new(config: PipelineConfig) -> GovernancePipeline

Examples found in repository

examples/comparison_opa.rs (line 58)

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()
    );
}

examples/agent_gate.rs (line 27)

fn main() {
    println!("=== URGE Agent Governance Gate Demo ===\n");

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

    let actions = &[
        AgentAction {
            agent_id: "billing-agent",
            action: "submit_claim",
            is_authorized: true,
            audit_running: true,
            governance_expr: "must authorized and always audit_running",
        },
        AgentAction {
            agent_id: "rx-agent",
            action: "prescribe_medication",
            is_authorized: false, // Not authorized — should be denied.
            audit_running: true,
            governance_expr: "must authorized and must verified_order",
        },
        AgentAction {
            agent_id: "intake-agent",
            action: "access_phi",
            is_authorized: true,
            audit_running: false, // Audit not running — HIPAA violation.
            governance_expr: "must authorized and always audit_running",
        },
        AgentAction {
            agent_id: "scheduler-agent",
            action: "book_appointment",
            is_authorized: true,
            audit_running: true,
            governance_expr: "must authorized",
        },
    ];

    println!("{:<20} {:<25} {:<12}", "Agent", "Action", "Decision");
    println!("{}", "-".repeat(60));

    for action in actions {
        let slots: &[(&'static str, ContextValue)] = &[
            ("authorized", ContextValue::Bool(action.is_authorized)),
            ("audit_running", ContextValue::Bool(action.audit_running)),
            ("verified_order", ContextValue::Bool(false)), // Default: not verified.
        ];

        let ctx = EvalContext {
            slots,
            logical_time: 0,
            depth_limit: 16,
        };

        let verdict = pipeline.evaluate_str(action.governance_expr, &ctx);

        println!(
            "{:<20} {:<25} {}",
            action.agent_id,
            action.action,
            if verdict.valid {
                "PERMITTED ✓"
            } else {
                "DENIED    ✗"
            },
        );

        if !verdict.valid {
            println!(
                "  Confidence: {:.0}% | Conflicts: {} | Paradigms: {}",
                verdict.confidence.as_f32() * 100.0,
                verdict.cross_validation.conflicts_detected,
                verdict.paradigms_evaluated.iter().count(),
            );
            println!("  Formal: {}", verdict.formal_notation);
            println!("  Trace ({} steps):", verdict.trace.len());
            for entry in verdict.trace.entries.iter().take(3) {
                println!("    [{:?}] {:?}", entry.stage, entry.description);
            }
        }
    }

    println!("\n=== Agent governance summary ===");
    println!("  Every agent action is gated by formal logic, not behavioral alignment.");
    println!("  The governance layer is: deterministic, auditable, sub-millisecond.");
    println!("  No LLM inference involved in permit/deny decisions.");
    println!("  This is the URGE architecture operating as designed.");
}

pub fn default_healthcare() -> GovernancePipeline

pub fn default_embedded() -> GovernancePipeline

pub fn evaluate_str(&self, expression: &str, ctx: &EvalContext<'_>) -> Verdict

Evaluate a governance expression given as a string.

Full pipeline: tokenize → detect → parse → route → evaluate → validate → synthesize.

This is the primary API for string-based governance expressions.

Examples found in repository

examples/comparison_opa.rs (line 29)

fn evaluate(pipeline: &GovernancePipeline, authorized: bool, review_completed: bool) {
    let slots = &[
        ("authorized", ContextValue::Bool(authorized)),
        ("review_completed", ContextValue::Bool(review_completed)),
    ];
    let ctx = EvalContext {
        slots,
        logical_time: 0,
        depth_limit: 16,
    };
    let v = pipeline.evaluate_str(POLICY, &ctx);

    println!(
        "input: authorized={authorized}, review_completed={review_completed}\n\
         → verdict:    {}\n\
         → formal:     {}\n\
         → confidence: {:.0}%\n\
         → consistent: {} (conflicts: {}{})",
        if v.valid { "PERMIT" } else { "DENY" },
        v.formal_notation,
        v.confidence.as_f32() * 100.0,
        v.cross_validation.consistent,
        v.cross_validation.conflicts_detected,
        v.cross_validation
            .conflict_detail
            .map(|d| format!(" — {d}"))
            .unwrap_or_default(),
    );
    println!("→ trace ({} entries), last stages:", v.trace.len());
    for e in v.trace.entries.iter().rev().take(4).rev() {
        println!("    [{:?}] {}", e.stage, e.description);
    }
    println!();
}

examples/agent_gate.rs (line 76)

fn main() {
    println!("=== URGE Agent Governance Gate Demo ===\n");

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

    let actions = &[
        AgentAction {
            agent_id: "billing-agent",
            action: "submit_claim",
            is_authorized: true,
            audit_running: true,
            governance_expr: "must authorized and always audit_running",
        },
        AgentAction {
            agent_id: "rx-agent",
            action: "prescribe_medication",
            is_authorized: false, // Not authorized — should be denied.
            audit_running: true,
            governance_expr: "must authorized and must verified_order",
        },
        AgentAction {
            agent_id: "intake-agent",
            action: "access_phi",
            is_authorized: true,
            audit_running: false, // Audit not running — HIPAA violation.
            governance_expr: "must authorized and always audit_running",
        },
        AgentAction {
            agent_id: "scheduler-agent",
            action: "book_appointment",
            is_authorized: true,
            audit_running: true,
            governance_expr: "must authorized",
        },
    ];

    println!("{:<20} {:<25} {:<12}", "Agent", "Action", "Decision");
    println!("{}", "-".repeat(60));

    for action in actions {
        let slots: &[(&'static str, ContextValue)] = &[
            ("authorized", ContextValue::Bool(action.is_authorized)),
            ("audit_running", ContextValue::Bool(action.audit_running)),
            ("verified_order", ContextValue::Bool(false)), // Default: not verified.
        ];

        let ctx = EvalContext {
            slots,
            logical_time: 0,
            depth_limit: 16,
        };

        let verdict = pipeline.evaluate_str(action.governance_expr, &ctx);

        println!(
            "{:<20} {:<25} {}",
            action.agent_id,
            action.action,
            if verdict.valid {
                "PERMITTED ✓"
            } else {
                "DENIED    ✗"
            },
        );

        if !verdict.valid {
            println!(
                "  Confidence: {:.0}% | Conflicts: {} | Paradigms: {}",
                verdict.confidence.as_f32() * 100.0,
                verdict.cross_validation.conflicts_detected,
                verdict.paradigms_evaluated.iter().count(),
            );
            println!("  Formal: {}", verdict.formal_notation);
            println!("  Trace ({} steps):", verdict.trace.len());
            for entry in verdict.trace.entries.iter().take(3) {
                println!("    [{:?}] {:?}", entry.stage, entry.description);
            }
        }
    }

    println!("\n=== Agent governance summary ===");
    println!("  Every agent action is gated by formal logic, not behavioral alignment.");
    println!("  The governance layer is: deterministic, auditable, sub-millisecond.");
    println!("  No LLM inference involved in permit/deny decisions.");
    println!("  This is the URGE architecture operating as designed.");
}

pub fn evaluate_ast( &self, ast: &Box<Expr>, active_paradigms: ParadigmSet, ctx: &EvalContext<'_>, trace: LogicTrace, ) -> Verdict

Evaluate a pre-built AST directly.

Use this when you construct governance expressions programmatically (e.g., from a rule database) to skip tokenization and parsing overhead.