Struct PolicyEvent 

pub struct PolicyEvent {
    pub step: u32,
    pub kind: String,
    pub act: String,
    pub target: String,
    pub rule: Option<String>,
    pub layer: Option<String>,
    pub decision: Option<String>,
    pub source: Option<String>,
    pub performed: Option<String>,
}

One policy event in the trace: an action refused, or a human decision.

Records the path, command, rule, layer, and decision — never file contents or credentials. (The write payload of a deferred action is held separately in the pending-approval row, because resuming it requires replaying exactly what was approved.)

use io_harness::{PolicyEvent, Store};

// The audit an operator actually asks for: what did the agent try that it was
// not allowed to do, and which rule stopped it?
let events = store.events(run_id)?;
let refused = events.iter().find(|e| e.kind == "refusal").expect("one refusal");
assert_eq!(refused.target, "secrets/id_rsa");
// Attributed to the rule and the layer, so "why was this denied" is answered
// from the store rather than by re-deriving the policy stack by hand.
assert_eq!((refused.rule.as_deref(), refused.layer.as_deref()), (Some("secrets/*"), Some("app")));

// And the case that is easy to miss: an approval that changed the action. The
// agent asked for one command and a human let a different one through.
let approved = events.iter().find(|e| e.kind == "decision").expect("one decision");
assert_eq!(approved.decision.as_deref(), Some("approve"));
assert_eq!(approved.performed.as_deref(), Some("git push --dry-run"));

Fields

step: u32

1-based step the event occurred on.

kind: String

"refusal" or "decision".

act: String

"read", "write", or "exec".

target: String

The path, or the binary name plus argv for an exec.

rule: Option<String>

The glob that decided, when a rule rather than a tier default did.

layer: Option<String>

The layer the deciding rule came from.

decision: Option<String>

"approve", "deny", or "defer" for a decision.

source: Option<String>

Which approver decided, or "remembered" when a remembered rule did.

performed: Option<String>

The action actually performed, when approve-with-changes altered it.

Implementations

impl PolicyEvent

pub fn refusal( step: u32, act: impl Into<String>, target: impl Into<String>, ) -> Self

An action refused by the policy.

pub fn decision( step: u32, act: impl Into<String>, target: impl Into<String>, decision: impl Into<String>, source: impl Into<String>, ) -> Self

A human (or built-in approver) decision on a sensitive action.

pub fn with_rule( self, rule: impl Into<String>, layer: impl Into<String>, ) -> Self

Attribute the event to the rule and layer that produced it.

pub fn with_performed(self, performed: impl Into<String>) -> Self

Record that the action performed differed from the one requested.

Trait Implementations

impl Clone for PolicyEvent

fn clone(&self) -> PolicyEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PolicyEvent

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

Formats the value using the given formatter.

impl Eq for PolicyEvent

impl PartialEq for PolicyEvent

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PolicyEvent