blackboard.snapshot

Every worker of this repository — attached to a checkout's board or in an active mesh session on any linked machine — with the client it is, what it announced, its checkout, branch, machine and claims (advisory or exclusive); the claims that meet (potential, or confirmed when both are exclusive or the mesh marked one conflicted); the open reviews and untaken handovers; typed relations between workers, verified only when an explicit identifier joins them; the newest signals with the monitor's cursor a follower resumes from; each source with how it was read, and whether the answer is complete. Reads only.

query
experimental
module blackboard
#peers
#mesh
#monitor
#coordination

Exposure

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

surface	as
MCP	tool majordomus_blackboard
HTTP	GET /api/v1/blackboard operationId blackboard.snapshot
command line	majordomus blackboard

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

The input of blackboard.snapshot: how wide the board is, who reads it, and how much of what happened it carries.

property	type	required	description
checkouts	reference	no	Which checkouts' boards it covers: `repository` (every one, the default) or `this`. default "repository"
for	string \| null	no	Comma-separated names of the reader — a worker (`1b`), a role, a login — so that the signals addressed to it are marked `for_you`. An MCP caller is also its own board session.
signals	integer \| null	no	How many of the newest signals of the last hour it carries (default 30, at most 200); 0 reads no signals at all, for a follower that reads them by its own cursor.
sources	string \| null	no	A comma-separated subset of the monitor's sources, `mesh`, `executor` and `github` (default: `mesh,executor`).

JSON Schema

{
  "$defs": {
    "Checkouts": {
      "description": "Which checkouts a reading of the server status covers.\n\nThe two answers cost differently and that is the whole reason the choice exists: the\nrepository's checkouts are read from git's registry of them and each one costs a lease\nread and a probe, while this checkout alone costs one of each and enumerates nothing.\nThe word each variant serialises to is the word the query parameter, the tool input and\nthe command-line flag all take.\n\n```\nuse majordomus_cli::capability::builtin::server::Checkouts;\nassert_eq!(serde_json::to_value(Checkouts::This).unwrap(), \"this\");\nassert_eq!(serde_json::to_value(Checkouts::Repository).unwrap(), \"repository\");\nassert_eq!(Checkouts::default(), Checkouts::Repository, \"the wide answer is what a caller who says nothing has always got\");\n```",
      "oneOf": [
        {
          "const": "repository",
          "description": "Every checkout git registers for the repository, the primary first — a lease read\nand a probe each. The default, because it is the answer this capability gave before\nthere was anything to ask.",
          "type": "string"
        },
        {
          "const": "this",
          "description": "This checkout alone. No other checkout is enumerated, no other lease is read and no\nother server is probed; `servers` holds the one entry, and it is this one.",
          "type": "string"
        }
      ]
    }
  },
  "additionalProperties": false,
  "description": "The input of `blackboard.snapshot`: how wide the board is, who reads it, and how much of\nwhat happened it carries.",
  "properties": {
    "checkouts": {
      "$ref": "#/$defs/Checkouts",
      "default": "repository",
      "description": "Which checkouts' boards it covers: `repository` (every one, the default) or `this`."
    },
    "for": {
      "description": "Comma-separated names of the reader — a worker (`1b`), a role, a login — so that the signals addressed to it are marked `for_you`. An MCP caller is also its own board session.",
      "type": [
        "string",
        "null"
      ]
    },
    "signals": {
      "description": "How many of the newest signals of the last hour it carries (default 30, at most 200); 0 reads no signals at all, for a follower that reads them by its own cursor.",
      "format": "uint64",
      "minimum": 0,
      "type": [
        "integer",
        "null"
      ]
    },
    "sources": {
      "description": "A comma-separated subset of the monitor's sources, `mesh`, `executor` and `github` (default: `mesh,executor`).",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "title": "BlackboardInput",
  "type": "object"
}

output · Blackboard

The answer of blackboard.snapshot: who works on what in this repository, on every board and every linked machine, with what meets and what waits, read once from the records that know it.

property	type	required	description
at	string	yes	When it was read (RFC 3339).
boards	array	yes	Each checkout's board the summary lists: reached or not, with a server or a worker.
checkout	string	yes	The identity of the checkout whose server answered.
complete	boolean	yes	Whether every board was read and the mesh, when the repository declares one, could be asked. `false` names its reason in `sources`, so that "nobody is here" is never what "I could not ask" reads as. The monitor's sources are reported in `sources` with their state and do not decide it: an empty executor trail or an absent `gh` is no board that could not be read.
conflicts	array	yes	The claims that meet, at most a hundred, confirmed first.
conflicts_total	integer	yes	How many conflicts there are in all.
covered	integer	yes	How many checkouts the answer covers, listed in `boards` or counted in `omitted`.
cursor	string	yes	The monitor's cursor after these signals: where a follower resumes.
for_you	integer	yes	How many of them are for the reader.
handovers	array	yes	The handovers nobody has taken, at most fifty.
head	string \| null	no	That checkout's HEAD, when it has one.
omitted	object	no	The covered checkouts `boards` does not list, counted by standing (`absent`, `stale`): no server, nobody attached, no board.
present	integer	yes	How many workers are here now: attached to a board or in an active mesh session.
relations	array	yes	The typed relations between workers.
reviews	array	yes	The review requests nobody has answered, at most fifty.
signals	array	yes	The newest signals of the last hour, oldest first.
sources	array	yes	Each source and how it was read.
workers	array	yes	Every worker, this checkout's board first, then the other boards, then the mesh.

JSON Schema

{
  "$defs": {
    "BlackboardCertainty": {
      "description": "How sure a conflict is.",
      "oneOf": [
        {
          "const": "potential",
          "description": "Two claims meet and at least one of them is advisory: two workers about to touch the\nsame paths, told and not stopped.",
          "type": "string"
        },
        {
          "const": "confirmed",
          "description": "Two exclusive claims meet, or the mesh marked one conflicted: what an exclusive claim\nexists to prevent has happened.",
          "type": "string"
        }
      ]
    },
    "BlackboardClaim": {
      "description": "One claim a worker holds.",
      "properties": {
        "conflicted": {
          "description": "Whether the mesh found it conflicting with another live claim.",
          "type": "boolean"
        },
        "intent": {
          "description": "What it is for, in the worker's words.",
          "type": [
            "string",
            "null"
          ]
        },
        "issue": {
          "description": "The issue it is for, when the claim names one.",
          "type": [
            "string",
            "null"
          ]
        },
        "mode": {
          "$ref": "#/$defs/ClaimMode",
          "description": "`advisory` (an announcement: overlaps are reported) or `exclusive` (a second exclusive\nclaim meeting it is refused while it lives). A board announcement is advisory."
        },
        "name": {
          "description": "The claim's name, when its worker holds several.",
          "type": [
            "string",
            "null"
          ]
        },
        "record": {
          "description": "The mesh claim's key, when it is a journal record; a board announcement has none.",
          "type": [
            "string",
            "null"
          ]
        },
        "scope": {
          "description": "The repository paths it names.",
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "scope",
        "mode"
      ],
      "type": "object"
    },
    "BlackboardClaimRef": {
      "description": "One side of a conflict: a worker and which of its claims.",
      "properties": {
        "claim": {
          "description": "The claim's name, when it has one.",
          "type": [
            "string",
            "null"
          ]
        },
        "record": {
          "description": "The mesh claim's key, when it is a journal record.",
          "type": [
            "string",
            "null"
          ]
        },
        "worker": {
          "description": "The worker's key.",
          "type": "string"
        }
      },
      "required": [
        "worker"
      ],
      "type": "object"
    },
    "BlackboardConflict": {
      "description": "Two claims of two different workers whose scopes meet.",
      "properties": {
        "certainty": {
          "$ref": "#/$defs/BlackboardCertainty",
          "description": "Potential or confirmed."
        },
        "first": {
          "$ref": "#/$defs/BlackboardClaimRef",
          "description": "The claim that came first in the answer's order."
        },
        "paths": {
          "description": "The paths that meet, `yours` the first's and `theirs` the second's.",
          "items": {
            "$ref": "#/$defs/OverlapPath"
          },
          "type": "array"
        },
        "second": {
          "$ref": "#/$defs/BlackboardClaimRef",
          "description": "The claim that meets it."
        }
      },
      "required": [
        "certainty",
        "first",
        "second",
        "paths"
      ],
      "type": "object"
    },
    "BlackboardEvidence": {
      "description": "What a relation rests on.",
      "oneOf": [
        {
          "const": "verified",
          "description": "An explicit identifier or a journal record joins the two ends.",
          "type": "string"
        },
        {
          "const": "candidate",
          "description": "The ends could be joined and nothing proves it: more than one record fits.",
          "type": "string"
        }
      ]
    },
    "BlackboardHandover": {
      "description": "A handover published to the mesh that nobody has taken. Its body is not repeated here:\n`mesh.state` holds it. The journal names no recipient for a handover — whoever takes it\nis its addressee — so none is inferred here.",
      "properties": {
        "branch": {
          "description": "The branch it continues.",
          "type": [
            "string",
            "null"
          ]
        },
        "created_at": {
          "description": "When it was written.",
          "type": [
            "string",
            "null"
          ]
        },
        "id": {
          "description": "The handover's id.",
          "type": "string"
        },
        "issue": {
          "description": "The issue it continues.",
          "type": [
            "string",
            "null"
          ]
        },
        "name": {
          "description": "Its name, when it has one.",
          "type": [
            "string",
            "null"
          ]
        },
        "runtime": {
          "description": "The runtime that published it.",
          "type": "string"
        },
        "task": {
          "description": "The task it continues.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "id",
        "runtime"
      ],
      "type": "object"
    },
    "BlackboardOrigin": {
      "description": "Where a worker of the blackboard was found.",
      "oneOf": [
        {
          "const": "board",
          "description": "On a checkout's board: an MCP client attached to that checkout's server.",
          "type": "string"
        },
        {
          "const": "mesh",
          "description": "In the mesh journal only: a session no board of this repository holds — another\nmachine's, a task's, or a client's own.",
          "type": "string"
        }
      ]
    },
    "BlackboardPresence": {
      "description": "Whether a worker is here now.",
      "oneOf": [
        {
          "const": "attached",
          "description": "Attached to its board now.",
          "type": "string"
        },
        {
          "const": "departed",
          "description": "Gone from its board, kept because it still holds an announcement.",
          "type": "string"
        },
        {
          "const": "active",
          "description": "An open mesh session whose runtime still beats.",
          "type": "string"
        }
      ]
    },
    "BlackboardRelation": {
      "description": "A typed relation between two workers, or a worker and the addressee a record names.",
      "properties": {
        "evidence": {
          "$ref": "#/$defs/BlackboardEvidence",
          "description": "What it rests on."
        },
        "from": {
          "description": "A worker's key.",
          "type": "string"
        },
        "kind": {
          "$ref": "#/$defs/BlackboardRelationKind",
          "description": "What it is."
        },
        "record": {
          "description": "The record it rests on: a session or a review key.",
          "type": "string"
        },
        "to": {
          "description": "A worker's key, or the addressee as the record names it when no worker is it.",
          "type": "string"
        }
      },
      "required": [
        "kind",
        "evidence",
        "from",
        "to",
        "record"
      ],
      "type": "object"
    },
    "BlackboardRelationKind": {
      "description": "What a relation between two workers is.",
      "oneOf": [
        {
          "const": "same_worker",
          "description": "A board peer and a mesh session that may be one worker.",
          "type": "string"
        },
        {
          "const": "review",
          "description": "One worker asked another for a review.",
          "type": "string"
        }
      ]
    },
    "BlackboardReview": {
      "description": "A review request nobody has answered.",
      "properties": {
        "from": {
          "description": "The requesting worker's key, or its session key when no worker holds it.",
          "type": "string"
        },
        "issue": {
          "description": "The issue it names.",
          "type": [
            "string",
            "null"
          ]
        },
        "key": {
          "description": "The review's key in the journal.",
          "type": "string"
        },
        "reviewer": {
          "description": "Whom it asks, as the request names it; absent means anyone.",
          "type": [
            "string",
            "null"
          ]
        },
        "subject": {
          "description": "What it asks about.",
          "type": "string"
        }
      },
      "required": [
        "key",
        "from",
        "subject"
      ],
      "type": "object"
    },
    "BlackboardSource": {
      "description": "One source of the blackboard and how it was read.",
      "properties": {
        "reason": {
          "description": "Why it is not `ok`.",
          "type": [
            "string",
            "null"
          ]
        },
        "source": {
          "description": "`board`, `mesh`, or a monitor source as `monitor.<name>`.",
          "type": "string"
        },
        "state": {
          "$ref": "#/$defs/BlackboardSourceState",
          "description": "How it was read."
        }
      },
      "required": [
        "source",
        "state"
      ],
      "type": "object"
    },
    "BlackboardSourceState": {
      "description": "How one source of the blackboard was read.",
      "oneOf": [
        {
          "const": "ok",
          "description": "Read whole.",
          "type": "string"
        },
        {
          "const": "partial",
          "description": "Read, and some of what it covers could not be asked.",
          "type": "string"
        },
        {
          "const": "absent",
          "description": "Not read; the reason says why.",
          "type": "string"
        },
        {
          "const": "skipped",
          "description": "Not asked for.",
          "type": "string"
        }
      ]
    },
    "BlackboardWorker": {
      "description": "One worker of the repository: a board peer, a mesh session, or one of each that an\nexplicit identifier joins.",
      "properties": {
        "board_peer": {
          "description": "Its position on its board (`p3`): meaningful on that board only.",
          "type": [
            "string",
            "null"
          ]
        },
        "branch": {
          "description": "The branch it works on.",
          "type": [
            "string",
            "null"
          ]
        },
        "checkout": {
          "description": "The checkout's identity.",
          "type": [
            "string",
            "null"
          ]
        },
        "claims": {
          "description": "Its claims, board announcements and live mesh claims alike.",
          "items": {
            "$ref": "#/$defs/BlackboardClaim"
          },
          "type": "array"
        },
        "client": {
          "description": "The client's own name, from its MCP initialize or its mesh session.",
          "type": "string"
        },
        "connected_at": {
          "description": "When it attached to its board.",
          "type": [
            "string",
            "null"
          ]
        },
        "intent": {
          "description": "What it said it is doing; absent means it announced nothing.",
          "type": [
            "string",
            "null"
          ]
        },
        "issue": {
          "description": "The issue its mesh session names.",
          "type": [
            "string",
            "null"
          ]
        },
        "key": {
          "description": "Stable for as long as the worker is here: `board:<checkout>/<peer>` or\n`mesh:<stream>/<session>`. Never a bare peer id.",
          "type": "string"
        },
        "last_beat_ms": {
          "description": "Milliseconds since its runtime last beat. A beat is liveness, not work done.",
          "format": "uint64",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        },
        "last_seen_seconds_ago": {
          "description": "Seconds since its board last heard from it.",
          "format": "uint64",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        },
        "machine": {
          "description": "The machine's display name.",
          "type": [
            "string",
            "null"
          ]
        },
        "origin": {
          "$ref": "#/$defs/BlackboardOrigin",
          "description": "Where it was found."
        },
        "presence": {
          "$ref": "#/$defs/BlackboardPresence",
          "description": "Whether it is here now."
        },
        "runtime": {
          "description": "The runtime (`<node>-<runtime>`) its mesh session belongs to.",
          "type": [
            "string",
            "null"
          ]
        },
        "session": {
          "description": "Its mesh session's key, when it has one.",
          "type": [
            "string",
            "null"
          ]
        },
        "task": {
          "description": "The task its mesh session names.",
          "type": [
            "string",
            "null"
          ]
        },
        "title": {
          "description": "The client's display title or the worker it says it is, when it gave one.",
          "type": [
            "string",
            "null"
          ]
        },
        "version": {
          "description": "The client's version, from its initialize.",
          "type": [
            "string",
            "null"
          ]
        },
        "worktree": {
          "description": "The checkout's path on its machine.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "key",
        "origin",
        "presence",
        "client"
      ],
      "type": "object"
    },
    "BoardView": {
      "description": "One checkout's board, as the gather found it.\n\nPresent for every checkout the answer covers, whether or not its board could be read,\nbecause a listing that silently drops the checkouts it could not reach is the shape of\nanswer that made this capability wrong in the first place: a reader would see a short\nboard and conclude nobody else is working here.",
      "properties": {
        "attached": {
          "description": "How many of this board's peers are attached.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "branch": {
          "description": "The branch checked out there, when it could be read.",
          "type": [
            "string",
            "null"
          ]
        },
        "id": {
          "description": "The checkout's identity digest, the same value `server.status` reports as\n`checkout_id`. One per checkout, never a path, and stable across a restart.",
          "type": "string"
        },
        "reason": {
          "description": "Why this board is not in the answer. `None` when it is.",
          "type": [
            "string",
            "null"
          ]
        },
        "standing": {
          "$ref": "#/$defs/ServerStanding",
          "description": "Where its server stands, by the same reading `server.status` reports."
        },
        "stream": {
          "description": "The mesh stream of the server whose memory holds this board, when its mesh runs: the\nstream it projects the board's peers into as `board-pN` sessions. A position such as\n`p1` is that server's alone, so only this stream ties a board peer to its session.",
          "type": [
            "string",
            "null"
          ]
        },
        "this_checkout": {
          "description": "Whether this is the checkout of the server answering the call.",
          "type": "boolean"
        },
        "url": {
          "description": "The address its lease names, when it has one.",
          "type": [
            "string",
            "null"
          ]
        },
        "worktree": {
          "description": "Where the checkout is. The one thing on this board that a human can act on\ndirectly, and the one thing that survives a reconnect.",
          "type": "string"
        }
      },
      "required": [
        "id",
        "worktree",
        "this_checkout",
        "standing",
        "attached"
      ],
      "type": "object"
    },
    "ClaimMode": {
      "description": "Whether a claim excludes others or only tells them. Both are useful and they answer\ndifferent questions: an exclusive claim is a worker saying \"do not edit this while I\nam\", an advisory one is saying \"I am here\". Exclusive is the default because a claim\ntaken without a thought about the mode is a claim somebody expects to be respected.\n\n```\nuse majordomus_cli::mesh::journal::ClaimMode;\n\nassert_eq!(ClaimMode::default(), ClaimMode::Exclusive);\nassert_eq!(serde_json::to_value(ClaimMode::Advisory).unwrap(), serde_json::json!(\"advisory\"));\n```",
      "oneOf": [
        {
          "const": "exclusive",
          "description": "Exclusive: a second exclusive claim meeting this scope is refused while this one\nlives, on every runtime that knows of it.",
          "type": "string"
        },
        {
          "const": "advisory",
          "description": "Advisory: an announcement, like the peer board's. Overlaps are reported, never\nrefused.",
          "type": "string"
        }
      ]
    },
    "MonitorSeverity": {
      "description": "How much a signal asks of its reader.",
      "oneOf": [
        {
          "const": "info",
          "description": "Something happened; nothing is asked.",
          "type": "string"
        },
        {
          "const": "attention",
          "description": "Something failed or waits for someone: worth a look.",
          "type": "string"
        },
        {
          "const": "action",
          "description": "Something waits for the reader: a review asked of them, a handover for them.",
          "type": "string"
        }
      ]
    },
    "MonitorSignal": {
      "description": "One thing that happened, as one line a person or an agent can act on.",
      "properties": {
        "actor": {
          "description": "Who did it: a session's worker or client, the executor's actor, a GitHub login.",
          "type": [
            "string",
            "null"
          ]
        },
        "at": {
          "description": "When it happened, in Unix seconds, on the clock of whoever recorded it.",
          "format": "uint64",
          "minimum": 0,
          "type": "integer"
        },
        "branch": {
          "description": "The branch it is about.",
          "type": [
            "string",
            "null"
          ]
        },
        "for_you": {
          "default": false,
          "description": "Whether it names the reader: a review asked of them, an answer to their request, a\nhandover or a text that names them.",
          "type": "boolean"
        },
        "issue": {
          "description": "The issue it is about.",
          "type": [
            "string",
            "null"
          ]
        },
        "kind": {
          "description": "What happened, e.g. `session_joined`, `review_requested`, `merged`, `run_failed`.",
          "type": "string"
        },
        "link": {
          "description": "Where to read more, when there is a page for it.",
          "type": [
            "string",
            "null"
          ]
        },
        "machine": {
          "description": "The machine it happened on, by its display name when the mesh knows it.",
          "type": [
            "string",
            "null"
          ]
        },
        "paths": {
          "description": "The repository paths it is about.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "pr": {
          "description": "The pull request it is about.",
          "format": "uint64",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        },
        "session": {
          "description": "The session that did it.",
          "type": [
            "string",
            "null"
          ]
        },
        "severity": {
          "$ref": "#/$defs/MonitorSeverity",
          "description": "How much it asks of the reader."
        },
        "source": {
          "$ref": "#/$defs/MonitorSource",
          "description": "Which record it comes from."
        },
        "summary": {
          "description": "What happened, in one line of at most 200 characters.",
          "type": "string"
        }
      },
      "required": [
        "at",
        "source",
        "kind",
        "severity",
        "summary"
      ],
      "type": "object"
    },
    "MonitorSource": {
      "description": "Where a signal comes from.",
      "oneOf": [
        {
          "const": "mesh",
          "description": "The mesh journal: sessions on every linked machine (this checkout's board among\nthem), their claims, handovers and reviews.",
          "type": "string"
        },
        {
          "const": "executor",
          "description": "The executor's trail: the pull-request lane's merges, refreshes, repairs, closures\nand failures.",
          "type": "string"
        },
        {
          "const": "github",
          "description": "GitHub: pull requests opened, merged and closed, and finished workflow runs.",
          "type": "string"
        }
      ]
    },
    "OverlapPath": {
      "description": "One pair of claims that contain one another.",
      "properties": {
        "theirs": {
          "description": "The path the other peer claimed.",
          "type": "string"
        },
        "yours": {
          "description": "The path the announcing peer claimed.",
          "type": "string"
        }
      },
      "required": [
        "yours",
        "theirs"
      ],
      "type": "object"
    },
    "ServerStanding": {
      "description": "Where a checkout's server stands, decided from its lease, whether the server the lease\nnames answers for that checkout, and whether what answers is this executable's code.\n\n```\nuse majordomus_cli::capability::builtin::server::ServerStanding;\nlet all = [ServerStanding::Absent, ServerStanding::Starting, ServerStanding::Ready,\n           ServerStanding::Outdated, ServerStanding::Stale];\nlet words: Vec<&str> = all.iter().map(|s| s.as_str()).collect();\nassert_eq!(words, [\"absent\", \"starting\", \"ready\", \"outdated\", \"stale\"]);\nassert_eq!(serde_json::from_str::<ServerStanding>(\"\\\"stale\\\"\").unwrap(), ServerStanding::Stale);\n```",
      "oneOf": [
        {
          "const": "absent",
          "description": "No lease: nothing serves this checkout.",
          "type": "string"
        },
        {
          "const": "starting",
          "description": "A lease without an address, young enough that its owner is still binding.",
          "type": "string"
        },
        {
          "const": "ready",
          "description": "The server the lease names answers for this checkout, from the code on disk, at\nthis executable's version.",
          "type": "string"
        },
        {
          "const": "outdated",
          "description": "The server answers, but from older code than this executable, or from a file that\nhas been replaced since it started: everything it says is yesterday's.",
          "type": "string"
        },
        {
          "const": "stale",
          "description": "The lease names a server that does not answer, or is not a lease at all.",
          "type": "string"
        }
      ]
    }
  },
  "description": "The answer of `blackboard.snapshot`: who works on what in this repository, on every board\nand every linked machine, with what meets and what waits, read once from the records that\nknow it.",
  "properties": {
    "at": {
      "description": "When it was read (RFC 3339).",
      "type": "string"
    },
    "boards": {
      "description": "Each checkout's board the summary lists: reached or not, with a server or a worker.",
      "items": {
        "$ref": "#/$defs/BoardView"
      },
      "type": "array"
    },
    "checkout": {
      "description": "The identity of the checkout whose server answered.",
      "type": "string"
    },
    "complete": {
      "description": "Whether every board was read and the mesh, when the repository declares one, could be\nasked. `false` names its reason in `sources`, so that \"nobody is here\" is never what\n\"I could not ask\" reads as. The monitor's sources are reported in `sources` with their\nstate and do not decide it: an empty executor trail or an absent `gh` is no board that\ncould not be read.",
      "type": "boolean"
    },
    "conflicts": {
      "description": "The claims that meet, at most a hundred, confirmed first.",
      "items": {
        "$ref": "#/$defs/BlackboardConflict"
      },
      "type": "array"
    },
    "conflicts_total": {
      "description": "How many conflicts there are in all.",
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "covered": {
      "description": "How many checkouts the answer covers, listed in `boards` or counted in `omitted`.",
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "cursor": {
      "description": "The monitor's cursor after these signals: where a follower resumes.",
      "type": "string"
    },
    "for_you": {
      "description": "How many of them are for the reader.",
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "handovers": {
      "description": "The handovers nobody has taken, at most fifty.",
      "items": {
        "$ref": "#/$defs/BlackboardHandover"
      },
      "type": "array"
    },
    "head": {
      "description": "That checkout's HEAD, when it has one.",
      "type": [
        "string",
        "null"
      ]
    },
    "omitted": {
      "additionalProperties": {
        "format": "uint",
        "minimum": 0,
        "type": "integer"
      },
      "description": "The covered checkouts `boards` does not list, counted by standing (`absent`, `stale`):\nno server, nobody attached, no board.",
      "type": "object"
    },
    "present": {
      "description": "How many workers are here now: attached to a board or in an active mesh session.",
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "relations": {
      "description": "The typed relations between workers.",
      "items": {
        "$ref": "#/$defs/BlackboardRelation"
      },
      "type": "array"
    },
    "reviews": {
      "description": "The review requests nobody has answered, at most fifty.",
      "items": {
        "$ref": "#/$defs/BlackboardReview"
      },
      "type": "array"
    },
    "signals": {
      "description": "The newest signals of the last hour, oldest first.",
      "items": {
        "$ref": "#/$defs/MonitorSignal"
      },
      "type": "array"
    },
    "sources": {
      "description": "Each source and how it was read.",
      "items": {
        "$ref": "#/$defs/BlackboardSource"
      },
      "type": "array"
    },
    "workers": {
      "description": "Every worker, this checkout's board first, then the other boards, then the mesh.",
      "items": {
        "$ref": "#/$defs/BlackboardWorker"
      },
      "type": "array"
    }
  },
  "required": [
    "at",
    "checkout",
    "complete",
    "sources",
    "boards",
    "covered",
    "present",
    "workers",
    "conflicts",
    "conflicts_total",
    "reviews",
    "handovers",
    "relations",
    "signals",
    "for_you",
    "cursor"
  ],
  "title": "Blackboard",
  "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	2	this-checkout addressed
mcp	covered	2	this-checkout addressed
http	covered	2	this-checkout addressed