Struct Challenge 

pub struct Challenge {

    pub id: String,
    pub origin_ms: i64,
    pub question: String,
    pub situations: Vec<String>,
    pub consequence: String,
    pub area: String,
    pub engineers: Vec<String>,
    pub joined: BTreeMap<String, i64>,
    pub supersedes: Vec<String>,
    pub source: String,
    pub scope: Vec<String>,
    pub overrides: String,
    pub facets: Vec<String>,
    pub repo: String,
    pub reach: String,
    pub episodes: Vec<String>,
    pub version: u32,
    pub correction: String,
    pub off_system: bool,
    pub weight: f64,
    pub dormant: bool,
    pub consolidated: bool,
    pub explore: f64,
    pub belief: (f64, f64),
    pub trust: f64,
    pub activation: f64,
}

Fields

id: String

origin_ms: i64

Epoch ms of the correction this challenge was learned from.

question: String

situations: Vec<String>

World-model form of the lesson (see predict.rs); empty for question-only lessons.

consequence: String

area: String

Kind of concern (trust.rs AREAS); “other” for lessons learned before areas existed.

engineers: Vec<String>

Engineers whose corrections the lesson was learned from (git user.email).

joined: BTreeMap<String, i64>

When each later engineer joined the lesson (learn.rs Lesson::joined).

supersedes: Vec<String>

Lessons this one replaces or contradicts (set by borg learn or a queen answer).

source: String

“queen” for a queen answer (queen.rs lesson), empty otherwise.

scope: Vec<String>

Names the lesson is limited to (learn.rs Lesson::scope); empty: unscoped.

overrides: String

The outside rule this lesson replaces (learn.rs Lesson::overrides), shown with the question.

facets: Vec<String>

Alternative phrasings for search (learn.rs Lesson::facets): each is its own BM25 document of this lesson (rank), never shown.

repo: String

The repo the lesson was learned in (for an import: where the knowledge was written down).

reach: String

Who should hear it (reach.rs): empty for the team, repo, or personal (a withdrawn tombstone).

episodes: Vec<String>

The episodes the lesson was learned from (learn.rs Lesson::episodes), first first.

version: u32

The stored line’s version (learn.rs Lesson::version; a merge writes the next): which wording a check showed (pools.rs ver). 0 for a line without one (a ratified constraint).

correction: String

The engineer’s correction of the first of episodes this machine holds (with_corrections): shown with an A2 line (whole.rs line). Empty when none resolves (a synced peer’s lesson: its episodes stay on the peer) or none was read.

off_system: bool

Scoped to systems none of which is the work’s known system (systems.rs gate): scores 0.

weight: f64

Memory weight (memory.rs: activation × usefulness belief), multiplies the BM25 score; 1 for a new lesson without outcomes.

dormant: bool

Dormant (memory.rs): recalled only on a strong match (rank).

consolidated: bool

Consolidated (memory.rs): may be delivered early without a scope (early).

explore: f64

This session’s Thompson draw of the lesson’s usefulness relative to its mean (memory.rs): orders the lessons that cleared the bar when there are more than the slots (budget, early); 1 without a session.

belief: (f64, f64)

The usefulness belief behind explore (memory.rs Memory::alpha, beta): Beta(α, β), (1, 1) without outcomes. For the propensity of a slot (propensity).

trust: f64

Mean trust of the lesson’s authors in its area (trust.rs), 0.5 without evidence.

activation: f64

Its activation (memory.rs Memory::activation, the A behind weight), 0 for a new lesson: logged beside the pool’s scores (pools.rs act), never ranked by alone.

Implementations

impl Challenge

pub fn standing(&self) -> bool

A standing lesson: a constraint an engineer ratified (veto.rs ratify). Consolidated, never dormant, its weight and trust fixed (no outcome or author moves them), and delivered early whenever its scope is in play, whatever the match, on every harness that takes prompt context (standing_pool, hook.rs early).

Trait Implementations

impl Clone for Challenge

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Challenge

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

Formats the value using the given formatter.

impl Default for Challenge

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Challenge

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.