Enum GovernedAction 

pub enum GovernedAction {
    Store,
    Delete,
    Promote,
    Reflect,
}

Actions that governance gates. Used as the action_type column value in pending_actions and as the discriminator for enforcement calls.

Disambiguation (issue #970)

GovernedAction is the approval-queue discriminator — pending_actions.action_type and enforce_governance consult it to decide which substrate action is being approved. It is related-but-distinct from crate::governance::Op, which is the K9 permission-rule op discriminator:

• GovernedAction wire strings: "store", "delete", "promote", "reflect" (4 variants — the substrate actions that can be queued for approval).
• Op wire strings: "memory_store", "memory_link", "memory_delete", "memory_archive", "memory_consolidate", "memory_replay" (6 variants — every K9-gated tool, including ones that can never be queued for approval like memory_replay).

They look like the same vocabulary; they aren’t. Consolidating would require breaking one of the two on-wire string sets. See docs/internal/enum-proliferation-audit-970.md for the full audit.

Variants

Store

Delete

Promote

Reflect

v0.7.0 L1-8: memory_reflect approval gate. Queued when GovernancePolicy::require_approval_above_depth is set and the proposed reflection depth exceeds the threshold.

Implementations

impl GovernedAction

pub fn as_str(self) -> &'static str

Trait Implementations

impl Clone for GovernedAction

fn clone(&self) -> GovernedAction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for GovernedAction

impl Debug for GovernedAction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GovernedAction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for GovernedAction

impl PartialEq for GovernedAction

fn eq(&self, other: &GovernedAction) -> 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 GovernedAction

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 GovernedAction