Read work items. ops: get (id) → one normalized issue; query (role / typeRole / assignee, @me allowed / iteration, @current allowed / limit) → a filtered list; iterations (no args) → the provider's sprints, each with a current flag, empty where the provider has none.

Change a work item’s content. ops: create (title, typeRole, optional body/parentId/labels/initialRole); update (id, title and/or body — a patch, omitted fields are left alone); comment (id, body); assign (id, assignee — @me allowed); link (fromId, toId, type); set_iteration (id, iteration — @current allowed). Roles and type roles are abstract: the active policy maps them to the provider’s own states and types.

Move a work item through the workflow, or flag it. ops: transition (id, role, optional fields) — the semantic role layer, resolving an abstract role to the provider’s native state/column/label; on a provider whose transition carries a screen (Jira) a refusal with code TRANSITION_FIELDS_REQUIRED names the fields to pass back, verbatim, as fields; reconcile (id) — clear a role label the provider’s own state contradicts, commanding no role; block (id, reason — required) and unblock (id, optional reason), which set and clear an ORTHOGONAL flag and leave the role alone, so an item keeps the role it is blocked in.

Read source-control state. ops: pr_status (pullRequestId) → normalized state, review decision, mergeability and a checks rollup; pr_for_branch (sourceBranch, optional state — open default / merged / closed / all) → the most recent matching PR or null. open is the idempotency probe before creating one; merged is the drift probe.

Change source-control state. ops: branch_create (name, optional fromBranch — idempotent); pr_create (title, sourceBranch, optional targetBranch/body/draft/assignees/autoComplete, plus linkedIssueKey and linkedIssueRelation — closes finishes the item on merge, relates only references it); pr_thread (pullRequestId, body); pr_ready (pullRequestId) — take it out of draft; pr_merge (pullRequestId, optional strategy/deleteSourceBranch). A provider that declines a merge surfaces as MERGE_FAILED rather than a false success.

List the runnable recipes (built-ins + project recipes) with their declared inputs. Call this to discover what baron_recipe_run accepts before running a workflow.

Run a named recipe end-to-end as ONE deterministic, rule-enforced workflow (the engine — not you — enforces the step order). Supply all required inputs (from baron_recipe_list) in inputs; a missing required input errors rather than prompting. Prefer this over composing the individual issue/scm/ci tools yourself for a packaged workflow. Returns the run context as JSON (with its runId), and — when the recipe had anything to say — a SECOND text block with its messages. Read that block: it is where a recipe reports what it could not verify (task-land warns there when it merged past checks it could not see). Every run is journaled: if one fails partway, do NOT run it again from scratch (that repeats the steps that already mutated the provider — a second PR). Call this with resume: <runId> from the error instead: completed steps are replayed from the journal and the run carries on from where it stopped.

Record something durable in Baron's own store (not a provider's). ops: learning (title, body, optional tags) — a decision worth keeping; followup (title, optional body/tags) — an open loop to come back to.

Read Baron's own store. ops: learning (optional tag/text/limit); followup (optional status/tag/limit).

ESCAPE HATCH — a raw, authenticated, NON-PORTABLE provider REST call. Last resort for when no normalized tool (issue/scm/ci/notify) covers the need. You supply the provider-native method + path (+ query/body); Baron only attaches the base URL + auth and returns the (size-capped) response. Prefer the normalized tools — this is provider-specific and will not port to another provider. Only providers bound in the active policy are reachable.