product.domains

{
  "additionalProperties": false,
  "description": "Which domains to list.",
  "properties": {
    "status": {
      "default": null,
      "description": "Only domains of this status. Absent means the stable ones; pass `any` for every\ndomain the model holds.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "title": "DomainQuery",
  "type": "object"
}

{
  "$defs": {
    "ClaimRef": {
      "description": "One claim the feature names, with the status the matrix gives it.",
      "properties": {
        "claim": {
          "description": "The sentence.",
          "type": "string"
        },
        "id": {
          "description": "The claim id.",
          "type": "string"
        },
        "status": {
          "description": "`guaranteed`, `advisory`, `planned` or `rejected`.",
          "type": "string"
        },
        "test": {
          "description": "The test that settles it, as `docs/CLAIMS.yaml` records it — the one field that makes a\nclaim checkable rather than stated. Absent where the claim declares none, and where it\ndeclares `-`: a planned or rejected claim has nothing to run yet, and rendering a dash\nas a test would be a projection inventing evidence.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "id",
        "claim",
        "status"
      ],
      "type": "object"
    },
    "DomainCounts": {
      "description": "How much stands behind a domain: sums and distinct counts over its stable features.\n\n```\nuse majordomus_cli::product::DomainCounts;\nlet empty = DomainCounts::default();\nassert_eq!(empty.features, 0);\nlet v = serde_json::to_value(&empty).unwrap();\nfor key in [\"features\", \"claims\", \"tested\", \"use_cases\", \"rules\", \"enforced_rules\", \"capabilities\", \"moments\"] {\n    assert_eq!(v[key], 0, \"{key} is published, and zero for a domain nothing names\");\n}\n```",
      "properties": {
        "capabilities": {
          "description": "Distinct capabilities behind its features.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "claims": {
          "description": "Distinct claims its features name.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "enforced_rules": {
          "description": "Distinct rules among them the tool enforces.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "features": {
          "description": "Stable features filed under it.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "moments": {
          "description": "Distinct operational moments its features answer.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "rules": {
          "description": "Distinct rules its features name.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "tested": {
          "description": "Distinct claims that are guaranteed and name the test that settles them: what the\nclaims declare, not whether a recorded run supports them (that verdict is the\nevidence ledger's).",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "use_cases": {
          "description": "Distinct use cases its features name.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "features",
        "claims",
        "tested",
        "use_cases",
        "rules",
        "enforced_rules",
        "capabilities",
        "moments"
      ],
      "type": "object"
    },
    "DomainMember": {
      "description": "One stable feature of a domain, as a card shows it.\n\n```\nuse majordomus_cli::product::{DomainMember, Surfaces};\nlet m = DomainMember {\n    id: \"finish-contract\".into(),\n    label: \"Finish contract\".into(),\n    title: \"Done is a contract\".into(),\n    headline: \"A worker does not define its own completion.\".into(),\n    route: \"/features/finish-contract/\".into(),\n    featured: true,\n    surfaces: Surfaces::default(),\n    claims: 3,\n    tested: 2,\n    use_cases: 1,\n};\nlet v = serde_json::to_value(&m).unwrap();\nassert_eq!(v[\"tested\"], 2);\nassert_eq!(v[\"surfaces\"][\"cli\"], false);\n```",
      "properties": {
        "claims": {
          "description": "How many claims it names.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "featured": {
          "description": "Whether the homepage shows it as a chapter.",
          "type": "boolean"
        },
        "headline": {
          "description": "The feature's promise.",
          "type": "string"
        },
        "id": {
          "description": "The feature id.",
          "type": "string"
        },
        "label": {
          "description": "The name a narrow column shows: the short title, or the title.",
          "type": "string"
        },
        "route": {
          "description": "`/features/<id>/`.",
          "type": "string"
        },
        "surfaces": {
          "$ref": "#/$defs/Surfaces",
          "description": "The interfaces it is exposed through."
        },
        "tested": {
          "description": "How many of them are guaranteed and name the test that settles them.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "title": {
          "description": "The feature as a heading.",
          "type": "string"
        },
        "use_cases": {
          "description": "How many use cases show it in use.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "id",
        "label",
        "title",
        "headline",
        "route",
        "featured",
        "surfaces",
        "claims",
        "tested",
        "use_cases"
      ],
      "type": "object"
    },
    "FeatureEvidence": {
      "description": "What is guaranteed about a feature, counted from the claims it names: never a word a\nperson wrote about the feature's maturity.",
      "properties": {
        "claims": {
          "additionalProperties": {
            "format": "uint",
            "minimum": 0,
            "type": "integer"
          },
          "description": "Claims by status: `guaranteed`, `advisory`, `planned`, `rejected`.",
          "type": "object"
        },
        "modules": {
          "additionalProperties": {
            "format": "uint",
            "minimum": 0,
            "type": "integer"
          },
          "description": "The modules it names by stability.",
          "type": "object"
        }
      },
      "required": [
        "claims",
        "modules"
      ],
      "type": "object"
    },
    "MomentRef": {
      "description": "One operational moment the feature answers: derived from the moments that name any of\nthe feature's commands, capabilities, claims or rules.",
      "properties": {
        "hook": {
          "description": "The first-person line an index shows.",
          "type": "string"
        },
        "id": {
          "description": "The moment id.",
          "type": "string"
        },
        "route": {
          "description": "`/why/<id>/`.",
          "type": "string"
        },
        "title": {
          "description": "The title.",
          "type": "string"
        }
      },
      "required": [
        "id",
        "title",
        "hook",
        "route"
      ],
      "type": "object"
    },
    "ResolvedDomain": {
      "description": "One domain, resolved: the record as its file declares it, and everything derived from\nthe stable features that name it.\n\nThe declared record is flattened, so a reader sees one object: the domain's own fields\nbeside its derived members and counts.\n\n```\nuse majordomus_cli::product::{Domain, DomainCounts, FeatureEvidence, ResolvedDomain, Surfaces};\nlet domain: Domain = serde_json::from_value(serde_json::json!({\n    \"id\": \"context\", \"title\": \"Context\", \"status\": \"stable\",\n    \"headline\": \"h\", \"problem\": \"p\",\n}))\n.unwrap();\nlet resolved = ResolvedDomain {\n    domain,\n    features: vec![],\n    surfaces: Surfaces::default(),\n    moments: vec![],\n    claim_refs: vec![],\n    use_case_refs: vec![],\n    counts: DomainCounts::default(),\n    evidence: FeatureEvidence::default(),\n};\nlet v = serde_json::to_value(&resolved).unwrap();\nassert_eq!(v[\"id\"], \"context\", \"the record is flattened into the resolved view\");\nassert_eq!(v[\"counts\"][\"features\"], 0);\n```",
      "properties": {
        "body": {
          "description": "The Markdown body, without its front matter.",
          "type": "string"
        },
        "claim_refs": {
          "description": "Derived: the distinct claims its features name, with their status and test.",
          "items": {
            "$ref": "#/$defs/ClaimRef"
          },
          "type": "array"
        },
        "counts": {
          "$ref": "#/$defs/DomainCounts",
          "description": "Derived: how much stands behind it."
        },
        "evidence": {
          "$ref": "#/$defs/FeatureEvidence",
          "description": "Derived: what is guaranteed, by claim status."
        },
        "features": {
          "description": "Derived: the stable features that name it, in presentation order.",
          "items": {
            "$ref": "#/$defs/DomainMember"
          },
          "type": "array"
        },
        "headline": {
          "description": "What the product does about this domain, in one sentence.",
          "type": "string"
        },
        "id": {
          "description": "The identity, the slug and the file name.",
          "type": "string"
        },
        "moments": {
          "description": "Derived: the operational moments its features answer, in the catalogue's order.",
          "items": {
            "$ref": "#/$defs/MomentRef"
          },
          "type": "array"
        },
        "problem": {
          "description": "The operational failure this domain answers, in one sentence.",
          "type": "string"
        },
        "route": {
          "default": "",
          "description": "Derived: `/domains/<id>/`. Never authored; the schema refuses a `route` key.",
          "type": "string"
        },
        "source": {
          "default": "",
          "description": "Derived: the repository-relative file the record came from.",
          "type": "string"
        },
        "status": {
          "description": "`stable`, `draft` or `deprecated`.",
          "type": "string"
        },
        "surfaces": {
          "$ref": "#/$defs/Surfaces",
          "description": "Derived: the interfaces any of its features is exposed through."
        },
        "tags": {
          "default": [],
          "description": "Free tags.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "title": {
          "description": "The domain as a heading: one word or two.",
          "type": "string"
        },
        "use_case_refs": {
          "description": "Derived: the distinct use cases its features name.",
          "items": {
            "$ref": "#/$defs/UseCaseRef"
          },
          "type": "array"
        },
        "weight": {
          "default": 0,
          "description": "Presentation order, lowest first.",
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "id",
        "title",
        "headline",
        "problem",
        "status",
        "features",
        "surfaces",
        "moments",
        "claim_refs",
        "use_case_refs",
        "counts",
        "evidence"
      ],
      "type": "object"
    },
    "Surfaces": {
      "description": "The interfaces a feature is exposed through, decided from what its references project\nand from nothing a file says. Each is a fact with a reason a reader can check: `cli` is\ntrue when a module of the feature has a capability with a command-line path or the\nfeature names a shell command; `api` when a module has an HTTP route; `mcp` when a module\nhas an MCP tool or resource, or the feature names a kind, since every object of the layer\nis an MCP resource; `cockpit` when the feature names a Cockpit area or a module, since\nevery capability has a Cockpit page; `docs` when it names a document.",
      "properties": {
        "api": {
          "description": "The HTTP routes under `/api/v1/`, and the OpenAPI document over them.",
          "type": "boolean"
        },
        "cli": {
          "description": "The command line: the executable's own, or the shell tool's.",
          "type": "boolean"
        },
        "cockpit": {
          "description": "The Cockpit.",
          "type": "boolean"
        },
        "docs": {
          "description": "The documentation.",
          "type": "boolean"
        },
        "mcp": {
          "description": "MCP: a tool, or a resource.",
          "type": "boolean"
        }
      },
      "required": [
        "cli",
        "api",
        "mcp",
        "cockpit",
        "docs"
      ],
      "type": "object"
    },
    "UseCaseRef": {
      "description": "One use case the feature names.",
      "properties": {
        "category": {
          "description": "The category it is filed under.",
          "type": [
            "string",
            "null"
          ]
        },
        "id": {
          "description": "The use case id.",
          "type": "string"
        },
        "title": {
          "description": "The title.",
          "type": "string"
        }
      },
      "required": [
        "id",
        "title"
      ],
      "type": "object"
    }
  },
  "description": "Every domain of the product, each with what its features add up to.",
  "properties": {
    "count": {
      "description": "How many domains are listed.",
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "domains": {
      "description": "The domains, in presentation order: the stable ones, or every one with status=any.",
      "items": {
        "$ref": "#/$defs/ResolvedDomain"
      },
      "type": "array"
    },
    "fingerprint": {
      "description": "The hash of the model's sources and derived facts.",
      "type": "string"
    },
    "schema": {
      "description": "`SCHEMA`.",
      "type": "string"
    }
  },
  "required": [
    "schema",
    "fingerprint",
    "count",
    "domains"
  ],
  "title": "DomainList",
  "type": "object"
}