Struct Conversation 

pub struct Conversation {
    pub messages: Vec<Message>,
    pub taint: Taint,
    pub rewritten: Vec<Vec<Message>>,
}

A conversation, and what has entered it.

The taint lives here, with the messages, because that is what it is a property of. Tracking it per run meant the lethal trifecta was defeated by pressing Enter: fetch a hostile page on one turn, read a secret and send on the next, and the interlock saw a clean slate both times — while the attacker’s text sat in the model’s context the whole while, still able to steer it. A turn boundary is not a security boundary.

Bundling the two makes the right thing the default rather than something each caller has to remember. Keep the history and you keep the taint; start a new conversation — a batch item, a subagent, an eval case — and you get a clean one, because you built a new Conversation to do it.

Fields

messages: Vec<Message>

taint: Taint

What has entered this conversation so far. Grows, never shrinks: there is no way to un-read a page.

rewritten: Vec<Vec<Message>>

Full states of messages that an in-place rewrite replaced during the current run, oldest first — compaction, eviction, thinning. The loop snapshots the list before each rewrite pass and clears at run start; Session::record_run walks these before the final state, so turns a mid-run rewrite dropped still reach the file. Without this, a run long enough to compact itself lost its own head: the front-end records at run end, and the rewrite record carries only what survived.

On the conversation rather than the outcome for the same reason taint is: it is a fact about what the messages went through, and bundling it with them makes the right thing the default — the recording call receives the conversation and cannot skip what it carries.

Implementations

impl Conversation

pub fn new() -> Self

pub fn user(text: impl Into<String>) -> Self

Open with one user message.

pub fn resumed(messages: Vec<Message>, taint: Taint) -> Self

Resume a transcript whose taint is known — from a session file that recorded it.

pub fn push(&mut self, message: Message)

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

Trait Implementations

impl Clone for Conversation

fn clone(&self) -> Conversation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Conversation

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

Formats the value using the given formatter.

impl Default for Conversation

fn default() -> Conversation

Returns the “default value” for a type.

impl From<Vec<Message>> for Conversation

fn from(messages: Vec<Message>) -> Self

Messages with no recorded taint are treated as clean. That is right for a conversation being started and wrong for one being resumed — use Conversation::resumed there, or resuming launders the taint the same way a turn boundary used to.