Back to Browse

Murphy MCP Server

Developer ToolsLow Risk8.2MCP RegistryLocal
Free

Server data from the Official MCP Registry

Gives a coding agent a record it did not write: what changed on disk and in git, versus its claims.

About

Gives a coding agent a record it did not write: what changed on disk and in git, versus its claims.

Security Report

8.2
Low Risk8.2Low Risk

murphy-mcp is a clean, read-only-oriented workspace observer that snapshots files and git status and compares them against agent claims, with no network calls, no shell string interpolation (git invoked via execFile with fixed args), symlinks never followed, and no hardcoded secrets. Minor observations are limited to writing checkpoints under the workspace .murphy directory, reading all file contents for hashing across the workspace, and the lack of authentication, which is typical and acceptable for a local stdio server; these do not meaningfully lower the score. Supply chain analysis found 1 known vulnerability in dependencies (0 critical, 1 high severity). Package verification found 1 issue.

12 files analyzed · 7 issues found

Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.

Permissions Required

This plugin requests these system permissions. Most are normal for its category.

File System Read

Reads files on your machine. Normal for tools that analyze or process local data.

File System Write

Writes or modifies files on your machine. Check that this is expected for the tool.

process_spawn

Check that this permission is expected for this type of plugin.

system_info

Check that this permission is expected for this type of plugin.

How to Install

Add this to your MCP configuration file:

{
  "mcpServers": {
    "murphy-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "murphy-mcp@0.1.0"
      ]
    }
  }
}

Some servers take additional arguments. See the repository for details.

Documentation

View on GitHub

From the project's GitHub README.

murphy-mcp

An MCP server that gives a coding agent a record it did not write.

A coding agent finishes a task and tells you what it did. The report is coherent, well structured, and usually correct. It is also the only account you have, written by the party being assessed.

This server produces the other account. It records the workspace before the work starts, reads it again afterwards, and reports what actually changed: every file added, modified or deleted, plus what moved in git. Then it holds the agent's own account against that record and reports the disagreements.

It does not ask the agent what happened. That is the point.

Built on the 2026-07-28 MCP specification with the v2 TypeScript SDK. MIT licensed.


What it catches

The failure mode is not a lying agent. An agent's report is a summary written from its own context window, and that context is a partial view of a system with far more state than the agent can hold. The report is usually accurate about intent and less reliable about effect.

Three things show up again and again:

  • Side effects outside the narrative. The agent describes editing three files. Four were written. The fourth was a cache, a lockfile, a generated artifact, or a config the tooling rewrote.
  • Completion claimed at the boundary of knowledge. The agent finishes the part it can see and reports the task complete, because from inside its context the task is complete.
  • Claims nothing on disk supports. "The tests pass." "The bug is fixed." Possibly true, and not something a file listing can settle either way.

This server names all three, separately.

Install

Published builds:

npx -y murphy-mcp

Claude Code:

claude mcp add murphy -- npx -y murphy-mcp

Any MCP client, by config:

{
  "mcpServers": {
    "murphy": {
      "command": "npx",
      "args": ["-y", "murphy-mcp"]
    }
  }
}

From a clone:

npm install && npm run build

then point the client at node /absolute/path/to/murphy-mcp/dist/index.js.

Use

Take a checkpoint before the work, then check the account afterwards.

checkpoint        { root: "/path/to/project", label: "refactor auth" }
                  -> checkpointId

... the agent works ...

check_claims      { root, checkpointId,
                    claimedPaths: ["src/auth.ts", "src/session.ts"],
                    claimedStatements: ["All tests pass."] }

What comes back:

# Evidence report

**2 unreported · 1 contradicted · 1 confirmed · 1 unverifiable**

## Unreported: observed on disk, never mentioned
- `b.txt` (deleted)
- `generated/out.bin` (added)

## Contradicted: claimed, but nothing changed
- `never_touched.ts` — no such file at checkpoint time and none now

## Unverifiable: outside what this record can settle
- The test suite passes. — a filesystem and git record cannot settle this; it needs its own evidence

## Confirmed: claimed and observed
- `a.txt` (modified)

Disagreements come first, because that is what a person is for. Nobody reviews a flat log of 50,000 events; anyone can scan a list of four disagreements in a minute.

The four buckets

They are kept apart on purpose. Collapsing them is what makes a claim read as evidence.

BucketMeaning
confirmedClaimed, and observed on disk
contradictedClaimed, and nothing changed
unreportedChanged on disk, and never mentioned
unverifiableNothing in a filesystem or git record can settle it

unverifiable is stated explicitly instead of being quietly guessed. Presenting a guess at the same confidence as a fact is the failure this is meant to stop.

Tools

checkpoint

Records the workspace as it is now: path, size, modification time and SHA-256 for every file, plus git HEAD, branch and status --porcelain. Returns a checkpoint id.

root (required) · label · ignore · noDefaultIgnores · maxFiles · maxFileBytes

evidence_since

Rescans and reports what changed since the checkpoint. The observed record alone, with no claims involved.

root (required) · checkpointId (required) · the same scan options

check_claims

Holds the agent's account against the record and returns the four buckets.

root (required) · checkpointId (required) · claimedPaths · claimedStatements · the same scan options

list_checkpoints

Lists the checkpoints stored under a workspace, most recent first.

root (required)

Design decisions worth knowing

Build output is not ignored. Only .git, node_modules and the server's own .murphy store are skipped by default. Ignoring dist, .next, target or coverage would hide exactly the writes that tend to fall outside an agent's account. If you want them skipped, pass them in ignore.

Checkpoints are written to disk, under .murphy/checkpoints in the workspace, with a .gitignore that keeps the store out of the repository. The 2026-07-28 protocol core is stateless, so nothing that has to outlive a single call is kept in the process. It also means the evidence survives the session it describes, which is when anyone actually wants to read it.

Symbolic links are recorded and never followed. A snapshot that can wander outside its root cannot say where it looked.

Hashing has limits, and they are reported. Files over 8 MiB are not hashed; for those a change is inferred from size and modification time, which is weaker evidence, and the report says so. Every truncation, skipped directory and unhashed file appears under "What this report does not cover".

What this does not do

Honest scope, so nobody is surprised:

  • No process ancestry and no network capture. It sees the filesystem and the git repository. It cannot tell you which command produced a write, or what was fetched.
  • It does not read .gitignore. The default ignore list is the three directories above and whatever you pass.
  • It is not a sandbox or a guardrail. It observes after the fact. It blocks nothing.
  • It cannot verify behaviour. "The tests pass" comes back as unverifiable every time, by design. Run the tests.

Relation to MURPHY

MURPHY is a separate, commercial, local-first Windows tool that reconstructs agent activity from process ancestry, filesystem activity, workspace boundaries and network behaviour. This server is an independent, cross-platform, open implementation of the filesystem and git half of the same idea, usable from any MCP client.

The reasoning behind both is written up in An agent's report is not evidence.

Development

npm install
npm run build
node test/smoke.mjs

The smoke test builds a throwaway git workspace, drives the server over a real stdio MCP connection, makes three changes, reports one of them, and asserts that the other two come back as unreported.

Licence

MIT. See LICENSE.

Reviews

No reviews yet

Be the first to review this server!