Struct LayeredPermissionsConfig 

pub struct LayeredPermissionsConfig {
    pub mode: PermissionMode,
    pub layers: Vec<PermissionLayer>,
}

Layered permission configuration.

Layers are ordered by priority (highest first). The merging semantics for check_static are:

• deny: any layer denies → denied (union)
• allow: any layer allows → allowed (union)
• interactive: any layer marks as interactive → interactive (union)

The mode field provides session-level behaviour on top of these static rules.

Fields

mode: PermissionMode

Session-wide permission mode.

layers: Vec<PermissionLayer>

Ordered layers (highest priority first).

Implementations

impl LayeredPermissionsConfig

pub fn check_static( &self, tool_name: &str, is_readonly: bool, content: Option<&str>, ) -> Permission

Check whether a tool is allowed or denied, taking the current PermissionMode into account.

Checks are applied in priority order (highest first):

0. Safety check (Goal 196) — if content resolves to a file path under a protected location (.git, .ssh, etc.), deny with DecisionReason::SafetyCheck. This is enforced even under BypassPermissions. Read-only tools are exempt.
1. Plan mode — blocks write tools unless bypass_available (always exempts exit_plan_mode).
2. BypassPermissions — skips all rules, allows everything.
3. DontAsk — denies tools in the interactive list.
4. AcceptEdits — auto-allows write tools.
5. Deny/allow rules — static deny (union) then allow (union).
6. Default — falls through with Unknown (no rule matched). invoke_with_audit treats Unknown as allowed for non-interactive tools and delegates to the registered PermissionHook for interactive tools in non-headless contexts (Goal-212).

content is the call-time content the tool will operate on. For write_file / read_file it should be the file path; for apply_patch it should be the full V4A patch body. Other tools can pass None. See [extract_file_path_from_content].

pub fn is_plan_mode(&self, tool_name: &str) -> bool

Check whether a tool requires plan mode.

Returns true if the session mode is Plan. Returns false if the tool is denied.

pub fn is_interactive(&self, tool_name: &str) -> bool

Check whether a tool requires interactive confirmation.

Returns true if any layer marks the tool as interactive. Returns false if the tool is denied (denied tools never prompt).

pub fn any_interactive(&self, tool_name: &str) -> bool

Returns true if the tool is in the interactive list of any layer.

pub fn all_deny(&self) -> impl Iterator<Item = &str>

Iterate over all deny patterns across all layers.

pub fn all_allow(&self) -> impl Iterator<Item = &str>

Iterate over all allow patterns across all layers.

pub fn all_interactive(&self) -> impl Iterator<Item = &str>

Iterate over all interactive patterns across all layers.

pub fn add_session_rule(&mut self, behavior: RuleBehavior, pattern: String)

Add a permission rule to the session layer at runtime.

The session layer is always the highest-priority layer (index 0). If it doesn’t exist yet, it is created on first use.

Rules added via this method take effect immediately for all subsequent check_static calls, without requiring a restart. They are not persisted to disk — they live only in memory for the current session.

pub fn remove_session_rule(&mut self, behavior: RuleBehavior, pattern: &str)

Remove a permission rule from the session layer.

The pattern is matched against existing rules as a substring. All rules whose string representation contains pattern are removed from the corresponding behaviour list.

pub fn session_rules(&self) -> &PermissionLayer

Return a reference to the session layer.

Panics if the session layer does not exist — call session_layer_mut() first to ensure it is created.

Trait Implementations

impl Clone for LayeredPermissionsConfig

fn clone(&self) -> LayeredPermissionsConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LayeredPermissionsConfig

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

Formats the value using the given formatter.

impl Default for LayeredPermissionsConfig

fn default() -> LayeredPermissionsConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LayeredPermissionsConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<OldPermissionsConfig> for LayeredPermissionsConfig

fn from(old: OldPermissionsConfig) -> Self

Converts to this type from the input type.