Struct KnowledgeStatus 

pub struct KnowledgeStatus {

    pub present: bool,
    pub branch: String,
    pub last_derived: Option<LedgerMark>,
    pub last_closed: Option<LedgerMark>,
    pub closed_without_derivation: usize,
    pub candidates: usize,
    pub on_this_branch: usize,
    pub freshness: Freshness,
    pub age_minutes: Option<i64>,
    pub freshness_reason: String,
    pub judged: bool,
    pub stopped_writer: bool,
    pub knowledge_on_end: bool,
    pub knowledge_on_compact: bool,
    pub findings: Vec<String>,
}

Whether the deriver is still writing, and what it last wrote.

The judgement is ADR 0052’s, applied to this writer: while episodes keep closing, a derivation follows every close. It compares episode ids, never line order or timestamps between the two events, because the close derives before it appends session.closed. It is the freshness half of the judgement only; whether the close path and the compaction adapter still call the deriver is read from the source by the shell validator, which is where the source is.

use majordomus_cli::capability::builtin::knowledge_base::KnowledgeStatus;
let fresh: KnowledgeStatus = serde_json::from_str(r#"{
  "present": false, "branch": "master", "closed_without_derivation": 0, "candidates": 0,
  "on_this_branch": 0, "freshness": "unknown", "freshness_reason": "no episode has closed here",
  "judged": false, "stopped_writer": false, "knowledge_on_end": true, "knowledge_on_compact": true
}"#).unwrap();
assert!(!fresh.present, "a fresh clone has no ledger, and that is not a fault");
assert!(!fresh.stopped_writer);

Fields

present: bool

Whether anything is here to judge: a ledger line or a candidate. False in a fresh clone.

branch: String

The branch this checkout is on, or DETACHED.

last_derived: Option<LedgerMark>

The newest knowledge.derived line, or None when the deriver has never run here.

last_closed: Option<LedgerMark>

The newest session.closed line, or None when no episode has closed here.

closed_without_derivation: usize

How many closed episodes in this ledger no knowledge.derived line names.

candidates: usize

How many records carry status: candidate under the candidates class.

on_this_branch: usize

How many of those came from an episode on this branch.

freshness: Freshness

How old the newest closed episode is, judged against session.freshness.

age_minutes: Option<i64>

That age in whole minutes, when it could be measured.

freshness_reason: String

Why it was judged that way. Never empty.

judged: bool

Whether the stopped-writer judgement was made at all. False, with the reason among findings, while no episode has closed here, while the switch is off, or while no derivation has yet run in this checkout.

stopped_writer: bool

The finding: episodes close here and no derivation followed the newest one within the stale threshold. True only when judged.

knowledge_on_end: bool

session.knowledge_on_end, as the policy declares it; absent means on.

knowledge_on_compact: bool

session.knowledge_on_compact, likewise.

findings: Vec<String>

What a reader should know: why the judgement was withheld, or what it found.

Trait Implementations

impl Clone for KnowledgeStatus

fn clone(&self) -> KnowledgeStatus

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KnowledgeStatus

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KnowledgeStatus

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for KnowledgeStatus

impl JsonSchema for KnowledgeStatus

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 PartialEq for KnowledgeStatus

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

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 KnowledgeStatus