Struct Thread 

pub struct Thread {
    pub id: String,
    pub subject: String,
    pub created: i64,
    pub updated: i64,
    pub active_policy: Option<String>,
    pub orchestrator: Option<String>,
    pub server_thread: Option<String>,
    pub pending_job: Option<String>,
    pub draft: Option<String>,
    pub messages: Vec<Message>,
}

A stored conversation. server_thread is the x-nsed-session-id used for cheap same-policy continuation; it is an optimisation, not the source of truth — the source of truth is messages.

Fields

id: String

subject: String

created: i64

updated: i64

active_policy: Option<String>

orchestrator: Option<String>

server_thread: Option<String>

pending_job: Option<String>

Job id of a launched turn whose reply hasn’t landed yet. Persisted so a deliberation that finishes while the TUI is closed can be reconciled on reopen (fetch the result by this id). Cleared when the reply is appended.

draft: Option<String>

Unsent compose text (pastes already expanded), persisted so a long draft survives a restart / a failed send instead of being lost with the TUI process. Restored into the compose box on reopen; cleared once sent.

messages: Vec<Message>

Implementations

impl Thread

pub fn new(subject: impl Into<String>) -> Self

A fresh thread with a generated id and the current timestamps.

pub fn push_message(&mut self, turn: Message)

Append a message and bump updated. An unrooted turn (parent_id unset) continues the current tip — linear-append, the common case — so callers that don’t care about branching keep working. Use Self::reply to root a turn under a specific node (or as a new root).

pub fn get(&self, id: &str) -> Option<&Message>

Look up a message by id.

pub fn children(&self, parent_id: Option<&str>) -> Vec<&Message>

Direct replies to parent_id (None = root turns).

pub fn is_leaf(&self, id: &str) -> bool

A message with no replies — the tip of its branch.

pub fn fork_depth(&self, id: &str) -> usize

How many forks lie in a node’s ancestry — its indent depth in the reader. A linear lineage shares one branch (depth 0); each fork along the path introduces a new branch (+1). = distinct branch_ids on the path − 1.

pub fn path_to_root(&self, id: &str) -> Vec<&Message>

Root→node path following parent_id. Empty if id is unknown.

pub fn tip(&self) -> Option<&Message>

The newest message overall — the default reply target (“continue the conversation”). None on an empty thread. Ties on ts (same-second turns) resolve to the last appended: max_by_key returns the last of equal maxima, and messages are pushed in order.

pub fn reply( &mut self, parent_id: Option<&str>, role: impl Into<String>, content: impl Into<String>, ) -> String

Attach a new turn under parent_id and return its id. Branch rule: a reply to a current leaf inherits the parent’s branch (linear continuation); a reply under a non-leaf node (or a root turn) starts a fresh branch (a fork). The pre-append leaf check is what makes the FIRST reply continue and a SECOND reply to the same node fork.

pub fn rollback_last_user_turn(&mut self) -> bool

Roll back the most recently added turn — used when the orchestrator rejects a just-sent turn (e.g. no agents online) so the thread doesn’t keep a phantom “deliberating” turn with no job behind it. Removes the last message only if it’s a childless user turn (the optimistic send) and clears pending_job. Returns whether a turn was removed.

pub fn migrate_linear(&mut self)

Backfill tree fields on a pre-tree (linear) thread: assign ids, chain each message under the previous one, and share a single branch. A no-op once every message already carries an id.

pub fn to_deliberation_query_from( &self, parent_id: Option<&str>, new_user_message: &str, ) -> String

Render the root→parent_id path plus a new user message into one task string for the native deliberation API. A fork only carries its own lineage (the path), which is what makes “reply under wsup? only” differ from “continue after Hi!”. Subject leads as framing (see Self::to_deliberation_query).

pub fn to_deliberation_query(&self, new_user_message: &str) -> String

Render the stored conversation plus a new user message into a single task string for the native deliberation API (which takes one user_query, not a message array). Mirrors the server compat layer’s to_query_string so a multi-turn thread over the native transport reads the same way: prior non-empty messages prefixed with [role], the new question last. The thread’s subject (when set) leads the request as a Subject: line so the agents see the conversation’s framing.

Trait Implementations

impl Clone for Thread

fn clone(&self) -> Thread

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Thread

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Thread

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Thread

impl PartialEq for Thread

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Thread

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 Thread