capabilities.projections

{
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "module": {
      "type": [
        "string",
        "null"
      ],
      "description": "Only capabilities composed in this module.",
      "default": null
    },
    "unmet": {
      "type": "boolean",
      "description": "Only the capabilities whose declared exposures are not all answered by their\nsurface. Empty is the closure the rule asks for.",
      "default": false
    }
  },
  "description": "The input of `capabilities.projections`: which rows, and whether only the unmet claims.",
  "title": "ProjectionsInput"
}

{
  "type": "object",
  "properties": {
    "rows": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/Row"
      },
      "description": "One row per capability, in id order."
    },
    "unbacked": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Runnable commands of the command line that no capability claims, in command order."
    },
    "unclassified": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Of those, the ones `crate::cli::local::LOCAL` does not explain either: a command\nthat is neither the projection of a capability nor declared command-line-only with\na reason. Empty is the closure the rule asks for; anything here is an operation\nthat left the API by accident rather than by decision."
    }
  },
  "required": [
    "rows",
    "unbacked",
    "unclassified"
  ],
  "description": "The whole matrix, with the findings and the debt beside it: one value that answers\n\"where does each capability appear, and is any claim unmet\".",
  "title": "ClosureMatrix",
  "$defs": {
    "Row": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "description": "The canonical id."
        },
        "module": {
          "type": "string",
          "description": "The module that composes it."
        },
        "kind": {
          "type": "string",
          "description": "Query, command or resource."
        },
        "stability": {
          "type": "string",
          "description": "Where it stands."
        },
        "effect": {
          "$ref": "#/$defs/ExecutionEffect",
          "description": "What a call changes: nothing, this process's memory, or the repository. The same\nclassification every projection reads, so the matrix answers \"where is it reachable\"\nand \"what does reaching it risk\" in one row."
        },
        "cli": {
          "type": [
            "string",
            "null"
          ],
          "description": "The command line, when it declares one and clap has it."
        },
        "http": {
          "type": [
            "string",
            "null"
          ],
          "description": "The HTTP route, when it declares one."
        },
        "mcp_tool": {
          "type": [
            "string",
            "null"
          ],
          "description": "The MCP tool name, when it declares one."
        },
        "mcp_resource": {
          "type": [
            "string",
            "null"
          ],
          "description": "The MCP resource URI, when it declares one."
        },
        "closed": {
          "type": "boolean",
          "description": "Whether every exposure this row declares is answered by its surface."
        },
        "source": {
          "type": "string",
          "description": "Where the capability is declared; repository-relative."
        }
      },
      "required": [
        "id",
        "module",
        "kind",
        "stability",
        "effect",
        "closed",
        "source"
      ],
      "description": "Where one capability is projected, and where it is not.\n\nThis is the coverage matrix of the rule: a row per capability, a column per interface.\nIt is derived, never written down — a capability that reaches nothing shows as a row of\n`false`, which is exactly the \"exists but is invisible\" case worth seeing."
    },
    "ExecutionEffect": {
      "oneOf": [
        {
          "type": "string",
          "const": "read",
          "description": "Nothing changes. Every query and every resource of this executable."
        },
        {
          "type": "string",
          "const": "process_state",
          "description": "This process's own memory changes, and nothing outside it."
        },
        {
          "type": "string",
          "const": "repository_mutation",
          "description": "The repository changes.\n\nFor most of this executable's life nothing classified to this, because no capability\nof any kind wrote to the repository. That day arrived with [ADR 0040]: development\nsemantics are capabilities of this runtime, and the first of them — `plan.transition`\n— stamps a field into an issue's own tracked record. The variant was put on the model\nin advance so that when one did, it would say so *here*, where a projection already\nreads it and a client already asks before running it, rather than in whichever page\nhappens to render its button.\n\nIt is not classified from the kind, because the kind cannot know it: a command that\nannounces a peer and a command that writes a tracked file are the same kind. A\nhandler that writes the repository says so with\n`ExecutionPolicy::writes_repository`, the way one that stops says so with\n`ExecutionPolicy::stoppable`.\n\n[ADR 0040]: https://github.com/korczis/prismatic-majordomus/blob/master/.ai/repo/adrs/0040-development-semantics-are-capabilities-of-one-runtime.md"
        }
      ],
      "description": "What running a capability changes outside the caller.\n\nClassified, never declared: it follows from the kind, which is the field a declaration\nalready carries. A projection reads this to decide whether to ask before running\nsomething — the Cockpit's confirmation is derived from it — instead of naming\ncapabilities it must treat carefully, which is a list that goes stale the day after it\nis written."
    }
  }
}