rsct-framework MCP server
Commit Nov 14, 2026Enforces engineering governance and workflow protocols for AI coding agents through mechanical guardrails and project memory.
Also known as raphaelfnds/rsct-framework
- Stars
- 3
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 14, 2026
- License
- MIT
What is rsct-framework MCP?
rsct-framework enforces engineering governance and workflow protocols for AI coding agents through mechanical guardrails and project memory.
Summary generated from the project's README
About rsct-framework MCP server
Engineering teams that use Claude Code can use this framework to transform AI coding agents into disciplined engineers. It implements a structured workflow consisting of Research, Specification, Verification, Code, Review, and Test phases to prevent common issues like scope creep or skipped tests. By enforcing these stages through mechanical guardrails, the system ensures that agents do not drift from project standards or commit code without proper authorization.
The setup involves a local installation of the rsct-mcp companion server, which can be registered at either a user scope for solo developers or a project scope for teams. It relies on the agent reading project memory and CLAUDE.md files at the start of every session. The framework uses specific slash commands to manage the lifecycle of a task, including a mandatory review phase that prevents code from being committed until a human or the agent has verified it against the project context.
What you can do with it
- 1Mandate code reviewsEnsure no code is committed to a repository without a completed and stamped review.
Written from the project's README. Every use case is checked against a quote from it.
Configuration
RSCT_ASSUME_YES
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachableraphaelfnds/rsct-framework is public and reachablegithub.com/raphaelfnds/rsct-framework ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-13github.com/raphaelfnds/rsct-framework ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubRSCT Framework
Operational implementation of the RSCT Workflow Framework as governance protocols for AI-assisted engineering.
TL;DR — RSCT turns an AI coding agent into a disciplined engineer. It reads your project's memory at the start of every session and is mechanically prevented — via a companion MCP server — from skipping the plan, committing without your OK, or drifting from your conventions. The cycle is Research → Specification → Verification → Code → Review → Test, with guardrails at every phase.
Why it exists. LLM coding agents are capable but undisciplined: they skip plans, lose context between sessions, reuse stale authorizations, and quietly drift from a project's standards. RSCT addresses this at two layers:
- a passive layer — project memory + the §0–§M rules in
CLAUDE.mdthat the agent reads at session start; - a mechanical layer —
rsct-mcp, an MCP server that enforces the rules (authorization gates, phase machine, branch protection) instead of trusting the model to follow them.
What this is
A file structure that turns RSCT theory into concrete AI behavior rules for real projects.
Built for Claude Code. The framework relies on Claude Code's native
behavior of reading CLAUDE.md and per-project memory entries at session
start. Other AI tools (Cursor, Copilot, Codex) do not currently load
CLAUDE.md automatically — supporting them with auto-generated
.cursorrules and .github/copilot-instructions.md is planned for a future release.
Research → Specification → Verification → Code → Review → Test
Each phase has guardrails that prevent common AI failure modes:
scope creep, missing reversibility, skipped tests, accidental commits.
The Verification phase (V) shipped in M3 (v0.3.0) — it runs
between spec-approval and code-edit, walking reverse dependencies +
running a four-category checklist (gap / breakage / redundancy /
forgotten) against the project's institutional context. Tier table:
trivial+small skip V; standard+complex run V. The Review phase
(code and tests reviewed together, after Test) is mandatory at every tier since
2.11.0: rsct_request_commit refuses code that no completed review stamped, on
every authorization path. The review removes every comment from the touched
files — a measured fact moves to the decisions file first — and anything it
cannot verify goes to a dialog only the dev answers. There is no flag to skip it.
Both phases bind on their findings: every finding raised needs a
decision (block / address-now / capture-as-issue / defer /
accept) before the phase closes, and block aborts it. Answering an id
the phase never raised is refused. V's findings come from its checklist;
the Review's are the ones the agent declares, so that half is a
commitment the agent makes rather than one the machine can impose.
Documentation
The end-user guides live in docs/:
- Getting started — prerequisites, install,
restart,
/rsct-setup, and a 5-minute first-project walkthrough (the single-repo happy path). - Command reference — a per-command manual for all four slash commands.
- Multi-repo & contracts — the T2 layer: topology modes, the org universe, contracts & surfaces, producer-vs-consumer, and a step-by-step multi-repo walkthrough.
- Troubleshooting — common failures and fixes.
The companion server's tool-by-tool reference is in
mcp-server/README.md.
Installation
One-time, per machine. Installs runtime files to ~/.rsct/, registers
Claude Code slash commands at ~/.claude/commands/rsct-*.md, and — unless you
skip it — copies the rsct-mcp companion into ~/.rsct/mcp-server and links the
global rsct-mcp command to that copy. What runs is the copy, never the clone: to
update, git pull and run the installer again.
This installer, run from a clone, is the only way the companion is distributed. It is
not on npm: a registry package named rsct-mcp is not this project's — see
SECURITY.md.
⚠️ On Windows: open Git Bash, not PowerShell, and not WSL — unless your Claude Code itself runs inside WSL (see below).
The install/uninstall scripts are POSIX shell. PowerShell can invoke
bash, but Windows ships with several differentbashbinaries (Git Bash, WSL bash, Cygwin) and they mount Windows drives at different paths (/c/...vs/mnt/c/...). By default the scripts refuse to run under WSL because that would install to/home/<user>/.rsct/, which Claude Code on the Windows side does not read.Open Git Bash from the Start menu (or right-click a folder → "Git Bash Here") and run the commands below from there. The prompt will look like
MINGW64followed by your path.Claude Code inside WSL. If you run Claude Code from a WSL distro (its CLI installed inside that distro), install from a shell in that distro with
bash scripts/install.sh --wsl, and uninstall withbash scripts/uninstall-framework.sh --wsl. The installer needs Claude Code's CLI installed inside WSL, and node and npm there for the companion (without them only the companion is skipped). With--wslthe scripts drop every Windows-side folder from PATH, stop ifnode,npmorclaudeis still a Windows program, and stop before writing or removing anything when a folder they would touch (~/.rsct,~/.claude/commands, Claude Code's config file and folder, npm's global folder) is on the Windows side (/mnt/c/...) or cannot be checked. A Windows install, if you also have one, is not touched.--wsloutside WSL stops. The limits are listed in ADR-032 (docs/decisions.md).This applies to the install and uninstall scripts above. If you are contributing to the framework, Git Bash matters for the test suite too — but there the harness locates it for you, from whichever shell you start. See CONTRIBUTING.md.
git clone https://github.com/raphaelfnds/rsct-framework ~/dev/rsct-framework
cd ~/dev/rsct-framework
bash scripts/install.sh
⚠️ Restart your IDE / Claude Code after install. Slash commands are loaded at IDE startup. New
rsct-*commands installed while the IDE is running will not appear in the chat autocomplete until you fully close and reopen the VSCode/Claude Code window. If you type/rsct-setupand see "No matching commands", that's the symptom — restart fixes it.
After install (and restart), four slash commands are available in any project on this machine — no path needed.
Unattended / non-interactive install (CI, provisioning)
Both install.sh and uninstall-framework.sh accept a non-interactive mode:
# Framework files only — no prompts, no rsct-mcp companion, no global side effects:
RSCT_ASSUME_YES=1 RSCT_SKIP_MCP=1 bash scripts/install.sh
# equivalently: bash scripts/install.sh --yes --skip-mcp
-
RSCT_ASSUME_YES=1(or--yes/-y) — answer every prompt with its default. -
RSCT_SKIP_MCP=1(or--skip-mcp) — skip the rsct-mcp companion entirely (no copy into~/.rsct/mcp-server, no globalnpm install -g, noclaude mcp add; a companion already installed is left as it is). Omit it and the companion is always installed globally without prompting; whether it is also registered depends on~/.rsct/mcp-scope(#71):Recorded scope What an unattended run does user, or no marker at allruns claude mcp add rsct rsct-mcp --scope user, verifies it landed, and recordsuseronly if it didproject, no user-scope entry presentrecords project—/rsct-setupwrites and approves the.mcp.jsonin each project laterproject, with a user-scope entry presentremoves nothing and rewrites nothing. Removing it would de-register every project on the machine unattended; recording userwould destroy a deliberateproject. Re-run interactively to switch.skip(legacy)registers nothing, marker left as skipan unreadable marker registers nothing until you pick from the menu Because
~/.rsct/survives/rsct-uninstalland gets copied between machines, an imaged or inherited home carries its scope with it — and an inheritedprojectmarker now also means/rsct-setupwill create a.mcp.jsonin every project you run it in. To force a deterministic first-install default in a provisioning script, delete the marker first:rm -f ~/.rsct/mcp-scope.
The same flags work for uninstall-framework.sh (--skip-mcp there leaves the
global companion, its files in ~/.rsct/mcp-server and any user-scope
registration untouched). Both scripts also take --wsl, for a Claude Code that
runs inside WSL (see the Windows note above).
The uninstaller finds a user-scope registration in the file Claude Code uses
($CLAUDE_CONFIG_DIR/.claude.json when that is set, otherwise .claude.json in
your home folder), removes it with claude mcp remove rsct --scope user, and
re-reads the file to confirm. When it cannot remove it (no claude on PATH, or the
entry is still there afterwards), it names the file and how to remove the entry, and its
closing line says the registration is still in place — as it also does when you keep it
(answering n, or --skip-mcp). When the file can no longer be read after the removal,
the closing line says the removal is not confirmed. Detection needs node;
without it the closing line says the registration was not checked.
Under --wsl, a run where the Windows rsct-mcp still comes first on PATH
installs the companion inside WSL but registers nothing and leaves the recorded
scope as it was, whatever the table above says; the message names the folder to
put first.
Registering rsct-mcp with Claude Code
The install script (scripts/install.sh) asks where to register the
MCP server during the install run. It is a binary choice:
| Choice | What actually happens | Where to use |
|---|---|---|
| 1. Solo developer — user scope (recommended) | claude mcp add rsct rsct-mcp --scope user, then verified in the host config before the choice is recorded |
One-time per machine. rsct__* tools become available in every project after IDE restart. |
| 2. Team — project scope | asks to remove the user-scope entry (it would mask project scope everywhere), then /rsct-setup writes and approves a .mcp.json in each project |
Commit the .mcp.json so teammates pick it up. Teammates should pick [2] as well. |
[3] Skip was removed in #73. A scope you never register is not a scope,
and the old menu recorded a [2] choice that never took effect. A skip
already written to ~/.rsct/mcp-scope by an older release is still read: it
resolves to the documented default [1] for the menu, and an unattended run
(RSCT_ASSUME_YES) registers nothing and leaves the marker alone.
Your choice is recorded in ~/.rsct/mcp-scope, and since #73 it records what is
true on the machine, not what was asked for — if the user-scope entry
survives (you declined the removal, or the CLI failed), the marker says user.
Pressing Enter takes [1] on a first install, or whatever the marker
records on any later run (#71), so re-installing never silently resets a
project choice.
Manual steps the install can never automate
| Step | When |
|---|---|
| Restart IDE / Claude Code | After install, and after any claude mcp add/remove. Slash commands + MCP registrations load at IDE startup. |
/rsct-setup inside each project |
Once per project, to write CLAUDE.md, documentation/, memory entries, and the enforcement hooks (SessionStart sanitizer + PreToolUse edit-scope and terminal guards). |
For the typical solo-dev path: bash scripts/install.sh → choose User
scope → restart Claude Code → run /rsct-setup in each project.
Three steps, one restart.
Project scope detail (when to use option 2)
When you pick Project scope during install, the installer records the
choice in ~/.rsct/mcp-scope. The next time you run /rsct-setup in a
project, it AUTOMATICALLY creates / updates a committable .mcp.json in that
project root (CAP-48) — no manual step needed. The installer also reads the
marker on every later run and offers it as the menu default, so re-installing
and pressing Enter keeps the scope you chose instead of resetting it to
user scope (#71). You can still register manually
with claude mcp add rsct rsct-mcp --scope project. Either path writes:
-
.mcp.jsonin the project root:{ "mcpServers": { "rsct": { "command": "rsct-mcp", "args": [] } } }No hardcoded path and no
${workspaceFolder}placeholder — the server auto-detects the project root (its cwd, orCLAUDE_PROJECT_DIRwhich Claude Code sets). That keeps the committed file portable across every teammate's checkout (nothing machine-specific). Each teammate still needsrsct-mcpinstalled (the binary on PATH) for it to connect — see Team onboarding below.CAP-49: an earlier version wrote
args: ["--project-root", "${workspaceFolder}"]. Claude Code does not expand that placeholder, so the server received it literally and reportedrsct_installed: false. Re-running/rsct-setupauto-migrates a committed file that still carries it back toargs: []. -
Should you commit
.mcp.json? YES if you want your team to share the config — add it to git:git add .mcp.json && git commit -m "chore: register rsct-mcp project scope"Teammates who pull will pick up the registration automatically on their next Claude Code session (after restart). If you keep it uncommitted (or
.gitignoreit), the registration is local to your clone only. -
Approval — the step that used to be missing from these docs. A project
.mcp.jsondoes not spawn until that project has approved it. Until thenclaude mcp listreports:rsct: rsct-mcp - ⏸ Pending approval (run `claude` to approve)/rsct-setupnow does this for you: it writes<project>/.claude/settings.local.jsonwith"enabledMcpjsonServers": ["rsct"]. That file is per-developer — the RSCT.gitignoreblock ignores it, so the approval never travels with the repo. Each teammate approves on their own machine, either by running/rsct-setupor by answering the prompt Claude Code shows on first open.If you previously answered no to that prompt, the refusal is recorded in
disabledMcpjsonServersand wins over any approval./rsct-setupwill not override it — remove the entry yourself if you change your mind. -
Verify the registration:
claude mcp list # Expect a line like: # rsct: rsct-mcp - ✓ ConnectedRun this from inside the project directory (so the project scope is picked up). If
rsctdoes not appear, the.mcp.jsonis missing, malformed, or thersct-mcpbinary is not on PATH. If it appears as ⏸ Pending approval, see step 3. -
User scope MASKS project scope — they do not coexist. If you have both
~/.claude.jsonmcpServers.rsct(user scope) AND<project>/.mcp.jsonmcpServers.rsct(project scope), the user-scope entry wins, in that project too. Measured with two distinguishable processes: only the user-scope one is ever spawned, and the project entry never executes. Approving the project entry does not change it.Earlier releases of this README claimed the opposite ("Claude Code uses the project-scope entry for that project only"). That was wrong, and it contradicted both the
CHANGELOG.mdCAP-47 entry and the installer's own warning. Corrected in #73.So project scope is only effective on a machine with no user-scope
rsctentry. Choosing [2] in the installer now offers to remove it for you — see Installation. -
Remove project scope later:
/rsct-uninstallscrubs both halves automatically — thersctentry from.mcp.json, and thersctapproval from.claude/settings.local.json. Both by key/value, preserving anything else in either file, and each file is removed only if it held nothing but the RSCT entry. A refusal you recorded indisabledMcpjsonServersis left alone. Or do it manually:claude mcp remove rsct --scope project # then commit the removed .mcp.json change if it was tracked # (the approval is local and gitignored — nothing to commit there) -
Troubleshooting — if
rsct_*tools do not appear after IDE restart:- Check
~/.claude.json($CLAUDE_CONFIG_DIR/.claude.jsonwhen that is set) and<project>/.mcp.jsonfor thersctentry (both are JSON, editable by hand if needed). - If
claude mcp listsays ⏸ Pending approval, the project has not approved the entry — see step 3. Re-run/rsct-setup, or answer the prompt Claude Code shows on first open. - Confirm the binary:
where rsct-mcp(Windows) orwhich rsct-mcp(macOS/Linux) should print a path. - Confirm the boot smoke:
cmd /c "rsct-mcp < NUL"(PowerShell) orrsct-mcp < /dev/null(Git Bash / macOS / Linux) should print the ready log on stderr. - Fully close all Claude Code windows + reopen. Slash commands + MCP registrations load at IDE startup only.
- Check
Team onboarding — the .mcp.json shares the registration, not the
binary. The committed .mcp.json only points Claude Code at the rsct-mcp
command; the binary itself must exist on each machine's PATH. So:
-
First dev (owner): install with [2] Team — project scope, run
/rsct-setup, commit.mcp.json(plusCLAUDE.md,documentation/). -
Every other teammate: clone (they get
.mcp.jsonfrom git), then run the installer to get thersct-mcpbinary and pick [2] as well.This changed in #73. The old advice was to pick
[3] Skip, on the reasoning that the registration had already arrived via git. That was wrong twice over:[3]no longer exists, and picking[1]instead would add a user-scope entry that masks the committed.mcp.jsonin every repo — the team's shared registration would silently never run.[2]is the only correct answer on a teammate's machine.Picking
[2]also lets the installer offer to remove a user-scope entry they may already have from a solo install. Then restart Claude Code, and the project's.mcp.jsonis approved either by/rsct-setupor by the prompt Claude Code shows on first open → connected.
So: the binary is per-machine (everyone installs it), the registration is shared via git, and the approval is per-developer and never committed.
To uninstall the framework from the machine (different from removing RSCT from a project):
bash scripts/uninstall-framework.sh
(That script also offers to remove the global rsct-mcp install — keep it and
its files stay in ~/.rsct/mcp-server — and walks you through the per-project
claude mcp remove rsct step.)
Windows line endings (the LF will be replaced by CRLF warning)
On Windows with core.autocrlf=true (Git for Windows' default), git
prints warning: LF will be replaced by CRLF for every artifact
/rsct-setup generates (CLAUDE.md, .rsct.json, documentation/,
memory entries). This is harmless — RSCT idempotency never depends on
the on-disk line ending: every SHA the framework computes strips \r
first (tr -d '\r'), so a CRLF round-trip never flips a file from SKIP
to a spurious UPDATE.
If you'd rather silence the warning, add a .gitattributes in the
project root pinning the RSCT artifacts to LF:
# RSCT-generated artifacts — keep LF so the framework's SHA markers stay stable
CLAUDE.md text eol=lf
.rsct.json text eol=lf
documentation/** text eol=lf
This is optional and /rsct-setup never writes it for you (it won't
touch a file the dev owns) — add it yourself if the warnings bother you.
How to use
After installation, from inside any project on the machine. The stubs below are
quickstarts — the full per-command manual (preconditions, outputs, consent
gates, recovery) is in docs/commands.md.
New project (no existing CLAUDE.md)
/rsct-setup
Creates CLAUDE.md, documentation/ structure and memory entries from scratch.
Existing project (update)
/rsct-setup
Same command — detects what exists and only adds what is missing.
Create/adjust the org universe and/or link this project — /rsct-universe
/rsct-universe
One idempotent command that detects the current state and does the right thing:
- No universe yet → bootstraps a skeleton universe repository at
~/projects/<org>-universe/(CLAUDE.md§0,docs/governance/— LGPD/DNS/ naming/retention,docs/diagrams/.drawioplaceholders,applications/,hosts/) and links this project to it in the same run — one command takes you from nothing to linked. Templates carry TODO placeholders you fill as the org grows. - Universe exists but this project isn't linked → adds the
## 0. Canonical architectural sourcesection toCLAUDE.md, pointing at it. - Inside the universe repo → adjusts/refreshes the skeleton (adds only what's missing).
- Already linked → refreshes the link.
Replaces the older
/rsct-init-universeand/rsct-canonical-sourcecommands, which are removed on upgrade (their engine prompts live on internally). Only/rsct-universeappears to you.
Universe app registration
Once a project is linked to a universe (via /rsct-universe), re-running
/rsct-setup offers to register this app in the universe (consent-gated): it
renders an app README into applications/<app>/ and appends the app to the
universe's registered_apps[] index. It writes only to the universe repo and never
commits or pushes there — you review and commit those changes yourself.
From then on, rsct_status and rsct_load_context surface a universe block
describing the universe and whether this app is registered, and emit a one-line hint
to register it when it is not yet linked. See
the universe block for the field/state
reference.
Multi-repo org? Topology modes, contracts & surfaces, the producer-vs-consumer gate, and which session edits which repo are covered in
docs/multi-repo.md.
Uninstall RSCT from a project
/rsct-uninstall
Reverses what /rsct-setup and /rsct-universe created or modified in the
project, and lists, before you say OK, everything it keeps on purpose. Documentation
and memory files you edited are detected by SHA256 and left to your decision. In
CLAUDE.md, your text outside the RSCT markers stays; a framework section goes
whole, with any edit you made inside it (the report says so, and says whether git
has a copy); the file itself is deleted only when git proves setup created it. State
that a linked worktree or a monorepo package shares with its repository is named in
the report and never removed. Supports full uninstall and selective scopes
(memory-only, specific rules, docs-only, etc.).
rsct-framework MCP questions
What does the RSCT framework do?
It turns an AI coding agent into a disciplined engineer by preventing it from skipping plans, bypassing authorization, or drifting from project conventions.
Does this work with Cursor or GitHub Copilot?
Currently, it is built for Claude Code. Support for other tools like Cursor and Copilot via auto-generated rules is planned for a future release.
How do I install the framework?
You install it by cloning the repository and running the install script from a POSIX shell like Git Bash.
Is the MCP server available on npm?
No, the companion server is not distributed through npm; it is installed via the framework's installer.