Struct Harness 

pub struct Harness {

    pub name: String,
    pub register: Vec<String>,
    pub registered: Vec<String>,
    pub config: Option<String>,
    pub marker: Option<String>,
    pub snippet: Option<String>,
    pub config_json: Option<String>,
    pub json_pointer: Option<String>,
    pub json_entry: Option<String>,
    pub skills: Option<String>,
    pub hooks: Option<String>,
    pub hooks_named: Option<String>,
    pub hook_events: Vec<String>,
    pub plugin: Option<String>,
    pub plugin_template: Option<String>,
    pub probe: Vec<String>,
    pub clients: Vec<String>,
    pub start: Vec<String>,
    pub resume: Vec<String>,
}

One agent runner, as the seat’s own configuration describes it. The seat ships no runner’s name: the file at harnesses_path names them, one table each, and onboard and doctor read it.

A runner registers MCP servers one of two ways. register is a command that does it ({server} is replaced by the path to ljos-mcp) and registered a command that exits 0 once it is done. Or config is a file the runner reads, marker a line that means the entry is present, and snippet what to append when it is not. skills is the directory the runner loads skills from; the protocol goes to <skills>/ljos/SKILL.md.

Fields

name: String

register: Vec<String>

registered: Vec<String>

config: Option<String>

marker: Option<String>

snippet: Option<String>

config_json: Option<String>

A JSON config file the runner reads its MCP servers from, for a runner an appended snippet cannot serve.

json_pointer: Option<String>

Where in that file the entry goes, as a JSON pointer (/mcp/ljos).

json_entry: Option<String>

The entry to set there, as JSON text; {server} and {name} are replaced.

skills: Option<String>

hooks: Option<String>

A JSON settings file the runner reads hooks from, in the shape {"hooks": {"<Event>": [{"matcher": "...", "hooks": [{"type": "command", "command": "..."}]}]}}. onboard merges the seat’s memory hook into it, so what the seat knows about a command or a prompt reaches the agent at the point of action.

hooks_named: Option<String>

A hooks file whose top level maps a hook name to its events ({"NAME": {"PreToolUse": [...], "PreInvocation": [...]}}) takes the seat’s hooks under this name, each command told its event with --event, since that runner’s payload does not name it.

hook_events: Vec<String>

The events the memory hook fires on. Empty means HOOK_EVENTS, the prompt event alone: a panel of this seat’s personas settled on prompts over tool calls, because a turn issues many shell commands and one prompt. ["UserPromptSubmit", "PreToolUse"] injects on both.

plugin: Option<String>

Where a runner whose hooks are code loads a plugin from, for a runner with no hooks file: the plugin carries the memory hook and argv law and shells to ljos hook.

plugin_template: Option<String>

Which bundled plugin goes there: a name in PLUGIN_TEMPLATES.

probe: Vec<String>

A command that proves the runner loads the ljos tools, not only that its config names them: it must exit 0 and print ljos_sitting. A runner installed without its MCP support lists the entry and loads nothing.

clients: Vec<String>

The names this runner’s MCP client sends at initialize, when they are not the runner’s name: the seat is then the harness’s name, so one runner’s memory, ballots and trust rows stay one voter instead of scattering over acme and acme-mcp-client.

start: Vec<String>

How the runner starts in a persona’s home for a session the person can talk in; the runner’s name alone when unset.

resume: Vec<String>

How it resumes the latest session of the directory it starts in, so a persona’s next hand-off continues its conversation.

Trait Implementations

impl Clone for Harness

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 Harness

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

Formats the value using the given formatter.

impl Default for Harness

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Harness

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Harness

impl PartialEq for Harness

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Harness

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 Harness