HTTP API: reasoning

Jedna poradní schopnost a kdo ji nyní může poskytnout: řádek tabulky kapacity, kterou hlásí reasoning.advisors. Prázdné available obslouží lokální recenze.

use majordomus_cli::capability::builtin::reasoning::AdvisorCapacity;

let row: AdvisorCapacity = serde_json::from_value(serde_json::json!({
    "capability": "code_review", "description": "Critique of a change.", "available": [],
})).unwrap();
assert_eq!(row.capability, "code_review");
assert!(row.available.is_empty());

Otevřený jistič: konzultace, která jej otevřela, selhání za ním a kdy se zavře. Odvozeno ze záznamů a hodin, nikdy neuloženo.

use majordomus_cli::reasoning::availability::*;
use majordomus_cli::reasoning::catalogue::{AdvisorCatalogue, References};
use majordomus_cli::reasoning::record::ConsultationStatus;

struct All;
impl Presence for All {
    fn executable(&self, _: &str) -> bool { true }
    fn variable(&self, _: &str) -> bool { true }
}
let c: AdvisorCatalogue = majordomus_cli::metadata::yaml::parse_into(
    "version: 1\ncapabilities:\n  - id: code_review\n    description: x\nadvisors:\n  - id: a\n    title: A\n    transport: cli\n    adapter: a-cli\n    executable: a\n    capabilities: [code_review]\n",
).unwrap();
let limited = [Outcome {
    id: "consultation-1".into(), advisor: "a".into(),
    status: ConsultationStatus::RateLimited, at: 0, retry_after: Some(60),
}];
let refs = References::default();
let states = derive_availability(&c, &Inputs {
    refs: &refs, presence: &All, mode: ReasoningMode::Standard, disabled: &[],
    history: &limited, peers: &[], now: 10, cooldown: None,
});
let circuit: &AdvisorCircuit = states[0].circuit.as_ref().unwrap();
assert_eq!(circuit.opened_by, "consultation-1");
assert_eq!(circuit.until, "1970-01-01T00:01:00Z");

Jeden advisor tak, jak právě stojí: co o něm deklaruje katalog, jeho stav, jediné strojové slovo, které říká proč, a co bylo sondováno. Řádek, který hlásí reasoning.advisors a nad kterým plánuje politika.

use majordomus_cli::reasoning::availability::*;
use majordomus_cli::reasoning::catalogue::{AdvisorCatalogue, References};

struct Nothing;
impl Presence for Nothing {
    fn executable(&self, _: &str) -> bool { false }
    fn variable(&self, _: &str) -> bool { false }
}
let c: AdvisorCatalogue = majordomus_cli::metadata::yaml::parse_into(
    "version: 1\ncapabilities:\n  - id: code_review\n    description: x\nadvisors:\n  - id: a\n    title: A\n    transport: local_runtime\n    adapter: a-rt\n    executable: rt\n    capabilities: [code_review]\n",
).unwrap();
let refs = References::default();
let state: AdvisorState = derive_availability(&c, &Inputs {
    refs: &refs, presence: &Nothing, mode: ReasoningMode::Standard, disabled: &[],
    history: &[], peers: &[], now: 0, cooldown: None,
})
.remove(0);
assert_eq!((state.id.as_str(), state.status), ("a", AdvisorStatus::Unavailable));
assert_eq!(state.probe, "executable rt on PATH");
assert!(state.circuit.is_none() && !state.recovering);

Postavení advisora: zda se ho lze ptát nyní a když ne, jaký druh důvodu ho vylučuje. Do plánu vstupují jen advisoři available.

use majordomus_cli::reasoning::availability::AdvisorStatus;

assert_eq!(serde_json::to_value(AdvisorStatus::NotConfigured).unwrap(), "not_configured");
let s: AdvisorStatus = serde_json::from_str("\"rate_limited\"").unwrap();
assert_eq!(s, AdvisorStatus::RateLimited);

Jak se k poradci dostat. Transport rozhoduje, jak se zjišťuje jeho přítomnost (proměnná s přihlašovacím údajem, spustitelný soubor, odkaz meshe) a zda jej režim offline připouští.

use majordomus_cli::reasoning::catalogue::AdvisorTransport;

let t: AdvisorTransport = serde_json::from_str("\"local_runtime\"").unwrap();
assert_eq!(t, AdvisorTransport::LocalRuntime);
assert!(!t.is_remote());

Počty tokenů, které adaptér nahlásil. Chybí, když transport žádné nehlásí; nikdy se neodhadují.

Stav tyto hodnoty sčítá do svých součtů. Chybějící počet se čte jako nula, takže adaptér, který hlásí jen jednu ze dvou, přesto zaznamená, co hlásil.

use majordomus_cli::reasoning::record::AdvisorUsage;

let u: AdvisorUsage = serde_json::from_str(r#"{"input_tokens": 120}"#).unwrap();
assert_eq!(u, AdvisorUsage { input_tokens: 120, output_tokens: 0 });

Odpověď reasoning.advisors: platný režim, kolik poradců se smí a nesmí oslovit, stav každého poradce, kapacita na poradní schopnost a vlastní zjištění katalogu. operational je true bez ohledu na počty.

use majordomus_cli::capability::builtin::reasoning::AdvisorsReport;

let report: AdvisorsReport = serde_json::from_value(serde_json::json!({
    "operational": true,
    "mode": { "mode": "ci", "source": "CI" },
    "available": 0, "unavailable": 0, "advisors": [], "capacity": [],
})).unwrap();
assert!(report.operational && report.advisors.is_empty());
assert_eq!(report.mode.source, "CI");
assert!(report.diagnostics.is_empty(), "absent findings are the ordinary case");

Kde posouzení stojí, od otevřeného po validované.

Postavení se odvozuje, nikdy neukládá: nevyřešený spor jej činí sporným, ať je zaznamenáno cokoli jiného; jinak o něm rozhodují jeho platný závěr a validace tohoto závěru, a bez závěru jej zaznamenaný plán činí plánovaným.

#### use majordomus_cli::reasoning::record::ReasoningRecord;
#### use serde_json::json;
#### fn rec(id: &str, n: u32, body: serde_json::Value) -> ReasoningRecord {
####     serde_json::from_value(json!({
####         "schema": "majordomus/reasoning-record", "version": 1, "id": id, "task": "t",
####         "recorded_at": format!("2026-10-01T00:00:{n:02}Z"), "body": body,
####     }))
####     .unwrap()
#### }
use majordomus_cli::reasoning::state::{derive, AssessmentStanding};
use majordomus_cli::reasoning::store::Loaded;

let mut loaded = Loaded::default();
loaded.records.push(rec("assessment-1", 1, json!({ "kind": "assessment", "subject": "s" })));
assert_eq!(derive(&loaded, None).assessments[0].standing, AssessmentStanding::Open);

loaded.records.push(rec("disagreement-2", 2, json!({
    "kind": "disagreement", "assessment": "assessment-1",
    "positions": [
        { "source": "primary", "position": "A" },
        { "source": "consultation-9", "position": "B" },
    ],
    "discriminating_question": "do callers retry?",
})));
assert_eq!(derive(&loaded, None).assessments[0].standing, AssessmentStanding::Disputed);

Jedno posouzení a kde stojí.

Pohled nese to, co čtenář potřebuje, aby práci převzal: subjekt, jeho podstatnost, jeho odvozené postavení, závěr, který za něj platí, a otázky, které zanechal otevřené.

#### use majordomus_cli::reasoning::record::ReasoningRecord;
#### use serde_json::json;
#### fn rec(id: &str, n: u32, body: serde_json::Value) -> ReasoningRecord {
####     serde_json::from_value(json!({
####         "schema": "majordomus/reasoning-record", "version": 1, "id": id, "task": "t",
####         "recorded_at": format!("2026-10-01T00:00:{n:02}Z"), "body": body,
####     }))
####     .unwrap()
#### }
use majordomus_cli::reasoning::policy::Materiality;
use majordomus_cli::reasoning::state::{derive, AssessmentView};
use majordomus_cli::reasoning::store::Loaded;

let mut loaded = Loaded::default();
loaded.records.push(rec("assessment-1", 1, json!({
    "kind": "assessment", "subject": "lock scope", "materiality": "trivial",
    "questions": ["is it held across an await?"],
})));
let state = derive(&loaded, None);
let view: &AssessmentView = &state.assessments[0];
assert_eq!((view.id.as_str(), view.task.as_str()), ("assessment-1", "t"));
assert_eq!(view.materiality, Materiality::Trivial);
assert_eq!(view.conclusion, None);
assert_eq!(view.questions, ["is it held across an await?"]);

Jeden závěr, jak ho hlásí stav.

Vedle rozhodnutí a jeho vypočteného review pohled počítá validace zaznamenané proti závěru a jmenuje pozdější závěr, který jej nahradil, pokud nějaký je. Nahrazený závěr zůstává v seznamu; report ho vynechává.

#### use majordomus_cli::reasoning::record::ReasoningRecord;
#### use serde_json::json;
#### fn rec(id: &str, n: u32, body: serde_json::Value) -> ReasoningRecord {
####     serde_json::from_value(json!({
####         "schema": "majordomus/reasoning-record", "version": 1, "id": id, "task": "t",
####         "recorded_at": format!("2026-10-01T00:00:{n:02}Z"), "body": body,
####     }))
####     .unwrap()
#### }
use majordomus_cli::reasoning::state::{derive, ConclusionView};
use majordomus_cli::reasoning::store::Loaded;

let conclusion = |decision: &str, supersedes: Option<&str>| {
    json!({
        "kind": "conclusion", "assessment": "assessment-0", "decision": decision,
        "rationale": "r", "supersedes": supersedes,
        "reviewed_by": [], "independent_review_count": 0,
    })
};
let mut loaded = Loaded::default();
loaded.records.push(rec("conclusion-1", 1, conclusion("A", None)));
loaded.records.push(rec("validation-2", 2, json!({
    "kind": "validation", "conclusion": "conclusion-1", "check": "x", "outcome": "fail",
})));
loaded.records.push(rec("conclusion-3", 3, conclusion("B", Some("conclusion-1"))));

let state = derive(&loaded, None);
let first: &ConclusionView = &state.conclusions[0];
assert_eq!((first.validations_passed, first.validations_failed), (0, 1));
assert_eq!(first.superseded_by.as_deref(), Some("conclusion-3"));
assert_eq!(state.conclusions[1].superseded_by, None);

Jak konzultace skončila, jak ji klasifikoval adaptér.

Radu nese a jako review se počítá jen dokončená konzultace; každý jiný stav je degradace, která se zaznamená, aby ji stav mohl hlásit, nikdy skrývat. Drátová podoba je slovo v snake_case, které vrací ConsultationStatus::as_str.

use majordomus_cli::reasoning::record::ConsultationStatus;

let s: ConsultationStatus = serde_json::from_str("\"rate_limited\"").unwrap();
assert_eq!(s, ConsultationStatus::RateLimited);
assert!(!s.is_transient());
assert!(ConsultationStatus::Timeout.is_transient());

Jedna konzultace, jak ji stav hlásí.

Selhaná konzultace se hlásí stejně prostě jako dokončená: její stav a diagnostika adaptéru stojí tam, kde by stála rada, takže degradace je viditelná, ne tiše chybějící.

#### use majordomus_cli::reasoning::record::ReasoningRecord;
#### use serde_json::json;
#### fn rec(id: &str, n: u32, body: serde_json::Value) -> ReasoningRecord {
####     serde_json::from_value(json!({
####         "schema": "majordomus/reasoning-record", "version": 1, "id": id, "task": "t",
####         "recorded_at": format!("2026-10-01T00:00:{n:02}Z"), "body": body,
####     }))
####     .unwrap()
#### }
use majordomus_cli::reasoning::record::ConsultationStatus;
use majordomus_cli::reasoning::state::{derive, ConsultationView};
use majordomus_cli::reasoning::store::Loaded;

let mut loaded = Loaded::default();
loaded.records.push(rec("consultation-1", 1, json!({
    "kind": "consultation", "plan": "plan-0", "advisor": "alpha",
    "status": "timeout", "diagnostic": "timeout: no answer in 60s",
})));
let state = derive(&loaded, None);
let view: &ConsultationView = &state.consultations[0];
assert_eq!(view.status, ConsultationStatus::Timeout);
assert_eq!(view.conclusion, None);
assert_eq!(view.diagnostic.as_deref(), Some("timeout: no answer in 60s"));
assert_eq!(state.totals.consultations_failed, 1);

Jedna strana nesouhlasu: čí je to stanovisko a stanovisko v jedné větě.

Zdrojem je primary pro executora nebo id dokončené konzultace; úložiště odmítne pozici, jejímž zdrojem je konzultace, která nebyla dokončena.

use majordomus_cli::reasoning::record::DisagreementPosition;

let p = DisagreementPosition { source: "primary".into(), position: "keep the lock".into() };
let json = serde_json::to_value(&p).unwrap();
assert_eq!(json, serde_json::json!({ "source": "primary", "position": "keep the lock" }));

Jeden rozpor, tak jak jej stav hlásí.

Pohled jmenuje otázku, která rozpor rozhoduje, a po zaznamenání rozřešení i rozřešení a pozici, kterou jeho důkazy favorizovaly. Pohled bez rozřešení je nevyřešený rozpor, který blokuje jeho posouzení.

#### use majordomus_cli::reasoning::record::ReasoningRecord;
#### use serde_json::json;
#### fn rec(id: &str, n: u32, body: serde_json::Value) -> ReasoningRecord {
####     serde_json::from_value(json!({
####         "schema": "majordomus/reasoning-record", "version": 1, "id": id, "task": "t",
####         "recorded_at": format!("2026-10-01T00:00:{n:02}Z"), "body": body,
####     }))
####     .unwrap()
#### }
use majordomus_cli::reasoning::state::{derive, DisagreementView};
use majordomus_cli::reasoning::store::Loaded;

let mut loaded = Loaded::default();
loaded.records.push(rec("disagreement-1", 1, json!({
    "kind": "disagreement", "assessment": "assessment-0",
    "positions": [
        { "source": "primary", "position": "A" },
        { "source": "consultation-9", "position": "B" },
    ],
    "discriminating_question": "do callers retry?",
})));
loaded.records.push(rec("resolution-2", 2, json!({
    "kind": "resolution", "disagreement": "disagreement-1",
    "experiment": "read the callers", "outcome": "none retries",
    "favours": "consultation-9",
    "evidence": [{ "kind": "file", "reference": "src/caller.rs" }],
})));
let state = derive(&loaded, None);
let view: &DisagreementView = &state.disagreements[0];
assert_eq!(view.discriminating_question, "do callers retry?");
assert_eq!(view.resolution.as_deref(), Some("resolution-2"));
assert_eq!(view.favours.as_deref(), Some("consultation-9"));

Jeden poradce vynechaný z plánu, jeho stav v době sestavení plánu a proč: jeho stav, schopnost, kterou nenabízí, nebo už vyčerpaný rozpočet.

use majordomus_cli::reasoning::availability::{AdvisorState, AdvisorStatus, ModeResolution, ReasoningMode};
use majordomus_cli::reasoning::policy::{plan, ExcludedAdvisor, Materiality, PlanRequest};

fn advisor(id: &str, adapter: &str, status: &str) -> AdvisorState {
    serde_json::from_value(serde_json::json!({
        "id": id, "title": id, "transport": "api", "adapter": adapter,
        "capabilities": ["independent_reasoning"], "status": status,
        "reason": "present", "probe": "",
    }))
    .unwrap()
}
let mode = ModeResolution { mode: ReasoningMode::Standard, source: "default".into() };
let request = PlanRequest { materiality: Materiality::Material, ..Default::default() };
let states = [advisor("a", "x-api", "available"), advisor("b", "y-api", "available")];
let p = plan(&request, &mode, &states);
let left: &ExcludedAdvisor = &p.excluded[0];
assert_eq!((left.advisor.as_str(), left.status), ("b", AdvisorStatus::Available));
assert!(left.reason.contains("budget was spent"));

Jak moc by nejisté rozhodnutí mohlo záležet. Seřazeno od trivial po critical: s režimem nastavuje rozpočet review a od material výše nese rozhodnutí učiněné samostatně strukturované lokální review.

use majordomus_cli::reasoning::policy::Materiality;

assert_eq!(Materiality::default(), Materiality::Low);
assert!(Materiality::Material < Materiality::Critical);
let m: Materiality = serde_json::from_str("\"high\"").unwrap();
assert_eq!(m, Materiality::High);

Platný režim a co o něm rozhodlo, tak jak ho vrací resolve_mode. Plán i zpráva nesou zdroj vedle režimu, takže čtenář zjistí, proč je režim takový, jaký je.

use majordomus_cli::reasoning::availability::{resolve_mode, ModeResolution, ReasoningMode};

let r: ModeResolution = resolve_mode(None, true, None);
assert_eq!(r, ModeResolution { mode: ReasoningMode::Ci, source: "CI".into() });

O čem plán rozhodl: konzultovat vybrané poradce, rozhodnout na lokálních důkazech, nebo znovu použít platný závěr. Rozhodnutí lokálně je běžný výsledek, ne selhání.

use majordomus_cli::reasoning::availability::{ModeResolution, ReasoningMode};
use majordomus_cli::reasoning::policy::{plan, Materiality, PlanOutcome, PlanRequest};

let mode = ModeResolution { mode: ReasoningMode::Ci, source: "CI".into() };
let request = PlanRequest { materiality: Materiality::Critical, ..Default::default() };
let outcome: PlanOutcome = plan(&request, &mode, &[]).outcome;
assert_eq!(outcome, PlanOutcome::DecideLocally);
assert_eq!(serde_json::to_value(outcome).unwrap(), "decide_locally");

Tělo uloženého záznamu: přijatý vstup s tím, co zapisovatel vypočetl.

Zrcadlí ReasoningInput variantu po variantě, až na to, že plán se ukládá jako StoredPlan a závěr jako StoredConclusion. Vyrábí ho jen úložiště, když přijme vstup; jeho forma JSON je označena kind stejně jako vstup.

use majordomus_cli::reasoning::record::{AssessmentInput, ReasoningBody};

let body = ReasoningBody::Assessment(AssessmentInput {
    subject: "lock scope".into(),
    ..Default::default()
});
assert_eq!(body.kind(), "assessment");
assert_eq!(serde_json::to_value(&body).unwrap()["kind"], "assessment");

Odpověď reasoning.check: zda je čistý, provedené kontroly v pořadí a každý nález. ok je true právě tehdy, když je findings prázdné.

use majordomus_cli::capability::builtin::reasoning::ReasoningCheck;

let clean: ReasoningCheck = serde_json::from_value(serde_json::json!({
    "ok": true, "checks": ["catalogue"], "findings": [],
})).unwrap();
assert!(clean.ok && clean.findings.is_empty());
assert_eq!(clean.checks, ["catalogue"]);

Jak si je primární executor jistý svou aktuální hypotézou. high snižuje rozpočet review o jedna; ostatní úrovně ho nechávají tak, jak ho nastavují režim a významnost.

use majordomus_cli::reasoning::availability::{ModeResolution, ReasoningMode};
use majordomus_cli::reasoning::policy::{plan, Materiality, PlanRequest, ReasoningConfidence};

let mode = ModeResolution { mode: ReasoningMode::Strict, source: "default".into() };
let budget = |confidence: ReasoningConfidence| {
    let request = PlanRequest { materiality: Materiality::Critical, confidence, ..Default::default() };
    plan(&request, &mode, &[]).budget
};
assert_eq!(budget(ReasoningConfidence::Medium), 3);
assert_eq!(budget(ReasoningConfidence::High), 2);

Odkaz na něco, co podporuje tvrzení.

Důkaz je ukazatel, nikdy kopie: cesta, případ, id nebo příkazová řádka, s volitelnou jednořádkovou poznámkou, co ukazuje. Neznámá pole se odmítají, takže chybně napsané pole je chyba, ne tiše zahozené tvrzení.

use majordomus_cli::reasoning::record::{ReasoningEvidence, ReasoningEvidenceKind};

let e: ReasoningEvidence = serde_json::from_value(serde_json::json!({
    "kind": "file",
    "reference": "src/worker.rs:42",
}))
.unwrap();
assert_eq!(e.kind, ReasoningEvidenceKind::File);
assert_eq!(e.note, None);

let typo = serde_json::from_value::<ReasoningEvidence>(serde_json::json!({
    "kind": "file", "reference": "x", "notes": "misspelt",
}));
assert!(typo.is_err());

Co je důkaz.

Druh říká čtenáři, jak odkaz sledovat: otevřít soubor, spustit test, přečíst ADR nebo pravidlo, ukázat commit. Dřívější externí názor je samostatný druh, aby dřívější závěr poradce, předaný jinému poradci, nebyl nikdy čten jako fakt.

use majordomus_cli::reasoning::record::ReasoningEvidenceKind;

let kind: ReasoningEvidenceKind = serde_json::from_str("\"prior_external_opinion\"").unwrap();
assert_eq!(kind, ReasoningEvidenceKind::PriorExternalOpinion);
assert_eq!(serde_json::to_string(&ReasoningEvidenceKind::Adr).unwrap(), "\"adr\"");

Záznam se vším, na čem stojí, a vším, co stojí na něm.

Nese samotný záznam, posouzení, ke kterému patří, a celý řetězec původu tohoto posouzení jako kroky časové osy v pořadí. Záznam, který nepatří k žádnému posouzení, má řetězec jen sám ze sebe.

#### use majordomus_cli::reasoning::record::ReasoningRecord;
#### use serde_json::json;
#### fn rec(id: &str, n: u32, body: serde_json::Value) -> ReasoningRecord {
####     serde_json::from_value(json!({
####         "schema": "majordomus/reasoning-record", "version": 1, "id": id, "task": "t",
####         "recorded_at": format!("2026-10-01T00:00:{n:02}Z"), "body": body,
####     }))
####     .unwrap()
#### }
use majordomus_cli::reasoning::state::{explain, ReasoningExplanation};
use majordomus_cli::reasoning::store::Loaded;

let mut loaded = Loaded::default();
loaded.records.push(rec("attempt-1", 1, json!({
    "kind": "attempt", "attempt": "inline it", "observed_failure": "still slow",
})));
let e: ReasoningExplanation = explain(&loaded, "attempt-1").unwrap();
assert_eq!(e.record.id, "attempt-1");
assert_eq!(e.assessment, None);
assert_eq!(e.chain.len(), 1);

Jeden nález reasoning check: která kontrola, kde a co je špatně.

check je jedno z CHECKS; subject je cesta relativní k repozitáři, id záznamu nebo advisor; message je jedna věta, která říká, co pravidlo zamítá. Zjištění se hlásí, nikdy neopravují.

use majordomus_cli::reasoning::catalogue::{AdvisorCatalogue, References};
use majordomus_cli::reasoning::check::{run, ReasoningFinding, CHECKS};
use majordomus_cli::reasoning::store::Loaded;

let root = tempfile::tempdir().unwrap();
let loaded = Loaded { records: vec![], unreadable: vec!["t/broken.json".into()] };
let found = run(root.path(), &AdvisorCatalogue::default(), &References::default(), &loaded);
let expected = ReasoningFinding {
    check: "records".into(),
    subject: "t/broken.json".into(),
    message: "a reasoning record that does not parse".into(),
};
assert_eq!(found, [expected]);
assert!(CHECKS.contains(&found[0].check.as_str()));

Cokoli, co relace zaznamenává, tak jak bylo napsáno.

Forma JSON je označena pomocí kind, s poli varianty vedle značky. To přijímají povrchy CLI, HTTP a MCP; crate::reasoning::store::admit ji promění v uložené ReasoningBody, nebo ji odmítne.

use majordomus_cli::reasoning::record::ReasoningInput;

let input: ReasoningInput = serde_json::from_value(serde_json::json!({
    "kind": "plan",
    "assessment": "assessment-1",
}))
.unwrap();
assert!(matches!(input, ReasoningInput::Plan(ref p) if p.assessment == "assessment-1"));
let unknown = serde_json::json!({ "kind": "opinion", "text": "x" });
assert!(serde_json::from_value::<ReasoningInput>(unknown).is_err());

Kolik nezávislého posouzení smí relace použít a odkud. Politika z toho čte rozpočet na posouzení; dostupnost z toho čte, které poradce vynechat (ci všechny, offline každého, který opouští stroj). Výchozí je standard.

use majordomus_cli::reasoning::availability::ReasoningMode;

assert_eq!(ReasoningMode::default(), ReasoningMode::Standard);
assert_eq!(serde_json::to_value(ReasoningMode::Offline).unwrap(), "offline");
let m: ReasoningMode = serde_json::from_str("\"strict\"").unwrap();
assert_eq!(m, ReasoningMode::Strict);

Fáze časové osy uvažování.

Každý záznam se mapuje na jednu fázi: plán na consulting, local nebo reuse podle jeho výsledku, konzultace na odpověď poradce nebo degradaci podle jejího stavu a každý jiný druh na fázi stejného jména.

#### use majordomus_cli::reasoning::record::ReasoningRecord;
#### use serde_json::json;
#### fn rec(id: &str, n: u32, body: serde_json::Value) -> ReasoningRecord {
####     serde_json::from_value(json!({
####         "schema": "majordomus/reasoning-record", "version": 1, "id": id, "task": "t",
####         "recorded_at": format!("2026-10-01T00:00:{n:02}Z"), "body": body,
####     }))
####     .unwrap()
#### }
use majordomus_cli::reasoning::state::{derive, ReasoningPhase};
use majordomus_cli::reasoning::store::Loaded;

let mut loaded = Loaded::default();
loaded.records.push(rec("consultation-1", 1, json!({
    "kind": "consultation", "plan": "plan-0", "advisor": "alpha", "status": "unavailable",
})));
let phases: Vec<ReasoningPhase> =
    derive(&loaded, None).timeline.iter().map(|s| s.phase).collect();
assert_eq!(phases, [ReasoningPhase::Degradation]);
let word = serde_json::to_value(ReasoningPhase::AdvisorResponse).unwrap();
assert_eq!(word, "advisor_response");

Uložený záznam: tělo s obálkou, kterou razítkuje jen zapisovatel.

Obálka nese schéma a verzi, jedinečné id, úlohu, čas zaznamenání, commit, na kterém checkout byl, a tvary tajemství vyredigované z jejího textu. Jeden záznam je jeden soubor JSON v úložišti; úložiště čte zpět jen záznamy, jejichž schéma a verze odpovídají.

use majordomus_cli::reasoning::record::*;

let record = ReasoningRecord {
    schema: RECORD_SCHEMA.into(),
    version: RECORD_VERSION,
    id: "attempt-20261001T000000Z-abcdef".into(),
    task: "untasked".into(),
    recorded_at: "2026-10-01T00:00:00Z".into(),
    head: None,
    redacted: vec![],
    body: ReasoningBody::Attempt(AttemptInput {
        assessment: None,
        attempt: "inline the call".into(),
        observed_failure: "the test still fails".into(),
        assumption_invalidated: None,
        evidence: vec![],
        updated_hypothesis: None,
    }),
};
let text = serde_json::to_string(&record).unwrap();
assert!(!text.contains("\"head\""), "an absent head is not written");
let back: ReasoningRecord = serde_json::from_str(&text).unwrap();
assert_eq!(back.id, record.id);
assert_eq!(back.body.kind(), "attempt");

Vstup reasoning.record: jeden záznam, jak je napsán, označený svým kind. Vše ostatní (id, úlohu, razítko, výběr plánu) si zapisovač vypočítá sám.

use majordomus_cli::capability::builtin::reasoning::ReasoningRecordInput;
use majordomus_cli::reasoning::record::ReasoningInput;

let input: ReasoningRecordInput = serde_json::from_value(serde_json::json!({
    "record": { "kind": "plan", "assessment": "assessment-1" },
})).unwrap();
assert!(matches!(input.record, ReasoningInput::Plan(ref p) if p.assessment == "assessment-1"));

Odpověď reasoning.record: záznam tak, jak je uložen, kam byl zapsán, a krok časové osy, který přidává.

use majordomus_cli::capability::builtin::reasoning::ReasoningRecorded;

let schema = serde_json::to_value(schemars::schema_for!(ReasoningRecorded)).unwrap();
for field in ["record", "path", "step"] {
    assert!(schema["required"].as_array().unwrap().iter().any(|f| f == field), "{field}");
}

Stav uvažování úlohy (nebo každé úlohy).

Je to to, co hlásí každý povrch: posouzení, konzultace, spory a závěry úlohy, časová osa každého záznamu, součty a soubory úložiště, které nebylo možné přečíst. Odvozeno pomocí derive(), nikdy neukládáno.

#### use majordomus_cli::reasoning::record::ReasoningRecord;
#### use serde_json::json;
#### fn rec(id: &str, task: &str, body: serde_json::Value) -> ReasoningRecord {
####     serde_json::from_value(json!({
####         "schema": "majordomus/reasoning-record", "version": 1, "id": id, "task": task,
####         "recorded_at": "2026-10-01T00:00:00Z", "body": body,
####     }))
####     .unwrap()
#### }
use majordomus_cli::reasoning::state::{derive, ReasoningState};
use majordomus_cli::reasoning::store::Loaded;

let mut loaded = Loaded::default();
let assessment = |subject: &str| json!({ "kind": "assessment", "subject": subject });
loaded.records.push(rec("assessment-1", "t1", assessment("a")));
loaded.records.push(rec("assessment-2", "t2", assessment("b")));
loaded.unreadable.push("t2/broken.json".into());

let one: ReasoningState = derive(&loaded, Some("t1"));
assert_eq!((one.task.as_str(), one.assessments.len()), ("t1", 1));
let all = derive(&loaded, None);
assert_eq!((all.task.as_str(), all.totals.records), ("all", 2));
assert_eq!(all.unreadable, ["t2/broken.json"]);

Odpověď reasoning.status: platný režim, počty poradců, stav, který záznamy odvozují, a tento stav vykreslený jako Markdown, který nese předávka.

use majordomus_cli::capability::builtin::reasoning::ReasoningStatus;

let schema = serde_json::to_value(schemars::schema_for!(ReasoningStatus)).unwrap();
for field in ["mode", "advisors_available", "advisors_unavailable", "state", "report"] {
    assert!(schema["required"].as_array().unwrap().iter().any(|f| f == field), "{field}");
}

Jeden krok časové osy: kdy, který záznam, která fáze a jedna řádka o tom, co se stalo.

Shrnutí se ořízne na jediný řádek o nejvýše 140 znacích, takže časová osa se vykreslí stejně v terminálu, na stránce i v předávce.

#### use majordomus_cli::reasoning::record::ReasoningRecord;
#### use serde_json::json;
#### fn rec(id: &str, n: u32, body: serde_json::Value) -> ReasoningRecord {
####     serde_json::from_value(json!({
####         "schema": "majordomus/reasoning-record", "version": 1, "id": id, "task": "t",
####         "recorded_at": format!("2026-10-01T00:00:{n:02}Z"), "body": body,
####     }))
####     .unwrap()
#### }
use majordomus_cli::reasoning::state::{derive, ReasoningPhase, ReasoningStep};
use majordomus_cli::reasoning::store::Loaded;

let mut loaded = Loaded::default();
loaded.records.push(rec("attempt-1", 1, json!({
    "kind": "attempt", "attempt": "share the client\nacross threads",
    "observed_failure": "the handle is not Sync",
})));
let state = derive(&loaded, None);
let step: &ReasoningStep = &state.timeline[0];
assert_eq!(step.at, "2026-10-01T00:00:01Z");
assert_eq!(step.phase, ReasoningPhase::Attempt);
assert_eq!(step.summary, "share the client failed: the handle is not Sync");

Součty přes záznamy odvozené úlohy: počty, recenzenti a hlášené tokeny.

Nezávislí recenzenti jsou odlišní poradci s alespoň jednou dokončenou konzultací; počty tokenů se sčítají jen z toho, co adaptéry nahlásily, nikdy se neodhadují.

#### use majordomus_cli::reasoning::record::ReasoningRecord;
#### use serde_json::json;
#### fn rec(id: &str, n: u32, body: serde_json::Value) -> ReasoningRecord {
####     serde_json::from_value(json!({
####         "schema": "majordomus/reasoning-record", "version": 1, "id": id, "task": "t",
####         "recorded_at": format!("2026-10-01T00:00:{n:02}Z"), "body": body,
####     }))
####     .unwrap()
#### }
use majordomus_cli::reasoning::state::{derive, ReasoningTotals};
use majordomus_cli::reasoning::store::Loaded;

let answer = |plan: &str| {
    json!({
        "kind": "consultation", "plan": plan, "advisor": "alpha", "status": "completed",
        "conclusion": "A", "stance": "supports",
        "usage": { "input_tokens": 100, "output_tokens": 20 },
    })
};
let mut loaded = Loaded::default();
loaded.records.push(rec("consultation-1", 1, answer("plan-a")));
loaded.records.push(rec("consultation-2", 2, answer("plan-b")));
let totals: ReasoningTotals = derive(&loaded, None).totals;
assert_eq!(totals.consultations_completed, 2);
assert_eq!(totals.independent_reviewers, 1, "one advisor, however often asked");
assert_eq!((totals.input_tokens, totals.output_tokens), (200, 40));

Plán: rozhodnutí s přiloženými důvody. Nese to, na co odpovídalo (režim, významnost, jistota, schopnosti), rozpočet, výsledek s jednou větou proč, každého vybraného či vyloučeného advisora a lokální revizi, je-li na řadě.

use majordomus_cli::reasoning::availability::{ModeResolution, ReasoningMode};
use majordomus_cli::reasoning::policy::{plan, Materiality, PlanRequest, ReviewPlan, LOCAL_REVIEW};

let mode = ModeResolution { mode: ReasoningMode::Offline, source: "MAJORDOMUS_REASONING_MODE".into() };
let request = PlanRequest { materiality: Materiality::Material, ..Default::default() };
let p: ReviewPlan = plan(&request, &mode, &[]);
assert_eq!(p.mode_source, "MAJORDOMUS_REASONING_MODE");
assert_eq!(p.capabilities, ["independent_reasoning"]);
assert_eq!((p.budget, p.available), (1, 0));
assert_eq!(p.local_review.len(), LOCAL_REVIEW.len());
assert!(p.reason.starts_with("no available advisor offers"));

Jeden vybraný poradce, požadované schopnosti, které pokrývá, a proč ho chamtivý výběr zvolil na jeho pozici.

use majordomus_cli::reasoning::availability::{AdvisorState, ModeResolution, ReasoningMode};
use majordomus_cli::reasoning::policy::{plan, Materiality, PlanRequest, SelectedAdvisor};

fn advisor(id: &str, adapter: &str, status: &str) -> AdvisorState {
    serde_json::from_value(serde_json::json!({
        "id": id, "title": id, "transport": "api", "adapter": adapter,
        "capabilities": ["independent_reasoning"], "status": status,
        "reason": "present", "probe": "",
    }))
    .unwrap()
}
let mode = ModeResolution { mode: ReasoningMode::Standard, source: "default".into() };
let request = PlanRequest { materiality: Materiality::Material, ..Default::default() };
let p = plan(&request, &mode, &[advisor("a", "x-api", "available")]);
let chosen: &SelectedAdvisor = &p.selected[0];
assert_eq!(chosen.advisor, "a");
assert_eq!(chosen.covers, ["independent_reasoning"]);
assert!(chosen.why.starts_with("the first available advisor"));

Kde stojí odpověď advisora vůči hypotéze executoru.

Dokončená konzultace musí uvést svůj postoj; úložiště odmítne tu, která jej nemá. Postoj je štítek pro časovou osu, ne hlas: shoda nic nerozhoduje.

use majordomus_cli::reasoning::record::Stance;

let s: Stance = serde_json::from_str("\"alternative\"").unwrap();
assert_eq!(s, Stance::Alternative);
assert!(serde_json::from_str::<Stance>("\"agrees\"").is_err());

Závěr tak, jak je uložen: vstup a to, co spočítá jen zapisovatel.

Vstup je zploštěn, takže uložený závěr se čte jako vstup plus dvě pole: poradci, jejichž dokončené konzultace cituje, každý jednou a v kanonickém pořadí, a jejich počet. Obě se počítají při přijetí a znovu je kontroluje reasoning.check, takže ručně upravený počet se ohlásí.

use majordomus_cli::reasoning::record::{ConclusionInput, StoredConclusion};

let stored = StoredConclusion {
    input: ConclusionInput {
        assessment: "assessment-1".into(),
        decision: "keep the lock".into(),
        rationale: "measured".into(),
        ..Default::default()
    },
    reviewed_by: vec!["alpha".into()],
    independent_review_count: 1,
};
let json = serde_json::to_value(&stored).unwrap();
assert_eq!(json["decision"], "keep the lock");
assert_eq!(json["independent_review_count"], 1);

Plán tak, jak je uložen: rozhodnutí a dostupnost, proti níž bylo učiněno.

Store ji staví, když přijímá PlanInput; nic jiného ne. Snapshot dostupnosti je to, proti čemu se přijímá pozdější konzultace, takže odpověď, která dorazí po otevření okruhu poradce, stále patří plánu, který se na ni ptal.

use majordomus_cli::reasoning::availability::{ModeResolution, ReasoningMode};
use majordomus_cli::reasoning::policy::PlanOutcome;
use majordomus_cli::reasoning::record::*;
use majordomus_cli::reasoning::store::{admit, Admission, Loaded};

let mode = ModeResolution { mode: ReasoningMode::Standard, source: "default".into() };
let admission = Admission { mode: &mode, availability: &[] };
let mut loaded = Loaded::default();
loaded.records.push(ReasoningRecord {
    schema: RECORD_SCHEMA.into(),
    version: RECORD_VERSION,
    id: "assessment-1".into(),
    task: "t".into(),
    recorded_at: "2026-10-01T00:00:01Z".into(),
    head: None,
    redacted: vec![],
    body: ReasoningBody::Assessment(AssessmentInput {
        subject: "a name".into(),
        ..Default::default()
    }),
});
let input = ReasoningInput::Plan(PlanInput { assessment: "assessment-1".into() });
let ReasoningBody::Plan(stored) = admit(input, &loaded, &admission).unwrap() else {
    panic!("a plan input is stored as a plan");
};
let stored: StoredPlan = stored;
assert_eq!(stored.assessment, "assessment-1");
assert_eq!(stored.plan.outcome, PlanOutcome::DecideLocally);
assert!(stored.availability.is_empty());

Zda provedený krok validace prošel, nebo selhal.

Jedna neúspěšná validace stačí k tomu, aby se stav posouzení v odvozeném stavu označil jako validation_failed, ať prošlo cokoli jiného.

use majordomus_cli::reasoning::record::ValidationOutcome;

let o: ValidationOutcome = serde_json::from_str("\"fail\"").unwrap();
assert_eq!(o, ValidationOutcome::Fail);
assert_eq!(serde_json::to_string(&ValidationOutcome::Pass).unwrap(), "\"pass\"");