Struct DelegationState 

pub struct DelegationState {
    pub beliefs: BTreeMap<String, BetaPosterior>,
    pub config: DelegationConfig,
}

Per-session CADMAS-CTX sidecar.

Fields

beliefs: BTreeMap<String, BetaPosterior>

Posteriors keyed by (agent_id, skill, bucket).

config: DelegationConfig

Runtime configuration.

Implementations

impl DelegationState

pub fn with_config(config: DelegationConfig) -> Self

Create a fresh state seeded with the supplied config.

pub fn enabled(&self) -> bool

Whether CADMAS-CTX routing is enabled for this session.

CODETETHER_DELEGATION_ENABLED overrides the persisted config when present so operators can toggle the feature process-wide.

pub fn key(agent: &str, skill: &str, bucket: Bucket) -> String

Serialise a (agent, skill, bucket) triple into the flat string key used by the sidecar.

The encoding is "{agent}|{skill}|{difficulty}|{dependency}|{tool_use}" where each bucket field is the canonical snake_case string from Difficulty::as_str, Dependency::as_str, and ToolUse::as_str — matching the serde representation. Persisted keys therefore stay stable across enum reorderings / variant renames, because the as_str methods are explicitly documented as never-renamed.

pub fn ensure( &mut self, agent: &str, skill: &str, bucket: Bucket, c_self: f64, ) -> &mut BetaPosterior

Look up or create the posterior for (agent, skill, bucket) using c_self as the weak-prior seed.

pub fn score(&self, agent: &str, skill: &str, bucket: Bucket) -> Option<f64>

Current LCB score for (agent, skill, bucket); None when the triple has never been seeded or updated.

pub fn update( &mut self, agent: &str, skill: &str, bucket: Bucket, outcome: bool, )

Apply an observed outcome for (agent, skill, bucket). Creates the posterior with a neutral c_self = 0.5 seed when absent.

pub fn delegate_to<'a>( &self, local: &'a str, peers: &'a [&'a str], skill: &str, bucket: Bucket, ) -> Option<&'a str>

Pick a peer to delegate to over local, or return None to self-execute. Applies the margin rule score(peer) > score(local) + δ.

pub fn rank_candidates<'a>( &self, candidates: &'a [&'a str], skill: &str, bucket: Bucket, ) -> Option<&'a str>

Rank candidates by their LCB score for (skill, bucket) and return the best one, or None when the input is empty.

Unlike Self::delegate_to this does not honour a margin δ — it’s the right primitive for orchestration sites that pick “which executor runs this subtask” (src/swarm/orchestrator.rs step 28), “which persona handles this handoff” (src/ralph/ralph_loop.rs step 29), and “which autochat persona goes next” (src/tui/app/autochat/ step 31) — there is no “local” agent competing for the slot, so the margin rule doesn’t apply.

Candidates with no posterior yet score 0.0 (conservative) and are only picked when every other candidate also has no data — i.e. the cold-start tie-break preserves the caller’s input order.

Examples

use codetether_agent::session::delegation::{DelegationConfig, DelegationState};
use codetether_agent::session::delegation_skills::SWARM_DISPATCH;
use codetether_agent::session::relevance::{Bucket, Dependency, Difficulty, ToolUse};

let b = Bucket {
    difficulty: Difficulty::Easy,
    dependency: Dependency::Isolated,
    tool_use: ToolUse::No,
};
let mut state = DelegationState::with_config(DelegationConfig::default());
// Cold start: no data → first candidate wins by input-order tie-break.
let pick = state.rank_candidates(&["shell_executor", "planner"], SWARM_DISPATCH, b);
assert_eq!(pick, Some("shell_executor"));

pub fn shrink_cold_start( &mut self, agent: &str, skill: &str, bucket: Bucket, neighbors: &[Bucket], m_z: f64, )

Pull at most m_z pseudo-counts from neighbors into the posterior for (agent, skill, bucket) when that posterior has no real observations yet.

Empirical-Bayes cold-start per CADMAS-CTX Section 3.6. Bounded by m_z ≤ 2 so neighbour mass cannot drown real evidence.

Trait Implementations

impl Clone for DelegationState

fn clone(&self) -> DelegationState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DelegationState

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

Formats the value using the given formatter.

impl Default for DelegationState

fn default() -> DelegationState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DelegationState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DelegationState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.