Struct Episodes 

pub struct Episodes {
    pub present: bool,
    pub store: String,
    pub worktree: String,
    pub current: String,
    pub episodes: Vec<Episode>,
    pub findings: Vec<String>,
}

Every open episode of this checkout’s store — the answer continuity.state cannot give, because it reads the pointer and this reads the store.

current is the one episode the pointer resolves to, and it is one row of episodes rather than a separate thing: the whole correction this type carries is that the pointed-at episode is a member of the set and not the set. On the day this was written the store held five open episodes in one checkout and every surface could name one of them.

present: false is a fresh clone, which is not a fault — nobody has opened an episode here yet — and is reported as itself rather than as an error.

use majordomus_cli::capability::builtin::lifecycle::Episodes;
use serde_json::json;

// a clone in which no episode has ever been opened: absence, answered as absence
let fresh: Episodes = serde_json::from_value(json!({
    "present": false,
    "store": ".ai/local/state/sessions-open",
    "worktree": "example/a-fresh-clone",
})).unwrap();
assert!(!fresh.present);
assert!(fresh.episodes.is_empty() && fresh.current.is_empty());
assert!(fresh.findings.is_empty(), "nothing to warn about; it is simply new");

// and a store with work in it: `current` names one of the rows, never a sixth thing
let busy: Episodes = serde_json::from_value(json!({
    "present": true,
    "store": ".ai/local/state/sessions-open",
    "worktree": "example/wt",
    "current": "s-0002",
    "episodes": [
        {"session_id": "s-0001", "path": "a.yaml", "standing": "open",
         "events": 3, "note": "this worktree, not pointed at"},
        {"session_id": "s-0002", "path": "b.yaml", "standing": "current",
         "events": 9, "note": "the pointer resolves to it"},
    ],
})).unwrap();
assert_eq!(busy.episodes.len(), 2, "the pointer is blind to the first of these");
assert!(busy.episodes.iter().any(|e| e.session_id == busy.current));

Fields

present: bool

Whether the open-episode store exists. False in a fresh clone, which is not a fault.

store: String

The store, repository-relative.

worktree: String

This worktree, absolute. Every standing above is decided against it.

current: String

The episode id the pointer resolves to, when it resolves to one.

episodes: Vec<Episode>

Every open episode, newest first by recorded start.

findings: Vec<String>

What a reader should know before trusting the above: a file that does not parse, a pointer that resolves to nothing. Empty is the good case.

Trait Implementations

impl Clone for Episodes

fn clone(&self) -> Episodes

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Episodes

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Episodes

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Episodes

impl JsonSchema for Episodes

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 Episodes

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

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 Episodes