Enum MemoryScope 

pub enum MemoryScope {
    Private,
    Team,
    Unit,
    Org,
    Collective,
}

v0.7.0 multi-agent literal-sweep (scanner B, finding F-B2.x) — typed closed-set discriminator for memory.metadata.scope (Task 1.5). Paired with the VALID_SCOPES string allowlist + the validator at crate::validate::validate_scope; the parity test tests/memory_scope_count_invariant.rs asserts both stay in lockstep.

#[serde(rename_all = "snake_case")] keeps the wire shape and the existing metadata.scope JSON column byte-identical to what every v0.6.x / v0.7.x writer already emits ("private", "team", etc.).

Variants

Private

Memory is visible only to its owning agent within its own namespace. The default for unmarked rows (per the query layer).

Team

Memory is visible to every agent whose namespace falls within the same team subtree. Subtree matching honours MAX_NAMESPACE_DEPTH.

Unit

Memory is visible to every agent within the same unit subtree.

Org

Memory is visible to every agent within the same org subtree.

Collective

Memory is visible to every authenticated caller, regardless of namespace.

Implementations

impl MemoryScope

pub const COUNT: usize = 5

Total number of MemoryScope variants. SSOT for the “5 visibility scopes at v0.7.0” narrative across docs. Adding a new variant requires bumping this const, the VALID_SCOPES slice, the Self::as_str / Self::from_str match arms, and the visibility-policy dispatch in src/storage/mod.rs::is_visible.

pub const fn all() -> &'static [Self; 5]

Canonical enumeration in declaration order (private, team, unit, org, collective). Use this anywhere external code would otherwise hand-roll the list — federation handshake, capability advertisement, parity tests.

pub const fn all_strs() -> &'static [&'static str; 5]

String enumeration matching VALID_SCOPES byte-for-byte. Parity-test-asserted against the VALID_SCOPES const.

pub fn from_str(s: &str) -> Option<Self>

Parse the string form stored in metadata.scope.

Returns None for unknown values so callers can decide whether to default to Self::Private (the query-layer convention for unmarked rows) or surface a typed error.

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

Canonical wire string for this variant. Mirrors the serde rename_all + the literals every existing call site already writes to metadata.scope.

Trait Implementations

impl Clone for MemoryScope

fn clone(&self) -> MemoryScope

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for MemoryScope

impl Debug for MemoryScope

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

Formats the value using the given formatter.

impl Default for MemoryScope

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MemoryScope

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for MemoryScope

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

Formats the value using the given formatter.

impl Eq for MemoryScope

impl FromStr for MemoryScope

type Err = String

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for MemoryScope

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for MemoryScope

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

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 MemoryScope