release.next

What the integration executor raises the trunk's version to when it lands a head (ADR 0134): the version the trunk declares, how far the head moves the public contract measured against the trunk's committed registry, what that movement requires under the version's mode, the repository's floor from `release.floor` in the policy, the exemption class that lowered the floor if every changed path falls in one, the larger of the requirement and the floor, and the trunk's version raised by it — with one sentence per step. Everything is read from git at the two refs, so the answer does not depend on which executable runs or on the branch's own version, which is why a retried landing cannot raise twice. It decides and writes nothing; an input that cannot be read is refused rather than guessed.

query
implemented
module release
#release
#version
#integration

Exposure

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

surface	as
MCP	tool majordomus_release_next
HTTP	GET /api/v1/release/next operationId release.next
command line	—

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 · ReleaseNextInput

The input of release.next: the landing it is asked about.

use majordomus_cli::capability::builtin::release::NextInput;
// nothing named is the landing the executor performs: this branch onto the trunk
let input = NextInput::default();
assert_eq!((input.base(), input.head()), ("origin/master", "HEAD"));

property	type	required	description
base	string \| null	no	The trunk the landing raises from; `origin/master` when absent.
head	string \| null	no	What lands; `HEAD` when absent.

JSON Schema

{
  "additionalProperties": false,
  "description": "The input of `release.next`: the landing it is asked about.\n\n```\nuse majordomus_cli::capability::builtin::release::NextInput;\n// nothing named is the landing the executor performs: this branch onto the trunk\nlet input = NextInput::default();\nassert_eq!((input.base(), input.head()), (\"origin/master\", \"HEAD\"));\n```",
  "properties": {
    "base": {
      "description": "The trunk the landing raises from; `origin/master` when absent.",
      "type": [
        "string",
        "null"
      ]
    },
    "head": {
      "description": "What lands; `HEAD` when absent.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "title": "ReleaseNextInput",
  "type": "object"
}

output · LandingDecision

What a landing allocates, and why, step by step.

use majordomus_cli::release::compat::Impact;
use majordomus_cli::release::landing::{decide, LandingDecision, ReleasePolicy, DECISION_SCHEMA};
use majordomus_cli::release::version::Version;
let d: LandingDecision = decide(Version::parse("1.2.3").unwrap(), Impact::None, &ReleasePolicy::default(), &[]);
assert_eq!(d.schema, DECISION_SCHEMA);
assert_eq!(d.next_version, "1.2.3", "nothing moved and nothing is owed");

property	type	required	description
allocation	reference	yes	Whether the policy allocates at landing; the decision is computed either way.
exemption	one of 2	no	The exemption that lowered the floor, if one did.
explanation	array	yes	One sentence per step, in the order the decision was made.
floor	reference	yes	The policy's floor, or `none` when an exemption applied.
mode	reference	yes	The compatibility mode the trunk's version puts in force.
next_version	string	yes	The trunk's version raised by `selected`.
observed	reference	yes	How far the change moves the public contract, measured (ADR 0051).
required_by_compatibility	reference	yes	What that movement requires under the version's mode.
schema	string	yes	`DECISION_SCHEMA`.
selected	reference	yes	The larger of the requirement and the floor.
trunk_version	string	yes	What the trunk declares: the number the next one is raised from.

JSON Schema

{
  "$defs": {
    "AppliedExemption": {
      "description": "The exemption a decision applied, by class.\n\n```\nuse majordomus_cli::release::landing::AppliedExemption;\nlet e = AppliedExemption { id: \"plan-records\".into(), reason: \"plan records\".into() };\nassert_eq!(e.id, \"plan-records\");\n```",
      "properties": {
        "id": {
          "description": "The class's id.",
          "type": "string"
        },
        "reason": {
          "description": "The class's description, which is the reason the floor did not apply.",
          "type": "string"
        }
      },
      "required": [
        "id",
        "reason"
      ],
      "type": "object"
    },
    "ReleaseAllocation": {
      "description": "Whether the integration executor allocates the version when it lands a pull request.\n\n```\nuse majordomus_cli::release::landing::Allocation;\n// a policy that says nothing changes nothing: a pull request raises its own version\nassert_eq!(Allocation::default(), Allocation::Off);\nlet a: Allocation = serde_json::from_str(\"\\\"landing\\\"\").unwrap();\nassert_eq!(a.as_str(), \"landing\");\n```",
      "oneOf": [
        {
          "const": "off",
          "description": "The version is raised by whoever changes the contract, as before ADR 0134.",
          "type": "string"
        },
        {
          "const": "landing",
          "description": "The integration executor raises it at landing; a pull request does not.",
          "type": "string"
        }
      ]
    },
    "ReleaseImpact": {
      "description": "How much a change moves the contract.\n\nOrdered, so that \"the declared bump covers what is required\" is a comparison rather than\na table:\n\n```\nuse majordomus_cli::release::compat::Impact;\nassert!(Impact::Major > Impact::Minor);\nassert!(Impact::Minor > Impact::Patch);\nassert!(Impact::Patch > Impact::None);\n```",
      "oneOf": [
        {
          "const": "none",
          "description": "The contract did not move.",
          "type": "string"
        },
        {
          "const": "patch",
          "description": "It moved behind the boundary: a caller cannot tell.",
          "type": "string"
        },
        {
          "const": "minor",
          "description": "Something arrived; every existing caller still works.",
          "type": "string"
        },
        {
          "const": "major",
          "description": "Something a caller could hold is gone or changed under it.",
          "type": "string"
        }
      ]
    },
    "ReleasePolicyMode": {
      "description": "How this project turns a measured impact into the version it owes.\n\nSemantic versioning hands `0.y.z` a blanket exemption — \"anything MAY change at any\ntime\" — and Elm refuses the exemption by starting every package at `1.0.0`, because a\nrule with an escape hatch is a rule about when to use the hatch. This repository is `0.x`\nand has not earned `1.0.0`, so neither answer is available: demanding `major` would\ndemand `1.0.0` for a single removal, and granting the exemption would let a breaking\nchange ship as a patch.\n\nSo below `1.0.0` the floor is a minor. Any movement of the surface, gone or new, is at\nleast a minor release; only an unchanged surface owes nothing. That is the strongest\nsignal `0.x` has, and a removal is still *named* as breaking whatever the verdict, so the\nevidence does not quietly become a minor along with the number.\n\nAt `1.0.0` the shift ends: `Mode::Semver` is the ordinary rule, and the transition is\none line of `Policy::required_of`.\n\n```\nuse majordomus_cli::release::compat::{Mode, Policy};\nuse majordomus_cli::release::version::Version;\nassert_eq!(Policy::for_version(Version::parse(\"0.9.0\").unwrap()).mode, Mode::Pre1_0Strict);\nassert_eq!(Policy::for_version(Version::parse(\"1.0.0\").unwrap()).mode, Mode::Semver);\n```",
      "oneOf": [
        {
          "const": "pre1-0-strict",
          "description": "Below `1.0.0`: breaking changes are allowed, and cost a minor rather than nothing.",
          "type": "string"
        },
        {
          "const": "semver",
          "description": "At or above `1.0.0`: the impact is the requirement.",
          "type": "string"
        }
      ]
    }
  },
  "description": "What a landing allocates, and why, step by step.\n\n```\nuse majordomus_cli::release::compat::Impact;\nuse majordomus_cli::release::landing::{decide, LandingDecision, ReleasePolicy, DECISION_SCHEMA};\nuse majordomus_cli::release::version::Version;\nlet d: LandingDecision = decide(Version::parse(\"1.2.3\").unwrap(), Impact::None, &ReleasePolicy::default(), &[]);\nassert_eq!(d.schema, DECISION_SCHEMA);\nassert_eq!(d.next_version, \"1.2.3\", \"nothing moved and nothing is owed\");\n```",
  "properties": {
    "allocation": {
      "$ref": "#/$defs/ReleaseAllocation",
      "description": "Whether the policy allocates at landing; the decision is computed either way."
    },
    "exemption": {
      "anyOf": [
        {
          "$ref": "#/$defs/AppliedExemption"
        },
        {
          "type": "null"
        }
      ],
      "description": "The exemption that lowered the floor, if one did."
    },
    "explanation": {
      "description": "One sentence per step, in the order the decision was made.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "floor": {
      "$ref": "#/$defs/ReleaseImpact",
      "description": "The policy's floor, or `none` when an exemption applied."
    },
    "mode": {
      "$ref": "#/$defs/ReleasePolicyMode",
      "description": "The compatibility mode the trunk's version puts in force."
    },
    "next_version": {
      "description": "The trunk's version raised by `selected`.",
      "type": "string"
    },
    "observed": {
      "$ref": "#/$defs/ReleaseImpact",
      "description": "How far the change moves the public contract, measured (ADR 0051)."
    },
    "required_by_compatibility": {
      "$ref": "#/$defs/ReleaseImpact",
      "description": "What that movement requires under the version's mode."
    },
    "schema": {
      "description": "`DECISION_SCHEMA`.",
      "type": "string"
    },
    "selected": {
      "$ref": "#/$defs/ReleaseImpact",
      "description": "The larger of the requirement and the floor."
    },
    "trunk_version": {
      "description": "What the trunk declares: the number the next one is raised from.",
      "type": "string"
    }
  },
  "required": [
    "schema",
    "trunk_version",
    "observed",
    "required_by_compatibility",
    "floor",
    "selected",
    "next_version",
    "allocation",
    "mode",
    "explanation"
  ],
  "title": "LandingDecision",
  "type": "object"
}

Policies

benchmark: waived — waived: published_history
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	waived (published_history)	0
mcp	waived (published_history)	0
http	waived (published_history)	0