Enum MessageKind 

pub enum MessageKind {
    Conversation,
    Compaction,
    ToolCall,
    ToolResult,
    HarnessNotice,
    Unknown,
}

A single conversation turn persisted per session (the unit of message-level analytics).

PATTERN: adding a variant here is the whole cost of adding a message class. It reaches the MCP schema through mcp_server::message_kind_values, the CLI through clap, and the default result set through MessageKind::default_search_set, all derived from these variants. Do not pair a new variant with an include_<variant> flag or an is_<variant> column.

Variants

Conversation

Compaction

ToolCall

ToolResult

HarnessNotice

A message the harness injected into the transcript, addressed to the agent rather than written by the user or the model: Stop-hook feedback, PreToolUse blocks, local-command caveats and stdout, task notifications. Not user prose, so it is excluded from results by default, but it is the ONLY record of what a hook told an agent and what the agent did next, so it is stored rather than discarded.

Unknown

Implementations

impl MessageKind

pub const EXCLUDABLE_BY_DEFAULT: &'static [Self]

Every class MessageFilters::kind_predicate can leave out when the caller names no set: HarnessNotice always, Compaction under no_compaction. Together a small share of any real index (2 % of 2.69 M rows measured), which is what lets a count over the default predicate be written as count(everything) - count(these); the storage layer keeps a partial index over exactly this set for the second term. Kept in ascending name order so the SQL rendered from it is stable.

pub fn as_str(&self) -> &'static str

pub fn default_search_set() -> Vec<Self>

Classes returned when a caller names no set: everything the user or the model wrote, plus tool traffic. HarnessNotice is excluded because it is the harness talking to the agent, so including it by default would change every existing result and skew the user-prose analytics (corrections, repeats, vocab) built on message content.

pub fn from_db_str(value: &str) -> Self

Parse a kind value read back from the index, mapping anything unrecognized to MessageKind::Unknown.

DELIBERATELY UNLIKE Provider::from_db_str and Role::from_db_str, which debug_assert! on an unrecognized spelling because theirs can only come from corruption. This column is different in kind: Unknown is a real variant that exists precisely to absorb spellings this build does not know, and older index versions legitimately store values outside the current MessageKind::as_str set — reading them is exactly what the self-healing migration path does. Asserting here turns “opened an older index” into a panic; a proven case is cli_search_self_heals_v4_hybrid_missing_trigram_from_intact_messages against rows storing kind = 'message'.

What this still fixes is the duplication: delegating to std::str::FromStr removes the second, hand-maintained match list where a newly added variant could silently fall through to Unknown forever. The round-trip test over every variant is what guards that.

Trait Implementations

impl Clone for MessageKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for MessageKind

impl Debug for MessageKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MessageKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for MessageKind

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

Formats the value using the given formatter.

impl Eq for MessageKind

impl FromStr for MessageKind

type Err = String

The associated error which can be returned from parsing.

fn from_str(value: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for MessageKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for MessageKind

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for MessageKind

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 MessageKind

impl ValueEnum for MessageKind

fn value_variants<'a>() -> &'a [Self]

All possible argument values, in display order.

fn to_possible_value<'a>(&self) -> Option<PossibleValue>

The canonical argument value.

fn from_str(input: &str, ignore_case: bool) -> Result<Self, String>

Parse an argument into Self.