HTTP API: mesh

Jeden příkaz, který připouští pravidlo: štítek pravidla, jeho vektor argumentů přesně tak, jak jej provádí apply, a totéž v uvozovkách jako jeden řádek, který člověk vloží do kořenového shellu. Obojí jsou projekce jednoho vektoru, takže to, co zpráva ukazuje, je to, co běží.

use std::net::Ipv4Addr;
use majordomus_cli::mesh::firewall::{plan, render, AdmitCommand, Backend};
use majordomus_cli::mesh::MeshConfig;

let config: MeshConfig = serde_json::from_value(serde_json::json!({
    "schema": "mesh/v1", "kind": "mesh-declaration", "id": "doc", "enabled": true,
})).unwrap();
let p = plan(Some(&config), &[Ipv4Addr::new(10, 0, 0, 2)], None);
let commands: Vec<AdmitCommand> = render(Backend::Ufw, &p, None);
assert_eq!(commands[0].argv[0], "ufw");
assert_eq!(commands[0].rule, "udp/7741 to 239.255.77.77 from any");
assert_eq!(commands[0].line, "ufw allow in proto udp to 239.255.77.77 port 7741 comment 'majordomus mesh: multicast discovery'");

Firewallová vrstva, kterou tento hostitel provozuje, pokud to exekutor dokáže říct bez oprávnění: určeno detect z platformy a cesty, a věc, pro kterou jsou render, observe a apply specifické.

use majordomus_cli::mesh::firewall::Backend;

assert_eq!(serde_json::to_value(Backend::ApplicationFirewall).unwrap(), "application_firewall");
assert_eq!(Backend::None.as_str(), "none");

Vstup mesh.claim.

Zda nárok ostatní vylučuje, nebo jim jen oznamuje. Obojí je užitečné a odpovídají na různé otázky: výhradní nárok je pracovník říkající „needitujte to, dokud tu jsem“, poradní říká „jsem tady“. Výhradní je výchozí, protože nárok převzatý bez zamyšlení nad režimem je nárok, u kterého někdo očekává, že bude respektován.

use majordomus_cli::mesh::journal::ClaimMode;

assert_eq!(ClaimMode::default(), ClaimMode::Exclusive);
assert_eq!(serde_json::to_value(ClaimMode::Advisory).unwrap(), serde_json::json!("advisory"));

Dva živé nároky různých relací, jejichž rozsahy se setkávají, alespoň jeden poradní: hlásí se, nikdy neodmítají.

Překryv je informace, ne verdikt — takhle se dva pracovníci dozvědí, že jsou na stejném místě, aniž by jednoho z nich cokoli zastavilo. Setkávající se cesty jsou uvedeny po dvojicích, ne shrnuty, protože užitečná otázka je, která moje cesta se setkává s kterou jejich.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{ClaimMode, EventBody, Journal, StreamLiveness};
use majordomus_cli::mesh::state::{fold, ClaimOverlap};

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
for (claim, session, mode) in [
    ("c1", "s1", ClaimMode::Exclusive),
    ("c2", "s2", ClaimMode::Advisory),
] {
    j.append_own(EventBody::ClaimAcquired { claim: claim.into(), session: session.into(),
        scope: vec!["apps".into()], intent: None, mode, issue: None }).unwrap();
}

let state = fold(&j.events(), &|_| StreamLiveness::Own);
let overlap: &ClaimOverlap = &state.overlaps[0];
assert_ne!(overlap.first, overlap.second, "two claims, two sessions");
assert_eq!(overlap.paths, [("apps".to_string(), "apps".to_string())]);

Stav nároku a — kde skončil nebo prohrál — co jej ukončilo. Dvě varianty nesoucí řetězec existují, protože holý verdikt není použitelný: worker, kterému se řekne, že jeho nárok vypršel, potřebuje vědět, zda se jeho relace uzavřela, nebo jeho runtime přestal tepat, a ten, kterému se řekne, že jeho nárok je v konfliktu, potřebuje klíč nároku, který jej porazil, což je tentýž klíč na každém runtime.

use majordomus_cli::mesh::state::ClaimState;

assert!(ClaimState::Held.is_live());
assert!(ClaimState::Conflicted("s/c1".into()).is_live(), "still held, and not the winner");
assert!(!ClaimState::Released.is_live());

// the detail travels with the verdict, so a reader is never left asking who won
let value = serde_json::to_value(ClaimState::Conflicted("s/c1".into())).unwrap();
assert_eq!(value["state"], "conflicted");
assert_eq!(value["detail"], "s/c1");

Jeden claim kdekoli v meshi: kdo co vzal, k čemu a kde to stojí. Lamportovo razítko a sekvence získání se nesou, ne odvozují na požádání, protože jsou tím, čím se rozhoduje o exkluzivitě — každý runtime řadí dva konkurující claimy podle téže trojice, a proto pojmenuje téhož vítěze, bez předávání zpráv a bez „poslední paket vyhrává“.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{ClaimMode, EventBody, Journal, StreamLiveness};
use majordomus_cli::mesh::state::{fold, ClaimState, ClaimView};

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
j.append_own(EventBody::ClaimAcquired { claim: "c1".into(), session: "s1".into(),
    scope: vec!["apps/majordomus-cli".into()], intent: Some("document the mesh".into()),
    mode: ClaimMode::Exclusive, issue: Some("#184".into()) }).unwrap();

let state = fold(&j.events(), &|_| StreamLiveness::Own);
let claim: &ClaimView = &state.claims[0];
assert_eq!(claim.scope, ["apps/majordomus-cli"]);
assert_eq!(claim.state, ClaimState::Held);
assert!(claim.acquired_lamport > 0, "the order exclusivity is decided in");

Odpověď mesh.handover.consume.

Čítače propojení a replikace od startu: co tento runtime udělal, ne co drží. Jsou monotónní a nikdy se nenulují, takže dvě čtení s minutovým odstupem jsou rychlost — což je jediný způsob, jak poznat mesh, který funguje, od meshe, který opakuje, protože oba ukazují stejné peery ve stejných stavech.

Počty jsou všude rozděleny podle směru (handshakes_out proti handshakes_in, refused_in proti refused_out), protože runtime, který odmítá všechny, a ten, kterého odmítají všichni, potřebují opačnou nápravu.

#### use std::collections::BTreeMap;
#### use std::sync::{Arc, Mutex, Weak};
#### use majordomus_cli::mesh::config::{CooperationConfig, TrustConfig};
#### use majordomus_cli::mesh::cooperation::*;
#### use majordomus_cli::mesh::identity::NodeIdentity;
#### use majordomus_cli::mesh::link::{LinkReply, LinkTransport, Signed, HELLO_PATH};
#### use majordomus_cli::mesh::registry::MeshRegistry;
#### use majordomus_cli::mesh::repository::{of_root_commits, runtime_id};
#### use majordomus_cli::mesh::trust::TrustPolicy;
#### #[derive(Default)] struct Net(Mutex<BTreeMap<String, Weak<Cooperation>>>);
#### impl LinkTransport for Net {
####   fn post(&self, e: &str, p: &str, m: &Signed) -> Result<LinkReply, String> {
####     let peer = (self.0.lock().unwrap().get(e).and_then(Weak::upgrade))
####         .ok_or_else(|| format!("{e}: nobody there"))?;
####     Ok(if p == HELLO_PATH { peer.accept_hello(m) } else { peer.accept_sync(m) }) } }
#### let net = Arc::new(Net::default());
#### let runtime = |endpoint: &str| { let c = Cooperation::new(CooperationSetup {
####     identity: Arc::new(NodeIdentity::ephemeral().unwrap()), runtime: runtime_id(endpoint),
####     repository: of_root_commits(&["root".into()]), endpoints: vec![endpoint.into()],
####     version: "doc".into(), config: CooperationConfig::default(),
####     trust: TrustConfig { policy: TrustPolicy::Tofu, allow: vec![] }, journal_path: None,
####     registry: Arc::new(MeshRegistry::new()),
####     transport: Arc::clone(&net) as Arc<dyn LinkTransport>, board: None,
####     checkout: CheckoutFacts::default() }).unwrap();
####   net.0.lock().unwrap().insert(endpoint.into(), Arc::downgrade(&c)); c };
#### let (a, b) = (runtime("a:1"), runtime("b:1"));
let key = a.dial(&["b:1".into()]).unwrap();
a.sync_with(&key).unwrap();

let dialer: CooperationCounters = a.status().counters;
let answerer = b.status().counters;
assert_eq!((dialer.handshakes_out, dialer.syncs_out), (1, 1));
assert_eq!((answerer.handshakes_in, answerer.syncs_in), (1, 1), "the other side of it");
assert_eq!(answerer.handshakes_out, 0, "B never dialed anybody");

Celý sloučený stav, každá kolekce v pořadí klíčů, a jeho otisk: dva runtimy, které souhlasí, vypíšou stejný otisk.

Smyslem je otisk. Konvergence je jinak tvrzení, které z jednoho stroje nikdo neověří; s otiskem dva operátoři porovnají jediný krátký řetězec a vědí, zda jejich runtime vidí tentýž svět. opaque_events je druhá polovina téže poctivosti: události druhů, které tento spustitelný soubor neinterpretuje, se počítají a přeposílají místo zahazování, takže provoz novějšího peera je vidět a tiše nechybí.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{EventBody, Journal, SessionInfo, StreamLiveness};
use majordomus_cli::mesh::state::{fold, CooperationState};

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
j.append_own(EventBody::SessionOpened { info: SessionInfo::named("s1", "cli") }).unwrap();

let events = j.events();
let state: CooperationState = fold(&events, &|_| StreamLiveness::Own);
assert_eq!(state.digest.len(), 32);

// the same events in another order, and twice over, are the same state
let mut shuffled = events.clone();
shuffled.reverse();
shuffled.extend(events);
assert_eq!(fold(&shuffled, &|_| StreamLiveness::Own).digest, state.digest);

Celý runtime spolupráce tak, jak ho hlásí každý povrch: příkazová řádka, HTTP povrch i MCP vykreslují tuto jedinou hodnotu, takže člověk a agent, kteří se ptají na totéž téhož runtime, nikdy nedostanou různé odpovědi.

Jediným čtením odpovídá na tři otázky, které mesh vyvolává — spolupracuje tento runtime vůbec, čím mluví a s kým je propojen — a zůstává použitelný i tehdy, když je odpověď záporná: neaktivní runtime stále hlásí svůj rozsah protokolu a důvod, místo absence, kterou by volající musel složitě vykládat.

#### use std::sync::Arc;
#### use majordomus_cli::mesh::config::{CooperationConfig, TrustConfig};
#### use majordomus_cli::mesh::cooperation::{CheckoutFacts, Cooperation, CooperationSetup};
#### use majordomus_cli::mesh::identity::NodeIdentity;
#### use majordomus_cli::mesh::link::HttpTransport;
#### use majordomus_cli::mesh::registry::MeshRegistry;
#### use majordomus_cli::mesh::repository::of_root_commits;
#### let cooperation = Cooperation::new(CooperationSetup {
####     identity: Arc::new(NodeIdentity::ephemeral().unwrap()), runtime: "0000000000000001".into(),
####     repository: of_root_commits(&["root".into()]), endpoints: vec!["127.0.0.1:9".into()],
####     version: "doc".into(), config: CooperationConfig::default(), trust: TrustConfig::default(),
####     journal_path: None, registry: Arc::new(MeshRegistry::new()),
####     transport: Arc::new(HttpTransport), board: None, checkout: CheckoutFacts::default(),
#### }).unwrap();
use majordomus_cli::mesh::cooperation::CooperationStatus;

let running: CooperationStatus = cooperation.status();
assert_eq!(running.runtime.as_deref(), Some(cooperation.runtime_key()));
assert!(running.peers.is_empty(), "nothing is dialed until something dials");

// and where there is no runtime at all, the same shape says why
let none = CooperationStatus::inactive("the mesh declaration is disabled");
assert_eq!(none.protocol, running.protocol, "still answerable about what it speaks");

Verdikt jedné kontroly.

Zda událost, kterou tento runtime zapsal, dosáhla disku tohoto stroje: co potvrzuje připojení a jediná věc, kterou o tom smí volající říct.

use majordomus_cli::mesh::journal::Durability;
assert_eq!(serde_json::to_value(Durability::NotDurable).unwrap(), "not_durable");
assert_eq!(Durability::default(), Durability::Unknown, "an answer that did not say");
assert!(Durability::Synced.is_on_disk() && !Durability::NotDurable.is_on_disk());

Žádný vstup.

Obálka na drátě: inzerát plus jeho podpis.

Odpověď mesh.events.

Vlastní slovo firewallu, posouzené proti plánu: stav, důkazy za ním a štítky pravidel, která nebyla přijata, když je stav missing.

use majordomus_cli::mesh::firewall::{judge_ufw, plan, FirewallObservation, FirewallObservationState};

let o: FirewallObservation = judge_ufw("Status: inactive\n", &plan(None, &[], None));
assert_eq!(o.state, FirewallObservationState::Inactive);
assert!(o.missing.is_empty() && o.detail.contains("inactive"));

Co firewall hostitele říká o plánu, jedním slovem. Samo o sobě je selháním jen missing; unobservable je absence, kterou může log jádra ještě změnit v selhání.

use majordomus_cli::mesh::firewall::FirewallObservationState;

assert_eq!(serde_json::to_value(FirewallObservationState::Unobservable).unwrap(), "unobservable");

Co deklarace implikuje, že tento hostitel musí připouštět: pravidla, sítě, ze kterých je připouštějí, porty hubů, pro které je tento stroj uveden, a adresy, které plán viděl. Odpověď plan; prázdné rules je „nic není potřeba“, což je odpověď pro žádnou deklaraci i pro vypnutou.

use majordomus_cli::mesh::firewall::{plan, FirewallPlan};

let nothing: FirewallPlan = plan(None, &[], None);
assert!(nothing.rules.is_empty() && nothing.hub_ports.is_empty() && nothing.networks.is_empty());

Celý report: plán, backend, příkazy, slovo firewallu a jádra, s jednou větou verdiktu a jedním ok. To, co odpovídá mesh.firewall a co čte kontrola firewall doctoru.

use majordomus_cli::mesh::firewall::{report, FirewallReport, BLOCK_WINDOW_SECONDS};

let r: FirewallReport = report(None, &[], None);
assert!(r.ok && r.commands.is_empty());
assert_eq!(r.window_seconds, BLOCK_WINDOW_SECONDS);
assert_eq!(r.platform, std::env::consts::OS);

Jedno příchozí povolení, které mesh na tomto hostiteli potřebuje: protokol a port, skupina, na kterou je adresováno, jde-li o multicast, sítě, z nichž smí přijít, a věta, která říká proč. Pravidlo se vždy odvozuje, nikdy nepíše ručně; FirewallRule::label je to, jak je pojmenovává verdikt.

use majordomus_cli::mesh::firewall::{FirewallRule, Protocol, Role};

let rule = FirewallRule {
    role: Role::Hub,
    protocol: Protocol::Tcp,
    port: 8791,
    destination: None,
    sources: vec!["192.168.7.0/24".into()],
    reason: "this machine is a declared rendezvous hub".into(),
};
assert_eq!(rule.label(), "tcp/8791 from 192.168.7.0/24");

Předávka tak, jak ji nese mesh: fakta záznamu a jeho tělo, omezené.

Putuje psaný text plus těch několik faktů, které příjemci umožní ho zařadit — úloha, úkol, větev, commit. Není mezi nimi žádná cesta z disku autora, protože checkout, který to čte, je jinde, a cesta z jiného stroje je nanejvýš šum. Identitou je digest těla, takže předávka publikovaná dvakrát opakováním nebo dvěma runtimy je všude jedna předávka.

use majordomus_cli::mesh::journal::HandoverBody;

let body = "# Objective\nship the mesh\n".to_string();
let handover = HandoverBody {
    id: HandoverBody::digest_of(&body),
    task: Some("t-1".into()),
    issue: Some("#184".into()),
    milestone: None,
    branch: Some("feature/mesh-cooperation".into()),
    head: None,
    created_at: None,
    name: None,
    body,
};
assert_eq!(handover.id, HandoverBody::digest_of(&handover.body));

let wire = serde_json::to_value(&handover).unwrap();
assert!(wire.get("milestone").is_none(), "what it does not say is omitted");

Vstup mesh.handover.consume.

Vstup mesh.handover.publish.

Předávka kdekoli v meshi se všemi, kdo ji převzali. Id je otisk těla, takže táž předávka publikovaná dvakrát — opakovaným pokusem nebo dvěma runtime, které ji obě viděly — je tady jedna předávka; a consumed_by je to, co brání tomu, aby dva workery mlčky převzaly totéž pokračování, protože seznam se skládá z událostí, které má každý runtime.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{EventBody, HandoverBody, Journal, StreamLiveness};
use majordomus_cli::mesh::state::{fold, HandoverView};

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
let body = "# Objective\nship\n".to_string();
let handover = HandoverBody { id: HandoverBody::digest_of(&body), task: None, issue: None,
    milestone: None, branch: Some("feature/x".into()), head: None, created_at: None,
    name: None, body };
let id = handover.id.clone();
j.append_own(EventBody::HandoverPublished { handover }).unwrap();
j.append_own(EventBody::HandoverConsumed { handover: id.clone(), session: "s1".into() })
    .unwrap();

let state = fold(&j.events(), &|_| StreamLiveness::Own);
let view: &HandoverView = &state.handovers[0];
assert_eq!(view.id, id, "identified by what it says, not by who said it");
assert_eq!(view.consumed_by.len(), 1, "somebody has picked this one up");

Jeden běh uzlu: 16 hex znaků entropie OS, nových při každém startu procesu. Restart zachová id uzlu a mění toto, podle čehož čtenář rozliší „vrátil se tentýž uzel“ od „tentýž proces tu stále je“.

Čítače žurnálu od startu: kolik drží, kolik zapsal, přijal, vstřebal, odmítl, zadržel a zhutnil. Právě ony umožňují diagnostikovat problém replikace z jediného počítače — runtime, jehož received nikdy neroste, není propojen, ten, jehož rejected roste, dostává něco, co nepřijme, a ten, jehož pending zůstává vysoké, mu chybí událost před tím, co má.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{EventBody, Journal, JournalTallies};

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
let before: JournalTallies = j.tallies();
assert_eq!((before.written, before.events), (0, 0));

j.append_own(EventBody::SessionClosed { session: "s1".into() }).unwrap();
let after = j.tallies();
assert_eq!((after.written, after.events, after.streams), (1, 1, 1));
assert!(after.lamport > before.lamport);

Odmítnutí: kód, důvod slovy a rozsah protokolu odmítajícího, aby šlo nesoulad verzí diagnostikovat z obou konců.

Nést rozsah protokolu odmítajícího v každém odmítnutí, ne jen v tom o protokolech, je to, co činí problém verzí viditelným ze strany, která má log: volající vidí, co odpovídající mluví, aniž by kdokoli musel číst druhý stroj.

use majordomus_cli::mesh::link::{LinkRefusal, RefusalCode, LINK_PROTOCOL_MAX};

let refusal = LinkRefusal::new(RefusalCode::Untrusted, "the key is not in the allowlist");
assert_eq!(refusal.code, RefusalCode::Untrusted);
assert_eq!(refusal.proto_max, LINK_PROTOCOL_MAX);
assert_eq!(refusal.to_string(), "untrusted: the key is not in the allowlist");

Co hello nebo sync odpovídá po drátě: podepsanou zprávu nebo odmítnutí. Obojí jsou úspěšné odpovědi — transport je nese stejně a ani jedno není chyba — protože odmítnutí je rozhodnutí, které tento protokol chce mít zaznamenané a viditelné, a odpověď, která by dorazila jako selhání HTTP, by se nedala odlišit od peera, který je mimo provoz.

use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::link::{sign, Domain, LinkReply, RefusalCode};

let node = NodeIdentity::ephemeral().unwrap();
let accepted = LinkReply::accepted(sign(&node, Domain::Welcome, serde_json::json!({})));
assert!(accepted.signed.is_some() && accepted.refusal.is_none());

let refused = LinkReply::refused(RefusalCode::SelfLink, "this runtime dialled itself");
assert!(refused.signed.is_none());
assert_eq!(refused.refusal.unwrap().code, RefusalCode::SelfLink);

Postavení linky z pohledu tohoto runtimu. Je to tvrzení o spojení a nikdy o peerovi: runtime dosažitelný jen přes třetí stranu je zde Expired, zatímco jeho proudy všude pulzují, což je důvod, proč claimy následují proudy, ne tohle.

Varianty jsou řazeny podle toho, jak hluboko článek spadl, takže nejhorší článek v tabulce je maximum a čtenář je nikdy nemusí řadit ručně.

use majordomus_cli::mesh::cooperation::LinkState;

let table = [LinkState::Connected, LinkState::Unreachable, LinkState::Degraded];
assert_eq!(table.iter().max(), Some(&LinkState::Unreachable), "the worst link shows");
assert_eq!(serde_json::to_value(LinkState::Connected).unwrap(), "connected");

Jeden stroj ve stromu peerů.

Jeden živý nárok, stručně: čí je, k čemu slouží a kolik cest drží, s jeho záměrem oříznutým na SUMMARY_TEXT znaků — dost na to, aby bylo jasné, koho se zeptat.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{ClaimMode, EventBody, Journal, SessionInfo, StreamLiveness};
use majordomus_cli::mesh::state::fold;

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
j.append_own(EventBody::SessionOpened { info: SessionInfo::named("s1", "claude-code") })
    .unwrap();
for (claim, path) in [("c1", "apps/a"), ("c2", "apps/b")] {
    j.append_own(EventBody::ClaimAcquired { claim: claim.into(), session: "s1".into(),
        scope: vec![path.into()], intent: Some("work".into()), mode: ClaimMode::Exclusive,
        issue: Some("#1".into()) }).unwrap();
}
j.append_own(EventBody::ClaimReleased { claim: "c1".into() }).unwrap();
let state = fold(&j.events(), &|_| StreamLiveness::Own);
use majordomus_cli::mesh::page::{summarize, ClaimBrief};

let summary = summarize(&state, &[]);
let newest: &ClaimBrief = summary.runtimes[0].newest_claim.as_ref().unwrap();
assert_eq!((newest.issue.as_deref(), newest.paths), (Some("#1"), 1));

Claimy podle postavení: držené, konfliktní, uvolněné a vypršelé. Držené a konfliktní jsou živé; zbylé dva jsou historie, počítané, ne vypisované.

use majordomus_cli::mesh::page::ClaimCounts;

let counts = ClaimCounts { held: 2, released: 5, ..ClaimCounts::default() };
assert_eq!(serde_json::to_value(&counts).unwrap()["released"], 5);

Které claimy úplná odpověď ponechá: všechny včetně ukončených, nebo jen ty stále živé — otázka, kterou executor klade, než převezme lease.

use majordomus_cli::mesh::page::ClaimFilter;

assert_eq!(ClaimFilter::default(), ClaimFilter::All);
assert_eq!(serde_json::from_str::<ClaimFilter>(r#""live""#).unwrap(), ClaimFilter::Live);

Celá autokontrola.

Jedna událost tak, jak ji nese drát a úložiště. Tělo se drží jako JSON, aby událost neznámého druhu přežila uložení i přenos bajt po bajtu; MeshEvent::body ho interpretuje.

Každé pole nad podpisem je jím kryto, což činí relay neškodným: runtime, který událost přeposílá, nemůže změnit její proud, pořadí, repozitář ani tělo, aniž by si toho další čtenář všiml, a tak za nic neručí. Nástěnné hodiny jsou jediné pole, kterým se nic nerozhoduje — aktuálnost se měří beaty a monotónními hodinami, nikdy porovnáním představ dvou strojů o čase.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{EventBody, Journal, MeshEvent};

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
j.append_own(EventBody::SessionClosed { session: "s1".into() }).unwrap();

let event: &MeshEvent = &j.events()[0];
assert_eq!(event.seq, 1, "dense from 1 within its stream");
assert_eq!(event.kind(), "session_closed");
assert_eq!(event.id(), format!("{}/1", event.stream));

// a relayed byte changed anywhere under the signature is a different event
let mut tampered = event.clone();
tampered.repo = "another-repository".into();
assert_ne!(tampered.signing_bytes(), event.signing_bytes());

Předávka, kterou nikdo nepřevzal, stručně: id, které mesh.handover.consume přebírá, kdo ji publikoval a na co navazuje. Její tělo zůstává v plném pohledu.

use majordomus_cli::mesh::page::HandoverBrief;

let brief = HandoverBrief { id: "ab12".into(), runtime: "n-r".into(),
    branch: Some("feature/x".into()), issue: None, published_lamport: 7 };
assert_eq!(serde_json::to_value(&brief).unwrap()["branch"], "feature/x");

Odpověď mesh.identity: identita uzlu tohoto stroje, pouze veřejná polovina.

Jedna kolekce složeného stavu, jak ji pojmenovává kind: čtenář, který chce jen revize, nedostane claimy.

use majordomus_cli::mesh::page::Kind;

assert_eq!(serde_json::from_str::<Kind>(r#""reviews""#).unwrap(), Kind::Reviews);
assert!(serde_json::from_str::<Kind>(r#""everything""#).is_err());

Zdraví poskytovatele, tak jak ho hlásí každý povrch.

Z čeho byla odvozena identita repozitáře, což čtenář potřebuje, aby ji mohl posoudit: identita převzatá z kořenových commitů je fakt o historii, kterou sdílejí dva klony, zatímco deklarovaná je rozhodnutí, které někdo učinil, a jen druhou lze změnit úpravou souboru.

use majordomus_cli::mesh::repository::{declared, of_root_commits, MeshRepositoryBasis};

assert_eq!(declared("majordomus").unwrap().basis, MeshRepositoryBasis::Declared);
assert_eq!(
    of_root_commits(&["a".repeat(40)]).basis,
    MeshRepositoryBasis::RootCommits,
);

Identita repozitáře v meshi, kterou nese každé oznámení, link a událost, spolu s popisem, odkud pochází. detail existuje proto, aby člověk, kterému se řekne, že dva checkouty nejsou týž repozitář, viděl, z čeho byl každý odvozen, místo porovnávání dvou neprůhledných digestů.

use majordomus_cli::mesh::repository::MeshRepositoryIdentity;
use majordomus_cli::mesh::repository::of_root_commits;

let identity: MeshRepositoryIdentity = of_root_commits(&["a".repeat(40)]);
assert_eq!(identity.id.len(), 32, "32 hex characters, on every machine");
assert_eq!(identity.detail, "aaaaaaaaaaaa", "the evidence, short enough to read");

Otevřená žádost o review, stručně: její klíč, co se má posoudit a koho se ptá. V souhrnu jsou uvedeny jen žádosti, na které nikdo neodpověděl.

use majordomus_cli::mesh::page::ReviewBrief;

let brief = ReviewBrief { key: "s/r1".into(), subject: "feature/x".into(), issue: None,
    reviewer: None };
assert!(serde_json::to_value(&brief).unwrap().get("issue").is_none(), "absent, not null");

Jeden runtime, spočtený: jeho živost a tep, jeho relace a claimy podle postavení a jeho nejnovější živý claim. Souhrn je vypisuje, živé runtimy první.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{ClaimMode, EventBody, Journal, SessionInfo, StreamLiveness};
use majordomus_cli::mesh::state::fold;

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
j.append_own(EventBody::SessionOpened { info: SessionInfo::named("s1", "claude-code") })
    .unwrap();
for (claim, path) in [("c1", "apps/a"), ("c2", "apps/b")] {
    j.append_own(EventBody::ClaimAcquired { claim: claim.into(), session: "s1".into(),
        scope: vec![path.into()], intent: Some("work".into()), mode: ClaimMode::Exclusive,
        issue: Some("#1".into()) }).unwrap();
}
j.append_own(EventBody::ClaimReleased { claim: "c1".into() }).unwrap();
let state = fold(&j.events(), &|_| StreamLiveness::Own);
use majordomus_cli::mesh::page::{summarize, RuntimeSummary};

let summary = summarize(&state, &[]);
let runtime: &RuntimeSummary = &summary.runtimes[0];
assert_eq!((runtime.sessions.active, runtime.claims.held, runtime.claims.released), (1, 1, 1));

Relace podle stavu: kolik je aktivních, uzavřených a vypršelých. Počet zůstává stejně velký, kolik relací mesh viděl, a proto souhrn nese počty.

use majordomus_cli::mesh::page::SessionCounts;

let none = SessionCounts::default();
assert_eq!(serde_json::to_value(&none).unwrap(),
    serde_json::json!({ "active": 0, "closed": 0, "expired": 0 }));

Odkud pozorování pochází. Záznam jich shromažďuje víc; provenance je odpovědí na „proč vidím tento uzel“.

Odpověď mesh.state.

Celý mesh tak, jak ho hlásí každý povrch.

Mesh v odpovědi, kterou pracovník čte celou: počty, každý runtime, otevřené recenze a nepřevzaté předávky, každý seznam omezený SUMMARY_LIST se zbytkem započítaným.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{ClaimMode, EventBody, Journal, SessionInfo, StreamLiveness};
use majordomus_cli::mesh::state::fold;

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
j.append_own(EventBody::SessionOpened { info: SessionInfo::named("s1", "claude-code") })
    .unwrap();
for (claim, path) in [("c1", "apps/a"), ("c2", "apps/b")] {
    j.append_own(EventBody::ClaimAcquired { claim: claim.into(), session: "s1".into(),
        scope: vec![path.into()], intent: Some("work".into()), mode: ClaimMode::Exclusive,
        issue: Some("#1".into()) }).unwrap();
}
j.append_own(EventBody::ClaimReleased { claim: "c1".into() }).unwrap();
let state = fold(&j.events(), &|_| StreamLiveness::Own);
use majordomus_cli::mesh::page::{summarize, Summary};

let summary: Summary = summarize(&state, &[]);
assert_eq!((summary.claims.held, summary.claims.released), (1, 1));
assert_eq!(summary.digest, state.digest);

Jedna ověřovací kontrola: co se kontrolovalo, zda to platí, důkazy a — když je něco špatně nebo omezeno — dopad a co s tím dělat.

Dopad a nápravu nese verdikt s sebou, místo aby je nechával na tom, kdo ho vykresluje, takže selhávající kontrola je použitelná, kdekoli se čte — v terminálu, v odpovědi JSON nebo u agenta, který mesh nikdy neviděl. Kontrola, která platí, nenese ani jedno, protože není co dělat.

#### use std::sync::Arc;
#### use majordomus_cli::mesh::config::{CooperationConfig, TrustConfig};
#### use majordomus_cli::mesh::cooperation::{CheckoutFacts, Cooperation, CooperationSetup};
#### use majordomus_cli::mesh::identity::NodeIdentity;
#### use majordomus_cli::mesh::link::HttpTransport;
#### use majordomus_cli::mesh::registry::MeshRegistry;
#### use majordomus_cli::mesh::repository::of_root_commits;
#### let cooperation = Cooperation::new(CooperationSetup {
####     identity: Arc::new(NodeIdentity::ephemeral().unwrap()), runtime: "0000000000000001".into(),
####     repository: of_root_commits(&["root".into()]), endpoints: vec!["127.0.0.1:9".into()],
####     version: "doc".into(), config: CooperationConfig::default(), trust: TrustConfig::default(),
####     journal_path: None, registry: Arc::new(MeshRegistry::new()),
####     transport: Arc::new(HttpTransport), board: None, checkout: CheckoutFacts::default(),
#### }).unwrap();
use majordomus_cli::mesh::cooperation::MeshVerifyCheck;

let report = cooperation.verify();
let first: &MeshVerifyCheck = &report.checks[0];
assert_eq!(first.check, "cooperation");
assert!(first.detail.contains(cooperation.runtime_key()), "the evidence, not a verdict");
assert!(first.remediation.is_none(), "a check that holds asks for nothing");

Co mesh verify zjistil: místní kontroly, kolo každého peera a následný digest stavu. Digest je to, co činí report hodným spuštění na dvou strojích — dva runtimy, které vypíší stejný digest, mají stejné relace, claims, předávky a recenze, a dva, které ne, mají co sladit, ať říkají jejich odkazy cokoli.

ok je konjunkce všeho pod ním, takže volající může jednat podle jednoho pole a člověk může číst zbytek, aby zjistil, která jeho část nebyla pravdivá.

#### use std::sync::Arc;
#### use majordomus_cli::mesh::config::{CooperationConfig, TrustConfig};
#### use majordomus_cli::mesh::cooperation::{CheckoutFacts, Cooperation, CooperationSetup};
#### use majordomus_cli::mesh::identity::NodeIdentity;
#### use majordomus_cli::mesh::link::HttpTransport;
#### use majordomus_cli::mesh::registry::MeshRegistry;
#### use majordomus_cli::mesh::repository::of_root_commits;
#### let cooperation = Cooperation::new(CooperationSetup {
####     identity: Arc::new(NodeIdentity::ephemeral().unwrap()), runtime: "0000000000000001".into(),
####     repository: of_root_commits(&["root".into()]), endpoints: vec!["127.0.0.1:9".into()],
####     version: "doc".into(), config: CooperationConfig::default(), trust: TrustConfig::default(),
####     journal_path: None, registry: Arc::new(MeshRegistry::new()),
####     transport: Arc::new(HttpTransport), board: None, checkout: CheckoutFacts::default(),
#### }).unwrap();
use majordomus_cli::mesh::cooperation::MeshVerifyReport;

let report: MeshVerifyReport = cooperation.verify();
assert_eq!(report.runtime.as_deref(), Some(cooperation.runtime_key()));
assert_eq!(report.digest, Some(cooperation.state().digest), "what a peer is compared to");
assert_eq!(report.ok, report.checks.iter().all(|c| c.ok), "one field for every check");

Kolik nese odpověď o meshi. Souhrn je výchozí, protože je to odpověď, kterou pracovník přečte celou bez ohledu na historii meshe; plný fold je o jedno slovo dál, když čtenář potřebuje každý záznam.

use majordomus_cli::mesh::page::View;

assert_eq!(View::default(), View::Summary);
assert_eq!(serde_json::to_value(View::Full).unwrap(), "full");

Stabilní identita uzlu: 32 hex znaků SHA-256 jeho veřejného klíče Ed25519. Odvozená, nikdy volená: dva uzly s jedním id drží jeden klíč.

Odpověď mesh.nodes: každý uzel, který tento proces pozoroval.

Jeden objevený uzel: kanonický záznam, který promítá každý povrch.

Odpověď mesh.peer.

Odpověď mesh.peers: stroj → runtime → relace → nárok, každá úroveň z jednoho žurnálu a jedné tabulky spojení.

Co řekl jeden kolo synchronizace, spuštěné teď a ne vzpomenuté, o jednom peeru. Ověření nehlásí stav spojení a nekončí tím: vymění si data s peerem a řekne, zda výměna fungovala a zda obě strany skončily se stejnými značkami, což je rozdíl mezi peerem, který odpovídá, a peerem, který souhlasí.

round_trip a converged jsou volitelné, protože peer, kterého tento runtime nevolá, se neptá — chybějící odpověď není selhání a hlásit tam false by způsobilo, že spojení jen pro příchozí vypadá pokaždé rozbité.

#### use std::collections::BTreeMap;
#### use std::sync::{Arc, Mutex, Weak};
#### use majordomus_cli::mesh::config::{CooperationConfig, TrustConfig};
#### use majordomus_cli::mesh::cooperation::*;
#### use majordomus_cli::mesh::identity::NodeIdentity;
#### use majordomus_cli::mesh::link::{LinkReply, LinkTransport, Signed, HELLO_PATH};
#### use majordomus_cli::mesh::registry::MeshRegistry;
#### use majordomus_cli::mesh::repository::{of_root_commits, runtime_id};
#### use majordomus_cli::mesh::trust::TrustPolicy;
#### #[derive(Default)] struct Net(Mutex<BTreeMap<String, Weak<Cooperation>>>);
#### impl LinkTransport for Net {
####   fn post(&self, e: &str, p: &str, m: &Signed) -> Result<LinkReply, String> {
####     let peer = (self.0.lock().unwrap().get(e).and_then(Weak::upgrade))
####         .ok_or_else(|| format!("{e}: nobody there"))?;
####     Ok(if p == HELLO_PATH { peer.accept_hello(m) } else { peer.accept_sync(m) }) } }
#### let net = Arc::new(Net::default());
#### let runtime = |endpoint: &str| { let c = Cooperation::new(CooperationSetup {
####     identity: Arc::new(NodeIdentity::ephemeral().unwrap()), runtime: runtime_id(endpoint),
####     repository: of_root_commits(&["root".into()]), endpoints: vec![endpoint.into()],
####     version: "doc".into(), config: CooperationConfig::default(),
####     trust: TrustConfig { policy: TrustPolicy::Tofu, allow: vec![] }, journal_path: None,
####     registry: Arc::new(MeshRegistry::new()),
####     transport: Arc::clone(&net) as Arc<dyn LinkTransport>, board: None,
####     checkout: CheckoutFacts::default() }).unwrap();
####   net.0.lock().unwrap().insert(endpoint.into(), Arc::downgrade(&c)); c };
#### let (a, b) = (runtime("a:1"), runtime("b:1"));
a.dial(&["b:1".into()]).unwrap();

let dialer: &PeerVerdict = &a.verify().peers[0];
assert_eq!(dialer.round_trip, Some(true), "asked, and answered");

let answerer = &b.verify().peers[0];
assert!(!answerer.dialed, "B does not dial A, so B asks nothing of it");
assert_eq!(answerer.round_trip, None, "and reports no verdict it did not earn");

Jeden peer tak, jak ho ukazuje každý povrch: kdo to je, jak ho tento runtime oslovuje a čím si spojení prošlo. Čítače se nesou na peera, nejen v součtech, protože otázka, kterou si člověk u kolísajícího meshe klade, je, který peer kolísá, a restarts odpovídá na jinou než reconnects — peer, jehož proces stále umírá, proti spojení, které stále padá pod procesem, který nikdy nespadl.

#### use std::collections::BTreeMap;
#### use std::sync::{Arc, Mutex, Weak};
#### use majordomus_cli::mesh::config::{CooperationConfig, TrustConfig};
#### use majordomus_cli::mesh::cooperation::*;
#### use majordomus_cli::mesh::identity::NodeIdentity;
#### use majordomus_cli::mesh::link::{LinkReply, LinkTransport, Signed, HELLO_PATH};
#### use majordomus_cli::mesh::registry::MeshRegistry;
#### use majordomus_cli::mesh::repository::{of_root_commits, runtime_id};
#### use majordomus_cli::mesh::trust::TrustPolicy;
#### #[derive(Default)] struct Net(Mutex<BTreeMap<String, Weak<Cooperation>>>);
#### impl LinkTransport for Net {
####   fn post(&self, e: &str, p: &str, m: &Signed) -> Result<LinkReply, String> {
####     let peer = (self.0.lock().unwrap().get(e).and_then(Weak::upgrade))
####         .ok_or_else(|| format!("{e}: nobody there"))?;
####     Ok(if p == HELLO_PATH { peer.accept_hello(m) } else { peer.accept_sync(m) }) } }
#### let net = Arc::new(Net::default());
#### let runtime = |endpoint: &str| { let c = Cooperation::new(CooperationSetup {
####     identity: Arc::new(NodeIdentity::ephemeral().unwrap()), runtime: runtime_id(endpoint),
####     repository: of_root_commits(&["root".into()]), endpoints: vec![endpoint.into()],
####     version: "doc".into(), config: CooperationConfig::default(),
####     trust: TrustConfig { policy: TrustPolicy::Tofu, allow: vec![] }, journal_path: None,
####     registry: Arc::new(MeshRegistry::new()),
####     transport: Arc::clone(&net) as Arc<dyn LinkTransport>, board: None,
####     checkout: CheckoutFacts::default() }).unwrap();
####   net.0.lock().unwrap().insert(endpoint.into(), Arc::downgrade(&c)); c };
#### let (a, b) = (runtime("a:1"), runtime("b:1"));
a.dial(&["b:1".into()]).unwrap();

let peer: &PeerView = &a.peers()[0];
assert_eq!(peer.runtime, b.runtime_key(), "the durable identity, not the endpoint");
assert!(peer.outbound, "this runtime dials it");
assert_eq!(peer.handshakes, 1);
assert_eq!(peer.restarts, 0, "the peer's process has not died under the link");

Zda uzel nyní odpovídá, podle svých vlastních oznámení.

Transportní protokol pravidla: objevování jsou datagramy, registrace a linkový protokol jsou spojení. Serializováno jako slovo, které bere front firewallu.

use majordomus_cli::mesh::firewall::Protocol;

assert_eq!(serde_json::to_value(Protocol::Udp).unwrap(), "udp");
assert_eq!(serde_json::to_value(Protocol::Tcp).unwrap(), "tcp");

Stav jednoho poskytovatele: stav, proč a jeho čítače.

Co smí o tomto uzlu vědět každý: id, veřejný klíč, zobrazované jméno a instance tohoto běhu. Vše, co inzerát nese; nic, co podepisuje.

Proč byla zpráva spojení odmítnuta. Každé odmítnutí je typované, spočítané a zobrazené: mesh, který peera odmítne, říká, které pravidlo to udělalo, místo aby zahodil socket.

Kódy jsou diagnóza, kterou člověk potřebuje, když se dva runtimy nepropojí, a jsou záměrně různé tam, kde se nápravy liší: Untrusted je klíč k přidání, RepositoryMismatch jsou dva různé repozitáře, SelfLink je konfigurace, která volá vlastní endpoint, a UnknownLink není vůbec selhání, ale pokyn pozdravit znovu.

use majordomus_cli::mesh::link::RefusalCode;

// the wire word is the code's identity across surfaces, and it is stable
assert_eq!(RefusalCode::RepositoryMismatch.as_str(), "repository_mismatch");
assert_eq!(
    serde_json::to_value(RefusalCode::Untrusted).unwrap(),
    serde_json::json!("untrusted"),
);
assert_ne!(RefusalCode::Untrusted, RefusalCode::RepositoryMismatch);

Odmítnuté datagramy podle důvodu. Diagnóza nepřátelské nebo špatně nakonfigurované sítě: mesh, který slyší nesmysly, to říká s čísly, místo aby byl tiše prázdný.

Kandidát, který byl odmítnut, s pravidlem, které jej odmítlo. Odmítnutí se uchovává a zobrazuje, ne logovat a zahodit, protože nejčastějším selháním meshe je spojení, které se nikdy nevytvoří: osoba, která deklarovala seed a nevidí žádného peera, potřebuje rozhodnutí, které o něm padlo — špatný repozitář, klíč, který nikdo nepovolil, příliš velká odchylka hodin — a směr říká, která strana je učinila.

#### use std::collections::BTreeMap;
#### use std::sync::{Arc, Mutex, Weak};
#### use majordomus_cli::mesh::config::{CooperationConfig, TrustConfig};
#### use majordomus_cli::mesh::cooperation::*;
#### use majordomus_cli::mesh::identity::NodeIdentity;
#### use majordomus_cli::mesh::link::{LinkReply, LinkTransport, RefusalCode, Signed, HELLO_PATH};
#### use majordomus_cli::mesh::registry::MeshRegistry;
#### use majordomus_cli::mesh::repository::{of_root_commits, runtime_id};
#### use majordomus_cli::mesh::trust::TrustPolicy;
#### #[derive(Default)] struct Net(Mutex<BTreeMap<String, Weak<Cooperation>>>);
#### impl LinkTransport for Net {
####   fn post(&self, e: &str, p: &str, m: &Signed) -> Result<LinkReply, String> {
####     let peer = (self.0.lock().unwrap().get(e).and_then(Weak::upgrade))
####         .ok_or_else(|| format!("{e}: nobody there"))?;
####     Ok(if p == HELLO_PATH { peer.accept_hello(m) } else { peer.accept_sync(m) }) } }
#### let net = Arc::new(Net::default());
#### let runtime = |endpoint: &str, policy: TrustPolicy| {
####   let c = Cooperation::new(CooperationSetup {
####     identity: Arc::new(NodeIdentity::ephemeral().unwrap()), runtime: runtime_id(endpoint),
####     repository: of_root_commits(&["root".into()]), endpoints: vec![endpoint.into()],
####     version: "doc".into(), config: CooperationConfig::default(),
####     trust: TrustConfig { policy, allow: vec![] }, journal_path: None,
####     registry: Arc::new(MeshRegistry::new()),
####     transport: Arc::clone(&net) as Arc<dyn LinkTransport>, board: None,
####     checkout: CheckoutFacts::default() }).unwrap();
####   net.0.lock().unwrap().insert(endpoint.into(), Arc::downgrade(&c)); c };
#### let a = runtime("a:1", TrustPolicy::Tofu);
#### let strict = runtime("s:1", TrustPolicy::DenyUnknown);
a.dial(&["s:1".into()]).expect_err("reachable, and not trusted");

let refused: &RefusedView = &strict.status().refused[0];
assert_eq!(refused.refusal.code, RefusalCode::Untrusted);
assert_eq!(refused.direction, "inbound", "this runtime refused the hello");
assert_eq!(refused.runtime.as_deref(), Some(a.runtime_key()));

Co odpovídá registrace: zda byla obálka přijata a kandidáty, které rendezvous drží. Definováno zde vedle klienta; schopnost to znovu exportuje.

Vstup mesh.register: jedna podepsaná obálka přesně tak, jak ji nese drát.

Vstup mesh.release.

Jedna odpověď na žádost o review: kdo odpověděl, jak rozhodl a proč. Verdikt je jedno ze tří deklarovaných slov, takže žadatel podle něj může jednat, aniž by četl poznámku; poznámka je místo pro zdůvodnění a je volitelná, protože „schváleno“ ji často nepotřebuje.

use majordomus_cli::mesh::state::ReviewAnswer;

let answer = ReviewAnswer {
    session: "a1b2c3d4-r1-0f/s2".into(),
    verdict: "changes_requested".into(),
    note: Some("the fold is not deterministic".into()),
};
assert_eq!(answer.verdict, "changes_requested");

// the note is omitted rather than carried empty when there is nothing to say
let bare = ReviewAnswer { note: None, ..answer };
let value = serde_json::to_value(&bare).unwrap();
assert!(value.get("note").is_none());

Vstup mesh.review.answer.

Vstup mesh.review.request.

Stav žádosti o posouzení: zda na ni už někdo odpověděl. Záměrně tu není Approved ani Rejected — na žádost může odpovědět několik runtime a verdikty jsou vlastní odpovědi, takže jejich sloučení do jednoho stavu by zahodilo neshodu, kvůli které stojí za to ptát se druhého posuzovatele.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{EventBody, Journal, StreamLiveness};
use majordomus_cli::mesh::state::{fold, ReviewState};

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
j.append_own(EventBody::ReviewRequested { review: "r1".into(), session: "s1".into(),
    subject: "feature/x".into(), scope: vec![], issue: None, reviewer: None, body: None }).unwrap();
let asked = fold(&j.events(), &|_| StreamLiveness::Own);
assert_eq!(asked.reviews[0].state, ReviewState::Open);

let request = asked.reviews[0].key.clone();
j.append_own(EventBody::ReviewAnswered { request, session: "s2".into(),
    verdict: "approved".into(), note: None }).unwrap();
assert_eq!(fold(&j.events(), &|_| StreamLiveness::Own).reviews[0].state, ReviewState::Answered);

Jedna žádost o review kdekoli v meshi se všemi odpověďmi, které vyvolala. Žádost bez reviewer je nabídka celému meshi, nikoli nikomu, proto jsou odpovědi seznam: přidat ji může kterýkoli propojený runtime s funkcí reviews a jsou uloženy v Lamportově pořadí, aby je každý runtime četl ve stejné posloupnosti.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{EventBody, Journal, StreamLiveness};
use majordomus_cli::mesh::state::{fold, ReviewView};

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
j.append_own(EventBody::ReviewRequested { review: "r1".into(), session: "s1".into(),
    subject: "feature/mesh-cooperation".into(), scope: vec!["src/mesh".into()],
    issue: Some("#184".into()), reviewer: None, body: None }).unwrap();
let request = fold(&j.events(), &|_| StreamLiveness::Own).reviews[0].key.clone();
j.append_own(EventBody::ReviewAnswered { request, session: "s2".into(),
    verdict: "approved".into(), note: Some("reads well".into()) }).unwrap();

let state = fold(&j.events(), &|_| StreamLiveness::Own);
let review: &ReviewView = &state.reviews[0];
assert_eq!(review.subject, "feature/mesh-cooperation");
assert_eq!(review.reviewer, None, "offered to the mesh, not addressed");
assert_eq!(review.answers[0].verdict, "approved");

Vstup mesh.review.withdraw.

Proč pravidlo existuje: která část deklarace jej implikovala. Role je to, co člověk čte vedle pravidla a co jmenuje verdikt, a serializuje se v snake case.

use majordomus_cli::mesh::firewall::Role;

assert_eq!(serde_json::to_value(Role::Hub).unwrap(), "hub");
let back: Role = serde_json::from_value(serde_json::json!("multicast")).unwrap();
assert_eq!(back, Role::Multicast);

Jeden runtime ve stromě peerů.

Vstup mesh.session.close.

Co relace o sobě sděluje meshi. Každé pole je veřejný fakt o rozpracované práci; žádné není cestou na disku autora, tajemstvím ani přihlašovacím údajem.

Téměř vše zde je volitelné a to je návrh: relace říká, co ví, a pole, které vynechá, se vynechá, ne nese prázdné, takže čtenář odliší „žádná úloha“ od „úloha, která se nejmenuje nijak“. Opětovné otevření téhož id relace tento záznam nahradí, a tak relace, která svou větev zjistí později, informuje mesh.

use majordomus_cli::mesh::journal::SessionInfo;

let mut info = SessionInfo::named("s1", "claude-code");
assert_eq!(info.task, None);
assert!(serde_json::to_value(&info).unwrap().get("task").is_none(), "unsaid, not empty");

info.branch = Some("feature/mesh-cooperation".into());
assert_eq!(serde_json::to_value(&info).unwrap()["branch"], "feature/mesh-cooperation");

Vstup mesh.session.open: co relace říká sama o sobě.

Jedna relace ve stromu peerů.

Postavení relace, jak ho čte každý runtime meshe. Důležitý je rozdíl mezi Closed a Expired: první je relace, která řekla, že skončila, druhá taková, jejíž runtime přestal tepat a už nemůže říct nic. Obě ukončují nároky relace, ale jen druhá je stroj, od kterého by nikdo neměl čekat odpověď.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{EventBody, Journal, SessionInfo, StreamLiveness};
use majordomus_cli::mesh::state::{fold, SessionState};

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
j.append_own(EventBody::SessionOpened { info: SessionInfo::named("s1", "cli") }).unwrap();
assert_eq!(fold(&j.events(), &|_| StreamLiveness::Own).sessions[0].state, SessionState::Active);

// the same events, read on a runtime that no longer hears the writer
let gone = fold(&j.events(), &|_| StreamLiveness::Expired);
assert_eq!(gone.sessions[0].state, SessionState::Expired);

Jedna relace kdekoli v meshi, jak ji vidí fold: co o sobě relace řekla, odkud píše a zda se stále počítá. Klíčem je <stream>/<session>, nikoli vlastní id relace, protože dva runtimy mohou obě relace nazvat s1 a mesh je musí udržet odděleně.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{EventBody, Journal, SessionInfo, StreamLiveness};
use majordomus_cli::mesh::state::{fold, SessionView};

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
j.append_own(EventBody::SessionOpened { info: SessionInfo::named("s1", "claude-code") })
    .unwrap();

let state = fold(&j.events(), &|_| StreamLiveness::Own);
let view: &SessionView = &state.sessions[0];
assert!(view.key.ends_with("/s1"), "qualified by the stream that wrote it: {}", view.key);
assert_eq!(view.info.client, "claude-code");
assert_eq!(view.runtime, view.stream.runtime_key());

Jedna položka provenance: zdroj a odkud pozorování fyzicky pochází.

Podepsaná zpráva: tělo JSON a podpis Ed25519 nad jeho kanonickými bajty pod doménou zprávy. Tělo zůstává JSON, aby pole, která přidá novější peer, přežila zdejší ověření beze změny.

Uchování těla jako JSON, a ne jako bajtů, které byly podepsány, činí protokol rozšiřitelným: pole, které přidal novější peer, projde ověřením nedotčené, protože podpis se kontroluje nad kanonickou podobou všeho, co tam je, a ne nad tvarem, který tato verze zná.

use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::link::{sign, verify_signed, Domain, Signed};

let node = NodeIdentity::ephemeral().unwrap();
let signed: Signed = sign(&node, Domain::SyncRequest, serde_json::json!({ "b": 2, "a": 1 }));
assert_eq!(signed.sig.len(), 128, "hex Ed25519");

// key order is not content, so a round trip through JSON still verifies
let wire = serde_json::to_string(&signed).unwrap();
let back: Signed = serde_json::from_str(&wire).unwrap();
assert!(verify_signed(&node.public.public_key, Domain::SyncRequest, &back));

Jeden proud: běh jednoho runtimu jednoho uzlu. <node 32 hex>-<runtime 16 hex>-<instance 16 hex>. Uzel je klíč stroje, runtime je server jednoho checkoutu na tom stroji, instance je jeden běh procesu tohoto serveru — takže dva worktrees na jednom stroji jsou dva proudy a restart je nový proud téhož runtimu.

Číslování událostí uvnitř streamu místo globálně činí replikaci levnou a jednoznačnou: mezera v jednom streamu je viditelná bez koordinace s kýmkoli a (stream, seq) identifikuje událost na každém stroji, který ji drží.

use majordomus_cli::mesh::journal::StreamId;

let id = StreamId::new(&"a".repeat(32), &"b".repeat(16), &"c".repeat(16)).unwrap();
assert_eq!(id.node(), "a".repeat(32));
assert_eq!(id.runtime(), "b".repeat(16));

// a restart is a new stream, and the same runtime
let after = StreamId::new(&"a".repeat(32), &"b".repeat(16), &"d".repeat(16)).unwrap();
assert_ne!(after, id);
assert_eq!(after.runtime_key(), id.runtime_key());

Zda proud právě mluví, podle hodin tohoto runtime. Je to verdikt o proudu, ne o spojení: runtime dosažitelný jen přes relay žije a runtime, který spadl, přestane tepat pro všechny najednou. Own se drží stranou od Live, protože vlastní proud runtime nepotřebuje důkaz — je to ta věc, která tepe.

use majordomus_cli::mesh::journal::StreamLiveness;

assert!(StreamLiveness::Own.is_alive() && StreamLiveness::Live.is_alive());
assert!(!StreamLiveness::Expired.is_alive());
assert_eq!(
    serde_json::to_value(StreamLiveness::Expired).unwrap(),
    serde_json::json!("expired"),
);

Živost jednoho proudu.

Součty registru pro stav a zdraví.

O čem politika rozhodla u jednoho uzlu.

Co operace zapsala, jako její odpověď volajícímu. Každá operace mesh je událost připojená do žurnálu tohoto runtime a volající dostane tři fakta, která si sám nezjistí: klíč vytvořené věci platný v celém mesh, událost, která to oznamuje, a Lamportovo razítko, které ji řadí vůči událostem všech ostatních.

Klíč je to, čím se adresuje pozdější operace — claim se uvolňuje klíčem, který vrátilo jeho získání, nikdy lokálním jménem, které dostal — a razítko je to, s čím porovnává volající, který čeká, až peer dožene stav.

#### use std::sync::Arc;
#### use majordomus_cli::mesh::config::{CooperationConfig, TrustConfig};
#### use majordomus_cli::mesh::cooperation::{CheckoutFacts, Cooperation, CooperationSetup};
#### use majordomus_cli::mesh::identity::NodeIdentity;
#### use majordomus_cli::mesh::link::HttpTransport;
#### use majordomus_cli::mesh::registry::MeshRegistry;
#### use majordomus_cli::mesh::repository::of_root_commits;
#### let cooperation = Cooperation::new(CooperationSetup {
####     identity: Arc::new(NodeIdentity::ephemeral().unwrap()), runtime: "0000000000000001".into(),
####     repository: of_root_commits(&["root".into()]), endpoints: vec!["127.0.0.1:9".into()],
####     version: "doc".into(), config: CooperationConfig::default(), trust: TrustConfig::default(),
####     journal_path: None, registry: Arc::new(MeshRegistry::new()),
####     transport: Arc::new(HttpTransport), board: None, checkout: CheckoutFacts::default(),
#### }).unwrap();
use majordomus_cli::mesh::cooperation::Written;
use majordomus_cli::mesh::journal::{ClaimMode, Durability, SessionInfo};

let session = SessionInfo::named("s1", "cli");
let written: Written = cooperation
    .claim(&session, vec!["docs".into()], None, ClaimMode::Advisory, None)
    .unwrap();
assert!(written.lamport > 0, "placed against every other runtime's events");
assert_eq!(written.durability, Durability::Memory, "this journal has no file");

// and the key it returned is how the claim is addressed from here on
cooperation.release(&written.key).unwrap();