Struct ProviderLifecycle 

pub struct ProviderLifecycle {
    pub id: String,
    pub title: String,
    pub lifecycle: Vec<String>,
    pub prompt_capture: bool,
    pub client_config: String,
    pub wired: Vec<String>,
    pub note: String,
}

One provider’s lifecycle surface: what its adapter declares it can do, and what this repository has wired to it.

The two halves come from different places and must not be confused. lifecycle and prompt_capture are the distribution’s declaration — what the shipped adapter can do for this provider at all — while wired is this repository’s policy naming that provider’s hook in wired_by. Either can be empty with the other full, and that pairing is the interesting finding: a provider this repository wires but the tool ships no lifecycle for is a hook that will never fire.

Neither half is inferred from a file on disk. Whether a shim is actually installed is majordomus capture status’s question, and this type deliberately does not answer it.

use majordomus_cli::capability::builtin::lifecycle::ProviderLifecycle;
use serde_json::json;

// a provider the tool adapts and this repository wires: both halves present
let full: ProviderLifecycle = serde_json::from_value(json!({
    "id": "claude",
    "title": "Claude Code",
    "lifecycle": ["SessionStart", "SessionEnd", "PreCompact"],
    "prompt_capture": true,
    "client_config": ".mcp.json",
    "wired": ["session.start", "session.close"],
    "note": "adapted and wired",
})).unwrap();
assert!(!full.lifecycle.is_empty() && !full.wired.is_empty());
assert!(full.prompt_capture);

// and one the tool ships no adapter for: it loses the automation and none of the model,
// because every command remains the same
let unadapted: ProviderLifecycle = serde_json::from_value(json!({
    "id": "some-editor",
    "title": "Some Editor",
    "prompt_capture": false,
    "note": "no lifecycle adapter ships for it",
})).unwrap();
assert!(unadapted.lifecycle.is_empty(), "nothing will fire for it");
assert!(unadapted.client_config.is_empty(), "and it reads no project-scoped config");

Fields

id: String

The provider id: the bootstrap template’s file stem.

title: String

The name a person knows it by.

lifecycle: Vec<String>

The lifecycle events its adapter declares, in the provider’s own vocabulary (SessionStart, SessionEnd, PreCompact). Empty means the tool ships no lifecycle adapter for it: such a provider loses the automation and none of the model, because every command remains the same.

prompt_capture: bool

Whether its adapter can archive the worker’s prompts.

client_config: String

The file it reads a project-scoped MCP client configuration from, when it has one.

wired: Vec<String>

The enforcement entries of this repository’s policy that name this provider’s hook in wired_by. Declared wiring, not a file on disk: whether a shim is installed is a question for majordomus capture status, which is the command that owns it.

note: String

What the two together mean.

Trait Implementations

impl Clone for ProviderLifecycle

fn clone(&self) -> ProviderLifecycle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProviderLifecycle

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProviderLifecycle

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ProviderLifecycle

impl JsonSchema for ProviderLifecycle

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for ProviderLifecycle

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ProviderLifecycle

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 ProviderLifecycle