Mandate<V> enum

Defines the Capability Profile and Authorization Scope for a Deputy.

When to use

You rarely need to interact with Mandate directly. Use the DeputyContext factories like DeputyContext.observer, DeputyContext.delegate, etc. Those factories set the mandate dimensions for you.

If you need a custom mandate, you can create one using the DeputyContext constructor directly.

How it works

The mandate defines what a deputy can do (authority), its identity (role), its autonomy (sovereignty), its structural rank (clearance), its temporal validity (lease), and its operational guardrails (constraints).

Non‑obvious

  • Some dimensions are static (immutable) while others are evolvable.
  • The evolvable flag controls whether a dimension can be refined when you call evolve() on a DeputyContext.
  • Static pillars (like role) prevent identity drift.

See also: DeputyContext, Clearance, Isolation, Sovereignty.

Inheritance
Implemented types
Mixed-in types
Available extensions

Values

authority → const Mandate<String>

The specific Functional Permission or operational "Verb" authorized for this Deputy.

Type: String (Comma-separated) Mutability: Fluid Boundary (Evolvable)

When to use

Use this to define what actions the deputy is allowed to perform (e.g., 'READ', 'WRITE', 'DELETE'). It's the primary way to enforce least privilege at the functional level.

How it works

During the mutual authorization handshake, the framework compares the deputy's authority string against the receptor's requirements. If the required verb isn't present, the pulse is neutralised.

Non‑obvious

  • This is an evolvable dimension – a deputy can further restrict its own authority when spawning child deputies.
  • Multiple verbs can be comma-separated (e.g., 'READ, WRITE').

Examples

  • 'PRUNE_EXPIRED_RECORDS' – only allowed to delete stale data.
  • 'MASK_PII_FIELDS' – only allowed to transform data for compliance.
const Mandate<String>(true)
role → const Mandate<String>

The intended Mission Identity or functional designation assigned to the Deputy.

The role provides a semantic classification of the deputy's purpose within the system. Unlike authority, which defines what the deputy can do, the role defines what the deputy is in the context of the current scene.

Type: String Mutability: Static Pillar (Invariant)

When to use

Use this to categorise deputies for auditing, monitoring, or group-based policies. It's the semantic identity of the agent.

How it works

The role is used by TestCell rules and monitoring tools to apply group‑based policies or filter logs. It is scrutinised during the mutual handshake.

Non‑obvious

  • This is a static pillar – once set, it cannot be changed. This prevents "role creep".
  • A role like 'Auditor' signals diagnostic intent, even if the deputy has write authority.

Examples

  • 'Auditor' – diagnostic, even with write permissions.
  • 'PolicyEnforcer' – applies encryption to pulses.
const Mandate<String>(false)
isolation → const Mandate<Isolation>

The Execution Boundary and virtualization level assigned to the Deputy.

Type: Isolation Mutability: Fluid Boundary (Evolvable)

When to use

Use this to control the blast radius of a deputy's actions – e.g., to run a simulation without affecting production state.

How it works

The isolation level determines where the deputy's pulses are executed:

  • shared: direct live execution.
  • scoped: restricted to a domain.
  • restricted: zero‑trust filtering.
  • sandboxed: virtualized, no side‑effects.
  • total: air‑gapped, only ingests.

Non‑obvious

  • This is evolvable – a deputy can tighten isolation for child tasks.
  • sandboxed mutations are not committed to the principal state.

Examples

  • Isolation.sandboxed – safe for speculative logic.
  • Isolation.restricted – live state but strict filtering.
const Mandate<Isolation>(true)
sovereignty → const Mandate<Sovereignty>

The Decision-Making Autonomy and oversight level granted to the Deputy.

Type: Sovereignty Mutability: Fluid Boundary (Evolvable)

When to use

Use this to control whether a deputy can act independently or needs approval – e.g., an emergency agent might be preemptive.

How it works

Sovereignty levels determine if a pulse requires approval before being committed:

  • supervised: all pulses queued for approval.
  • collaborative: mutates non‑critical state freely, blocks on high‑impact.
  • sovereign: fully autonomous.
  • preemptive: can override others for system safety.

Non‑obvious

  • This is evolvable – a deputy can be promoted (e.g., from supervised to sovereign) based on trust.
  • High‑sensitivity operations are blocked if sovereignty is insufficient.

Examples

  • Sovereignty.supervised – suggests changes, waits for principal.
  • Sovereignty.preemptive – overrides for emergency shutdown.
const Mandate<Sovereignty>(true)
clearance → const Mandate<Clearance>

The formal Structural Clearance level defining the deputy's mutation capacity and architectural "Rank."

Type: Clearance Mutability: Fluid Boundary (Evolvable)

When to use

Use this to control the severity of mutations – e.g., prevent structural changes with observational clearance.

How it works

Clearance is a ranked integer. The framework compares the deputy's clearance against the required level for an operation. If it's lower, the pulse is neutralised.

Non‑obvious

  • This is evolvable – a deputy can downgrade clearance for child tasks.
  • observational blocks all state mutations.
  • administrative allows structural refactoring.

Examples

  • Clearance.observational – read‑only.
  • Clearance.standard – mutate values.
  • Clearance.administrative – link/unlink cells.
const Mandate<Clearance>(true)
auditLevel → const Mandate<AuditLevel>

The required Observability Granularity and rigor of the causal trace.

Type: AuditLevel Mutability: Fluid Boundary (Evolvable)

When to use

Use this to control logging verbosity – e.g., full audit for compliance, none for high‑frequency telemetry.

How it works

The audit level determines how much trace data is preserved. Higher levels capture more metadata but cost more performance.

Non‑obvious

  • This is evolvable – a supervisor can increase audit rigour for risky tasks.
  • Some high‑integrity cells reject pulses with low audit levels.

Examples

  • AuditLevel.full – forensics.
  • AuditLevel.none – high‑frequency heartbeats.
const Mandate<AuditLevel>(true)
justification → const Mandate<String>

The semantic Rationale or human-readable "Why" behind the delegation of authority to the Deputy.

Type: String Mutability: Fluid Boundary (Evolvable)

When to use

Use this to document the mission intent – valuable for auditing and Explainable AI (XAI).

How it works

The justification is stored as a string and included in the causal trace. Receptors can use it to verify that the action aligns with the stated mission.

Non‑obvious

  • This is evolvable – a deputy can refine the justification for sub‑tasks.
  • It provides the "why" for forensic analysis.

Examples

  • 'Optimizing database indices due to high latency.'
  • 'Suspected PII leak; masking outbound telemetry.'
const Mandate<String>(true)
constraints → const Mandate<Map<String, dynamic>>

A machine-readable map of Quantifiable Operational Boundaries and resource limits.

Type: Map<String, dynamic> Mutability: Fluid Boundary (Evolvable)

When to use

Use this to set numeric limits like max_hop_count, timeout_ms, or batch_size to prevent runaway processes.

How it works

The framework checks these constraints in real time during the validation phase. If a pulse would exceed a limit, it's neutralised.

Non‑obvious

  • This is evolvable – a deputy can tighten constraints for child tasks.
  • Constraints are enforced at the integrity gate level.

Examples

  • { 'max_hop_count': 5, 'timeout_ms': 500 }
  • { 'max_nodes_modified': 100, 'batch_size': 10 }
const Mandate<Map<String, dynamic>>(true)

Properties

evolvable → bool
Indicates whether this Mandate Dimension is a structural invariant /// or a dynamic operational attribute.
final
hashCode → int
The hash code for this object.
no setterinherited
index → int
A numeric identifier for the enumerated value.
no setterinherited
name → String

Available on Enum, provided by the EnumName extension

The name of the enum value.
no setter
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited

Methods

entry(V value) → GovernanceEntry<Mandate<V>, V>
Creates a strongly-typed GovernanceEntry for this governance dimension.
inherited
isType(Object value) → bool
Validates if the provided value matches the expected type V.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

compose(GovernanceEntry<Governance, dynamic>? resolver(Mandate dimension)) → Iterable<GovernanceEntry<Governance, dynamic>>
Generates a comprehensive Mission Profile by synthesizing a value for every defined dimension in the Mandate ontology.
evolve(GovernanceEntry<Governance, dynamic>? resolver(Mandate dimension)) → Iterable<GovernanceEntry<Governance, dynamic>>
Synthesizes a Specialized Mission Extension by resolving only the fluid dimensions of the Mandate ontology.

Constants

values → const List<Mandate>
A constant List of the values in this enum, in order of their declaration.