HTTP API: sdílené typy

Aktivní úloha tohoto checkoutu, pokud nějaká je.

Kdy byl přečten stav za odpovědí: kontrakt čerstvosti odpovědi schopnosti.

Deklarováno jednou a neseno ve výstupním typu každé odpovědi, která je obrazem stavu, takže výstupní schéma, OpenAPI, schémata nástrojů MCP i JSON příkazové řádky ho nesou bez vlastního přenosu. Nastavuje se tam, kde se stav čte — build indexu, čtení gitu — nikdy executorem, který ví, kdy handler běžel, ne kdy byl pořízen stav, který četl.

use std::time::{Duration, UNIX_EPOCH};
use majordomus_cli::index::AnswerObservation;
let at = UNIX_EPOCH + Duration::from_secs(1_788_000_000);
let o = AnswerObservation::taken("git read", at, Some(Duration::from_secs(120)));
assert_eq!(o.observed_at, "2026-08-29T10:40:00Z");
assert_eq!(o.stale_after.as_deref(), Some("2026-08-29T10:42:00Z"));
assert!(!o.is_stale_at(at + Duration::from_secs(120)));
assert!(o.is_stale_at(at + Duration::from_secs(121)));

Stabilní, globálně smysluplná identita: jmenný prostor, tečka a lokální část. repository.info a objects.get pro programy; <kind>.<identity> pro deklarativní objekt (rule.majordomus.scope-integrity@1, document.docs/CLI.md, policy..ai/repo/policy.yaml).

Gramatika: jmenný prostor odpovídá [a-z][a-z0-9_-]*; lokální část je neprázdná a neobsahuje bílý znak ani řídicí znak, jakýkoli jiný Unicode ano, protože je neprůhledná: cesta, verzovaná identita nebo jméno, jak ji vytvořilo pravidlo identity druhu.

Čím schopnost je. Existují tři druhy, protože existují tři sémantiky: něco, co se provede a nic nemění, něco, co se provede a mění paměť vlastního procesu, a něco, co se čte. Příkaz může také zapisovat vlastní sledované záznamy repozitáře, což jeho druh neříká a jeho politika provádění ano (ExecutionPolicy::writes_repository).

Jak dlouho volání trvá, není druh. Čtení, které prochází každý soubor vrstvy, je stále čtení, a to, co jej činí hodným sledování — že hlásí průběh a zastaví se, když je o to požádáno — je jedna vlastnost jeho handleru, deklarovaná pomocí crate::capability::Executable::cancellable a nesená na ExecutionPolicy.

Odkud schopnost pochází. Nikdy absolutní cesta.

Které checkouty zahrnuje čtení stavu serveru.

Obě odpovědi stojí různě a to je celý důvod, proč volba existuje: checkouty repozitáře se čtou z registru gitu a každý stojí čtení leasu a sondu, kdežto samotný tento checkout stojí po jednom a nic nevyčísluje. Slovo, na které se každá varianta serializuje, je slovo, které přijímá parametr dotazu, vstup nástroje i příznak příkazové řádky.

use majordomus_cli::capability::builtin::server::Checkouts;
assert_eq!(serde_json::to_value(Checkouts::This).unwrap(), "this");
assert_eq!(serde_json::to_value(Checkouts::Repository).unwrap(), "repository");
assert_eq!(Checkouts::default(), Checkouts::Repository, "the wide answer is what a caller who says nothing has always got");

Jak dobře je kritérium neseno plánem: zda pro ně existuje práce, zda je tato práce hlídána důkazy a zda zaznamenaná mezera už viděla, že je pravdivé.

use majordomus_cli::intent_plan::CoverageStrength;
// the wire spelling every surface answers with
assert_eq!(serde_json::to_string(&CoverageStrength::Weak).unwrap(), "\"weak\"");
// the order is the one a reader ranks by: uncovered is the worst
assert!(CoverageStrength::Uncovered < CoverageStrength::Covered);

Jeden úkol, jak jej vidí pokrytí: který milník jej nese, jaký stav pro něj plán odvodil a kolik důkazů dluží, než smí být DONE.

use majordomus_cli::intent_plan::CoveringIssue;
let issue = CoveringIssue {
    id: "I1901".into(),
    milestone: "intent-planning".into(),
    status: "READY".into(),
    evidence_need: 2,
};
// an issue that owes no evidence covers a criterion only weakly
assert!(issue.evidence_need > 0);

Jedno kritérium jednoho záměru a práce, která je nese: živé úkoly, které mu slouží, milníky, pod nimiž ty úkoly leží, a síla z nich odvozená.

use majordomus_cli::intent_plan::{CoverageStrength, CriterionCoverage};
let c = CriterionCoverage {
    intent: "intent-planning".into(),
    criterion: "gap-is-recorded".into(),
    strength: CoverageStrength::Uncovered,
    issues: vec![],
    milestones: vec![],
};
// nothing serves it, so nothing in the plan will make it true
assert_eq!(c.strength, CoverageStrength::Uncovered);
assert!(c.issues.is_empty());

Jedno zjištění o deklarativním stavu, pojmenované stabilním kódem, vázané na cestu, pokud existuje, a nesoucí příkaz, který ho reprodukuje, pokud existuje.

Kolik commitů má jedna ref, které druhá nemá.

use majordomus_cli::worktree::trunk::Distance;
let d = Distance { behind: 779, ahead: 0 };
assert_eq!(serde_json::to_value(d).unwrap(), serde_json::json!({"behind": 779, "ahead": 0}));

Jak daleko je zaznamenaný commit záznamu od commitu, na kterém je tento checkout.

Čtyři slova jsou záměrně slova shellového nástroje. Čtenář, který by narazil na advanced z jedné plochy a stale z jiné, by se tytéž čtyři fakty musel učit dvakrát.

Tělo každé chybové odpovědi.

Co se pokazilo, jak to jmenuje projekce HTTP.

Jeden zaznamenaný běh jednoho testu: vše, co si toto úložiště o něm trvale pamatuje.

Každé pole je původ. Výsledek bez commitu je anonymní zelená, což je věc, z níž se odznak nikdy nesmí odvozovat.

use majordomus_cli::evidence::{digest_of, Execution, Origin, Outcome, Runner, TestId};

let id = TestId::of("apps/majordomus-cli/tests/why.rs").unwrap();
let run = Execution {
    test: id.as_string(),
    runner: Runner::Crate,
    source: id.source(),
    outcome: Outcome::Pass,
    seconds: 12,
    commit: "0".repeat(40),
    working_tree: "clean".into(),
    digest: digest_of(b"fn main() {}"),
    at: "2026-09-11T00:00:00Z".into(),
    origin: Origin::Ci,
    command: id.reproduce(),
    run: None,
};

// it is a value in a tracked JSON file, so it has to survive the file unchanged
let back: Execution = serde_json::from_str(&serde_json::to_string(&run).unwrap()).unwrap();
assert_eq!(back, run);
assert_eq!(back.test, "crate:why");
assert_eq!(back.command, "cargo test --test why");

Příklad

Jeden zaznamenaný běh s provenancí, kterou runner nenesl: který commit, jaký stav stromu, digest vlastního zdroje testu, kdy a jak jej spustit znovu.

use majordomus_cli::evidence::{Execution, Origin, Outcome, Runner};
let e = Execution {
    test: "suite:07_scope".into(),
    runner: Runner::Suite,
    source: "test/cases/07_scope.sh".into(),
    outcome: Outcome::Pass,
    seconds: 3,
    commit: "a04b65c9".into(),
    working_tree: "clean".into(),
    digest: "sha256:00".into(),
    at: "2026-09-11T00:00:00Z".into(),
    origin: Origin::Local,
    command: "bash test/run.sh 07_scope".into(),
    run: None,
};
assert!(e.outcome.proves());

Kde běh proběhl. Kanonický model je neutrální vůči providerům: adaptér CI zaznamenává Ci a nic zde neví ani nezajímá, o jaké CI šlo.

use majordomus_cli::evidence::Origin;

assert_eq!(Origin::parse("CI"), Some(Origin::Ci));
assert_eq!(Origin::parse("local"), Some(Origin::Local));
// naming the provider is the adapter's business; the ledger records the kind of run,
// so a repository that changes CI does not change what its old evidence says
assert!(Origin::parse("github-actions").is_none());

Příklad

use majordomus_cli::evidence::Origin;
assert_eq!(Origin::parse("ci"), Some(Origin::Ci));
assert_eq!(Origin::parse("nowhere"), None);

Co běh řekl o jednom testu.

NotRun záměrně chybí: je to absence provedení, ne výsledek, který nějaké mělo. Zakódovat je zde by umožnilo zapisovateli zapsat „tohle neběželo“ a nechat to započítat mezi to, co běželo.

use majordomus_cli::evidence::Outcome;

assert!(Outcome::parse("ok").proves());
assert!(!Outcome::parse("timeout").proves());
// exactly one of the five is evidence of anything; the other four are reasons there
// is none, kept apart because "it declined" and "the harness broke" are different bugs
assert_eq!(Outcome::parse("skipped"), Outcome::Skip);
assert_eq!(Outcome::parse("nonsense"), Outcome::Error);

Příklad

use majordomus_cli::evidence::Outcome;
assert!(Outcome::parse("ok").proves());
assert_eq!(Outcome::parse("wat"), Outcome::Error);

Běh kontinuální integrace, v němž bylo provedení zaznamenáno: dost na to, aby se šlo vrátit k běhu, který ho vytvořil.

Origin říká, o jaký druh běhu šlo, a záměrně nejmenuje žádného poskytovatele. Toto jmenuje jeden konkrétní běh slovy, jimiž ho poskytovatel oslovoval v okamžiku, kdy proběhl — jeho identifikátor, pokus, workflow a job a adresa, kterou čtenář následuje — protože odkaz sestavený později ze šablony by vedl tam, kam se vyvinula představa šablony o poskytovateli. Konstruuje ho jen adaptér; nic v modelu nečte jméno poskytovatele.

use majordomus_cli::evidence::RunRef;

let actions = |k: &str| {
    let v = match k {
        "GITHUB_ACTIONS" => "true",
        "GITHUB_SERVER_URL" => "https://github.com",
        "GITHUB_REPOSITORY" => "owner/repo",
        "GITHUB_RUN_ID" => "42",
        "GITHUB_RUN_ATTEMPT" => "2",
        "GITHUB_WORKFLOW" => "validate",
        "GITHUB_JOB" => "evidence",
        _ => return None,
    };
    Some(v.to_string())
};
let run = RunRef::from_env(actions).unwrap();
assert_eq!(run.id, "42");
assert_eq!(run.attempt, 2);
assert_eq!(run.url, "https://github.com/owner/repo/actions/runs/42/attempts/2");
// a run that names neither its pull request's head nor its event still names itself
assert_eq!((run.head_sha, run.event), (None, None));

let head = "0123456789abcdef0123456789abcdef01234567";
let pull = |k: &str| match k {
    "MJ_RUN_HEAD_SHA" => Some(head.to_string()),
    "GITHUB_EVENT_NAME" => Some("pull_request".to_string()),
    _ => actions(k),
};
let run = RunRef::from_env(pull).unwrap();
assert_eq!(run.head_sha.as_deref(), Some(head));
assert_eq!(run.event.as_deref(), Some("pull_request"));

// outside a run there is nothing to name, and a half-described run is not a run
assert!(RunRef::from_env(|_| None).is_none());
assert!(RunRef::from_env(|k| (k == "GITHUB_ACTIONS").then(|| "true".to_string())).is_none());

Který runner výsledek vytvořil, a tedy jak se test jmenuje a znovu spouští.

Repozitář má dnes přesně dva, které tvrzení může jmenovat. Třetí by byl variantou zde a větví v TestId::of; tvrzení jmenující něco, co žádný runner nevytváří, se hlásí jako ProofState::Unrunnable, místo aby se tiše počítalo jako pokryté.

use majordomus_cli::evidence::{Runner, TestId};

// which runner owns a test is read off where the test lives, never declared
assert_eq!(TestId::of("test/cases/07_scope.sh").unwrap().runner, Runner::Suite);
assert_eq!(
    TestId::of("apps/majordomus-cli/tests/why.rs").unwrap().runner,
    Runner::Crate
);
// and a path under neither directory belongs to no runner at all
assert!(TestId::of("test/lib.sh").is_none());

Příklad

use majordomus_cli::evidence::Runner;
assert_eq!(Runner::Suite.prefix(), "suite");
assert_eq!(Runner::Crate.prefix(), "crate");

Co spuštění schopnosti mění mimo volajícího.

Klasifikováno, nikdy deklarováno: vyplývá z druhu, což je pole, které deklarace už nese. Projekce to čte, aby rozhodla, zda se zeptat před spuštěním něčeho — potvrzení Cockpitu se z toho odvozuje — místo jmenování schopností, se kterými musí zacházet opatrně, což je seznam, který zastará den po napsání.

Jak starý je záznam, posuzováno vůči session.freshness v politice.

Toto je druhý ze dvou nezávislých úsudků, které nese každý záznam, a existuje proto, že první na tuto otázku odpovědět nemůže. Divergence říká, kde commit záznamu leží vzhledem k HEAD; advanced znamená, že tento commit je předkem aktuálního, což zní jako shoda a platí stejně v den zápisu záznamu i o měsíc později. Mezi 2026-09-05 a 2026-09-11 tento repozitář servíroval předávku, která byla advanced a šest dní mrtvá, a každý povrch, který tento model četl — MCP, HTTP API, Cockpit — prezentoval její Next Action jako to, co udělat (ADR 0052).

Prahové hodnoty jsou politika a čtou se, nikdy se zde nezopakují: konstanta v tomto souboru by byla druhým zdrojem pravdy pro číslo, které vlastní politika, a repozitář, jehož politika předchází klíči, je hlášen jako Freshness::Unknown s názvem chybějícího klíče, místo aby byl posuzován vůči výchozí hodnotě, kterou nikdo nedeklaroval.

Těch pět slov se dělí do dvou skupin a toto dělení je to, podle čeho volající jedná: fresh a aging jsou aktuální a lze je předložit jako instrukci, stale a invalid je nutné ukázat jako historii a unknown není ani jedno — záznam, který nelze datovat, není tím ještě starý záznam, a zacházet s ním tak by tiše zahodilo naprosto dobrý briefing. Freshness::history je toto dělení a je to jediné místo, kde se rozhoduje.

use majordomus_cli::capability::builtin::continuity::Freshness;

// the two renderings are one value: the serialised word is the word `as_str` gives,
// so a reader who met `stale` from MCP and from the command line met one fact
let stale = serde_json::to_value(Freshness::Stale).unwrap();
assert_eq!(stale, serde_json::json!("stale"));
assert_eq!(stale.as_str(), Some(Freshness::Stale.as_str()));

// and the division a caller acts on: absence of a judgement is not a bad judgement
assert!(Freshness::Stale.history() && Freshness::Invalid.history());
assert!(!Freshness::Unknown.history(), "undated is not old");
assert!(!Freshness::Fresh.history() && !Freshness::Aging.history());

Kde stojí jedna dimenze systému. Seřazeno podle závažnosti, takže o celku rozhoduje nejhorší kontrola.

Jedno kritérium s důkazy za ním: co záznam deklaroval, co o něm říká ledger, zda to splňuje, a příkaz, který by důkazy vytvořil znovu.

use majordomus_cli::evidence::ProofState;
use majordomus_cli::intent::{IntentCriterion, IntentEvidenceState};
let c = IntentCriterion {
    id: "stage-is-derived".into(),
    criterion: "the stage follows the plan".into(),
    evidence: "test".into(),
    reference: "apps/majordomus-cli/tests/intent.rs".into(),
    state: IntentEvidenceState::NotRun,
    met: false,
    proof: Some(ProofState::NotRun),
    reproduce: None,
};
// nothing recorded is not a pass
assert!(!c.met);

Co říkají důkazy za jedním kritériem, jedním slovem. Kritérium splňuje jen Current: zastaralý, selhávající, nezaznamenaný nebo neodvoditelný odkaz nikdy, a stejně tak ten, který se nevyřeší na nic.

Zda je zaznamenaný běh aktuální, se zde nerozhoduje. Kritérium test nebo claim posuzuje jediná pravdivostní tabulka modulu důkazů (evidence::freshness()) na pracovním stromu a čte se přes evidence::current, tentýž soud, jaký dělá report tvrzení a stránky subjektů; IntentEvidenceState::judged je celý překlad. Stav tak následuje důkazy oběma směry: kritérium splněné dnes se čte jako stale nebo failing, jakmile to řekne kniha nebo strom, a znovu jako splněné, jakmile se zaznamená aktuální úspěch.

use majordomus_cli::intent::IntentEvidenceState;
assert_eq!(serde_json::to_string(&IntentEvidenceState::NotRun).unwrap(), "\"not_run\"");
assert_ne!(IntentEvidenceState::Stale, IntentEvidenceState::Current);

Jeden nález validace: jeho úroveň, stabilní kód, který čtenář vyhledá grepem, záměr nebo milník, kterého se týká, jedna řádka o tom, co je špatně, a příkaz, který jej ukáže znovu.

use majordomus_cli::intent::{IntentFinding, FAIL};
let f = IntentFinding {
    level: FAIL.into(),
    code: "unknown_milestone".into(),
    subject: "intent-lifecycle".into(),
    message: "`no-such` is not a milestone".into(),
    reproduce: "majordomus intent validate".into(),
};
assert_eq!(f.level, "FAIL");
assert_eq!(f.reproduce, "majordomus intent validate");

Jeden milník, který intent jmenuje, tak, jak jej plán odvozuje. Milník, který se nevyřeší, se nese s resolved: false místo zahození, protože jméno, které ukazuje na nic, je nález, ne absence.

use majordomus_cli::intent::IntentMilestone;
let named = IntentMilestone { id: "no-such".into(), resolved: false, status: None };
assert!(!named.resolved);
assert!(named.status.is_none());

Kde záměr stojí, odvozeno při každém čtení a nikde neuloženo.

use majordomus_cli::intent::IntentStage;
// one word every surface prints, and an order that follows the work
assert_eq!(IntentStage::Executing.as_str(), "executing");
assert!(IntentStage::Declared < IntentStage::Satisfied);

Zda důkazy samy záměr rozhodují a které kritérium ho drží zpátky: každé nesplněné kritérium v pořadí, v němž je záznam deklaruje. Prázdné, když je verdikt satisfied, a když je unknown, protože záměr nedeklaruje žádné kritérium.

use majordomus_cli::intent::{verdict, IntentVerdict, IntentVerdictState};
// an intent that declares no criterion cannot be settled by evidence
let v: IntentVerdict = verdict(&[]);
assert_eq!(v.state, IntentVerdictState::Unknown);
assert!(v.reasons.is_empty());

Jedno kritérium, které zdržuje verdikt od satisfied: které, druh důkazu, který jmenuje, a stav, v jakém ten důkaz je — slovy samotného kritéria, ne novými.

use majordomus_cli::intent::{IntentEvidenceState, IntentVerdictReason};
let r = IntentVerdictReason {
    criterion: "probe-passes".into(),
    evidence: "test".into(),
    state: IntentEvidenceState::NotRun,
};
assert_eq!(r.state, IntentEvidenceState::NotRun);

Co o záměru říkají samotné důkazy, jako slovo: odvozeno z jeho kritérií a nikdy z plánu, takže může číst satisfied, zatímco milník je ještě otevřený (ADR 0107).

use majordomus_cli::intent::IntentVerdictState;
let word = serde_json::to_string(&IntentVerdictState::Unsatisfied).unwrap();
assert_eq!(word, "\"unsatisfied\"");
assert_eq!(IntentVerdictState::Satisfied.as_str(), "satisfied");

Jeden záměr tak, jak jej deklaruje jeho záznam a jak jej odvozují plán a ledger: tvrzení a invarianty tak, jak byly napsány, každý milník s odvozeným stavem, každé kritérium se stavem svých důkazů, fáze, která vyplývá z obojího, a verdikt, který vyplývá pouze z důkazů.

use majordomus_cli::intent::{verdict, IntentStage, IntentVerdictState, IntentView};
let view = IntentView {
    id: "intent-lifecycle".into(),
    title: "Work is traceable to the intent it serves".into(),
    statement: "A reader can ask what work is for.".into(),
    invariants: vec!["no intent status is stored".into()],
    stage: IntentStage::Declared,
    milestones: vec![],
    satisfaction: vec![],
    met: 0,
    verdict: verdict(&[]),
    governance: vec!["adr:adr-0070".into()],
    non_goals: vec![],
    superseded_by: None,
    source: ".ai/repo/project/intents/intent-lifecycle.yaml".into(),
};
// a record naming no milestone that resolves has not been planned
assert_eq!(view.stage, IntentStage::Declared);
// and one declaring no criterion cannot be settled by evidence
assert_eq!(view.verdict.state, IntentVerdictState::Unknown);

Odkud objekt pochází. Každé pole se počítá z repozitáře, nikdy se nepíše.

Jeden objekt, shrnutý pro výpis.

Identita peera po dobu života serveru: p1, p2, ... v pořadí připojení. p1 je relace, která server spustila.

Co o důkazu jednoho tvrzení dokáže repozitář říct právě teď.

Seřazeno od nejsilnějšího po nejslabší, takže souhrn řazený podle toho se čte jako žebříček.

use majordomus_cli::evidence::ProofState;

let mut states = vec![ProofState::NotRun, ProofState::Stale, ProofState::Proven];
states.sort();
assert_eq!(
    states,
    vec![ProofState::Proven, ProofState::Stale, ProofState::NotRun]
);

// the two strongest are deliberately not one state: `inputs unchanged` is the absence
// of a known invalidation, and collapsing it into `proven` is the unaccountable badge
assert_ne!(ProofState::Proven, ProofState::InputsUnchanged);
assert!(ProofState::Proven < ProofState::InputsUnchanged);
assert!(ProofState::InputsUnchanged.passing());

Příklad

use majordomus_cli::evidence::ProofState;
assert!(ProofState::Proven.passing());
assert!(!ProofState::NotRun.passing());
assert!(!ProofState::InputsUnchanged.meaning().is_empty());

Co conventional commit říká, že udělal.

Množina je ta, kterou používá vlastní konvence commitů repozitáře; commit, jehož předmět se nedá parsovat, je ChangeKind::Other a přesto se objeví, protože changelog, který mlčky zahazuje, co neumí klasifikovat, je changelog, který lže vynecháním.

Kde stojí server checkoutu, rozhodnuto z jeho lease, zda server, který lease jmenuje, odpovídá za tento checkout, a zda to, co odpovídá, je kód tohoto spustitelného souboru.

use majordomus_cli::capability::builtin::server::ServerStanding;
let all = [ServerStanding::Absent, ServerStanding::Starting, ServerStanding::Ready,
           ServerStanding::Outdated, ServerStanding::Stale];
let words: Vec<&str> = all.iter().map(|s| s.as_str()).collect();
assert_eq!(words, ["absent", "starting", "ready", "outdated", "stale"]);
assert_eq!(serde_json::from_str::<ServerStanding>("\"stale\"").unwrap(), ServerStanding::Stale);

Jak závažná je diagnostika. Error vyloučí dotčený soubor z indexu a uvede index do zhoršeného stavu; Warning a Info neudělají ani jedno.

Kde schopnost stojí, ve slovníku tvrzení samotného repozitáře. Schopnost, která je Planned nebo Unsupported, může být uvedena, ale není nikdy spustitelná přes žádnou projekci; registr se jinak odmítne sestavit.

Registr spočítaný: podle zdroje, druhu, stability a projekce.

Vzdálenost checkoutu od vzdáleného trunku, posouzená.

use majordomus_cli::worktree::trunk::{Distance, TrunkDistance, TrunkStanding};
let d: TrunkDistance = serde_json::from_value(serde_json::json!({
    "standing": "stale", "local_trunk_standing": "stale",
    "worktree": "/repo", "on_trunk": true,
    "checkout": {"behind": 779, "ahead": 0},
    "thresholds": {"warn_behind": 50, "fail_behind": 300},
    "message": "779 commits behind origin/master",
})).unwrap();
assert_eq!(d.standing, TrunkStanding::Stale);
assert_eq!(d.checkout, Some(Distance { behind: 779, ahead: 0 }));
// what is absent stays absent in the answer
assert!(serde_json::to_value(&d).unwrap().get("remedy").is_none());

Kde checkout stojí vůči vzdálenému trunku.

use majordomus_cli::worktree::trunk::TrunkStanding;
let s: TrunkStanding = serde_json::from_str(r#""lagging""#).unwrap();
assert_eq!(s, TrunkStanding::Lagging);
assert_eq!(serde_json::to_value(TrunkStanding::Unmeasured).unwrap(), "unmeasured");

Prahy, které deklaruje checkout.trunk_distance, v commitech za vzdáleným trunkem. Chybějící je chybějící: čtenář nedodává žádnou výchozí hodnotu a vzdálenost, jíž není s čím posoudit, se hlásí jako unjudged.

use majordomus_cli::worktree::trunk::TrunkThresholds;
let t: TrunkThresholds = serde_json::from_str(r#"{"warn_behind": 50, "fail_behind": 300}"#).unwrap();
assert_eq!((t.warn_behind, t.fail_behind), (Some(50), Some(300)));
assert_eq!(TrunkThresholds::default().warn_behind, None, "absent is not a default");