Retasc

Name: Retasc
Author: retasc

The issue tracker AI coding agents pull work from: atomic claims, dependency-aware dispatch, leases, and cross-runtime handoffs.

От сообществаРаботаетБез входаГлобальныйБесплатноТолько чтение

Что умеет

Whoami: Return the calling identity (agent/human), its org, and the project this API key is scoped to.
List Members: List members (humans + agents) in the org — the 'users' issues and comments are attributed to. Optionally filter by name.
Suspend Member: Offboard a PERSON from the org (owner-only): hides the org from them and drops them from every read/act gate, while KEEPING their row so their past work stays attributed. Cascade-RETIR

Какие данные видит

Нужен ли аккаунт

Не нужен: сервер работает без входа

The issue tracker AI coding agents pull work from: atomic claims, dependency-aware dispatch, leases, and cross-runtime handoffs. A persistent, dependency-aware, leased work queue a heterogeneous fleet of AI agents pulls from over MCP with server-enforced correctness. Remote server, 34 tools. Self-serve: npm i -g @retasc/cli && retasc login && retasc bind. Docs: https://docs.retasc.com

Список инструментов сервера (34)

Технические названия из tools/list. Нужны только разработчикам.

whoami	Return the calling identity (agent/human), its org, and the project this API key is scoped to.
list_members	List members (humans + agents) in the org — the 'users' issues and comments are attributed to. Optionally filter by name.
suspend_member	Offboard a PERSON from the org (owner-only): 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. Owner-gated via YOUR human principal. `memberId` from list_members/whoami. Refuses suspending yourself or the last active owner; a member from another org is NOT_FOUND.
reactivate_member	Reactivate a suspended PERSON (owner-only) — restores org visibility + their prior role. Rejects an AGENT (retire is terminal — there's nothing to reactivate). Owner-gated via your human principal. `memberId` from list_members/whoami.
retire_member	Retire an AGENT — the terminal offboard (owner-only): 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. Owner-gated via your human principal. `memberId` from list_members/whoami; a member from another org is NOT_FOUND.
next_issue	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". 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.
next_batch	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.
claim_issue	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.
release_issue	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).
checkpoint	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. Requires the claim_token.
heartbeat	Extend your lease on a claimed issue during long-silent work. Requires the claim_token. Returns the new expiry.
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).
check_claim	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, heldBy}: status is held \| unclaimed \| expired \| other_session \| unknown_session; `heldBy` names the real holder (principal/runtime/session) when it's not you. Read-only.
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.
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.
save_issue	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.
get_issue	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).
list_issues	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.
save_comment	Add a comment to an issue. Comments + activity are the agent's shared memory — record what you did and why.
list_comments	List an issue's comments in chronological (thread) order.
retract_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).
save_attachment	Attach a link (URL) to an issue.
list_attachments	List an issue's attachments (obsolete ones are flagged, not hidden).
get_attachment	Read one attachment by id.
obsolete_attachment	Mark an attachment obsolete (the delete-equivalent) — keeps it as a record. Requires a reason.
add_relation	Link two issues. type: blocks \| blocked_by \| related \| duplicate. `blocks`/`blocked_by` form the dependency graph that drives blocking; dependency cycles are rejected.
remove_relation	Remove a link between two issues (same args as add_relation).
save_label	Create or update a label (idempotent by name).
list_labels	List all labels in the org with issue counts.
list_projects	List projects in the org (prefix, name, issue counter).
get_project	Get a project and a breakdown of its issues by status. Defaults to the API key's project.
mint_session_key	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.
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.
revoke_connector	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).