HTTP API: product

Jedno architektonické rozhodnutí, které funkce jmenuje.

Whether one provider's client drives a browser in the same session as this repository's MCP server.

A bridge is the one way a single session both works on a page and reads and changes the live mesh (docs/MCP.md, "Claude in the browser"). It is a vendor capability like the two above, so it is declared with its citation; whether this machine has the bridge is a different fact, which preflight reads from the machine and never from here. A browser agent of the vendor's own — a side panel that reaches only the vendor's cloud — is not a bridge: nothing it does arrives in a session that holds this repository's server.

use majordomus_cli::share::BrowserSource;
assert_eq!(serde_json::from_str::<BrowserSource>("\"bridge\"").unwrap(), BrowserSource::Bridge);
assert!(serde_json::from_str::<BrowserSource>("\"extension\"").is_err(), "one word for it");
assert_eq!(BrowserSource::default(), BrowserSource::None, "undeclared reads as none");
assert_eq!(BrowserSource::Bridge.as_str(), "bridge");

Jedna schopnost modulu, který funkce jmenuje, s projekcemi, které pro ni registr deklaruje.

Jedno tvrzení, které funkce pojmenovává, se stavem, který mu matice dává.

Jedna oblast Cockpitu, kterou funkce jmenuje.

Jeden veřejný příkaz shellového nástroje, který funkce jmenuje, jak jej deklaruje share/commands.yaml.

Jeden dokument, který funkce jmenuje.

Kolik stojí za doménou: součty a počty rozlišných hodnot nad jejími stabilními funkcemi.

use majordomus_cli::product::DomainCounts;
let empty = DomainCounts::default();
assert_eq!(empty.features, 0);
let v = serde_json::to_value(&empty).unwrap();
for key in ["features", "claims", "tested", "use_cases", "rules", "enforced_rules", "capabilities", "moments"] {
    assert_eq!(v[key], 0, "{key} is published, and zero for a domain nothing names");
}

Každá doména produktu, každá s tím, co dohromady dávají její funkce.

Jedna stabilní funkce domény, jak ji ukazuje karta.

use majordomus_cli::product::{DomainMember, Surfaces};
let m = DomainMember {
    id: "finish-contract".into(),
    label: "Finish contract".into(),
    title: "Done is a contract".into(),
    headline: "A worker does not define its own completion.".into(),
    route: "/features/finish-contract/".into(),
    featured: true,
    surfaces: Surfaces::default(),
    claims: 3,
    tested: 2,
    use_cases: 1,
};
let v = serde_json::to_value(&m).unwrap();
assert_eq!(v["tested"], 2);
assert_eq!(v["surfaces"]["cli"], false);

Doména jako funkce na ni ukazuje: dost na drobečkovou navigaci.

use majordomus_cli::product::DomainRef;
let crumb = DomainRef {
    id: "context".into(),
    title: "Context".into(),
    route: "/domains/context/".into(),
};
let v = serde_json::to_value(&crumb).unwrap();
assert_eq!(v["route"], "/domains/context/");
assert_eq!(serde_json::from_value::<DomainRef>(v).unwrap(), crumb);

Jak lze vést hranici epizody pro jednoho providera.

Tři slova, protože tři věci platí o různých poskytovatelích a jejich sloučení do „podporováno / nepodporováno“ je to, co umožnilo, aby tento nástroj hlásil jednoho poskytovatele a mlčel o pěti dalších. Poskytovatel, který spouští vlastní události, není totéž co ten, který žádné nespouští, ale mluví MCP, a ani jeden není totéž co ten, který nemůže nic.

Slova jsou slova samotné deklarace a slovo mimo ně je odmítnuto, ne čteno jako none:

use majordomus_cli::share::EpisodeSource;
let read: EpisodeSource = serde_json::from_str("\"connection\"").unwrap();
assert_eq!(read, EpisodeSource::Connection);
assert_eq!(EpisodeSource::default(), EpisodeSource::None, "undeclared reads as none");
assert!(serde_json::from_str::<EpisodeSource>("\"hook\"").is_err(), "hooks, plural");

Kolik stojí za funkcí, každé číslo odvozeno.

Co je o funkci zaručeno, počítáno z tvrzení, která jmenuje: nikdy slovo, které o zralosti funkce napsal člověk.

Funkce tak, jak je čte klient.

Jedna funkce tak, jak ji ukazuje výpis: vše, co karta potřebuje, a nic, co potřebuje stránka.

Jeden druh objektu, který funkce pojmenovává, s počtem objektů tohoto druhu, které vrstva drží.

Každá funkce proti každému rozhraní a každý modul, příkaz a druh proti funkcím, které je jmenují.

Jeden řádek matice: funkce a povrchy, jimiž je vystavena.

Jeden modul schopností, který funkce jmenuje.

Jeden provozní okamžik, na který funkce odpovídá: odvozeno z okamžiků, které jmenují kterýkoli z příkazů, schopností, tvrzení nebo pravidel funkce.

Kolik toho model drží. Každý počet kdekoli je jedním z těchto.

Jedna věc produktu — modul, veřejný příkaz, druh — a funkce, které ji jmenují. Prázdné znamená, že stránka produktu o ní nic neříká, což je mezera, kterou validace hlásí a matice ukazuje, ne skrývá.

Jedna věc v produktovém modelu, která je špatně, pojmenovaná tam, kde je, s nejbližším kandidátem, pokud existuje.

Jeden poskytovatel, pro nějž má nástroj adaptér, objevený ze šablon, které distribuce dodává, a doplněný tím, co s ním tento repozitář dělá.

Co zjistila vlastní validace modelu.

Zda lze surový prompt osoby zachytit pod modelem pro jednoho poskytovatele.

Není tu žádné connection a nesmí být: MCP serveru se předávají volání nástrojů, nikdy prompt, který je vyvolal. Zachycení promptu je specifické pro poskytovatele a deklarace to říká, místo aby předstírala, že je může nahradit spojení.

use majordomus_cli::share::PromptSource;
assert_eq!(serde_json::from_str::<PromptSource>("\"hook\"").unwrap(), PromptSource::Hook);
assert!(serde_json::from_str::<PromptSource>("\"connection\"").is_err(),
        "no connection can observe a prompt");
assert_eq!(PromptSource::default(), PromptSource::None);

Jeden bootstrap, který poskytovatel vykresluje.

Každý poskytovatel.

Co může jeden poskytovatel udělat s životním cyklem relace a kde to bylo ověřeno.

Každá buňka nese své důkazy. Schopnost tvrzená bez citace je vada, již tento typ má znemožnit: dříve byl poskytovatel chybějící v shellové tabulce tiše nepodporovaný a poskytovatel v ní přítomný tiše schopný a žádný povrch nemohl čtenáři říct, z jaké stránky dodavatele která odpověď pochází — capture status vyjmenoval jediného poskytovatele, který měl adaptér, a o ostatních pěti, které tato distribuce deklaruje, neříkal vůbec nic. Pravidlo project.a-provider-capability-cites-its-evidence odmítne deklaraci bez ní.

Poskytovatel, který nedeklaruje nic, je none na obou osách s prázdnými důkazy — stav, který to pravidlo odmítá, takže mezera je zjištěním, a ne tiché „nepodporováno“:

use majordomus_cli::share::{EpisodeSource, PromptSource, ProviderOffers};
let undeclared = ProviderOffers::default();
assert_eq!((undeclared.episode, undeclared.prompts), (EpisodeSource::None, PromptSource::None));
assert!(undeclared.episode_evidence.is_empty() && undeclared.prompts_evidence.is_empty());
let generic: ProviderOffers = serde_json::from_value(serde_json::json!({
    "episode": "connection", "episode_evidence": "ADR 0103",
    "prompts": "none", "prompts_evidence": "MCP carries no prompt",
})).unwrap();
assert_eq!(generic.episode, EpisodeSource::Connection);

Jedna doména, rozřešená: záznam tak, jak ho deklaruje jeho soubor, a vše odvozené ze stabilních funkcí, které ji pojmenovávají.

Deklarovaný záznam je zploštěn, takže čtenář vidí jeden objekt: vlastní pole domény vedle jejích odvozených členů a počtů.

use majordomus_cli::product::{Domain, DomainCounts, FeatureEvidence, ResolvedDomain, Surfaces};
let domain: Domain = serde_json::from_value(serde_json::json!({
    "id": "context", "title": "Context", "status": "stable",
    "headline": "h", "problem": "p",
}))
.unwrap();
let resolved = ResolvedDomain {
    domain,
    features: vec![],
    surfaces: Surfaces::default(),
    moments: vec![],
    claim_refs: vec![],
    use_case_refs: vec![],
    counts: DomainCounts::default(),
    evidence: FeatureEvidence::default(),
};
let v = serde_json::to_value(&resolved).unwrap();
assert_eq!(v["id"], "context", "the record is flattened into the resolved view");
assert_eq!(v["counts"]["features"], 0);

Jedna funkce, vyřešená: záznam tak, jak ho deklaruje jeho soubor, a vše odvozené.

Jedno pravidlo, které funkce jmenuje.

Jeden povrch slovníku, jak ho čte klient.

Jeden webový povrch topologie, který funkce jmenuje.

Rozhraní, kterými je funkce zpřístupněna, určená z toho, co její odkazy promítají, a z ničeho, co říká soubor. Každé je skutečnost s důvodem, který si čtenář může ověřit: cli platí, když modul funkce má schopnost s cestou v příkazové řádce nebo funkce jmenuje shellový příkaz; api, když modul má HTTP routu; mcp, když modul má nástroj nebo zdroj MCP, nebo funkce jmenuje druh, protože každý objekt vrstvy je zdrojem MCP; cockpit, když funkce jmenuje oblast Cockpitu nebo modul, protože každá schopnost má stránku v Cockpitu; docs, když jmenuje dokument.

Jeden případ užití, který funkce jmenuje.