Struct KnowledgeCandidate 

pub struct KnowledgeCandidate {

    pub id: String,
    pub uri: String,
    pub path: String,
    pub class: String,
    pub status: String,
    pub epistemics: String,
    pub title: String,
    pub date: String,
    pub derived_from: Vec<String>,
    pub episode: String,
    pub branch: Option<String>,
    pub freshness: Freshness,
    pub age_minutes: Option<i64>,
    pub freshness_reason: String,
    pub age_source: AgeSource,
    pub about: String,
    pub route: String,
}

One candidate record awaiting review: what a reader needs to decide whether to open it.

use majordomus_cli::capability::builtin::knowledge_base::KnowledgeCandidate;
let c: KnowledgeCandidate = serde_json::from_str(r#"{
  "id": "e1-0123456789ab", "uri": "majordomus://knowledge/e1-0123456789ab",
  "path": ".ai/repo/knowledge/candidates/e1-0123456789ab.md", "class": "convention",
  "status": "candidate", "epistemics": "decided", "title": "Tests run in disposable repositories",
  "date": "2026-09-12", "derived_from": ["session:e1"], "episode": "e1",
  "freshness": "unknown", "freshness_reason": "no timestamp", "age_source": "date"
}"#).unwrap();
assert_eq!(c.episode, "e1");
assert_eq!(c.branch, None, "an episode this checkout never saw has no branch, and says so");

Fields

id: String

The record id, which is also its file name.

uri: String

majordomus://knowledge/<id>.

path: String

Repository-relative path.

class: String

fact, convention, constraint, memory or lesson.

status: String

Always candidate here; carried so that a reader sees the same record shape as record.

epistemics: String

observed, inferred or decided.

title: String

The assertion, in one line.

date: String

The day of the evidence, YYYY-MM-DD.

derived_from: Vec<String>

The typed references the record names as its evidence, as declared.

episode: String

The episode the record came from: the session: reference, or empty when it names none.

branch: Option<String>

The branch that episode ran on, joined to the tracked session record or, while that is not yet written, to the ledger’s session.started line. None when this checkout knows nothing about the episode — named rather than hidden, so that a reader can tell “not this branch” from “not known here”. Serialised as null in that case, never omitted.

freshness: Freshness

How long it has waited, judged against session.freshness.

age_minutes: Option<i64>

The wait in whole minutes, when it could be measured.

freshness_reason: String

Why it was judged that way, in one phrase. Never empty.

age_source: AgeSource

Where the wait was read from.

about: String

What the observation it was derived from is about (ADR 0118); empty for a record derived from anything else.

route: String

Which owner should look first, derived from about’s structure; empty without one.

Trait Implementations

impl Clone for KnowledgeCandidate

fn clone(&self) -> KnowledgeCandidate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KnowledgeCandidate

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KnowledgeCandidate

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for KnowledgeCandidate

impl JsonSchema for KnowledgeCandidate

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Ordered for KnowledgeCandidate

The queue orders by id, which the deriver makes total: the episode, then a digest of the evidence.

fn order_key(&self) -> OrderKey<'_>

The four parts this item is ordered by. Borrowed from the item: building a key allocates nothing, so sorting a large collection costs the comparisons and no more.

impl PartialEq for KnowledgeCandidate

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

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 KnowledgeCandidate