Skip to main content
Glama

Server Details

Retasc is a work queue for AI coding agents. The next agent picks up where the last one stopped.

Ownership verified
Status
Healthy
Uptime
100.0% over the last 24 hours
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
ChatGPT
–
Claude
–

TDQS

A3.8/5.0

Scored across 58 tools

Disambiguation4/5

Most tools target a distinct resource+action and the descriptions aggressively draw boundaries (e.g. heartbeat vs checkpoint vs check_claim vs claim_issue; get_attachment vs get_attachment_file; save_attachment vs save_attachment_file vs prepare_attachment_upload). The main clusters that can still be confused are the import family (list_import_sources/targets/statuses, import_history, latest_import, run_import) and the analytics family (analytics_overview vs analytics_issues vs usage_summary vs billing_summary), where an agent must read carefully to pick correctly. Overall clear, but a few near-neighbours keep it from a 5.

Naming Consistency4/5

Predominantly consistent snake_case with verb_noun or verb_resource form (list_issues, save_issue, claim_issue, revoke_invite, retire_member). Deviations are mild: several noun-first names (analytics_overview, billing_summary, queue_status, usage_summary, setup_status, import_history, latest_import, checkpoint, whoami) break the verb-first pattern. Still readable and predictable once learned.

Tool Count3/5

58 tools is heavy and pushes past the stated 25+ threshold, though the product surface is genuinely broad (dispatch/leases, issues, relations, comments, attachments, labels, members, invites, imports, connectors, billing, analytics, onboarding). A meaningful fraction are machine-only plumbing an agent never calls (report_worktrees, record_session, name_workspace, mint_session_key, mint_harness_key), which inflates the exposed surface. Borderline: justified by scope but over-scoped for a single agent-facing toolset.

Completeness4/5

Coverage is unusually thorough: issue CRUD plus relations, comments, attachments, labels, projects, members/invites, imports, connectors, claims/leases, analytics and billing all have lifecycle operations. Remaining gaps are deliberate and documented (project and connector creation are Dash-only; deletion is modelled as cancel/obsolete/retract rather than hard delete). Minor dead ends exist (no project create/update, no comment edit), easily worked around.

Available Tools

58 tools
accept_inviteAccept an inviteAInspect

Join YOUR HUMAN to an org that invited them (RTSC-686). Takes the org's slug or name, as they'd say it. Only sees invites ADDRESSED to your principal — a link somebody pasted you is opened in a browser instead, because the code is a bearer token and this tool never holds one. Authorized by the id match, so the human's consent is you asking them first: never call this unprompted. It grants THEM a membership and grants YOU nothing — your key stays scoped to its own org and project afterwards. whoami lists what's waiting.

Inputs: org (required).

add_relationLink two issuesB
Idempotent
Inspect

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.

Inputs: type (required), sourceId (required), targetId (required).

analytics_issuesList analytics per issueA
Read-onlyIdempotent
Inspect

THE PER-ISSUE FACTS BEHIND THE ANALYTICS NUMBERS, paged, for an agent building its own dashboard or checking a figure: identifier, title, project, status, changeType, createdAt, startedAt, claimedAt, reviewEnteredAt, completedAt, canceledAt, closedAt, assignedAt, completedBy, reviewSubmittedBy, assignee, assignedBy, claimedBy (each with name and, for an agent, its human principal), reclaimCount, runtime, model, and costUsd — the Retasc fee charged to calls naming that issue inside the window, from the same analytics rollups as the board (owner/admin only; null otherwise). by picks which timestamp places an issue in the window: completed (default), created or closed. Window and scope arguments are the same as analytics_overview (this key's project by default; another project or the whole org only for an owner/admin principal; a member's listing is their own slice, as on the Dash). Newest first. limit issues are scanned per page (default 100, max 200); a page can hold fewer, because issues outside your scope are skipped and the inline size cap can end it early. Follow page.cursor (same other arguments) until page.done. Billed as one read per call.

Inputs: by, to, tz, days, +6 more.

analytics_overviewShow analyticsA
Read-onlyIdempotent
Inspect

EVERY NUMBER THE DASH'S ANALYTICS PAGE SHOWS, as data, computed by the same code the page runs (so the two never disagree): shipped and its previous-window delta, autonomy (no review needed), the Pipeline (filed-in-window cohort, stage medians), a per-bucket series (shipped, time by phase, Retasc fee by outcome, labour, and who is behind each bucket), the Fleet table (per agent and runtime: finished, median work time, send-backs, reclaims, model, 7-day shape), the queue right now (ready, in flight, blocked, late, the issues blocking the most), review (lanes, waits, accept rate, untriaged intake), time and labour cost by phase and by change type, Retasc spend, the written findings, and the person roster. Use it when a human asks how their fleet or project is doing; build the chart yourself from what it returns. WINDOW: days (1, 7, 30 or 90 as on the page; default 30) or from+to (ISO 8601 or epoch ms, up to 366 days, within the last year), cut into calendar buckets in tz (default the org's zone). With no maxBars the window keeps its own unit (hours for 1 day, days for 7 and 30, weeks for 90), so "last 30 days" is the same window the Dash shows on a laptop; maxBars caps the bucket count, and a cap below that coarsens to wider buckets and snaps the window outward to whole ones. SCOPE: this key's own project by default. project (prefix or id) for another one, or allProjects: true for the whole org, ONLY when the key's principal is an owner or admin — a member's key asking for more is refused with FORBIDDEN. person (a member id from the people section) narrows to one human and their agents (owner/admin; a member's view is already their own). Money and the roster are owner/admin, as on the Dash. Every response carries asOf, timezone, the window, units and a one-line definition per metric. sections limits what is returned (summary, pipeline, series, fleet, queue, review, time, money, findings, people); bucketFrom+bucketTo add the per-issue card for one bucket when reading one person. Past the inline size cap it returns page.cursor: call again with the same arguments plus cursor for the rest. Billed as one read per call.

Inputs: to, tz, days, from, +8 more.

billing_summaryShow billingA
Read-onlyIdempotent
Inspect

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.

Inputs: no named parameters.

check_claimCheck a claimA
Read-onlyIdempotent
Inspect

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 one lease after it (30 minutes behind the retasc mcp-proxy, 2 hours for a claim made with no proxy) — 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. renewedByYourCalls answers the same question directly for a no-proxy session: true means your own calls to Retasc are renewing THIS claim, so you need no separate heartbeat while you keep working. It goes false after a reconnect (a new session id means the claim still names your old session), so re-claim with your claimToken to move it across. It is null where your calls cannot renew anything (behind the retasc proxy, or with no session id): read lastRenewedAt there. Whether to re-claim is reclaimWouldMove: true means claim_issue with your claimToken would move this lease onto you, false means it would change nothing. Re-claim only on true. This call is the one tool that never renews anything, so it can't fake either answer. A status of other_session is NOT always someone else: if you were restarted or /resume'd, your client may have started a NEW session and the holder named in heldBy is your own former one. You still have that lease's claim_token — pass it to claim_issue to move the lease onto this session, then carry on. Read-only.

Inputs: identifier (required).

checkpointSave a checkpointAInspect

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 reset to the lease's length from the moment it lands) — so this is the PREFERRED call at any long-silence boundary: same renewal, plus the note. Pass the claim_token when you have it; a same-session caller that lost it is still recognized (RTSC-758) unless the claim was taken over a bare shared workspace key, which always needs it.

Inputs: note (required), identifier (required), claimToken.

claim_ghostClaim a placeholder identityA
DestructiveIdempotent
Inspect

Record that one imported placeholder IS your human, absorbing its history into their account. Call this ONLY with the id they explicitly chose from list_claimable_ghosts — never on your own inference, and never for anyone but them (the server binds the claim to the human this key acts for, so it could not do otherwise). One placeholder per source tool. Refused while an import is still running, because the rest of that run would recreate the row. 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.

Inputs: name (required), memberId (required).

claim_issueClaim an issueAInspect

Claim one specific issue by id (instead of letting next_issue pick). Fails if it's already held (active lease), blocked, non-work (work:false — tracking containers aren't claimable), or in a status that isn't todo, doing or review. A review IS claimable, and claiming one is how a reviewer takes the work (RTSC-257): the issue stays in review, and accepting it later with save_issue status:"done" is REFUSED unless you hold that lease (CLAIM_REQUIRED). You cannot claim the review of work you submitted yourself (AUTHOR_CANNOT_REVIEW). Returns a claim_token. ALSO THE RESUME DOOR: if you were restarted or /resume'd, your client may have started a NEW session, in which case the server sees a different session holding your issue and done fails with CLAIM_MISMATCH. You don't have to wait out the lease or give the work back — call this with the claimToken you were given before the restart and the lease moves onto your new session (a fresh token, rebound: true, status and progress untouched; if THIS session already held it, nothing moves, the same token comes back with renewedOnly: true, and it costs a 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 behind the retasc mcp-proxy and 2 hours after with no proxy (the response carries the exact claimExpiresAt). Behind the retasc mcp-proxy, ONLY heartbeat and checkpoint renew it — nothing else does, not comments, not status updates, not reading the issue. With NO proxy, if your client echoes the Mcp-Session-Id we hand you at initialize, your own calls renew instead (RTSC-858): every call renews every claim THIS session took, a read as much as a write. Each renewal is a FULL reset to the lease's length 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 their bare TTL and are yours to renew. With no watchdog and no session id echoed, every renewal is yours. With no watchdog but a session id, your own calls carry it, right up until your client RECONNECTS, which starts a new session and stops renewal for claims taken under the old one; claim_issue with your claimToken moves them onto the new session and renewal resumes. check_claim settles all of it: renewedByYourCalls says whether this session's calls are renewing that claim right now, and 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.

Inputs: identifier (required), claimToken.

dismiss_ghost_promptDismiss the placeholder promptA
Idempotent
Inspect

Record that none of the currently offered placeholders are your human. Covers only the source tools on offer right now, so a later migration still asks them. Call it only when they have said so — it is an answer on their behalf either way. 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.

Inputs: no named parameters.

get_attachmentRead an attachmentA
Read-onlyIdempotent
Inspect

Read one attachment's METADATA by id: title, issue, obsolete flag, and — when it is an uploaded file (hasFile) — its filename, contentType and bytes. To read the file's CONTENT, call get_attachment_file.

Inputs: attachment (required).

get_attachment_fileRead an attached fileA
Read-onlyIdempotent
Inspect

Read the CONTENT of a file attached to an issue, in ONE call. No API key needed from you — this is a normal tool call, so never go looking for a credential or try to curl the download URL yourself. An image comes back as an image you can see; text (logs, CSV, PEM, patches, config) comes back as text you can read; anything else as base64 you can write to a file yourself. Size limit 131072 bytes (128KB), or 2MB for an image, because on this connection the bytes have to travel through your context. For anything bigger, run your MCP through retasc mcp-proxy and call this tool again — the proxy downloads the file to disk and hands you the path, at any size. Check bytes on list_attachments or get_attachment first if you want to know before you ask. A link attachment (save_attachment) has no bytes to return; fetch its URL yourself.

Inputs: attachment (required).

get_issueRead an issueA
Read-onlyIdempotent
Inspect

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).

Inputs: identifier (required).

get_projectRead a projectA
Read-onlyIdempotent
Inspect

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

Inputs: prefix.

heartbeatRenew a claimA
Idempotent
Inspect

Extend your lease on a claimed issue during long-silent work. Pass the claim_token when you have it — the fast, unambiguous path. Lost it? Omit it: the same session that claimed the issue is still recognized (RTSC-758), unless the claim was taken over a bare shared workspace key with no per-session key, where identity can't tell callers apart and the real claim_token is still required. Returns the new expiry — a FULL reset, not a top-up: the lease becomes its whole length again (30 minutes behind the retasc mcp-proxy, 2 hours for a claim made with no proxy) 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 — lost-token recognition can't fix a lease that's actually gone.

Inputs: identifier (required), claimToken.

import_historyShow import historyA
Read-onlyIdempotent
Inspect

Which sources this org has imported before. Check it before running an import and WARN your human if their source appears: a re-import reconciles onto the same issues, so edits made in Retasc since the last run are overwritten. Owner or admin only.

Inputs: no named parameters.

invite_memberInvite a personAInspect

Invite a PERSON into your org, on behalf of YOUR human (RTSC-724) — mints an invite code and, if you pass an email, sends it. Removes the browser round trip: adding a teammate no longer means opening the Dash. Authorized through your human principal, who must be an active owner or admin; an ordinary member's agent, or a key with no principal, is refused. Joining is a consent act and the invite is a bearer token, so NEVER call this unprompted — your human names the person and you relay it. The invite is always to YOUR org — that comes from your key, not from you. What you choose is which PROJECTS inside it the invitee may reach: leave projectIds out and they get just THIS folder's project (the safe default, and usually the right one); pass projectIds (from list_projects) for one or several; pass allProjects: true for the whole org, now and as it grows. CALL IT WITH NO ARGUMENTS FIRST: it returns the QUESTIONS to put to your human, as data with exact options — which projects, how to deliver it, and whether it is for someone they already work with. Ask those, then call again with their answers plus decided: true. Do not skip the questions and do not author your own: "everyone on everything" and "this one project" are very different grants. Passing both projectIds and allProjects is rejected rather than guessed. Returns the raw code ONCE — it's stored only as a hash, and anyone holding it can redeem it, so hand it to your human rather than pasting it anywhere it persists. If you gave an email, they already have it and you do not need to repeat it. If you addressed it to somebody your human already works with, the invite is mailed to the address Retasc already holds for them (RTSC-772) — never go hunting for one, and never ask your human for an address you were not offered. The invitee joins as a member; owner invites are not self-serve. It grants YOU nothing — your key stays scoped to its own org and project afterwards. Reversible: an owner can revoke it from the Dash, and it expires on its own.

Inputs: email, decided, projectIds, allProjects, +2 more.

latest_importShow the latest importA
Read-onlyIdempotent
Inspect

Progress and outcome of the most recent import in this org: status, issues done/total, the summary, and the failure reason if it failed. One import runs per org at a time, so poll this rather than starting another. Owner or admin only.

Inputs: no named parameters.

list_attachmentsList attachmentsA
Read-onlyIdempotent
Inspect

List an issue's attachments (obsolete ones are flagged, not hidden). Each carries hasFile (an uploaded file, vs a plain link), its bytes and contentType — so you can tell which ones you can read, and what pulling one will cost you, before you call get_attachment_file.

Inputs: issue (required).

list_claimable_ghostsList claimable placeholdersA
Read-onlyIdempotent
Inspect

The imported placeholder identities in this org that your human could be — people carried in by a migration who have never signed in, so their history is attributed to nobody. RELAY THE NAMES TO YOUR HUMAN VERBATIM AND ASK WHICH ONE IS THEM. Do NOT guess from a name, an email or anything else: a wrong claim permanently re-attributes somebody else's work, and only an owner can unpick it. An empty list means there is nothing to answer. Read-only.

Inputs: no named parameters.

list_commentsRead commentsB
Read-onlyIdempotent
Inspect

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

Inputs: issue (required).

list_connectorsList connectorsA
Read-onlyIdempotent
Inspect

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.

Inputs: no named parameters.

list_import_sourcesList import sourcesA
Read-onlyIdempotent
Inspect

What can be imported into Retasc (Linear, Jira, Asana, ClickUp, Shortcut), and exactly what each source needs from your human. Each descriptor carries authFields: ask for those fields BY THEIR LABEL, and use the hint to tell your human where to find the value. Fields marked secret are credentials — say plainly that the value will pass through this conversation, and never print one back. Read-only. Start here before any other import tool.

Inputs: no named parameters.

list_import_statusesList a source's columnsA
Read-onlyIdempotent
Inspect

The chosen target's columns, so each one can be mapped to a Retasc status. RELAY THIS LIST TO YOUR HUMAN AND ASK THEM COLUMN BY COLUMN. Do NOT infer the mapping from column names, however obvious it looks: a Rejected column that quietly imported as canceled took live work out of dispatch with no error anywhere, which is why the name-based guesser was deleted and this question exists. Returns [] for sources that do not support mapping. Owner or admin only.

Inputs: auth (required), source (required), targetRef (required).

list_import_targetsList a source's projectsA
Read-onlyIdempotent
Inspect

The teams / projects / workspaces the given credentials can see at the source, so your human can choose which one to bring across. Pass source and the auth values you collected from them. Owner or admin only. The credentials are used for this call and never stored.

Inputs: auth (required), source (required).

list_invitesList invitesA
Read-onlyIdempotent
Inspect

Invites minted for your org — pending, accepted, revoked and expired — so you can see what is outstanding and get the id revoke_invite needs (RTSC-729). Owner or admin, through your human principal. NEVER returns the invite code: codes are bearer tokens stored only as hashes, and displayPrefix is the handle for telling two apart. mintedByAgent says whether an agent minted it rather than a person on the Dash.

Inputs: no named parameters.

list_issuesList issuesA
Read-onlyIdempotent
Inspect

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.

Inputs: label, limit, author, status, +3 more.

list_labelsList labelsA
Read-onlyIdempotent
Inspect

List all labels in the org with issue counts.

Inputs: no named parameters.

list_membersList membersA
Read-onlyIdempotent
Inspect

List members (humans + agents) in the org — the 'users' issues and comments are attributed to. Optionally filter by name. Each carries status: active, suspended (a person) or retired (an agent). Retired and suspended members stay listed because past work is attributed to them, so check status before treating a name as someone who can act.

Inputs: query.

list_projectsList projectsA
Read-onlyIdempotent
Inspect

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

Inputs: no named parameters.

list_review_candidatesList reviewer candidatesA
Read-onlyIdempotent
Inspect

Who can be named as the reviewer for a column you are mapping to review. Only people who can actually sign in and claim appear — imported placeholders are excluded, because a review parked on one strands it and blocks everything it gates. An empty list means nobody is eligible yet: say so and map that column to something else. Owner or admin only.

Inputs: no named parameters.

mint_harness_keyMint a tool key (proxy only)AInspect

Mint the API key for ONE TOOL in this workspace — the middle tier between the folder's workspace key and a session key. The watchdog proxy calls this once it knows which harness is on the other end (the initialize handshake names it), caches the result, and mints its session key from THAT rather than from the workspace key. This is what makes one tool independently retirable: every tool started in a folder shares one .mcp.json, so without it, retiring Grok also stops Claude Code and Codex. Workspace keys only. Same access as your key — no privilege change. The raw key is returned ONCE, and a harness retired in this workspace is refused.

Inputs: harness (required).

mint_session_keyMint a session key (proxy only)AInspect

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.

Inputs: label, autoUpdate, cliVersion.

name_workspaceName the workspace folderA
Idempotent
Inspect

Tell Retasc which FOLDER your workspace key is bound to, so the Dash can say where an agent runs. The CLI calls this itself (at bind, from the watchdog proxy at session start, and from retasc setup for every folder a machine has bound); an agent has no folder of its own to report. Workspace keys only. Send the folder's own name, never a path — Retasc never stores paths.

Inputs: workspace (required).

next_batchPlan or claim a batch of issuesAInspect

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 behind the retasc mcp-proxy and 2 hours after with no proxy (the response carries the exact claimExpiresAt). Behind the retasc mcp-proxy, ONLY heartbeat and checkpoint renew it — nothing else does, not comments, not status updates, not reading the issue. With NO proxy, if your client echoes the Mcp-Session-Id we hand you at initialize, your own calls renew instead (RTSC-858): every call renews every claim THIS session took, a read as much as a write. Each renewal is a FULL reset to the lease's length 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 their bare TTL and are yours to renew. With no watchdog and no session id echoed, every renewal is yours. With no watchdog but a session id, your own calls carry it, right up until your client RECONNECTS, which starts a new session and stops renewal for claims taken under the old one; claim_issue with your claimToken moves them onto the new session and renewal resumes. check_claim settles all of it: renewedByYourCalls says whether this session's calls are renewing that claim right now, and 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.

Inputs: n, claim, allLanes.

next_issueClaim the next issueAInspect

Pull the next issue to work on, project-scoped — atomically claims the highest-priority unblocked issue and returns it with a claim_token. Dispatch is NOT todo-only (RTSC-257): a review — finished work awaiting acceptance — is claimable work in its reviewer's lane and is handed out here too, ahead of a todo at equal rank, and it is never handed back to whoever submitted it. A todo claims into 'doing'; a review pick STAYS 'review' (the lease is on the review, so a release or a reclaim returns it to review, never to todo). 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 behind the retasc mcp-proxy and 2 hours after with no proxy (the response carries the exact claimExpiresAt). Behind the retasc mcp-proxy, ONLY heartbeat and checkpoint renew it — nothing else does, not comments, not status updates, not reading the issue. With NO proxy, if your client echoes the Mcp-Session-Id we hand you at initialize, your own calls renew instead (RTSC-858): every call renews every claim THIS session took, a read as much as a write. Each renewal is a FULL reset to the lease's length 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 their bare TTL and are yours to renew. With no watchdog and no session id echoed, every renewal is yours. With no watchdog but a session id, your own calls carry it, right up until your client RECONNECTS, which starts a new session and stops renewal for claims taken under the old one; claim_issue with your claimToken moves them onto the new session and renewal resumes. check_claim settles all of it: renewedByYourCalls says whether this session's calls are renewing that claim right now, and 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.

Inputs: allLanes.

obsolete_attachmentMark an attachment obsoleteA
DestructiveIdempotent
Inspect

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.

Inputs: reason (required), attachment (required).

prepare_attachment_uploadGet the file upload endpointA
Read-onlyIdempotent
Inspect

Get the raw upload endpoint for an issue's file attachments. PREFER save_attachment_file — it attaches a file in one call and needs no credential from you. Use this one only if you are a human or a script that already holds an agent API key: it returns { uploadUrl }, and you then POST the raw bytes with that key as a Bearer header (add &filename= for the download name and optional &title=). Example: curl -X POST "<uploadUrl>&filename=shot.png" -H "Authorization: Bearer <yourApiKey>" --data-binary @shot.png → {"id":"...","url":"..."}. The key must be an agent API key (the kind retasc writes to its keystore bindings), NOT a CLI session token from a user login. If you are a model: you do not have that key by design, so do not read config files hunting for one — call save_attachment_file. For a plain link rather than a file, use save_attachment.

Inputs: issue (required).

queue_statusShow the queueA
Read-onlyIdempotent
Inspect

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).

Inputs: no named parameters.

reactivate_memberReactivate a personA
Idempotent
Inspect

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.

Inputs: memberId (required).

record_sessionRecord a session transcriptA
Idempotent
Inspect

Record this harness session's transcript id on YOUR session key, so the Dash can show the conversation behind the work and hand a human claude --resume <id>. The watchdog proxy calls this itself once it learns the id (Claude Code's SessionStart hook, Grok's GROK_SESSION_ID); an agent only needs it when running without the proxy. Session keys only. Stores the NAME of the transcript, never its contents. Also records which MODEL ran the session, and whether it is a subagent, when the harness reports them.

Inputs: transcriptId (required), model, agentId, harness, +2 more.

release_issueRelease a claimed issueA
Idempotent
Inspect

Give a claimed issue back to the queue (reverts to todo). Pass the claim_token when you have it. Lost it (crash, dropped field, a context summary)? Omit it — the SAME session that claimed the issue is still recognized and this still goes through, unless the claim was taken over a shared workspace key with no per-session key, which always needs the real 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).

Inputs: identifier (required), note, claimToken.

remove_relationUnlink two issuesA
DestructiveIdempotent
Inspect

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.

Inputs: type (required), sourceId (required), targetId (required).

report_worktreesReport worktrees (proxy only)A
Idempotent
Inspect

MACHINE TOOL — your mcp-proxy calls this on its own; an agent never needs to. It reports git worktrees on rtsc-NN/<slug> branches that exist on this machine and that no live claim covers, so Retasc can SEE work somebody started without claiming it (RTSC-962). The server never reads git; the local proxy does, and reports. Each reported issue gets a PROVISIONAL HOLD: it becomes visible on get_issue / list_issues as hold, and automatic dispatch (next_issue / next_batch) withholds it, exactly as it skips another human's lane. A hold is NOT a lease — it has no token, heartbeat/checkpoint/done do not accept it, check_claim reports it as not held, and it lapses 60 minutes after the last report. Nothing refuses an explicit claim_issue: a named claim from ANY session converts the hold into a real claim, which is how the agent that forgot to claim gets its work back. Ignores anything already claimed, terminal, work:false, or outside this key's project.

Inputs: worktrees (required).

retire_memberRetire an agentA
DestructiveIdempotent
Inspect

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.

Inputs: memberId (required).

retract_commentRetract a commentA
DestructiveIdempotent
Inspect

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.

Inputs: note (required), comment (required).

revoke_connectorRevoke a connectorA
DestructiveIdempotent
Inspect

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).

Inputs: connectorId (required).

revoke_inviteRevoke an inviteA
DestructiveIdempotent
Inspect

Kill an invite before anyone uses it (RTSC-729) — the undo for invite_member, so a mis-sent invite does not need a human at the Dash. Owner or admin, through your human principal. inviteId comes from list_invites. An ALREADY-ACCEPTED invite is refused: revoking does nothing once someone is in, and suspend_member removes the person instead. An invite from another org is NOT_FOUND. Safe to call twice.

Inputs: inviteId (required).

run_importImport a backlogA
Destructive
Inspect

Bring a backlog across from Linear, Jira, Asana, ClickUp or Shortcut. This CANNOT BE UNDONE and it writes real issues, so confirm with your human first, in plain words, including the re-import warning if import_history showed this source before. destination is REQUIRED and is your human's answer, not yours: this_project puts the issues in the project THIS folder is bound to, and new_project creates a separate project for them — which you will NOT be able to see from here, so say that before they choose it. If the bound project is empty, offer this_project first; if it already has work, offer both and let them decide. statusMap maps EVERY source column id to one of todo | doing | review | done | canceled, and must be the answer your human actually gave you — the server refuses a missing or empty map, and a wrong mapping silently moves live work out of dispatch. reviewerByStatus is required for each column you mapped to review. Owner or admin only. 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.

Inputs: auth (required), source (required), target (required), destination (required), +2 more.

save_attachmentAttach a linkBInspect

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.

Inputs: url (required), issue (required), title.

save_attachment_fileAttach a fileAInspect

Attach a FILE to an issue in ONE call, by passing its bytes as base64. No API key needed from you — this is a normal tool call, so never go reading credential files to attach something. Size limit 262144 bytes decoded (~256KB), because base64 in a tool argument is generated token by token and a large file costs more context than the attachment is worth. For anything bigger, run your MCP through retasc mcp-proxy and call this tool with path instead — the proxy reads the file off disk and uploads it, at any size, with the credential it already holds. For a plain link rather than a file, use save_attachment. 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.

Inputs: issue (required), filename (required), contentBase64 (required), title.

save_commentComment on an issueAInspect

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.

Inputs: body (required), issue (required).

save_issueCreate or update an issueA
Destructive
Inspect

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, and MOVING AN ISSUE INTO review requires handoff unless it already carries a checkpoint — a finished-work claim has to say where the work is. labels replaces the issue's labels. CREATE requires FOUR 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; and (3) changeType — which of the Conventional Commits types this change is, which is what the Cost page splits spend by; and (4) reviewedSimilar — the open look-alikes you have read, demanded only when there ARE any. A create missing any of them is rejected. The fourth CANNOT be filled in blind: it is a list of issue ids only the server produces. So if nothing looks like this work you never send it, and if something does the create is refused with DUPLICATE_CHECK_REQUIRED naming the candidates and you re-call with them — or you searched first with list_issues, name them yourself, and pass in ONE call. Read them before you name them: the gate proves you were shown them, not that you judged them right, and the cheapest issue to file is the one you don't file twice. 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.

Inputs: body, work, dueAt, title, +11 more.

save_labelCreate or update a labelB
Idempotent
Inspect

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.

Inputs: name (required), color.

setup_statusCheck setupA
Read-onlyIdempotent
Inspect

Where this workspace is in onboarding, and what to do next. Call it when a human asks you to set Retasc up or to finish setting it up, when you have just connected, and any time you are unsure whether setup is complete — it is cheap and it is the ONLY authoritative answer. Returns one state and an instruction written for you: follow the instruction, including anything it tells you to say to your human. It is computed fresh from server state every call, so it is correct after a restart, in a different runtime, or a week later — there is nothing you need to remember between sessions. Never guess at onboarding steps from documentation you read earlier; this is the current procedure.

Inputs: no named parameters.

suspend_memberSuspend a personA
DestructiveIdempotent
Inspect

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.

Inputs: memberId (required).

usage_summaryShow usageA
Read-onlyIdempotent
Inspect

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. capped: true means a read bound was hit and every volume and money figure is a LOWER BOUND rather than a total — normally false, true only while a large org's rollup backfill is still catching up.

Inputs: no named parameters.

whoamiShow the connected workspaceA
Read-onlyIdempotent
Inspect

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

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      Self-hosted task tracker and MCP server for AI coding agents. Append-only case files preserve decisions, failed attempts, questions, and check results across sessions. A live web board lets people track progress and answer agents. Runs locally in Docker and connects to Claude Code, Codex, Cursor, and other Streamable HTTP MCP clients. MIT licensed.
      30
      6
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Lets AI agents in different harnesses hand each other concrete tasks, claim and report on them, and continue after restarts via a live dashboard and unattended workers.
      MIT
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.

    Resources