graph.get

One graph by id: its nodes and edges with the vocabularies that say what each kind means, the file every node was derived from, and whether the result is acyclic. Deterministic for a given tree and executable.

query
behaviorally_verified
module graph
#graph

Exposure

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

surface	as
MCP	tool majordomus_graph
HTTP	GET /api/v1/graph operationId graph.get
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 · GraphInput

Which graph to derive.

property	type	required	description
id	string	yes	The graph's id, as `graph.list` gives it (`registry`, `layer`, `rules`, `adrs`, `use-cases`).

JSON Schema

{
  "additionalProperties": false,
  "description": "Which graph to derive.",
  "properties": {
    "id": {
      "description": "The graph's id, as `graph.list` gives it (`registry`, `layer`, `rules`, `adrs`,\n`use-cases`).",
      "type": "string"
    }
  },
  "required": [
    "id"
  ],
  "title": "GraphInput",
  "type": "object"
}

output · Graph

A derived graph: what it is, where it came from, what its vocabularies mean, and the nodes and edges themselves.

property	type	required	description
description	string	yes	One paragraph: what a reader learns from it.
edge_kinds	object	yes	Edge kind to what that edge asserts.
edges	array	yes	Sorted.
id	string	yes	The identity, `[a-z][a-z0-9-]*`; the last segment of its route.
metadata	reference	yes	Counts and invariants.
node_kinds	object	yes	Node kind to what that kind means.
nodes	array	yes	Sorted by id.
source	string	yes	What it was derived from, in the repository's own words.
title	string	yes	The short name.

JSON Schema

{
  "$defs": {
    "Edge": {
      "description": "One directed edge. Both ends are node ids of the same graph; a derivation that cannot\nresolve an end adds an external node rather than a dangling edge.",
      "properties": {
        "kind": {
          "description": "One of the graph's declared edge kinds.",
          "type": "string"
        },
        "source": {
          "description": "The node the edge leaves.",
          "type": "string"
        },
        "target": {
          "description": "The node the edge enters.",
          "type": "string"
        }
      },
      "required": [
        "source",
        "target",
        "kind"
      ],
      "type": "object"
    },
    "Fact": {
      "anyOf": [
        {
          "description": "A yes or a no.",
          "type": "boolean"
        },
        {
          "description": "A whole number: an order, a version, a weight.",
          "format": "int64",
          "type": "integer"
        },
        {
          "description": "One short value.",
          "type": "string"
        },
        {
          "description": "Several short values.",
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      ],
      "description": "One fact a node carries from its object's front matter, in the shapes a node can hold."
    },
    "GraphMetadata": {
      "description": "What a reader needs to know about the graph as a whole before drawing it.",
      "properties": {
        "acyclic": {
          "description": "Whether the edges form a directed acyclic graph. Derived, never declared: a graph\nwhose contract is a DAG and whose answer here is `false` is a defect in the data.",
          "type": "boolean"
        },
        "edges": {
          "description": "How many edges.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "nodes": {
          "description": "How many nodes.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "truncated": {
          "description": "True when the derivation stopped at [`MAX_NODES`] and the graph is a prefix of\nwhat the repository holds.",
          "type": "boolean"
        }
      },
      "required": [
        "nodes",
        "edges",
        "acyclic",
        "truncated"
      ],
      "type": "object"
    },
    "Node": {
      "description": "One node. `id` is unique within the graph; `kind` is what the graph's `node_kinds`\ndeclares it to be; `route` is where the Cockpit shows the thing itself, when it shows\nit anywhere.",
      "properties": {
        "external": {
          "description": "True when the node stands for something the graph names but does not hold: a\nreference that resolves to nothing in this repository.",
          "type": "boolean"
        },
        "facts": {
          "additionalProperties": {
            "$ref": "#/$defs/Fact"
          },
          "description": "What the object's own kind declares about it, as its schema validated it: the\nfields of its front matter that are facts about the thing rather than the document\nitself. A rule carries its class and its statement, a skill its inputs and\noutputs, a decision its date — the vocabulary that makes each kind worth having,\nrather than the four fields every kind happens to share.",
          "type": "object"
        },
        "id": {
          "description": "Unique within the graph.",
          "type": "string"
        },
        "kind": {
          "description": "One of the graph's declared node kinds.",
          "type": "string"
        },
        "label": {
          "description": "The short label a renderer draws.",
          "type": "string"
        },
        "route": {
          "description": "Where the Cockpit shows this thing, when it shows it.",
          "type": [
            "string",
            "null"
          ]
        },
        "source": {
          "description": "The repository-relative file the node was derived from, when one file owns it.",
          "type": [
            "string",
            "null"
          ]
        },
        "status": {
          "description": "A status word the graph's own vocabulary defines (`accepted`, `active`, `query`).",
          "type": [
            "string",
            "null"
          ]
        },
        "summary": {
          "description": "One line about the thing, when the source holds one.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "id",
        "kind",
        "label"
      ],
      "type": "object"
    }
  },
  "description": "A derived graph: what it is, where it came from, what its vocabularies mean, and the\nnodes and edges themselves.",
  "properties": {
    "description": {
      "description": "One paragraph: what a reader learns from it.",
      "type": "string"
    },
    "edge_kinds": {
      "additionalProperties": {
        "type": "string"
      },
      "description": "Edge kind to what that edge asserts.",
      "type": "object"
    },
    "edges": {
      "description": "Sorted.",
      "items": {
        "$ref": "#/$defs/Edge"
      },
      "type": "array"
    },
    "id": {
      "description": "The identity, `[a-z][a-z0-9-]*`; the last segment of its route.",
      "type": "string"
    },
    "metadata": {
      "$ref": "#/$defs/GraphMetadata",
      "description": "Counts and invariants."
    },
    "node_kinds": {
      "additionalProperties": {
        "type": "string"
      },
      "description": "Node kind to what that kind means.",
      "type": "object"
    },
    "nodes": {
      "description": "Sorted by id.",
      "items": {
        "$ref": "#/$defs/Node"
      },
      "type": "array"
    },
    "source": {
      "description": "What it was derived from, in the repository's own words.",
      "type": "string"
    },
    "title": {
      "description": "The short name.",
      "type": "string"
    }
  },
  "required": [
    "id",
    "title",
    "description",
    "source",
    "node_kinds",
    "edge_kinds",
    "nodes",
    "edges",
    "metadata"
  ],
  "title": "Graph",
  "type": "object"
}

Policies

benchmark: required — a target on every transport the exposure declares; the cases are the input type's
cache: process — up to 16 entries in the process, scoped by the registry fingerprint

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	8	registry cold+warm layer cold+warm rules cold+warm adrs cold+warm use-cases cold+warm why cold+warm product cold+warm composed cold+warm
mcp	covered	8	registry cold+warm layer cold+warm rules cold+warm adrs cold+warm use-cases cold+warm why cold+warm product cold+warm composed cold+warm
http	covered	8	registry cold+warm layer cold+warm rules cold+warm adrs cold+warm use-cases cold+warm why cold+warm product cold+warm composed cold+warm