devtask.issue

Identity, title, intent, status, milestone, acceptance criteria, dependencies, blockers, the commits its own evidence names and the commits git found, its branches, the sessions that worked on it, its readiness and everything wrong with its records — each field carrying whether a person authored it (`explicit`), a machine worked it out by a rule that cannot be wrong (`derived`), a machine worked it out by a rule that can (`inferred`, with the rule stated), or it is not available at all (`unknown`, with the reason). A key the record does not carry is `unknown`, never an empty string: `objective: ""` and a record with no objective are the same string and different facts. An id the model does not declare is answered, not refused. `git: false` answers from the records alone, which is what a comparison across machines wants.

query
behaviorally_verified
module devtask
#devtask
#plan
#issue
#provenance
#readiness
#git

Exposure

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

surface	as
MCP	tool majordomus_devtask
HTTP	GET /api/v1/devtask/issue operationId devtask.issue
command line	majordomus devtask issue

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

Which issue to read as a development task.

property	type	required	description
git	boolean \| null	no	Consult git for the branches and commits that realised it. Default: yes. Set it to false for a deterministic answer that depends on the records alone — which is what a generated document or a comparison across machines wants.
issue	string	yes	The issue id, as the canonical model spells it (`I0901`). An id the model does not declare is answered with `declared: false` and every canonical field `unknown`, never refused and never answered with empty strings that read as authored.

JSON Schema

{
  "additionalProperties": false,
  "description": "Which issue to read as a development task.",
  "properties": {
    "git": {
      "description": "Consult git for the branches and commits that realised it. Default: yes. Set it to\nfalse for a deterministic answer that depends on the records alone — which is what a\ngenerated document or a comparison across machines wants.",
      "type": [
        "boolean",
        "null"
      ]
    },
    "issue": {
      "description": "The issue id, as the canonical model spells it (`I0901`). An id the model does not\ndeclare is answered with `declared: false` and every canonical field `unknown`,\nnever refused and never answered with empty strings that read as authored.",
      "type": "string"
    }
  },
  "required": [
    "issue"
  ],
  "title": "DevTaskInput",
  "type": "object"
}

output · DevTask

One issue as an executable development task: what was authored, where it sits, what has happened to it, where its external projection stands, and whether a worker may start it.

property	type	required	description
attestation	reference	yes	How much of the answer was authored and how much a machine worked out.
declaration	reference	yes	What a person authored.
declared	boolean	yes	Whether the canonical model declares it. False is answered rather than refused, with every canonical field `unknown`: a typo that read as "nothing has been authored" is the one answer this must never give.
diagnostics	array	yes	Everything wrong with its records.
execution	reference	yes	What happened locally.
issue	string	yes	The issue id, as asked for.
position	reference	yes	Where the plan graph puts it.
readiness	reference	yes	Whether it can be worked on, and what is in the way.
record	string \| null	no	Repository-relative path of the canonical record, when there is one.
synchronisation	reference	yes	Where the external projection stands.

JSON Schema

{
  "$defs": {
    "AttestationTally": {
      "description": "How much of one answer was authored, and how much a machine worked out.\n\nNot decoration: it is the measurement that makes the provenance discipline checkable\nfrom outside. A task whose declaration is mostly `unknown` is a placeholder however\ncomplete its derived half looks, and this is the number that says so.",
      "properties": {
        "derived": {
          "description": "Fields worked out by a rule that cannot be wrong about a readable repository.",
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        },
        "explicit": {
          "description": "Fields a person authored in the canonical record.",
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        },
        "inferred": {
          "description": "Fields worked out by a rule that can be wrong.",
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        },
        "unknown": {
          "description": "Fields not available at all.",
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "explicit",
        "derived",
        "inferred",
        "unknown"
      ],
      "type": "object"
    },
    "AttestedCount": {
      "description": "A count with its provenance. Separate from [`AttestedText`] because a wave, a commit\ntally and an evidence count are numbers a caller does arithmetic on, and a number\nrendered as a string is a number every client has to parse back.",
      "properties": {
        "provenance": {
          "$ref": "#/$defs/FieldProvenance",
          "description": "Where it came from."
        },
        "reason": {
          "description": "Why the provenance is what it is, when that is worth a sentence.",
          "type": [
            "string",
            "null"
          ]
        },
        "source": {
          "description": "The one place a reader goes to check it.",
          "type": "string"
        },
        "value": {
          "description": "The number, absent exactly when the provenance is `unknown`.",
          "format": "uint32",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        }
      },
      "required": [
        "provenance",
        "source"
      ],
      "type": "object"
    },
    "AttestedList": {
      "description": "A list with its provenance. The distinction a bare `Vec` cannot make is the one that\nmatters here: `depends_on: []` in the record is an authored empty list, and a record with\nno `depends_on` key is unknown. Both are empty; only one is a statement.",
      "properties": {
        "provenance": {
          "$ref": "#/$defs/FieldProvenance",
          "description": "Where they came from."
        },
        "reason": {
          "description": "Why the provenance is what it is, when that is worth a sentence.",
          "type": [
            "string",
            "null"
          ]
        },
        "source": {
          "description": "The one place a reader goes to check them.",
          "type": "string"
        },
        "values": {
          "description": "The items, in the order the record or the derivation produced them. Empty for an\nauthored empty list and for an unknown field alike; `provenance` tells them apart.",
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "values",
        "provenance",
        "source"
      ],
      "type": "object"
    },
    "AttestedText": {
      "description": "One scalar with its provenance: the unit every field of a development task is made of.\n\nThe invariant the constructors enforce, and [`AttestedText::is_consistent`] states, is\nthat a value is present exactly when the provenance is not [`FieldProvenance::Unknown`].\nWithout it the shape can express \"unknown, and here is the value\", which is the defect\nthis whole module exists to prevent.",
      "properties": {
        "provenance": {
          "$ref": "#/$defs/FieldProvenance",
          "description": "Where it came from."
        },
        "reason": {
          "description": "Why the provenance is what it is, when that is worth a sentence: always for\n`unknown` and for `inferred`, and omitted otherwise.",
          "type": [
            "string",
            "null"
          ]
        },
        "source": {
          "description": "The one place a reader goes to check it: a repository-relative path with the key it\nwas read from, a capability id, or a command. Never a machine path.",
          "type": "string"
        },
        "value": {
          "description": "The value, absent exactly when the provenance is `unknown`.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "provenance",
        "source"
      ],
      "type": "object"
    },
    "Blocker": {
      "description": "One thing standing between a task and being startable, with what to do about it.",
      "properties": {
        "detail": {
          "description": "What is wrong, in one line a person can act on.",
          "type": "string"
        },
        "kind": {
          "$ref": "#/$defs/BlockerKind",
          "description": "What kind of thing it is."
        },
        "subject": {
          "description": "The thing: an issue id, a milestone id, an evidence token.",
          "type": "string"
        }
      },
      "required": [
        "kind",
        "subject",
        "detail"
      ],
      "type": "object"
    },
    "BlockerKind": {
      "description": "What kind of thing is holding a task back. The five are the five the canonical model can\nactually produce; there is no `other`.",
      "oneOf": [
        {
          "const": "issue",
          "description": "An issue this one depends on that is not `DONE`.",
          "type": "string"
        },
        {
          "const": "milestone",
          "description": "The milestone gate: an outcome this one's milestone requires is not `DONE`.",
          "type": "string"
        },
        {
          "const": "evidence",
          "description": "A required evidence token the record does not carry, with completion recorded.",
          "type": "string"
        },
        {
          "const": "reference",
          "description": "A dependency that resolves to nothing: the model has no such issue.",
          "type": "string"
        },
        {
          "const": "cycle",
          "description": "A dependency cycle this task is in or downstream of, so it can never become ready.",
          "type": "string"
        }
      ]
    },
    "DevTaskDeclaration": {
      "description": "What a person authored in the canonical record. Every field is [`FieldProvenance::Explicit`]\nor [`FieldProvenance::Unknown`] and nothing else: a value here was written down, or it\ndoes not exist.",
      "properties": {
        "acceptance_criteria": {
          "$ref": "#/$defs/AttestedList",
          "description": "What must be true before it is finished."
        },
        "cancelled": {
          "$ref": "#/$defs/AttestedText",
          "description": "Whether it was withdrawn."
        },
        "completed_at": {
          "$ref": "#/$defs/AttestedText",
          "description": "When completion was recorded."
        },
        "completion": {
          "$ref": "#/$defs/AttestedText",
          "description": "What the author says about how far it got. Authored prose, never a status: the\nstatus is derived, and this is the one field where a person may disagree with it."
        },
        "created_at": {
          "$ref": "#/$defs/AttestedText",
          "description": "When the record was created."
        },
        "current_state": {
          "$ref": "#/$defs/AttestedText",
          "description": "Where the repository stands before it."
        },
        "depends_on": {
          "$ref": "#/$defs/AttestedList",
          "description": "The issues it declares a dependency on, exactly as declared — including one that\ndoes not exist, which is a diagnostic and not a silent omission."
        },
        "desired_state": {
          "$ref": "#/$defs/AttestedText",
          "description": "Where the repository stands once it is real."
        },
        "evidence_commits": {
          "$ref": "#/$defs/AttestedList",
          "description": "The commits the record's own evidence entries name. Authored, and therefore a\ndifferent fact from the commits git finds on the branches — which are in\n[`DevTaskExecution::commits`] and are derived."
        },
        "evidence_present": {
          "$ref": "#/$defs/AttestedList",
          "description": "The evidence tokens it actually carries."
        },
        "evidence_required": {
          "$ref": "#/$defs/AttestedList",
          "description": "The evidence tokens it requires before it may be complete."
        },
        "milestone": {
          "$ref": "#/$defs/AttestedText",
          "description": "The milestone it belongs to."
        },
        "non_scope": {
          "$ref": "#/$defs/AttestedList",
          "description": "The paths it deliberately does not touch."
        },
        "objective": {
          "$ref": "#/$defs/AttestedText",
          "description": "What the issue is for."
        },
        "owner": {
          "$ref": "#/$defs/AttestedText",
          "description": "Who owns it."
        },
        "parallel_safe": {
          "$ref": "#/$defs/AttestedText",
          "description": "Whether it may run beside another issue of its wave."
        },
        "priority": {
          "$ref": "#/$defs/AttestedText",
          "description": "`p0` … `p3`."
        },
        "profile": {
          "$ref": "#/$defs/AttestedText",
          "description": "The execution profile it is worked under."
        },
        "risk": {
          "$ref": "#/$defs/AttestedText",
          "description": "What could go wrong."
        },
        "scope": {
          "$ref": "#/$defs/AttestedList",
          "description": "The paths it may touch."
        },
        "slug": {
          "$ref": "#/$defs/AttestedText",
          "description": "The slug."
        },
        "started_at": {
          "$ref": "#/$defs/AttestedText",
          "description": "When execution began."
        },
        "title": {
          "$ref": "#/$defs/AttestedText",
          "description": "One line naming the outcome."
        },
        "updated_at": {
          "$ref": "#/$defs/AttestedText",
          "description": "When it last moved."
        },
        "validation": {
          "$ref": "#/$defs/AttestedList",
          "description": "The commands that check it."
        },
        "verified_at": {
          "$ref": "#/$defs/AttestedText",
          "description": "When implementation was declared finished."
        },
        "why": {
          "$ref": "#/$defs/AttestedText",
          "description": "Why it is worth doing."
        }
      },
      "required": [
        "title",
        "objective",
        "why",
        "current_state",
        "desired_state",
        "completion",
        "milestone",
        "priority",
        "profile",
        "parallel_safe",
        "owner",
        "risk",
        "slug",
        "cancelled",
        "created_at",
        "updated_at",
        "started_at",
        "verified_at",
        "completed_at",
        "scope",
        "non_scope",
        "depends_on",
        "acceptance_criteria",
        "validation",
        "evidence_required",
        "evidence_present",
        "evidence_commits"
      ],
      "type": "object"
    },
    "DevTaskDiagnostic": {
      "description": "One thing wrong with this task's records, in the shape `project.finding-carries-reproduce`\nasks for.",
      "properties": {
        "code": {
          "description": "The stable code a reader greps for.",
          "type": "string"
        },
        "level": {
          "description": "`FAIL` or `WARN`, as the plan's own finding levels.",
          "type": "string"
        },
        "message": {
          "description": "What is wrong, in one line.",
          "type": "string"
        },
        "reproduce": {
          "description": "The one command that shows it again.",
          "type": "string"
        }
      },
      "required": [
        "level",
        "code",
        "message",
        "reproduce"
      ],
      "type": "object"
    },
    "DevTaskExecution": {
      "description": "Local execution state: what actually happened in this checkout's git history and session\nrecords. Derived where the relation was declared, inferred where it was not, and the\nfields say which.",
      "properties": {
        "branches": {
          "$ref": "#/$defs/AttestedList",
          "description": "The branches whose name carries this issue's id, local first."
        },
        "commits": {
          "$ref": "#/$defs/AttestedCount",
          "description": "How many distinct commits those branches hold that the trunk did not."
        },
        "commits_complete": {
          "$ref": "#/$defs/AttestedText",
          "description": "True when every branch's commits could be derived. False when one reached the trunk\nwithout a merge commit of its own, so part of the work cannot be told from the\ntrunk's — reported rather than counted as zero."
        },
        "git_consulted": {
          "description": "Whether git was consulted at all. False makes every git-derived field below\n`unknown` rather than empty, which is the difference between \"nothing realised this\"\nand \"nobody looked\".",
          "type": "boolean"
        },
        "merged_branches": {
          "$ref": "#/$defs/AttestedList",
          "description": "Of those, the ones that reached the trunk."
        },
        "sessions": {
          "$ref": "#/$defs/AttestedList",
          "description": "The session records whose own `issues` key names this issue. Derived: the key is\nworked out from the episode's ledger events, not authored and not guessed."
        },
        "sessions_by_branch": {
          "$ref": "#/$defs/AttestedList",
          "description": "The session records that reach this issue only through their branch name, and which\ntherefore may be wrong. Never overlaps [`DevTaskExecution::sessions`]: a session that\ndeclared the issue is reported there and not here, so the weaker relation never\nstands in for the stronger one."
        },
        "trunk": {
          "$ref": "#/$defs/AttestedText",
          "description": "The trunk every branch was measured against."
        }
      },
      "required": [
        "git_consulted",
        "branches",
        "merged_branches",
        "commits",
        "trunk",
        "commits_complete",
        "sessions",
        "sessions_by_branch"
      ],
      "type": "object"
    },
    "DevTaskPosition": {
      "description": "Where the task sits in the plan graph. Every field is derived; nothing here is authored,\nand nothing here is stored anywhere.",
      "properties": {
        "blocked_by": {
          "$ref": "#/$defs/AttestedList",
          "description": "The dependencies that are not `DONE`, plus the milestone gate when it applies."
        },
        "dependents": {
          "$ref": "#/$defs/AttestedList",
          "description": "The issues that wait on this one."
        },
        "evidence_have": {
          "$ref": "#/$defs/AttestedCount",
          "description": "How many evidence tokens it carries."
        },
        "evidence_need": {
          "$ref": "#/$defs/AttestedCount",
          "description": "How many it needs."
        },
        "milestone_blocked_by": {
          "$ref": "#/$defs/AttestedList",
          "description": "The outcomes that milestone still waits on."
        },
        "milestone_rank": {
          "$ref": "#/$defs/AttestedCount",
          "description": "The milestone's layer in the milestone graph."
        },
        "milestone_status": {
          "$ref": "#/$defs/AttestedText",
          "description": "The status of the milestone it belongs to."
        },
        "status": {
          "$ref": "#/$defs/AttestedText",
          "description": "The canonical status, from the one derivation of it."
        },
        "transitive_dependents": {
          "$ref": "#/$defs/AttestedCount",
          "description": "Every issue that waits on it, directly or through another. The measure of what\nfinishing it unblocks."
        },
        "wave": {
          "$ref": "#/$defs/AttestedCount",
          "description": "The execution wave: one past the longest path to it. Unknown when a cycle prevents\nit from ever having one."
        }
      },
      "required": [
        "status",
        "wave",
        "blocked_by",
        "dependents",
        "transitive_dependents",
        "milestone_status",
        "milestone_rank",
        "milestone_blocked_by",
        "evidence_have",
        "evidence_need"
      ],
      "type": "object"
    },
    "DevTaskSynchronisation": {
      "description": "The external projection. Nothing here is ever written by this executable, and the fields\nthat only the adapter can answer say so rather than reading as empty.",
      "properties": {
        "adapter": {
          "description": "The adapter that owns the projection. The one thing that can answer the live state.",
          "type": "string"
        },
        "external_id": {
          "$ref": "#/$defs/AttestedText",
          "description": "The external record's own identifier — a GitHub number — which GitHub assigns and\nnothing local records. Always `unknown`, for the same reason."
        },
        "reconcile_with": {
          "description": "The commands that answer the external half.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "repository": {
          "$ref": "#/$defs/AttestedText",
          "description": "The repository the projection targets, from `project.yaml`."
        },
        "state": {
          "$ref": "#/$defs/AttestedText",
          "description": "The reconciliation state of the external record. Always `unknown` from here: it is a\nnetwork fact, and this executable makes none. The reason names the command."
        },
        "writable": {
          "description": "Whether this executable may write any of it. Always false; stated as a field so that\na client need not know the rule to respect it.",
          "type": "boolean"
        }
      },
      "required": [
        "adapter",
        "repository",
        "state",
        "external_id",
        "reconcile_with",
        "writable"
      ],
      "type": "object"
    },
    "FieldProvenance": {
      "description": "Where a value came from, and therefore how much weight a reader may put on it.\n\nThe four words are not degrees of confidence, they are four different relations to the\nrepository, and the distinction that matters most is the first from the last two: a\nperson wrote it, or a machine worked it out.\n\n```\nuse majordomus_cli::devtask::{AttestedText, FieldProvenance};\n\n// a value the record itself carried\nlet title = AttestedText::explicit(\"Ship it\", \".ai/repo/project/issues/I0001.yaml#title\");\nassert_eq!(title.provenance, FieldProvenance::Explicit);\n\n// a key the record does not have is unknown, and unknown carries no value\nlet missing = AttestedText::unknown(\n    \".ai/repo/project/issues/I0001.yaml#objective\",\n    \"the record declares no `objective`\",\n);\nassert_eq!(missing.provenance, FieldProvenance::Unknown);\nassert!(missing.value.is_none());\n```",
      "oneOf": [
        {
          "const": "explicit",
          "description": "A person authored it, in the canonical record, under this key. The strongest thing\nthat can be said about a value, and the only one that survives a rewrite of every\nderivation in this repository.",
          "type": "string"
        },
        {
          "const": "derived",
          "description": "A machine worked it out from records or from git, by a rule that cannot be wrong\nabout a repository it can read: an issue's dependents are the issues that name it.\nRe-derived on every call and stored nowhere.",
          "type": "string"
        },
        {
          "const": "inferred",
          "description": "A machine worked it out by a rule that *can* be wrong, because the relation it reads\nwas never declared: a session belongs to an issue because its branch name contains\nthe issue's id. Useful, and never to be mistaken for a declaration.",
          "type": "string"
        },
        {
          "const": "unknown",
          "description": "Not available. Either the record does not carry the key, or the fact lives outside\nwhat this process may read — a live GitHub state, for one — and the field says which\nin its `reason`. An unknown field never carries a value.",
          "type": "string"
        }
      ]
    },
    "ReadinessVerdict": {
      "description": "The readiness verdict, with everything it was derived from beside it.",
      "properties": {
        "blockers": {
          "description": "Everything standing in the way, each with what to do about it.",
          "items": {
            "$ref": "#/$defs/Blocker"
          },
          "type": "array"
        },
        "canonical_status": {
          "description": "The canonical status it refines, so the two can never be read apart.",
          "type": "string"
        },
        "reason": {
          "description": "Why it is in that state, in one line.",
          "type": "string"
        },
        "startable": {
          "description": "May a worker pick it up right now?",
          "type": "boolean"
        },
        "state": {
          "$ref": "#/$defs/TaskReadiness",
          "description": "Where the task stands, as work."
        },
        "terminal": {
          "description": "Is there nothing further to do?",
          "type": "boolean"
        }
      },
      "required": [
        "state",
        "canonical_status",
        "reason",
        "startable",
        "terminal",
        "blockers"
      ],
      "type": "object"
    },
    "TaskReadiness": {
      "description": "Where a development task stands, as work.\n\n```\nuse majordomus_cli::devtask::TaskReadiness;\n\n// every state names the canonical status it refines, and refines only one\nassert_eq!(TaskReadiness::Ready.canonical(), \"READY\");\nassert_eq!(TaskReadiness::Waiting.canonical(), \"BLOCKED\");\nassert_eq!(TaskReadiness::Blocked.canonical(), \"BLOCKED\");\nassert_eq!(TaskReadiness::Review.canonical(), \"VERIFY\");\nassert_eq!(TaskReadiness::CompletionBlocked.canonical(), \"VERIFY\");\n\n// and one state is the absence of a record rather than a status of one\nassert!(TaskReadiness::Undeclared.canonical().is_empty());\n```",
      "oneOf": [
        {
          "const": "ready",
          "description": "Nothing holds it back and nobody has started it. Canonical `READY`.",
          "type": "string"
        },
        {
          "const": "blocked",
          "description": "At least one issue it depends on is not `DONE`. Canonical `BLOCKED`.",
          "type": "string"
        },
        {
          "const": "waiting",
          "description": "Every issue dependency is satisfied; the milestone gate holds it. Canonical\n`BLOCKED`, and a distinct situation because it is resolved in another milestone.",
          "type": "string"
        },
        {
          "const": "in_progress",
          "description": "Execution began: the record carries `started_at`. Canonical `ACTIVE`.",
          "type": "string"
        },
        {
          "const": "review",
          "description": "Implementation is declared finished and completion has not been recorded: the record\ncarries `verified_at`. Canonical `VERIFY`.",
          "type": "string"
        },
        {
          "const": "completion_blocked",
          "description": "Completion *was* recorded and the evidence the record itself requires is not all\nthere, so the plan refuses to call it `DONE`. Canonical `VERIFY`, and the case the\n`evidence_missing` finding is about.",
          "type": "string"
        },
        {
          "const": "complete",
          "description": "Finished on its own terms: not cancelled, completion recorded, every required\nevidence token present. Canonical `DONE`.",
          "type": "string"
        },
        {
          "const": "cancelled",
          "description": "Withdrawn. Canonical `CANCELLED`.",
          "type": "string"
        },
        {
          "const": "undeclared",
          "description": "The canonical model does not declare this id. Not a status: the absence of a record.",
          "type": "string"
        }
      ]
    }
  },
  "description": "One issue as an executable development task: what was authored, where it sits, what has\nhappened to it, where its external projection stands, and whether a worker may start it.",
  "properties": {
    "attestation": {
      "$ref": "#/$defs/AttestationTally",
      "description": "How much of the answer was authored and how much a machine worked out."
    },
    "declaration": {
      "$ref": "#/$defs/DevTaskDeclaration",
      "description": "What a person authored."
    },
    "declared": {
      "description": "Whether the canonical model declares it. False is answered rather than refused, with\nevery canonical field `unknown`: a typo that read as \"nothing has been authored\" is\nthe one answer this must never give.",
      "type": "boolean"
    },
    "diagnostics": {
      "description": "Everything wrong with its records.",
      "items": {
        "$ref": "#/$defs/DevTaskDiagnostic"
      },
      "type": "array"
    },
    "execution": {
      "$ref": "#/$defs/DevTaskExecution",
      "description": "What happened locally."
    },
    "issue": {
      "description": "The issue id, as asked for.",
      "type": "string"
    },
    "position": {
      "$ref": "#/$defs/DevTaskPosition",
      "description": "Where the plan graph puts it."
    },
    "readiness": {
      "$ref": "#/$defs/ReadinessVerdict",
      "description": "Whether it can be worked on, and what is in the way."
    },
    "record": {
      "description": "Repository-relative path of the canonical record, when there is one.",
      "type": [
        "string",
        "null"
      ]
    },
    "synchronisation": {
      "$ref": "#/$defs/DevTaskSynchronisation",
      "description": "Where the external projection stands."
    }
  },
  "required": [
    "issue",
    "declared",
    "declaration",
    "position",
    "execution",
    "synchronisation",
    "readiness",
    "diagnostics",
    "attestation"
  ],
  "title": "DevTask",
  "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	records-only with-git
mcp	covered	2	records-only with-git
http	covered	2	records-only with-git