MCP tools

Generated from the MCP server of OpenRig 0.7.10 (commit a226b1b6): rig mcp serve over stdio, MCP tools/list. No tool was called. 37 tools, in the server's order.

This is the full list a local caller sees. A caller over rig mcp serve --http with a grant that is not an owner grant is offered fewer: its work tools, and the workspace tools only with --workspace.

Required inputs are marked below. JSON schemas are kept in full for nested constraints.

rig_up

Launch a rig from a rig spec (.yaml), a .rigbundle or a .rigtopology, or restore an existing rig by its name from its latest snapshot

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "sourceRef": {
      "type": "string",
      "description": "An absolute path to a rig spec (.yaml), .rigbundle or .rigtopology, or the name of an existing rig to restore. The daemon reads the path, so a relative one resolves against the daemon's directory."
    },
    "plan": {
      "description": "Plan mode — preview without executing",
      "type": "boolean"
    },
    "autoApprove": {
      "description": "Auto-approve trusted actions",
      "type": "boolean"
    },
    "targetRoot": {
      "description": "Target root directory for package installation",
      "type": "string"
    },
    "cwd": {
      "description": "Working directory for a new launch's agents. It must be absolute: this server has no caller directory to resolve a relative one against.",
      "type": "string"
    },
    "env": {
      "description": "Environment variables for a new launch from one rig spec or bundle, not saved with the rig (as rig up --env NAME=value). A .rigtopology or a restore by name doesn't use them.",
      "type": "object",
      "propertyNames": {
        "type": "string",
        "pattern": "^[A-Z_][A-Z0-9_]*$"
      },
      "additionalProperties": {
        "type": "string",
        "minLength": 1
      }
    },
    "rigName": {
      "description": "A new launch's rig name instead of the spec's (as rig up --name)",
      "type": "string",
      "minLength": 1
    },
    "fresh": {
      "description": "When restoring an existing rig: the seats (logical ids, e.g. dev.impl) to start fresh instead of resuming (as rig up --fresh)",
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "sourceRef"
  ]
}

rig_down

Tear down a rig

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "rigId": {
      "type": "string",
      "description": "Rig name or identifier to tear down"
    },
    "delete": {
      "description": "Delete rig record after stopping",
      "type": "boolean"
    },
    "force": {
      "description": "Kill sessions immediately",
      "type": "boolean"
    },
    "snapshot": {
      "description": "Take snapshot before teardown",
      "type": "boolean"
    }
  },
  "required": [
    "rigId"
  ]
}

rig_ps

List rigs and their status

No inputs.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {}
}

rig_status

Check daemon health

No inputs.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {}
}

rig_snapshot_create

Create a snapshot for a rig

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "rigId": {
      "type": "string",
      "description": "Rig name or identifier"
    }
  },
  "required": [
    "rigId"
  ]
}

rig_snapshot_list

List snapshots for a rig

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "rigId": {
      "type": "string",
      "description": "Rig name or identifier"
    }
  },
  "required": [
    "rigId"
  ]
}

rig_restore

Start restoring a rig from a snapshot. It answers at once with an attemptId while the restore runs in the background; follow the attempt with rig_restore_status.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "rigId": {
      "type": "string",
      "description": "Rig name or identifier"
    },
    "snapshotId": {
      "type": "string",
      "description": "Snapshot identifier"
    }
  },
  "required": [
    "rigId",
    "snapshotId"
  ]
}

rig_restore_status

Read where a restore attempt stands: the receipt for the attemptId rig_restore returned. An attempt with no completion yet (still running, or stopped before it finished) answers attempt_incomplete; it isn't a receipt.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "rigId": {
      "type": "string",
      "description": "Rig name or identifier"
    },
    "attemptId": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991,
      "description": "The attemptId rig_restore returned"
    }
  },
  "required": [
    "rigId",
    "attemptId"
  ]
}

rig_discover

Scan for tmux sessions to discover

No inputs.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {}
}

rig_bind

Bind a discovered session to an existing node or create a new node in a pod

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "discoveryId": {
      "type": "string",
      "description": "Discovery session identifier"
    },
    "rigId": {
      "type": "string",
      "description": "Target rig name or identifier"
    },
    "logicalId": {
      "description": "Existing node logical ID (mode: bind to existing)",
      "type": "string"
    },
    "podNamespace": {
      "description": "Pod namespace to create node in (mode: create in pod)",
      "type": "string"
    },
    "memberName": {
      "description": "Member name for new node (required with podNamespace)",
      "type": "string"
    }
  },
  "required": [
    "discoveryId",
    "rigId"
  ]
}

rig_bundle_inspect

Inspect a .rigbundle file

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "bundlePath": {
      "type": "string",
      "description": "Path to .rigbundle file"
    }
  },
  "required": [
    "bundlePath"
  ]
}

rig_agent_validate

Validate an AgentSpec (agent.yaml) from YAML text

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "yaml": {
      "type": "string",
      "description": "YAML text of the agent spec"
    }
  },
  "required": [
    "yaml"
  ]
}

rig_rig_validate

Validate a RigSpec (rig.yaml) from YAML text

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "yaml": {
      "type": "string",
      "description": "YAML text of the rig spec"
    }
  },
  "required": [
    "yaml"
  ]
}

rig_rig_nodes

Get node inventory for a rig — session names, status, attach commands, resume commands

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "rigId": {
      "type": "string",
      "description": "Rig name or identifier"
    }
  },
  "required": [
    "rigId"
  ]
}

rig_send

Send a message to an agent's terminal using reliable two-step send

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "session": {
      "type": "string",
      "description": "Target session name (e.g. dev-impl@my-rig)"
    },
    "text": {
      "type": "string",
      "description": "Message text to send"
    },
    "verify": {
      "description": "Verify delivery by checking pane content",
      "type": "boolean"
    },
    "force": {
      "description": "Send even if target appears mid-task",
      "type": "boolean"
    },
    "waitForIdleSeconds": {
      "description": "Wait until explicit idle evidence before sending. If the seat is still busy or its activity is unknown when the wait ends, nothing is sent and nothing is kept; separate work belongs in a queue row",
      "type": "number",
      "exclusiveMinimum": 0
    }
  },
  "required": [
    "session",
    "text"
  ]
}

rig_capture

Capture terminal output from an agent session

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "session": {
      "description": "Session name (omit for multi-target with rig/pod)",
      "type": "string"
    },
    "rig": {
      "description": "Capture all sessions in a rig",
      "type": "string"
    },
    "pod": {
      "description": "Capture all sessions in a pod",
      "type": "string"
    },
    "lines": {
      "description": "Number of lines to capture (default: 20)",
      "type": "number"
    }
  }
}

rig_chatroom_send

Send a message to a rig's chatroom as this server's seat

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "rigName": {
      "type": "string",
      "description": "Rig name or identifier"
    },
    "body": {
      "type": "string",
      "description": "Message body"
    }
  },
  "required": [
    "rigName",
    "body"
  ]
}

rig_chatroom_watch

Read a rig's recent chatroom messages: the most recent ones (default 20), oldest first, optionally one topic's or one sender's. It returns what is there now and doesn't wait for new messages.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "rigName": {
      "type": "string",
      "description": "Rig name or identifier"
    },
    "topic": {
      "description": "Only messages in this topic",
      "type": "string"
    },
    "sender": {
      "description": "Only messages from this seat",
      "type": "string"
    },
    "limit": {
      "description": "How many recent messages (default 20)",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "rigName"
  ]
}

rig_add

Add a single member to an existing pod in a running rig (the add_member converge op). Identity-migration-free: mints a fresh seat, nothing existing re-keys.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "rigId": {
      "type": "string",
      "description": "Target rig name or identifier"
    },
    "podNamespace": {
      "type": "string",
      "description": "Namespace of the existing pod to add the member to"
    },
    "member": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {},
      "description": "Member fragment with spec snake_case fields: id, runtime, agent_ref, profile, cwd (and optional model, codex_config_profile, restore_policy, label)"
    },
    "edges": {
      "description": "Optional pod-local edges (from/to are member ids within the pod; resolved against the new member + existing pod-mates)",
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "from": {
            "type": "string"
          },
          "to": {
            "type": "string"
          },
          "kind": {
            "type": "string"
          }
        },
        "required": [
          "from",
          "to",
          "kind"
        ]
      }
    },
    "rigRoot": {
      "description": "Root directory for agent resolution",
      "type": "string"
    }
  },
  "required": [
    "rigId",
    "podNamespace",
    "member"
  ]
}

rig_queue_create

Hand a task to another seat as a durable queue item. Returns its qitemId: read the answer later with rig_queue_show. If the call times out, check rig_queue_show with the same qitemId before retrying; never retry with a new id. To ask for a revision of earlier work, name it in revises: the new item opens with 'Revision of <id>' and records it in its chainOfRecord.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "destination": {
      "type": "string",
      "description": "Destination seat (e.g. dev-impl@my-rig)"
    },
    "body": {
      "type": "string",
      "description": "The task: what to do and what to return"
    },
    "summary": {
      "description": "One-line summary",
      "type": "string"
    },
    "tags": {
      "description": "Tags, e.g. mission:<name>",
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "priority": {
      "description": "Priority (as rig queue create --priority)",
      "type": "string"
    },
    "tier": {
      "description": "Tier (as rig queue create --tier)",
      "type": "string"
    },
    "qitemId": {
      "description": "Request id to reuse when retrying the same create (default: a new id)",
      "type": "string"
    },
    "revises": {
      "description": "The qitemId of the work this asks to revise",
      "type": "string"
    },
    "alert": {
      "description": "For an ask to a person that's urgent: something only they can do, or an approval whose wait costs now (as rig queue create --alert). It stands out in Slack. Without it the ask still posts to Slack unless the person's Slack subscription is urgent-only, in which case it waits on Steering and the TUI",
      "type": "boolean"
    }
  },
  "required": [
    "destination",
    "body"
  ]
}

rig_queue_show

Read one queue item and its transitions. For a task you handed off, this is where its answer is: the state, the closure reason and target, the notes the assignee recorded, and evidenceRef when it names an artifact (read it with rig_artifact_read). When the item was handed on, successor names the next item (on another host: its id and host); follow it with rig_queue_show. null means none was found. A revision names the work it revises in chainOfRecord.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "qitemId": {
      "type": "string",
      "description": "The qitemId returned by rig_queue_create (or any queue item)"
    }
  },
  "required": [
    "qitemId"
  ]
}

rig_queue_list

List queue items. owned: assigned to this seat. mine: this seat is the source or the destination. Without a scope, this seat's rig. Without state, open items only (all adds closed ones); a state filter returns exactly those states, closed ones included. since finds work updated after a time; handedOffFrom finds where a handed-off item went.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "owned": {
      "description": "Only items assigned to this seat: its whole inbox (overrides destination)",
      "type": "boolean"
    },
    "mine": {
      "description": "Items this seat sent or owns",
      "type": "boolean"
    },
    "destination": {
      "description": "Filter by destination seat",
      "type": "string"
    },
    "source": {
      "description": "Filter by source seat",
      "type": "string"
    },
    "state": {
      "description": "Only these states, comma-separated; closed states included when named",
      "type": "string"
    },
    "all": {
      "description": "Without state: include closed items",
      "type": "boolean"
    },
    "since": {
      "description": "Only items updated at or after this ISO-8601 time, e.g. done work since Monday: state done, since 2026-10-19",
      "type": "string"
    },
    "handedOffFrom": {
      "description": "The items handed on from this qitemId, in any state and any rig",
      "type": "string"
    },
    "limit": {
      "description": "Result limit (default 100)",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  }
}

rig_queue_claim

Claim a queue item assigned to this seat before working on it.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "qitemId": {
      "type": "string",
      "description": "The queue item to claim"
    }
  },
  "required": [
    "qitemId"
  ]
}

rig_queue_update

Update a queue item: add a note, block it, close it, or reopen a closed one. To answer a task, close it with state done, a closure reason and the answer in resolution, which the item keeps; note records why this transition happened.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "qitemId": {
      "type": "string",
      "description": "The queue item to update"
    },
    "state": {
      "description": "New state (e.g. in-progress, blocked, done)",
      "type": "string"
    },
    "closureReason": {
      "description": "Why it closed: no-follow-on for finished work, or handed_off_to, denied, canceled, escalation or superseded (as rig queue update --closure-reason)",
      "type": "string"
    },
    "closureTarget": {
      "description": "Closure target, when the reason needs one",
      "type": "string"
    },
    "note": {
      "description": "Transition note: progress, or why this transition happened (required to reopen)",
      "type": "string"
    },
    "resolution": {
      "description": "The outcome the item keeps, stored only by the update that closes an open item (as rig queue update --resolution)",
      "type": "string"
    },
    "reopen": {
      "description": "Reopen a closed item: give an active state (pending, in-progress or blocked) and a note (as rig queue update --reopen)",
      "type": "boolean"
    },
    "summary": {
      "description": "Replace the one-line summary",
      "type": "string"
    },
    "evidenceRef": {
      "description": "Pointer to the durable artifact, stored on the item when closing with state done or parking on a human seat; other updates refuse it",
      "type": "string"
    },
    "blockedOn": {
      "description": "What it waits on, when blocking: another qitemId (this item returns to pending when that one closes), or the address of the person this item came from, not a shared channel (they're asked with this item's summary, and their answer returns it to you in progress)",
      "type": "string"
    },
    "wakeAfterSeconds": {
      "description": "Wake this seat after this many seconds, when blocking. Delivered only to a seat with a terminal: an attached app can't receive it today, so the item just waits until it is checked.",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "qitemId"
  ]
}

rig_environment_export

Transfer a bound worker's actual JSON artifact to the host, verify its bytes/schema/context and append a durable receipt to its existing work. Does not close work, stop compute or restore native history. Requires an authenticated HTTP work connection.

Part of rig environment, the OpenShell worker. Its cleanup still fails against OpenShell 0.1.6, so recreate and restore can't run; see What's new.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "bindingId": {
      "type": "string"
    },
    "operationId": {
      "type": "string"
    },
    "taskId": {
      "type": "string"
    },
    "generation": {
      "type": "string"
    },
    "path": {
      "type": "string"
    },
    "sha256": {
      "type": "string"
    },
    "bytes": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 1048576
    },
    "schema": {
      "type": "object",
      "properties": {
        "format": {
          "type": "string",
          "const": "json-object/v1"
        },
        "fields": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "type": "string",
            "enum": [
              "string",
              "number",
              "boolean"
            ]
          }
        },
        "required": {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      },
      "required": [
        "format",
        "fields",
        "required"
      ]
    },
    "context": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": [
          "string",
          "number",
          "boolean"
        ]
      }
    }
  },
  "required": [
    "bindingId",
    "operationId",
    "taskId",
    "generation",
    "path",
    "sha256",
    "bytes",
    "schema",
    "context"
  ]
}

rig_telemetry_events

Read one bounded page of event metadata: seq, rig, node, type and time, never payloads. Without a cursor it starts at the newest event and returns no rows; start retained reads the retained past instead. Continue with page.nextCursor and the same filters. coverage.gaps names any history it could not read, including a daemon restart, after which the old cursor can't continue.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "cursor": {
      "description": "page.nextCursor from the previous page; not with start",
      "type": "string"
    },
    "start": {
      "description": "Without a cursor: latest (default) or retained",
      "type": "string",
      "enum": [
        "latest",
        "retained"
      ]
    },
    "rigId": {
      "description": "Rig name or identifier; events with no rig are left out",
      "type": "string"
    },
    "nodeId": {
      "description": "Node identifier",
      "type": "string"
    },
    "limit": {
      "description": "Source rows to scan (default and maximum 128); a filter can return fewer",
      "type": "integer",
      "minimum": 1,
      "maximum": 128
    }
  }
}

rig_whoami

Show which OpenRig seat this server acts as: its rig, pod, peers and edges, and caller: authenticated (a validated HTTP credential, with its principal) or declared (OPENRIG_SESSION_NAME where the server was configured, which nothing verifies).

No inputs.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {}
}

rig_team

Show a rig's team: its lead, the rig's one delegates_to root (the seat that delegates to others and that nothing delegates to: the seat to delegate to), and each seat's pod, role, runtime, delegation (reportsTo, delegatesTo) and activity as the daemon reports it. Activity the daemon doesn't know reads unknown, never idle. hostedMembers are the rig's members that live outside a terminal (roster entries marked hosted): their authored capabilities and limits, with no pane and activity unknown.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "rigId": {
      "type": "string",
      "description": "Rig name or identifier"
    }
  },
  "required": [
    "rigId"
  ]
}

rig_slices

List the work tree's slices, most recently active first: name, mission, status, description and how many queue items name it. Paths and readiness detail are left out.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "missionId": {
      "description": "Only this mission's slices",
      "type": "string"
    },
    "filter": {
      "description": "Only slices with this status (default all)",
      "type": "string",
      "enum": [
        "all",
        "active",
        "done",
        "blocked"
      ]
    },
    "limit": {
      "description": "Most slices to return (default 50)",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    }
  }
}

rig_mission

Read one mission: its status and its slices as summaries.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "missionId": {
      "type": "string",
      "description": "The mission's id (its folder name)"
    }
  },
  "required": [
    "missionId"
  ]
}

rig_context_pack

Show one context pack: its purpose and the files it declares (path, role, summary, estimated tokens), so a file can be read with rig_context_get as <pack>/<file>.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "ref": {
      "type": "string",
      "description": "The pack's ref, as rig context list shows it (e.g. project-world)"
    }
  },
  "required": [
    "ref"
  ]
}

rig_context_get

Read one context file or one section of it, as rig context get does: <pack>/<file>, or <pack>/<file>#<h2-slug>[/<h3-slug>]. Text over 48000 characters is cut (truncated: true); address a section to read the rest.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "address": {
      "type": "string",
      "description": "<pack>/<file>[#<h2-slug>[/<h3-slug>]]"
    }
  },
  "required": [
    "address"
  ]
}

rig_artifact_read

Read a finished item's artifact (its evidenceRef), or a named file, through the daemon's shared roots (OPENRIG_FILES_ALLOWLIST), as text: at most 48000 characters from offset; nextOffset reads on. An artifact outside every shared root, a link, or an item with no evidenceRef comes back as available: false with the reason and the shared roots' names; nothing outside those roots is read.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "qitemId": {
      "description": "Read this item's evidenceRef",
      "type": "string"
    },
    "root": {
      "description": "A shared root's name: with path, the file to read; with qitemId, the root a relative evidenceRef is under",
      "type": "string"
    },
    "path": {
      "description": "With root: the file's path inside that root",
      "type": "string"
    },
    "offset": {
      "description": "The character to start from (default 0)",
      "type": "integer",
      "minimum": 0,
      "maximum": 9007199254740991
    }
  }
}

rig_human_decision_room

Before deciding a question you asked a person: the decision room of the mode they have on, in their own words (what the team may decide for them meanwhile, and what it may not), or none, with why. You judge whether your decision falls inside it; with none, the question stays theirs to answer.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "qitemId": {
      "type": "string",
      "description": "Your pending ask to the person (a queue item addressed to <person>@external)"
    }
  },
  "required": [
    "qitemId"
  ]
}

rig_queue_decide

Record a decision you made on a person's behalf, on your own pending ask to them, inside the decision room of the mode they have on: read it first with rig_human_decision_room and pass its applicationId. It's recorded beside their answers, never as one, and the ask closes. The daemon refuses it when they have no room, their mode changed since you read it, the ask is a permission prompt or an approval gate, they've started answering, or another seat asked. This server never answers as the person.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "qitemId": {
      "type": "string",
      "description": "Your pending ask to the person"
    },
    "applicationId": {
      "type": "string",
      "description": "decisionRoom.applicationId from rig_human_decision_room: the room you judged against"
    },
    "choices": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "questionId": {
            "description": "The question's id, when the ask has structured questions",
            "type": "string"
          },
          "chosen": {
            "type": "string",
            "description": "The option's id; for an ask without questions, the choice in words"
          }
        },
        "required": [
          "chosen"
        ]
      },
      "description": "One choice per structured question; for an ask without questions, one choice without questionId"
    },
    "reason": {
      "type": "string",
      "description": "Why this choice"
    },
    "reversible": {
      "type": "boolean",
      "description": "Whether the decision can be undone"
    }
  },
  "required": [
    "qitemId",
    "applicationId",
    "choices",
    "reason",
    "reversible"
  ]
}

rig_queue_handoff

Pass a queue item this seat holds on to the next seat in one step: the item closes as handed off and a new item opens for that seat, carrying the work's lineage in chainOfRecord, so whoever follows the work reaches the new item from rig_queue_show. Without body the new item keeps the task's text. If the call times out, check rig_queue_show on this qitemId before retrying: when it reads handed off, its successor is the new item, so don't hand it off again.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "qitemId": {
      "type": "string",
      "description": "The queue item to pass on"
    },
    "to": {
      "type": "string",
      "description": "The next seat (e.g. qa@my-rig)"
    },
    "body": {
      "description": "The task as the next seat should read it (default: the item's own text)",
      "type": "string"
    },
    "note": {
      "description": "Transition note on the item passed on: why it goes there",
      "type": "string"
    },
    "summary": {
      "description": "One-line summary for the new item",
      "type": "string"
    },
    "tags": {
      "description": "Tags for the new item (default: the item's own)",
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "priority": {
      "description": "Priority for the new item (default: the item's own)",
      "type": "string"
    },
    "evidenceRef": {
      "description": "Pointer to the durable artifact, which a new item for a person needs",
      "type": "string"
    }
  },
  "required": [
    "qitemId",
    "to"
  ]
}

rig_queue_unclaim

Put back a queue item this seat claimed and won't finish: it returns to pending for its destination seat, ready to be claimed again, and the transition records why. Only a claimed (in-progress) item can be put back. To pass the work to another seat instead, use rig_queue_handoff.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "qitemId": {
      "type": "string",
      "description": "The claimed queue item to put back"
    },
    "reason": {
      "description": "Why it's put back, recorded as 'unclaimed: <reason>' (default: manual)",
      "type": "string"
    }
  },
  "required": [
    "qitemId"
  ]
}