Enum EntryPayload 

pub enum EntryPayload {
    Header {
        header: SessionHeader,
    },
    Item {
        item: Item,
    },
    Usage {
        usage: TokenUsage,
    },
    Cancelled {
        reason: String,
    },
    Compaction {
        digest: Vec<Item>,
        prefix_end: usize,
        kept_from: usize,
        degraded: bool,
    },
    BranchMove {
        keep_items: usize,
    },
    Supersede {
        digest: Vec<Item>,
    },
    PendingAsk {
        id: String,
        summary: String,
        protected_why: Option<String>,
    },
    AskResolved {
        id: String,
        allowed: bool,
    },
    Rename {
        name: String,
    },
    ModeSet {
        mode: String,
    },
    PendingQuestion {
        id: String,
        question: Question,
    },
    QuestionResolved {
        id: String,
        answer: String,
    },
    Todos {
        items: Vec<Todo>,
    },
    Unknown,
}

Variants

Header

Fields

header: SessionHeader

Item

Fields

item: Item

Usage

Fields

usage: TokenUsage

Cancelled

Fields

reason: String

Compaction

Compaction re-points the projection: history before kept_from is replaced by digest items; the log itself keeps everything.

Fields

digest: Vec<Item>

prefix_end: usize

Leading items of the pre-compaction projection preserved verbatim.

kept_from: usize

Index into the pre-compaction projection where the verbatim tail starts. Both indices are relative to the projection at compaction time; replay reconstructs by applying compactions in log order.

degraded: bool

True when the summarize call failed and the floor was applied.

BranchMove

Re-point the projection to its first keep_items items — the branch_move of the commit-protocol vocabulary, expressed against the linear projection (M3b). Fork UIs arrive with M4; the entry and its replay semantics are settled here.

Fields

keep_items: usize

Supersede

Digest of an abandoned branch, appended after a branch_move so the lesson survives without the tokens (commit-protocol supersede).

Fields

digest: Vec<Item>

PendingAsk

A permission ask committed before it surfaces (durable asks): if the process dies before a matching ask_resolved, replay sees a dangling ask and resume re-surfaces it. Log-only (not a projection item).

Fields

id: String

summary: String

protected_why: Option<String>

AskResolved

Resolution of a pending_ask (§2b): the human answered.

Fields

id: String

allowed: bool

Rename

Sets/overwrites the session’s display name. Log-only — not a projection item (like PendingAsk); the last one wins on replay.

Fields

name: String

ModeSet

Sets the session’s effective permission mode (plan mode’s approve-and-continue, /mode, session/set_mode). Log-only, like Rename — not a projection item; the last one wins on replay, so hotl resume restores the mode the session was actually in. A string, not the enum, for forward-compat: the engine maps it.

Fields

mode: String

PendingQuestion

A structured question (ask_user, tier-1 gap #4) committed durably before it surfaces — mirrors PendingAsk/AskResolved exactly: if the process dies before a matching question_resolved, replay sees a dangling question and resume can re-surface it. Log-only (not a projection item).

Fields

id: String

question: Question

QuestionResolved

Resolution of a pending_question: the human’s answer (already formatted to the plain text the model reads — labels joined for a selection, the free-text body, or the no-human guidance).

Fields

id: String

answer: String

Todos

Durable snapshot of the todo_write checklist (M4/tier-1 gap #3). Log-only, like Rename/ModeSet — not a projection item, so it never rides in the model transcript; the last one wins on replay. The live list itself is ephemeral session context injected as a tagged user reminder (SyntheticReason::Todos), never committed as an Item.

Fields

items: Vec<Todo>

Unknown

Trait Implementations

impl Clone for EntryPayload

fn clone(&self) -> EntryPayload

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EntryPayload

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EntryPayload

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for EntryPayload

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for EntryPayload

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 EntryPayload