mcp server

retasc

The issue tracker AI coding agents pull work from: atomic claims, dependency-aware dispatch.

Description as published by the maintainer. Source

• version 1.0.0
• active

active — Registry entry last updated 2026-07-21.

What this server can do

35 functions, named and described by the server itself. Parameter names are shown because they say more about what a function does than its name usually does.

add_relation(type, sourceId, targetId)

Link two issues. type: blocks | blocked_by | related | duplicate. `blocks`/`blocked_by` form the dependency graph that drives blocking; dependency cycles are rejected. If this call is refused for billing (BILLING_INACTIVE or MONTHLY_CAP_REACHED), the response carries `tellHuman`, a ready-to-relay sentence: PASS IT TO YOUR HUMAN. You cannot fix it yourself — only an owner can — so do NOT absorb the refusal and continue with read-only work as if the session were healthy; every value-bearing write will keep failing until they act. Required: sourceId, targetId, type.

billing_summary

The org's whole billing picture in one call (owner authority required for the billing block): subscription status + spending caps, money now (pending / outstanding / charged / collected / credit), the charge ledger, and CONFIRMED ON-CHAIN PAYMENTS — both fanned across EVERY subscription/payment link the org has ever used, so changing payment link never hides prior history. Payments come from Xenarch's authoritative records (live read; degrades to `payments: null` + `paymentsError` if Xenarch is unreachable). Also returns the usage meter (lifetime estimate + what's actually pending). A key without owner authority — an agent whose principal isn't an owner, or a non-owner member — gets the usage meter only, with a `note`. Reading billing is not charged.

check_claim(identifier)

Does THIS session hold an issue? The session-aware companion to the commit gate: before committing or opening a PR on a `rtsc-NN/` branch, verify your session actually holds RTSC-NN so you can't mislabel work another session holds. Returns {youHold, status, expiresAt, lastRenewedAt, heldBy}: status is held | unclaimed | expired | other_session | unknown_session; `heldBy` names the real holder (principal/runtime/session) when it's not you. `lastRenewedAt` is when the lease was last renewed (by you or by a watchdog proxy on your behalf) and `expiresAt` is always exactly 30 minutes after it — call this twice across a long stretch and a lastRenewedAt that moved is proof something is renewing you; one frozen at claim time means nothing is, and the issue will be reclaimed mid-work. Read-only. Required: identifier.

checkpoint(note, claimToken, identifier)

Record a handoff checkpoint on your claimed issue — what's done, what's next, gotchas, branch/artifacts. It SURVIVES release + reclaim, so if your lease lapses or you crash, the next agent (even a different runtime) resumes from here instead of restarting. Also renews your lease, exactly as `heartbeat` does (a full 30-minute reset from the moment it lands) — so this is the PREFERRED call at any long-silence boundary: same renewal, plus the note. Requires the claim_token. Required: identifier, note, claimToken.

claim_issue(identifier)

Claim one specific issue by id (instead of letting next_issue pick). Fails if it's already held (active lease), not todo/doing, blocked, or non-work (work:false — tracking containers aren't claimable). Returns a claim_token. The response includes `branch` (the authoritative `rtsc-NN/<slug>` to land this work under — the one identifier every runtime shares) and `activeClaims` (how many OTHER leases are live right now — a real fleet-concurrency signal). REQUIRED after claiming, BEFORE your first edit: never work in the shared checkout. Create an isolated git worktree for `branch` and work ONLY there — e.g. `git worktree add ../<repo>-rtsc-NN -b <branch> origin/main` (if it already exists, reuse it; substitute your repo's default base if it isn't `origin/main`). Another agent can start in this same checkout at any moment, and isolation cannot be retrofitted once you have edits in flight — a worktree costs a folder and a few seconds; a collision corrupts branches and mislabels work. Only skip if you positively know this environment is single-use and isolated (e.g. an ephemeral per-task container) — and even then a worktree is harmless. A fresh worktree contains only tracked files — no installed dependencies or build artifacts. Before your first build or test in it, run the repo's usual setup (whatever its docs or CI run on a fresh checkout). A wall of errors in files you didn't touch usually means deps are missing, not that the code is broken. Your claim is a LEASE, not a permanent assignment: it expires 30 minutes after you take it (the response carries the exact `claimExpiresAt`). ONLY `heartbeat` and `checkpoint` renew it — nothing else does, not comments, not status updates, not reading the issue. Each renewal is a FULL reset to 30 minutes from that moment, so one call is enough however little was left. Before any stretch where you will not call Retasc for a while (a long test run, a build, waiting on CI), renew FIRST — prefer `checkpoint`, which renews AND records the handoff. If the lease lapses, a sweep returns the issue to `todo` within minutes and another agent can claim it while you are still working on it. WHO RENEWS depends on your client, and only you can tell which case you are in. If you run the `retasc` mcp-proxy watchdog, it renews the claims IT SAW THIS SESSION MAKE, roughly every 10 minutes by default, for as long as that process is alive — long silent work is then genuinely safe and you need no per-claim heartbeats. Nothing renews a claim the proxy did not see (made in another terminal, over direct HTTP MCP, or by a previous proxy before a restart), and nothing renews once the proxy stops: those run on the bare 30-minute TTL and are yours to renew. With no watchdog at all, every renewal is yours. `check_claim` settles it: `lastRenewedAt` moving across a long stretch proves something is renewing you. If this call is refused for billing (BILLING_INACTIVE or MONTHLY_CAP_REACHED), the response carries `tellHuman`, a ready-to-relay sentence: PASS IT TO YOUR HUMAN. You cannot fix it yourself — only an owner can — so do NOT absorb the refusal and continue with read-only work as if the session were healthy; every value-bearing write will keep failing until they act. Required: identifier.

get_attachment(attachment)

Read one attachment by id. Required: attachment.

get_issue(identifier)

Get one issue in full: body, status, priority, labels, relations, computed blocking (is it blocked, and by what), and its derived deadline surface (dueAt, effectiveDeadline, timeRemainingMs, slaState). Required: identifier.

get_project(prefix)

Get a project and a breakdown of its issues by status. Defaults to the API key's project.

heartbeat(claimToken, identifier)

Extend your lease on a claimed issue during long-silent work. Requires the claim_token. Returns the new expiry — a FULL reset, not a top-up: the lease becomes 30 minutes from the moment this call lands, whatever was left on it. PREFER `checkpoint` at long-silence boundaries: it renews identically AND leaves the handoff note that makes a reclaim recoverable. Use a bare heartbeat only when you have nothing worth recording yet. It cannot revive a lapsed lease: once expired you get CLAIM_LOST, even in the window before the sweep runs. Required: identifier, claimToken.

list_attachments(issue)

List an issue's attachments (obsolete ones are flagged, not hidden). Required: issue.

list_comments(issue)

List an issue's comments in chronological (thread) order. Required: issue.

list_connectors

List the org's intake connectors (e.g. GitHub Issues → Retasc issues, RTSC-189). Each row: provider, repo, target project, whether outbound sync-back is wired (hasToken), and created/revoked timestamps. METADATA ONLY — the inbound webhook secret and outbound GitHub token are NEVER returned. Read-only. Connecting a NEW repo is Dash-only (it takes a raw GitHub token that must not transit MCP); this surface is read + disconnect.

list_issues(label, limit, author, status, assignee, priority, slaState)

List issues in the project, compact (each includes its author + createdAt + derived deadline `slaState`). Defaults to active work (hides done/canceled). Filter by status (one or many), priority, label, author, or SLA state. Ordered priority-first (None last), recent tiebreak. Each issue carries `slaState` (ok | warning | breaching | breached) derived from its deadline — poll `slaState:"breaching"` to find near-breach work for /loop remediation.

list_labels

List all labels in the org with issue counts.

list_members(query)

List members (humans + agents) in the org — the 'users' issues and comments are attributed to. Optionally filter by name.

list_projects

List projects in the org (prefix, name, issue counter).

mint_session_key(label)

Mint a per-session API key bound to YOUR identity (same org/project/agent), distinctly labeled. The watchdog proxy calls this once at startup and uses the returned key, so concurrent sessions of one agent become distinguishable in queue_status/whoami. Same access as your key — no privilege change. The raw key is returned ONCE. If this call is refused for billing (BILLING_INACTIVE or MONTHLY_CAP_REACHED), the response carries `tellHuman`, a ready-to-relay sentence: PASS IT TO YOUR HUMAN. You cannot fix it yourself — only an owner can — so do NOT absorb the refusal and continue with read-only work as if the session were healthy; every value-bearing write will keep failing until they act.

next_batch(n, claim, allLanes)

Wave dispatch for a fleet: return the top N eligible issues (todo + unclaimed + unblocked WORK — work:false containers are never included), effective-priority ordered, ready to run in PARALLEL (they're mutually independent by construction). Default mode peeks (no claim) so an orchestrator can plan, then claim the ones it fans out; pass claim:true to atomically claim all N now (each comes with a claim_token). LANE-SCOPED by default (your principal's lane + unassigned); pass allLanes:true to include other humans' work. Returns {issues, ready, otherLanes, blocked, claimed} — otherLanes counts ready work stranded in other lanes. When the wave comes back EMPTY and otherLanes>0, the response also carries `tellHuman`, a ready-to-relay sentence: PASS IT TO YOUR HUMAN and let them answer, rather than reporting an idle queue. Each returned issue carries its own `branch` (the authoritative `rtsc-NN/<slug>` every runtime agrees on); with claim:true each also carries its own claim_token. REQUIRED once you claim (claim:true), BEFORE the first edit on any of them: give EACH claimed issue its own git worktree, created from THAT issue's `branch` — e.g. `git worktree add ../<repo>-rtsc-NN -b <branch> origin/main` per issue (reuse one that already exists; substitute your repo's default base if it isn't `origin/main`). Never run two of these issues in the same checkout: a wave is exactly the case this protects, since agents sharing one HEAD/index land their edits on each other's branches. A peek (the default) claims nothing, so it needs no worktree until you claim. Another agent can start in this same checkout at any moment, and isolation cannot be retrofitted once you have edits in flight — a worktree costs a folder and a few seconds; a collision corrupts branches and mislabels work. Only skip if you positively know this environment is single-use and isolated (e.g. an ephemeral per-task container) — and even then a worktree is harmless. A fresh worktree contains only tracked files — no installed dependencies or build artifacts. Before your first build or test in it, run the repo's usual setup (whatever its docs or CI run on a fresh checkout). A wall of errors in files you didn't touch usually means deps are missing, not that the code is broken. Your claim is a LEASE, not a permanent assignment: it expires 30 minutes after you take it (the response carries the exact `claimExpiresAt`). ONLY `heartbeat` and `checkpoint` renew it — nothing else does, not comments, not status updates, not reading the issue. Each renewal is a FULL reset to 30 minutes from that moment, so one call is enough however little was left. Before any stretch where you will not call Retasc for a while (a long test run, a build, waiting on CI), renew FIRST — prefer `checkpoint`, which renews AND records the handoff. If the lease lapses, a sweep returns the issue to `todo` within minutes and another agent can claim it while you are still working on it. WHO RENEWS depends on your client, and only you can tell which case you are in. If you run the `retasc` mcp-proxy watchdog, it renews the claims IT SAW THIS SESSION MAKE, roughly every 10 minutes by default, for as long as that process is alive — long silent work is then genuinely safe and you need no per-claim heartbeats. Nothing renews a claim the proxy did not see (made in another terminal, over direct HTTP MCP, or by a previous proxy before a restart), and nothing renews once the proxy stops: those run on the bare 30-minute TTL and are yours to renew. With no watchdog at all, every renewal is yours. `check_claim` settles it: `lastRenewedAt` moving across a long stretch proves something is renewing you. If this call is refused for billing (BILLING_INACTIVE or MONTHLY_CAP_REACHED), the response carries `tellHuman`, a ready-to-relay sentence: PASS IT TO YOUR HUMAN. You cannot fix it yourself — only an owner can — so do NOT absorb the refusal and continue with read-only work as if the session were healthy; every value-bearing write will keep failing until they act.

next_issue(allLanes)

Pull the next issue to work on, project-scoped — atomically claims the highest-priority unblocked todo and returns it with a claim_token (status becomes 'doing'). Only WORK is dispatched: non-work issues (work:false — tracking containers like epics) are never handed out. LANE-SCOPED by default: a bare pull only hands you work assigned to your own human principal, or left unassigned (the shared free pool) — never another human's work. Pass allLanes:true to reach into the whole ready pool (e.g. an owner is away and their work should still move). If nothing is eligible, returns {issue:null, ready, otherLanes, blocked, claimed} so a stall is never silent — otherLanes>0 means "nothing for you, but ready work is stranded in another human's lane" (opt in with allLanes, or go unblock the owner), distinct from "nothing anywhere". In that case the response also carries `tellHuman`, a ready-to-relay sentence: PASS IT TO YOUR HUMAN and let them answer. Never report an empty queue while withholding it, and never claim across lanes on your own just because you saw it — the decision is theirs. When more than one issue is ready, the response also carries an advisory `wave`: a capped, peek-only list of the OTHER issues available now (not reserved) — claim them as a batch via next_batch ONLY if you'll run them concurrently. Keep the claim_token: you need it to release/heartbeat. The response includes `branch` (the authoritative `rtsc-NN/<slug>` to land this work under — the one identifier every runtime shares) and `activeClaims` (how many OTHER leases are live right now — a real fleet-concurrency signal). REQUIRED after claiming, BEFORE your first edit: never work in the shared checkout. Create an isolated git worktree for `branch` and work ONLY there — e.g. `git worktree add ../<repo>-rtsc-NN -b <branch> origin/main` (if it already exists, reuse it; substitute your repo's default base if it isn't `origin/main`). Another agent can start in this same checkout at any moment, and isolation cannot be retrofitted once you have edits in flight — a worktree costs a folder and a few seconds; a collision corrupts branches and mislabels work. Only skip if you positively know this environment is single-use and isolated (e.g. an ephemeral per-task container) — and even then a worktree is harmless. A fresh worktree contains only tracked files — no installed dependencies or build artifacts. Before your first build or test in it, run the repo's usual setup (whatever its docs or CI run on a fresh checkout). A wall of errors in files you didn't touch usually means deps are missing, not that the code is broken. Your claim is a LEASE, not a permanent assignment: it expires 30 minutes after you take it (the response carries the exact `claimExpiresAt`). ONLY `heartbeat` and `checkpoint` renew it — nothing else does, not comments, not status updates, not reading the issue. Each renewal is a FULL reset to 30 minutes from that moment, so one call is enough however little was left. Before any stretch where you will not call Retasc for a while (a long test run, a build, waiting on CI), renew FIRST — prefer `checkpoint`, which renews AND records the handoff. If the lease lapses, a sweep returns the issue to `todo` within minutes and another agent can claim it while you are still working on it. WHO RENEWS depends on your client, and only you can tell which case you are in. If you run the `retasc` mcp-proxy watchdog, it renews the claims IT SAW THIS SESSION MAKE, roughly every 10 minutes by default, for as long as that process is alive — long silent work is then genuinely safe and you need no per-claim heartbeats. Nothing renews a claim the proxy did not see (made in another terminal, over direct HTTP MCP, or by a previous proxy before a restart), and nothing renews once the proxy stops: those run on the bare 30-minute TTL and are yours to renew. With no watchdog at all, every renewal is yours. `check_claim` settles it: `lastRenewedAt` moving across a long stretch proves something is renewing you. If this call is refused for billing (BILLING_INACTIVE or MONTHLY_CAP_REACHED), the response carries `tellHuman`, a ready-to-relay sentence: PASS IT TO YOUR HUMAN. You cannot fix it yourself — only an owner can — so do NOT absorb the refusal and continue with read-only work as if the session were healthy; every value-bearing write will keep failing until they act.

obsolete_attachment(reason, attachment)

Mark an attachment obsolete (the delete-equivalent) — keeps it as a record. Requires a reason. If this call is refused for billing (BILLING_INACTIVE or MONTHLY_CAP_REACHED), the response carries `tellHuman`, a ready-to-relay sentence: PASS IT TO YOUR HUMAN. You cannot fix it yourself — only an owner can — so do NOT absorb the refusal and continue with read-only work as if the session were healthy; every value-bearing write will keep failing until they act. Required: attachment, reason.

prepare_attachment_upload(issue)

Attach a FILE (image/blob) to an issue over MCP. Returns { uploadUrl } for the issue; then POST the raw file bytes to it with your API key as a Bearer header — the server encrypts the file at rest and attaches it. Add `&filename=` (download name) and optional `&title=` to the URL. Example: `curl -X POST "<uploadUrl>&filename=shot.png" -H "Authorization: Bearer <yourApiKey>" --data-binary @shot.png` → {"id":"...","url":"..."}. For a plain link (not a file), use save_attachment instead. Required: issue.

queue_status

Diagnose the queue: counts by status, how many are ready to pull, deadline SLA pressure (`breaching`/`breached` counts over non-terminal issues), exactly what's dependency-blocked (and by what), and what's currently claimed (by whom, lease expiry, and `lastRenewedAt` — a claim whose lastRenewedAt never moves is one nobody is renewing, running on the bare TTL).

reactivate_member(memberId)

Reactivate a suspended PERSON (owner or admin) — restores org visibility + their prior role. Rejects an AGENT (retire is terminal — there's nothing to reactivate). Authorized through your human principal; an admin may reactivate ordinary members only, never a suspended owner or admin. `memberId` from list_members/whoami. Required: memberId.

release_issue(note, claimToken, identifier)

Give a claimed issue back to the queue (reverts to todo). Requires the claim_token. Your comments + checkpoint stay so the next agent resumes. Pass `note` to record a final handoff checkpoint (done so far / next steps / gotchas). Required: identifier, claimToken.

remove_relation(type, sourceId, targetId)

Remove a link between two issues (same args as add_relation). If this call is refused for billing (BILLING_INACTIVE or MONTHLY_CAP_REACHED), the response carries `tellHuman`, a ready-to-relay sentence: PASS IT TO YOUR HUMAN. You cannot fix it yourself — only an owner can — so do NOT absorb the refusal and continue with read-only work as if the session were healthy; every value-bearing write will keep failing until they act. Required: sourceId, targetId, type.

retire_member(memberId)

Retire an AGENT — the terminal offboard (owner or admin): revokes its API keys, releases its live claim, removes it from the roster. An agent is its key, and a revoked key can't be un-revoked, so this is one-way (no reactivate). Keeps the row hidden for attribution if the agent ever did work; hard-deletes it if it never authenticated (a pure stray mint). For a PERSON use suspend_member instead — retiring a human is rejected. Authorized through your human principal; an agent carries its principal's authority, so an admin is refused an owner's or a peer admin's agent. `memberId` from list_members/whoami; a member from another org is NOT_FOUND. Required: memberId.

retract_comment(note, comment)

Retract a comment (strike it through) instead of deleting — the text stays as memory. Requires a note explaining why it's no longer valid (shown un-struck). If this call is refused for billing (BILLING_INACTIVE or MONTHLY_CAP_REACHED), the response carries `tellHuman`, a ready-to-relay sentence: PASS IT TO YOUR HUMAN. You cannot fix it yourself — only an owner can — so do NOT absorb the refusal and continue with read-only work as if the session were healthy; every value-bearing write will keep failing until they act. Required: comment, note.

revoke_connector(connectorId)

Disconnect an intake connector by id (from list_connectors). Marks it revoked so its inbound webhook stops syncing — that endpoint then answers 401. Revoke-don't-delete (the row stays, flagged), idempotent, org-scoped (only connectors in YOUR org; an unknown/other-org id is NOT_FOUND). To reconnect, use the Dash (a fresh webhook URL + secret). Required: connectorId.

save_attachment(url, issue, title)

Attach a link (URL) to an issue. If this call is refused for billing (BILLING_INACTIVE or MONTHLY_CAP_REACHED), the response carries `tellHuman`, a ready-to-relay sentence: PASS IT TO YOUR HUMAN. You cannot fix it yourself — only an owner can — so do NOT absorb the refusal and continue with read-only work as if the session were healthy; every value-bearing write will keep failing until they act. Required: issue, url.

save_comment(body, issue)

Add a comment to an issue. Comments + activity are the agent's shared memory — record what you did and why. If this call is refused for billing (BILLING_INACTIVE or MONTHLY_CAP_REACHED), the response carries `tellHuman`, a ready-to-relay sentence: PASS IT TO YOUR HUMAN. You cannot fix it yourself — only an owner can — so do NOT absorb the refusal and continue with read-only work as if the session were healthy; every value-bearing write will keep failing until they act. Required: issue, body.

save_issue(body, work, dueAt, title, labels, status, assignee, priority, blockedBy, identifier, cancelReason, noDependency)

Create an issue (omit `identifier`) or update one (pass `identifier`, e.g. XEN-12). Only `title` is required to create. Setting status to `canceled` requires `cancelReason`. `labels` replaces the issue's labels. CREATE requires TWO declarations: (1) a dependency declaration — `blockedBy` (ids this depends on) OR `noDependency` (a one-line reason there are none); and (2) `work` — true if this is a unit an agent executes, false if it's a tracking container. A create missing either is rejected. If this call is refused for billing (BILLING_INACTIVE or MONTHLY_CAP_REACHED), the response carries `tellHuman`, a ready-to-relay sentence: PASS IT TO YOUR HUMAN. You cannot fix it yourself — only an owner can — so do NOT absorb the refusal and continue with read-only work as if the session were healthy; every value-bearing write will keep failing until they act.

save_label(name, color)

Create or update a label (idempotent by name). If this call is refused for billing (BILLING_INACTIVE or MONTHLY_CAP_REACHED), the response carries `tellHuman`, a ready-to-relay sentence: PASS IT TO YOUR HUMAN. You cannot fix it yourself — only an owner can — so do NOT absorb the refusal and continue with read-only work as if the session were healthy; every value-bearing write will keep failing until they act. Required: name.

suspend_member(memberId)

Offboard a PERSON from the org (owner or admin): hides the org from them and drops them from every read/act gate, while KEEPING their row so their past work stays attributed. Cascade-RETIRES the agents they run (terminal — those agent keys are revoked, strays deleted), so no one keeps acting on their behalf. Reversible for the person via reactivate_member (they re-auth via GitHub). For an AGENT, use retire_member instead — suspending an agent is rejected. Authorized through YOUR human principal, who must be an active owner or admin. An ADMIN may offboard ordinary members only — an owner or a peer admin is refused. `memberId` from list_members/whoami. Refuses suspending yourself or the last active owner; a member from another org is NOT_FOUND. Required: memberId.

usage_summary

Usage METER for the org — activity volume, not a bill. Returns reads, writes, the read:write ratio, the rate card, and TWO distinct money figures: `lifetimeMeteredEstimateUsd` (ALL-TIME activity across every payment link, repriced at today's rate card — includes never-billable usage and diverges from what was historically booked; a diagnostic, NOT an amount owed) and `pendingUsd` (what the org actually owes right now — the current subscription's uncharged accrual, the same figure the Dash's PENDING shows). For the full picture — subscription, charges and on-chain payments across every link — use `billing_summary`. Reading the meter is not charged.

whoami

Return the calling identity (agent/human), its org, and the project this API key is scoped to.

Last successful function declaration observed on 2026-08-13. Source: https://mcp.retasc.com/mcp. We list what the server declared; we do not call any of these functions.

Endpoint status observed on 2026-08-13. Source: https://mcp.retasc.com/mcp.

Signals

These are separate measurements of different things. They are deliberately not combined into one score, because a popularity number that mixes website traffic with saves and stars cannot be checked or acted on.

Where to get it

• Website — https://retasc.com
• Remote endpoint (streamable-http) — https://mcp.retasc.com/mcp