Skip to main content
Glama

Move an issue to another status (board drag = this call). Scrum + AI agent: only for issues in a sprint a person has started, else 409 `sprint_not_started` (D79). AI agent: a move out of another role's lane still happens but the result carries `warnings` (D136) — stop and tell the user.

transition_issue

Move an issue to another status (board drag = this call). Scrum + AI agent: only for issues in a sprint a person has started, else 409 sprint_not_started (D79). AI agent: a move out of another role's lane still happens but the result carries warnings (D136) — stop and tell the user.

status must be a status id from get_project (never one marked removing: true — 409 column_removing). For several field changes at once use update_issue instead. A status with requires_comment: true (Feedback template: Declined, D143) needs comment — the reason, written as a comment — in the SAME call, else 400 comment_required (details.status); the same rule holds for update_issue with status. Move to Declined only when the user asks. On a pipeline board an issue moves Backlog → To Do → Developing → Dev Done → then, for each environment in environments order, Testing (env) testing_<id> → Passed (env) passed_<id> → … → Done. When testing fails in an environment, move it to Test Rejected (test_rejected) and it goes back to development. "Deployed to UAT" / "testing on UAT" means testing_<id of UAT>; "passed UAT" means passed_<id> — look the id up in get_project environments. Scrum boards (spec D79): you may change the status only of issues in a sprint a PERSON has started (list_sprints state active); otherwise 409 sprint_not_started — do not retry, ask the user to start the sprint in BoardMark. Backlog planning (create_issue, update_issue fields other than status, move_to_sprint, comments) is always fine. Move only the part of the flow that belongs to your role (developer: To Do → In Progress/Developing → In Review/Dev Done; QA: → Done/Passed (env) or Test Rejected; BA: up to To Do), unless the project's docs or the user say otherwise. Lanes (spec D136): each status belongs to a role (get_docs_context shows the Lane column). Pass as_role (e.g. Developer, QA) when the user told you your role; otherwise your token's role is used. The move always happens, but when it leaves another role's lane the result carries warnings (role_lane, skip_lane, self_review): stop there, tell the user what you did, and hand off with a comment — undo it (transition back to from) if the user did not want it. transition_issue also takes working, touches and if_unassigned (D179), so moving a card to in progress and claiming it is one call. Agent work context (D179): working = what you are doing on this card, how and why (markdown, ≤ 600 characters) and touches = the files, modules or APIs you change (≤ 10 entries ≤ 120) — the next agent or person on a linked card reads them before changing the same things. When you START a card, do it in ONE call: status (the in-progress status), working, touches and if_unassigned: true — an unassigned card becomes yours in the same commit; 409 already_assigned (details.assignee) means someone else holds it: nothing was written, pick another card or ask the user. Update working again only when your approach changes — not every step (comments are for decisions people should be emailed about). null clears; entering a done status clears both. working_at / working_by / working_by_agent are set by BoardMark. A result warnings[] item with code: unresolved_blocker means this card is blocked_by a card that is not done (blocker: key, title, status, its working): the move is done — read that card (get_issue_context) and agree the order before you change what it touches. code: touch_overlap (D180) means another in-progress card touches the same files / folders (overlap: key, title, assignee, its touch, yours, its working): the move is done — read its working and agree who changes what first.

WRITE: version = from your latest read (get_issue, list_comments, list_sprints, get_doc, read_file). 409 version_conflict (details.current, details.current_version): re-read, re-apply your change, retry — never overwrite blindly; when the changes disagree, ask the user.

Input Schema

NameRequiredDescriptionDefault
reasonNoSpec D144: why you make this change (≤ 200 characters). Optional, but give it when you act as an agent account — it is shown in the agent's run log ("moved KJ-12 To Do → In Progress because <reason>"). board-mcp records it in `agent.run`; board-core / board-files accept it and ignore it (it never changes the file, the version or the history).
statusYesStatus id; must exist in the project's `project.md` statuses.
as_roleNoAI agents (spec D136): the role you work as in this session (e.g. Developer, QA, BA, DevOps) when the user told you one; else your token's role is used. Only changes lane warnings, never what you may do. Ignored for people.
commentNoSpec D143 (6): a comment written in the same commit as the move (a normal comment by the actor; watchers are notified once). Required when the target status has `requires_comment: true` (Feedback template: Declined) — missing or empty → 400 `comment_required` (`details.status`). Optional for every other status.
touchesNoSpec D179: the files, modules or APIs your work changes (≤ 10 entries of ≤ 120 characters, e.g. `board-core/internal/engine/`), the complete list. `null` or [] clears it.
versionYesOptimistic-lock version of the file; +1 on every write. Every write must send the version it read.
workingNoSpec D179: what you are doing on this card, how and why (markdown, ≤ 600 characters) — read by the next agent or person on a linked card. Write it when you start and again only when your approach changes, not every step. `null` or "" clears it. Stamps `working_at` / `working_by`; cleared by board-core when the issue enters a done status.
issue_keyYesIssue key `{PROJECT}-{n}`, e.g. `KJ-101`.
project_keyYesProject key, e.g. `KJ`. 2–10 chars, uppercase letters and digits, starts with a letter.
if_unassignedNoSpec D179: claim the issue atomically. true → if someone else holds it (`assignee` set and not you) nothing is written and the answer is `409 already_assigned` (`details.assignee`); otherwise the write goes ahead and, when the issue has no assignee and the request names none, you become the assignee in the same commit. "You" = your agent account `agt_…` (D144), else your user. Use it with `status`, `working` and `touches` in one call when you start a card.

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed3 schema fields changed
    • addedInput schema / properties / if_unassigned
      Added value: +{
      +  "description": "Spec D179: claim the issue atomically. true → if someone else holds it (`assignee` set and not you) nothing is written and the answer is `409 already_assigned` (`details.assignee`); otherwise the write goes ahead and, when the issue has no assignee and the request names none, you become the assignee in the same commit. \"You\" = your agent account `agt_…` (D144), else your user. Use it with `status`, `working` and `touches` in one call when you start a card.",
      +  "type": "boolean"
      +}
    • addedInput schema / properties / touches
      Added value: +{
      +  "anyOf": [
      +    {
      +      "items": {
      +        "maxLength": 120,
      +        "minLength": 1,
      +        "type": "string"
      +      },
      +      "maxItems": 10,
      +      "type": "array",
      +      "uniqueItems": true
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "description": "Spec D179: the files, modules or APIs your work changes (≤ 10 entries of ≤ 120 characters, e.g. `board-core/internal/engine/`), the complete list. `null` or [] clears it."
      +}
    • addedInput schema / properties / working
      Added value: +{
      +  "description": "Spec D179: what you are doing on this card, how and why (markdown, ≤ 600 characters) — read by the next agent or person on a linked card. Write it when you start and again only when your approach changes, not every step. `null` or \"\" clears it. Stamps `working_at` / `working_by`; cleared by board-core when the issue enters a done status.",
      +  "maxLength": 600,
      +  "type": [
      +    "string",
      +    "null"
      +  ]
      +}
  2. Changed2 schema fields changed
    • addedInput schema / properties / comment
      Added value: +{
      +  "description": "Spec D143 (6): a comment written in the same commit as the move (a normal comment by the actor; watchers are notified once). Required when the target status has `requires_comment: true` (Feedback template: Declined) — missing or empty → 400 `comment_required` (`details.status`). Optional for every other status.",
      +  "maxLength": 20000,
      +  "minLength": 1,
      +  "type": "string"
      +}
    • addedInput schema / properties / reason
      Added value: +{
      +  "description": "Spec D144: why you make this change (≤ 200 characters). Optional, but give it when you act as an agent account — it is shown in the agent's run log (\"moved KJ-12 To Do → In Progress because <reason>\"). board-mcp records it in `agent.run`; board-core / board-files accept it and ignore it (it never changes the file, the version or the history).",
      +  "maxLength": 200,
      +  "type": "string"
      +}
  3. First observed

TDQS

A4.7/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations only declare the safety profile (not read-only, non-idempotent, non-destructive); the description goes far beyond, disclosing 409 sprint_not_started and comment_required, the warnings[] codes (role_lane, skip_lane, self_review, unresolved_blocker, touch_overlap), that entering a done status clears working/touches, and the optimistic-lock retry protocol. This is exactly the side-effect and failure-mode context the annotations leave out.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose and the hard Sprint constraint are front-loaded, but the body is a dense wall of prose that restates the `working`, `touches`, and `if_unassigned` schema descriptions almost verbatim. Much of it earns its place (error codes, lane rules, pipeline flow), but the duplication and sheer length cost readability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 10-parameter mutation with no output schema, the description covers everything an agent needs: status sourcing, pipeline flow, role lanes, comment requirements, atomic claim behavior, warnings handling, and version-conflict recovery. Nothing material is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3, and the description adds real meaning beyond it: status must come from get_project and never be `removing: true` (409 column_removing), and it prescribes the one-call combination of status + working + touches + if_unassigned when starting a card. It repeats some schema param text (working/touches/if_unassigned) rather than adding to it, so it stops short of 5.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The opening sentence states a specific verb and resource ('Move an issue to another status') and equates it to a board drag, and it explicitly names update_issue as the sibling for multi-field changes. An agent can distinguish this from update_issue and move_to_sprint without opening any schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives explicit when-to-use, when-not, and alternatives: use update_issue for several field changes, only move to Declined when the user asks, don't retry on 409 sprint_not_started, and stay in your role's lane unless docs/user say otherwise. Prerequisites (sprint started by a person, lane ownership, requires_comment) are all spelled out.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.

Resources