reasoning.check

The executable half of the rules advisors-are-optional and review-is-recorded-not-claimed: the advisor catalogue resolves against the provider table and the model catalogue; every adapter it names has its transport module; no provider-independent source names an advisor; no CI workflow or gate names a model credential; no document asserts a refused claim; every stored consultation names an advisor its plan selected, and every conclusion's review matches what it cites. The CI and claims checks judge what this repository's own workflows and documents say, so they apply only where the rule advisors-are-optional is declared; an adopter is held to what it adopted.

query
experimental
module reasoning
#reasoning
#governance

Exposure

Where this one definition is reachable. Absence is explicit: a surface not listed does not carry it.

surface	as
MCP	tool majordomus_reasoning_check
HTTP	GET /api/v1/reasoning/check operationId reasoning.check
command line	majordomus reasoning check

Schemas

The canonical input and output, from the Rust types; the MCP tool schema and the OpenAPI parameters and responses are derived from these.

input · Empty

No input.

No properties: the capability takes no input.

JSON Schema

{
  "additionalProperties": false,
  "description": "No input.",
  "title": "Empty",
  "type": "object"
}

output · ReasoningCheck

The answer of reasoning.check: whether it is clean, the checks performed in order, and every finding. ok is true exactly when findings is empty.

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"]);

property	type	required	description
checks	array	yes	The checks performed, in order.
findings	array	yes	What they found.
ok	boolean	yes	No finding.

JSON Schema

{
  "$defs": {
    "ReasoningFinding": {
      "description": "One finding of a reasoning check: which check, where, and what is wrong.\n\n`check` is one of `CHECKS`; `subject` is a repository-relative path, a record id or\nan advisor; `message` is one sentence saying what the rule refuses. Findings are\nreported, never repaired.\n\n```\nuse majordomus_cli::reasoning::catalogue::{AdvisorCatalogue, References};\nuse majordomus_cli::reasoning::check::{run, ReasoningFinding, CHECKS};\nuse majordomus_cli::reasoning::store::Loaded;\n\nlet root = tempfile::tempdir().unwrap();\nlet loaded = Loaded { records: vec![], unreadable: vec![\"t/broken.json\".into()] };\nlet found = run(root.path(), &AdvisorCatalogue::default(), &References::default(), &loaded);\nlet expected = ReasoningFinding {\n    check: \"records\".into(),\n    subject: \"t/broken.json\".into(),\n    message: \"a reasoning record that does not parse\".into(),\n};\nassert_eq!(found, [expected]);\nassert!(CHECKS.contains(&found[0].check.as_str()));\n```",
      "properties": {
        "check": {
          "description": "The check that found it.",
          "type": "string"
        },
        "message": {
          "description": "What is wrong.",
          "type": "string"
        },
        "subject": {
          "description": "Where: a file, a record, an advisor.",
          "type": "string"
        }
      },
      "required": [
        "check",
        "subject",
        "message"
      ],
      "type": "object"
    }
  },
  "description": "The answer of `reasoning.check`: whether it is clean, the checks performed in order,\nand every finding. `ok` is `true` exactly when `findings` is empty.\n\n```\nuse majordomus_cli::capability::builtin::reasoning::ReasoningCheck;\n\nlet clean: ReasoningCheck = serde_json::from_value(serde_json::json!({\n    \"ok\": true, \"checks\": [\"catalogue\"], \"findings\": [],\n})).unwrap();\nassert!(clean.ok && clean.findings.is_empty());\nassert_eq!(clean.checks, [\"catalogue\"]);\n```",
  "properties": {
    "checks": {
      "description": "The checks performed, in order.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "findings": {
      "description": "What they found.",
      "items": {
        "$ref": "#/$defs/ReasoningFinding"
      },
      "type": "array"
    },
    "ok": {
      "description": "No finding.",
      "type": "boolean"
    }
  },
  "required": [
    "ok",
    "checks",
    "findings"
  ],
  "title": "ReasoningCheck",
  "type": "object"
}

Policies

benchmark: required — a target on every transport the exposure declares; the cases are the input type's
cache: disabled — every call runs the handler

Benchmark targets

Derived from the registry for this repository: one requirement per transport, and the cases the input type provides. The whole matrix is on the benchmarks page.

transport	state	cases	targets
direct	covered	1	default
mcp	covered	1	default
http	covered	1	default