Struct Session 

pub struct Session {
    pub feature: String,
    pub branch: String,
    pub original: Original,
    pub checkout: PathBuf,
    pub project: PathBuf,
    pub tip: String,
    pub manifest: BTreeMap<String, String>,
    pub pid: u32,
    pub started_at: u64,
    pub notes: Vec<String>,
    pub hidden: Vec<String>,
    pub git: String,
}

An in-place run in progress: written before the checkout is switched, removed after it is switched back.

Fields

feature: String

The feature.

branch: String

speccoder/<feature>.

original: Original

Where the person was.

checkout: PathBuf

The checkout (the repository’s root).

project: PathBuf

The project root inside it.

tip: String

The branch’s tip as speccoder last left it.

manifest: BTreeMap<String, String>

Intent, judge and context files by hash, as the run expects them.

pid: u32

The running process.

started_at: u64

Seconds since the epoch.

notes: Vec<String>

What starting this run did on its own (a resume, work set aside, a tick restored): told with the outcome, never recorded.

hidden: Vec<String>

What git ignored when the session began (directories end in /): hidden from the model’s file tools, as a worktree would not hold it.

git: String

The repository’s configuration, hooks, info/ and refs (other than the session’s branch) by hash: nothing a run does may change them.

Implementations

impl Session

pub fn path(plane_dir: &Path) -> PathBuf

The record’s path in a project’s state directory.

pub fn load(plane_dir: &Path) -> Option<Self>

The record, if a session exists.

pub fn save(&self, plane_dir: &Path) -> Result<(), String>

Writes the record (temporary file, then rename).

pub fn is_live(&self) -> bool

Whether the process that owns it is running.

pub fn begin( project: &Path, plane_dir: &Path, feature: &str, policy: &Policy, ) -> Result<Self, InPlaceError>

Checks the preconditions, records the session, and switches the checkout to speccoder/<feature>.

pub fn check(&self, policy: &Policy) -> Result<(), InPlaceError>

The checkout guard and the manifest, before every task: HEAD where speccoder left it, nothing changed, the protected files as recorded.

pub fn check_before_tick(&self, policy: &Policy) -> Result<(), InPlaceError>

Session::check before a tick: the attempt’s own writes are in the checkout then, so only HEAD and the protected files are compared.

pub fn advance(&mut self, plane_dir: &Path)

After a speccoder commit: the new tip.

pub fn accept( &mut self, plane_dir: &Path, file: &Path, before: &[u8], accept: impl Fn(&[u8], &[u8]) -> bool, ) -> Result<(), InPlaceError>

After the engine’s tick or append of file (absolute): the manifest takes its new hash — only when the change is exactly that (accept says what the bytes before and after may be).

pub fn finish(&self, plane_dir: &Path) -> Result<(), InPlaceError>

Switches the checkout back to where the person was, when it is as speccoder left it; removes the record after.

impl Session

pub fn reconcile( &mut self, plane_dir: &Path, tasks_file: &Path, tasks: &ParsedTasks, tick: impl Fn(&Path, &str, &str) -> Result<(), String>, ) -> Vec<String>

A run killed between its verdict commit and the local tick: each open task whose newest commit names its line exactly (Task-Line) is ticked now, the manifest accepting it. Returns what was ticked.

impl Session

pub fn commit_and_tick( &mut self, plane_dir: &Path, tasks_file: &Path, line_hash: &str, message: &str, intent_digest: &str, tick: impl Fn() -> Result<(), String>, ) -> Committed

Commits a passed (or attested) task and ticks it. The evidence comes first: a tasks_file git ignores is never in a commit, so the commit names the tick as local (Tick: local), and the tick follows it. A tracked one is ticked and committed together, as in a worktree. Every commit says it was made in place, against which intent (intent_digest) and which task line (line_hash, before the tick).

impl Session

pub fn commit_round( &mut self, plane_dir: &Path, tasks_file: &Path, before: &[u8], message: &str, intent_digest: &str, ) -> Result<String, String>

Commits a convergence round in place: the append to tasks_file (old bytes an exact prefix of the new) is accepted into the manifest, and the commit says it was made in place, against which intent; a git-ignored task list is not in it, so the commit may be empty.

pub fn confine( &self, policy: Policy, runner: Runner, ) -> (Policy, Runner, Option<String>)

The model’s view of this checkout: the policy denies git that moves it and hides what git ignored; the sandbox keeps .git read-only and the ignored secrets unreadable.

impl Session

pub fn mode_line(&self) -> String

in-place · speccoder/<f> in <checkout> (returns to <original>).

Trait Implementations

impl Clone for Session

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 Session

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Session

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Session

impl PartialEq for Session

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Session

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 Session