Retasc

SSE

by Retasc

285 downloads Not rated yet

Website SSE

About

Details

Transport: SSE

Explore

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Retasc

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

From the repository

{
  "mcpServers": {
    "retasc": {
      "type": "http",
      "url": "https://mcp.retasc.com/mcp"
    }
  }
}

`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. `me…

`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/whoam…

`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.…

`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 in…

`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 firs…

`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 P…

`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 …

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

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "retasc": {
            "retasc": {
                "type": "http",
                "url": "https://mcp.retasc.com/mcp"
            }
        }
    }
}

McpServers

{
    "retasc": {
        "type": "http",
        "url": "https://mcp.retasc.com/mcp"
    }
}

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 fleet of AI agents pulls from over MCP with server-enforced correctness. Remote server, 33 tools. Self-serve: npm i -g @retasc/cli && retasc login && retasc bind. Docs: https://docs.retasc.com

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Explore

Setting up with Highlight

From the repository

whoami

list_members

suspend_member

reactivate_member

retire_member

next_issue

next_batch

claim_issue

release_issue

checkpoint

heartbeat

queue_status

check_claim

usage_summary

billing_summary

save_issue

get_issue

list_issues

save_comment

list_comments

retract_comment

save_attachment

list_attachments

get_attachment

obsolete_attachment

add_relation

remove_relation

save_label

list_labels

list_projects

get_project

mint_session_key

list_connectors

revoke_connector

Claude Desktop / Cursor

McpServers

More like this

Sentry

Github

Git

GitLab

`whoami`

`list_members`

`suspend_member`

`reactivate_member`

`retire_member`

`next_issue`

`next_batch`

`claim_issue`

`release_issue`

`checkpoint`

`heartbeat`

`queue_status`

`check_claim`

`usage_summary`

`billing_summary`

`save_issue`

`get_issue`

`list_issues`

`save_comment`

`list_comments`

`retract_comment`

`save_attachment`

`list_attachments`

`get_attachment`

`obsolete_attachment`

`add_relation`

`remove_relation`

`save_label`

`list_labels`

`list_projects`

`get_project`

`mint_session_key`

`list_connectors`

`revoke_connector`