Struct Goal 

pub struct Goal {
    pub schema: String,
    pub id: String,
    pub objective: String,
    pub context: Vec<PathBuf>,
    pub posture: String,
    pub invariants: Vec<String>,
    pub phases: Vec<Phase>,
    pub verify: String,
    pub created_ms: i64,
    pub updated_ms: i64,
}

A durable, resumable objective.

Fields

schema: String

id: String

Stable across resumes. The thing a log line can point at.

objective: String

One outcome. Not a list — a goal that wants three things is three goals, and the single objective is what makes “what was this run for?” answerable months later.

context: Vec<PathBuf>

Paths to read, not their contents. See the module docs.

posture: String

How to work: cautious, exploratory, ship-it. Free text, because the useful values differ per team and an enum would just be ignored.

invariants: Vec<String>

What must not change. Stated separately from the objective because the model reads the objective as an instruction and these as a boundary.

phases: Vec<Phase>

verify: String

How completion is checked, in words. The executable form is an crate::Acceptance; this is what a human reads to know what that check is supposed to be enforcing.

created_ms: i64

updated_ms: i64

Implementations

impl Goal

pub fn new( id: impl Into<String>, objective: impl Into<String>, now_ms: i64, ) -> Self

pub fn with_context<I, P>(self, paths: I) -> Self

where I: IntoIterator<Item = P>, P: Into<PathBuf>,

pub fn with_posture(self, p: impl Into<String>) -> Self

pub fn with_invariants<I, S>(self, items: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

pub fn with_phases<I, S>(self, titles: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

pub fn with_verify(self, v: impl Into<String>) -> Self

pub fn current(&self) -> Option<(usize, &Phase)>

The phase to work on: the one running, else the first not yet done.

A Failed phase is returned again rather than skipped — the run stopped there for a reason and resuming past it would quietly abandon work the goal still claims to want.

pub fn complete(&self) -> bool

Every phase is Done. A goal with no phases is never complete: it has not been broken down, so there is nothing to have finished.

pub fn start_current(&mut self, now_ms: i64) -> Option<usize>

Mark the current phase as in flight.

pub fn finish(&mut self, i: usize, note: impl Into<String>, now_ms: i64)

pub fn fail(&mut self, i: usize, why: impl Into<String>, now_ms: i64)

pub fn brief(&self) -> String

Render the brief for the current phase.

Includes the objective every time. A model resuming at phase 9 has none of the earlier conversation, and a phase title on its own (“wire the handler”) is not a task — it is a reminder to someone who already knew.

Trait Implementations

impl Clone for Goal

fn clone(&self) -> Goal

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Goal

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Goal

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Goal

impl PartialEq for Goal

fn eq(&self, other: &Goal) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Goal

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 Goal