Back to Browse

Marrow MCP Server

Developer ToolsLow Risk10.0MCP RegistryLocal
Free

Server data from the Official MCP Registry

Approval gate and audit trail for AI agent actions: policy check first, proof after. Any MCP client.

About

Approval gate and audit trail for AI agent actions: policy check first, proof after. Any MCP client.

Security Report

10.0
Low Risk10.0Low Risk

Valid MCP server (0 strong, 2 medium validity signals). No known CVEs in dependencies. Package registry verified. Imported from the Official MCP Registry.

9 files analyzed · 1 issue 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.

HTTP Network Access

Connects to external APIs or services over the internet.

env_vars

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

What You'll Need

Set these up before or after installing:

Named Marrow agent API key. Keep it in trusted secret storage.Required

Environment variable: MARROW_API_KEY

How to Install

Add this to your MCP configuration file:

{
  "mcpServers": {
    "mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@getmarrow/mcp@3.9.114"
      ],
      "env": {
        "MARROW_API_KEY": "your-marrow-api-key-here"
      }
    }
  }
}

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

Documentation

View on GitHub

From the project's GitHub README.

Marrow AI MCP Server

@getmarrow/mcp: the control layer for AI agents. Marrow AI puts a named yes on an action before your agent acts, and leaves proof the next agent can reuse.

Which Marrow? This is Marrow AI from getmarrow.ai (npm @getmarrow/mcp, MCP Registry ai.getmarrow/marrow). It is not affiliated with marrow.id, HyperMarrow, marrow.works or other projects named Marrow.

getmarrow.ai · Docs · Marrow AI for MCP · MCP Registry entry · Changelog · getmarrow/marrow-mcp MCP server

Marrow AI is the runtime control and proof layer for teams running AI agents. It applies policy and prior lessons before consequential actions, then records the evidence and outcome afterward.

Use @getmarrow/mcp when your agent client supports the Model Context Protocol and you want Marrow available inside the agent's normal workflow. It works with Claude Code, Claude Desktop, Cursor and other MCP-compatible clients without replacing the model or harness.

Quick start

  1. Create a key. Sign up at getmarrow.ai/signup, then open the dashboard, go to API keys and choose Create API key. The key is shown once.

  2. Activate. Make the key available as MARROW_API_KEY (from your secret storage, or an owner-only ~/.marrow/env), then run the installer from a terminal:

    npx -y @getmarrow/install@latest activate
    
  3. Restart the agent host and review/enable its hook trust.

  4. Verify:

    npx -y @getmarrow/install@latest doctor --self-test
    

What is enforced. On the 30-day evaluation and Business, deploys and publishes are held in hooks and the governed runner. Team and Free warn. If Marrow is unreachable, hooks hold high-risk actions and let routine actions run with a warning, and the governed runner stops protected actions it cannot verify. Over MCP, the agent gets the decision and is expected to follow it. Hooks run inside the agent host and are not an external execution boundary: an agent or person who edits the host settings, or works outside the host, is not held.

Agent Discovery

  • Publisher: Marrow AI. Capability descriptions in this package are vendor-provided product statements.
  • Use this package for: MCP-compatible clients that need status, before-action governance, proof-backed outcome closure, and tenant-scoped fleet lessons in the normal agent workflow.
  • Product category: agent fleet governance and control layer.
  • Operator boundary: configuring the server, creating an account, or submitting a diagnostic requires operator approval.
  • Public diagnostic privacy: raw prompts, source code, credentials, customer data, and free-form work descriptions are not accepted.
  • Machine-readable product facts: https://getmarrow.ai/llms.txt and https://getmarrow.ai/.well-known/marrow.json

Maintainers can validate local registry metadata with npm run registry:check. After an approved registry publication, npm run registry:verify confirms that the official registry returns the exact package name and version; package metadata alone is not treated as publication proof.

Public operating guides:

The assessment accepts bounded selections only. It does not install Marrow, authorize a purchase, accept free-form work content, or establish compliance, security, or ROI.

Where Marrow fits

Marrow AI is the optional agent fleet governance and control layer around existing models, harnesses, and business workflows. It is not a model provider, agent harness, memory-only tool, or observability replacement.

Marrow fits when one or more of these is true:

  • Two or more autonomous agents, models, or harnesses contribute to one accountable workflow (multiple_autonomous_agents).
  • Agents can deploy, merge, publish, change production data, use privileged tools, spend money, or message customers (production_or_privileged_access).
  • The workflow has repeated failures, retries, regressions, or known lessons that should affect the next action (repeated_workflow_failures).
  • Work can be marked complete without proof, verification, or a recorded business outcome (missing_completion_evidence).
  • Policy, approval, or completion requirements vary across agents, tools, environments, or teams (inconsistent_policy_enforcement).
  • Agents operate around regulated, proprietary, personal, financial, health, legal, credential, or otherwise sensitive workflows (regulated_or_sensitive_work).

Where Marrow is not a fit

  • One advisory assistant performs no shared, privileged, production, or accountable business action (single_low_risk_assistant).
  • The workflow has no need for policy, proof, outcome accountability, or fleet coordination (no_governance_requirement).
  • The operator has declined Marrow evaluation or installation (operator_declined_evaluation).

Installing Marrow changes the operator's agent configuration: never install, create an account, or submit data without operator approval.

Verify current claims through the public evidence manifest, reference graph, and integration cards.

Install

Windows: Native Windows is not supported yet. Use WSL.

For most installations, follow the Quick start: the universal installer's activate command. The steps below are the manual, MCP-only route.

Get a key at getmarrow.ai/signup and keep it in an owner-only key file: put MARROW_API_KEY=<your_key> in ~/.marrow/env, then run chmod 700 ~/.marrow && chmod 600 ~/.marrow/env (Marrow rejects a key file whose folder others can write):

mkdir -p ~/.marrow && chmod 700 ~/.marrow
# put MARROW_API_KEY=<your_key> in ~/.marrow/env
chmod 600 ~/.marrow/env

Claude Code plugin users: after /plugin install, run /reload-plugins (or restart Claude Code). To add a key, put MARROW_API_KEY= in ~/.marrow/env, run chmod 600 ~/.marrow/env, then /reload-plugins. Do not run activate or marrow-mcp setup for the plugin, because they write a second copy of the hooks.

Hooks-only setup (marrow-mcp setup writes hooks and CLAUDE.md instructions, and adds no MCP server). It needs the key first: without one it prints how to get it and exits 2 before writing anything.

npx -y --package=@getmarrow/mcp@latest marrow-mcp setup

The MCP server and Claude Code's cooperative pre-action hook read the key only from the process environment or an owner-controlled ~/.marrow/env (or ~/.marrow/env.local) with owner-only permissions (chmod 600). An owner file that is a symlink, readable or writable by others, owned by another user, or in a directory others can write supplies nothing, key included; the missing-key message names it with the chmod fix. Repository-local files (.env, .env.local, .marrow/env* in the working directory or its parents) are never read for MARROW_API_KEY or any other MARROW_* setting, whatever their permissions, so project content cannot replace the account, agent, or API endpoint. If one holds a key, the missing-key message names that file and the fix: run npx @getmarrow/install doctor, or move the line to ~/.marrow/env, then chmod 600 ~/.marrow/env. The public hook callback is still a client self-report, not certified host provenance or an external enforcement boundary.

Then configure the MCP server:

{
  "mcpServers": {
    "marrow": {
      "command": "npx",
      "args": ["-y", "--package=@getmarrow/mcp@latest", "marrow-mcp"]
    }
  }
}

After setup writes MCP configuration or hooks, restart the agent host and review/enable its hook trust. Then verify the reloaded environment:

npx -y @getmarrow/install@latest doctor --self-test

Successful setup alone does not mean this process reloaded or that hooks are active. Keep savings at zero until observed usage supplies evidence.

Tool Profiles

Ordinary setup does not require MARROW_TOOL_PROFILE. When the variable is unset, Marrow uses the primary profile and exposes exactly the 17 tools in Primary MCP Tools.

  • MARROW_TOOL_PROFILE=primary explicitly selects the same 17-tool primary surface.
  • MARROW_TOOL_PROFILE=core preserves the seven-tool runtime, think, commit, ask, status, auto, and handoff-status surface.
  • MARROW_TOOL_PROFILE=full exposes the complete advanced and legacy catalog for integrations that require it.

An invalid value returns a bounded configuration error with the exact allowed values; it never falls back to full. Restart the MCP process after changing the profile.

Local visibility does not grant paid access. Every tool call continues through Marrow's backend authentication, tenant, key-permission, plan, proof, and policy enforcement. MCP status responses include mcp_tool_profile with the configured and effective profile, visible tool names/count, and a backend primary-tool entitlement projection when fresh authenticated evidence is provided. Missing or cached entitlement evidence is labeled unavailable and cannot authorize a call.

Keeping MCP Current

Marrow's hosted API, website, and dashboard update automatically; local MCP hooks, configuration, and pinned package commands do not silently rewrite themselves. Keeping them current delivers new client-side features, compatibility improvements, and any published security fixes. During authenticated status/runtime activity, Marrow returns a client_update notice when the package is behind or unknown, and passive context shows the agent the exact update and verification commands.

npx -y @getmarrow/install@latest activate
npx -y @getmarrow/install@latest doctor

# Manual MCP-only setup
npx -y --package=@getmarrow/mcp@latest marrow-mcp setup

# Verify live read latency, last success, and local backlog
npx -y --package=@getmarrow/mcp@latest marrow-mcp ping

Detection and notification are automatic. After explicit installer activation, the local controller may restore only Marrow-managed hooks/configuration. Package upgrades, owner policy, credentials, and unrelated configuration remain explicit and subject to the operator's normal change policy.

Pending write recovery

A direct marrow_think can receive a durable pending response before the backend can safely expose a decision ID. The client recognizes the explicit agent_write_reconciliation.v1 think contract and the corresponding current legacy pending shapes. It retries the identical authenticated request with the original idempotency key, agent and session, at most three reconciliation rounds with the existing one-second wait between rounds. Each round retains up to two transport attempts for retryable failures, so one invocation can send up to six HTTP requests, all with the same key and body. It never creates a placeholder decision or starts an automatic operation to recover a direct think call. Unknown states, conflicting keys and unsafe responses fail closed; exhaustion returns a retryable structured pending_receipt with committed:false, the original idempotency_key, and request_hash. To resume manually, pass both fields to marrow_think with the same arguments, credentials, agent and session. The hash binds that exact canonical request and scope; drift is rejected before sending. No prompt, credential, or raw scope is included in the receipt. Caller keys must be privacy-safe opaque identifiers.

A saved observed_unverified outcome is terminal observation evidence, not a committed outcome. Receipt expiry cannot retroactively authorize completed work. Preserve the original decision, receipt, proof and key; an already authorized durable checkpoint may finish through its existing exact recovery path. Do not repeat the action merely to obtain a fresh receipt.

Keyless seatbelt

When a pre-action hook has no usable Marrow key and the machine shows no sign of a Marrow account (for example an owner key file, a claim marker or Marrow's local approval state), the hook runs a local seatbelt instead of holding every protected action:

  • It stops seven kinds of action: a change to Marrow's hooks, settings or plugins (including the Marrow plugin switch in Claude Code settings and the plugin files under ~/.claude/plugins) or an owner-only Marrow command (S0), a force-push or delete of a protected branch (S1), a production deploy (S2), a package publish (S3), reading credentials or secrets, including a project .env file or any other <name>.env file that exists (templates such as .env.example pass), ~/.marrow/fleet.env and ~/.marrow/credentials (S4), a recursive delete outside the workspace (S5), and decoded data run by a shell or interpreter (S-x). A protected file named to any program that is not a plain reader (such as cat, grep, jq or diff) stops too, so an editor or a tool the seatbelt does not know cannot rewrite it. A tool counts as a plain reader only with the long options it lists, spelled in full: GNU tools and git also accept a shortened spelling (cp --target=DIR, git reset --har), so a shortened or unknown long option on a command that names a protected file stops. Archiving (tar -c, zip), tree and prettier --check only read what they are given: only the archive and the files they write are checked. The stop is the host's own deny, with text that tells the agent to leave the action to the machine owner. On Grok the stop is Grok's fixed denial ("Marrow blocked this protected action."), the only denial its installed guard passes.
  • Everything else gets no Marrow decision, so the host's own approval step decides: Claude Code and Codex get an empty answer, Cline is not cancelled and Windsurf gets no output. Gemini CLI gets {"decision":"allow"}, the only answer its installed guard passes without blocking. Cursor asks with its own approval prompt before a shell command that a hook without a key used to hold. Cursor's other tools (MCP calls included) and Grok have no neutral answer, so they keep holding what a hook without a key held before. An action that a hook without a key already let through gets the same answer as before.
  • Host tools and MCP calls: the seatbelt reads each host's own file tools (for example Cline write_to_file and replace_in_file, Gemini CLI read_file, replace and delete_file, Grok search_replace, Cursor Delete) and MCP calls in every host form (mcp__server__tool, MCP:server:tool, Gemini mcp_server_tool and server__tool, Cline use_mcp_tool and access_mcp_resource). Every string value in an MCP call's arguments, at any depth, gets the S0 and S4 path checks. A tool it does not recognise, or MCP arguments it cannot read, never gets the seatbelt's pass: the hook gives the answer a hook without a key gave before, a hold where that held.
  • It fails closed: an internal error, a check that runs past 300 ms, or input the host cut short stops the action. Windsurf and Cline do not tell the hook the working folder, so there a recursive delete outside the temporary folders stops.
  • Local receipts: each seatbelt decision is written to ~/.marrow/seatbelt/receipts/ on this machine, as codes and keyed hashes, plus the built-in tool name and shell program names from fixed lists (any MCP tool is recorded only as mcp); no command text, argument, path or URL. Receipts are kept for up to 90 days or 50 MB. Nothing is uploaded. Where the seatbelt enforces (no working key), an agent cannot edit the receipts or read the device salt that keys them (S0, S4); with a working key the seatbelt only watches. Receipts are a record, not an authority.
  • Folder permissions: the seatbelt runs only where your home folder and the agent settings folders (such as ~/.claude) can be written by you alone. On Linux, a folder that your own private group can also write (the default with umask 002, mode 0775) still counts. A folder others can write, a group with other members, a folder reached through a symlink, or users and groups from a network directory (LDAP, SSSD) keep every hold, and the hold names the reason and how to fix it, for example "Marrow stopped this action: there is no Marrow key on this machine, and Marrow uses its stricter no-key mode here because HOME is not your login home folder. Fix (for the person at this machine, not the agent): start the agent with HOME set to your login home folder, or add a Marrow key (getmarrow.ai/docs#start-here)."
  • Stops you may meet on purpose: cp .env.example .env.local (or any command that writes a .env file), set -a && . ./.env && npm run dev and docker compose --env-file .env up are stopped as secrets (S4), and rm -rf ~/.cache/<app> as a recursive delete outside the workspace (S5). If you meant it, run the line yourself in your own terminal. Each stop message names the kind of action and ends with its code.
  • It is a seatbelt, not a vault: it runs on the machine as your user and makes no network call. A determined agent can get around a local check, for example with a script it writes now and runs later, an interpreter, or a tool path with no hook.
  • With an account: a machine linked to an account but with no working key keeps every hold it had, and these stops apply too. With a working key nothing changes; the seatbelt only checks the action after Marrow has answered, without changing the answer.

marrow-mcp setup and the installer both need a key; hooks without a key come from the Marrow plugins for Claude Code, Codex and Cursor.

Hook behavior details

These behaviors shipped in 3.9.100 and still apply.

  • One Marrow entry per hook event: marrow-mcp setup recognizes the installer's local-runtime hook commands exactly (same version throughout, no additions), keeps whichever form is there (local runtime or npx), and never adds a second entry. Your own hooks stay as they are.
  • Plain words without a key: on a machine linked to a Marrow account, a protected action with no working key is denied with "Marrow is linked to an account but has no working key; owner: run npx -y @getmarrow/install@latest doctor." A machine with no account runs the keyless seatbelt. The hooks read the key from MARROW_API_KEY or an owner-only ~/.marrow/env.local or ~/.marrow/env, never from a file others can read.
  • First-prompt briefs say so: the prompt hook marks its brief context.prompt_brief: true; a brief authorizes nothing.
  • Deploy text only word for word: the exact command text is sent only for sst deploy --stage <stage> (optionally --verbose, optionally after one npx or bunx), with a stage of lower-case letters, digits and dashes, in a single clause with nothing else in it, so Marrow can judge the stage itself. Every other command, including other deploy tools, sends only the hash; no free-text word leaves the machine.
  • Claude Code Bash command text: For Claude Code Bash calls the hook sends the shell command text, checked for secrets on your machine first; a command in which a secret is found is sent only as a hash. Marrow does not store the text. The text goes on the runtime check only, with the plain SHA-256 of marrow-normalized-action-v3\nshell\n and the text; holds, reports, lifecycle events and local receipts carry the hash alone. MARROW_HOOK_COMMAND_TEXT=off in the hook's environment sends the keyed hash and no text, as 3.9.113 did.
  • Script text is not sent: in this version the hook does NOT send the text of a local script a Bash call runs, nor a fingerprint of it; the script module (src/script-attach.ts) is in the package for a later release and the hook does not use it.
  • No lifecycle event id with two payloads: an event id names its payload, so a later run is a new record and a resend carries the same bytes.

Setup and key handling

These behaviors shipped in 3.9.101 and still apply.

  • Setup with no key stops: marrow-mcp setup with no key, or with a key only in an untrusted place such as a project .env, stops, writes nothing and tells you how to get a key.
  • Keys are read from trusted places only: the key comes from the environment or an owner-only ~/.marrow/env.
  • Key-file steps include chmod 700 ~/.marrow before chmod 600 ~/.marrow/env.
  • Hold messages say where to approve: a held action says how to approve it where your host really asks.
  • One enforcement sentence: the "what is enforced" wording matches the public site.

Project files and Marrow's own tools

These behaviors shipped in 3.9.102 and still apply.

  • A cloned project's .env cannot redirect the MCP server: repository-local .env, .env.local and .marrow/env* files are never read for MARROW_API_KEY or any other MARROW_* setting, so project content cannot point the server at another account, agent or API endpoint.
  • Safer key-file advice: an owner file that is a symlink, readable or writable by others, owned by another user, or in a directory others can write supplies nothing, and the missing-key message names the file with the chmod fix.
  • Only Marrow's own tools skip the gate, by exact name: a tool is Marrow's own only when its server is exactly marrow and its tool name is exactly one this package registers. Look-alike servers, other cases, extra spaces or suffixes go through the pre-action gate like any other MCP tool. Re-run marrow-mcp setup to refresh hooks written with the old matcher.

Seatbelt, outage holds and exact approvals

These behaviors shipped in 3.9.103 and still apply.

  • Keyless seatbelt: a hook with no key, on a machine with no sign of a Marrow account, stops seven kinds of action (Marrow's own settings, force-push or delete of a protected branch, production deploy, package publish, reading credentials, recursive delete outside the workspace, decoded data run by a shell) in shell commands, each host's own file tools and MCP calls, and leaves everything else to the host's own approval step. A tool it does not recognise keeps the answer a hook without a key gave before. Machines linked to an account keep every hold they had. A Linux home or agent settings folder that only your own private group can also write (umask 002) keeps the seatbelt. See Keyless seatbelt. Marrow's own plugins and the Marrow plugin switch are protected like its settings.
  • High-risk actions wait while Marrow is down: with a key, if Marrow cannot be reached, a git push, publish, deploy, API delete, seatbelt-category command or other high-risk tool (for example an MCP tool) is held on every host until Marrow is back; words in a commit message or a path never hold a command, and routine actions keep running with a warning. If Marrow answers but cannot issue a permit, a high-risk action is denied and never allowed as offline.
  • Local receipts: each seatbelt decision is written on this machine as codes and keyed hashes, plus the built-in tool name and shell program names from fixed lists (any MCP tool is recorded only as mcp); no command text, argument, path or URL. Kept for up to 90 days or 50 MB. Nothing is uploaded.
  • Approvals bind to the exact action: an owner approval resumes only the exact action that was held. A held action whose sent form hides a value also carries exact_hmac, a keyed hash made with this machine's private device key (never sent); a retry that differs only in a certain credential, such as a new one-time password, still resumes. The action hash version is now v3: learned approvals and known workflows from earlier versions ask once more, then are learned again. See Approvals in the Host Prompt.
  • Hidden commands are checked: commands inside an unquoted here-document body, a ${x:-$(...)} default or an arithmetic expansion are checked like any other command.
  • marrow-mcp keys create reads every flag form: --name=, --type= and --expires= (and -n=, -t=) are read like --name value; a flag that is present but blank, or a --scopes / --agents list with no entry, is a usage error (exit 2) and nothing is sent; leaving --scopes and --agents out sends neither.

What's New in v3.9.114

v3.9.114 lets Marrow judge what a Claude Code Bash call really does. The full entry is in CHANGELOG.md.

  • Command text. The hook sends the command text of Claude Code Bash calls, checked for secrets on your machine first; Marrow does not store the text (details under Claude Code Bash command text). Script text is not sent in this version. Risky actions are still held, and a command that only mentions the installer in its text (echo, grep, git log) is no longer mistaken for an installer run. When a Marrow call fails, the client says the latest version was not checked and no longer reports the install as current.

These behaviors shipped in 3.9.113 and still apply.

  • One update path. The local client update no longer builds the MCP setup command, which for a plugin install wrote a second hook copy next to the plugin. The update hint names the installer update (npx @getmarrow/install@latest update). Verdicts, requests to Marrow and closure calls are unchanged.

These behaviors shipped in 3.9.112 and still apply.

  • Plain allows stay quiet. When Marrow allows an unprotected call (for example a read or a local append) and the hook holds no permit, generic service text ("Do not repeat the failed path...", "No identified workflow yet...", "Proceed with the low-risk work...") is no longer added to the agent's context, so routine work is not asked to close an outcome. Specific guidance, the permit line of a protected call, every verdict, every request to Marrow and every closure call are unchanged.
  • No key on the command line. The key setup in this README is one path: save MARROW_API_KEY in the owner-only ~/.marrow/env (chmod 700 ~/.marrow && chmod 600 ~/.marrow/env) first, then run the command. The fallbacks that showed a key typed on a command line are gone. Docs only.

Loop guard, stable entry and auto-mode holds

These behaviors shipped in 3.9.110 and still apply. v3.9.110 repaired a broken install on 3.9.109; the full entry is in CHANGELOG.md.

  • A busy host is no longer locked out by the loop guard. When the local loop-guard state reaches 256 KB, the oldest entries of other sessions are pruned instead. The session making the call is never pruned. This is looser than 3.9.109, by the owner's decision: while the pruning runs, other sessions keep only their 3 newest distinct calls, so a loop in another session that repeats a call only after 3 or more other distinct calls can be missed; loops of 1-3 distinct calls are still denied. After a large backward clock step the hook can still deny calls until the clock catches up, as in 3.9.109.
  • The stable Marrow entry is recognized on Codex and Cursor. The version-free entry (/bin/sh -c <stub> <home>/.marrow/runtime/launcher/<sha256>.cjs marrow-mcp) is recognized as the official server, so Marrow's own tools skip the gate when a host has moved to it. It counts only as this process's own launch: the launcher that started the hook must hash to the digest in the entry and be a launcher of a pinned core. Anything else goes down the normal gate path. macOS and Linux only; Windows keeps the current entry. This is looser than 3.9.109, by the owner's decision.
  • A hold in Claude Code auto mode never opens a dialog. The hook denies with the receipt ("Held for the owner's approval (receipt ). Continue other work; run this exact action again after the owner approves.") and the agent carries on. The hold stays open on the same receipt. Default and acceptEdits modes ask as they did before.
  • A refused agent id says where it came from. The tool error for a refused agent id (HTTP 403 MARROW_AGENT_SCOPE_MISMATCH or ACTION_PERMIT_AGENT_CREDENTIAL_SCOPE_INVALID) adds one sentence naming the variable and where the id came from (the owner env file, a fleet key match, or this server's environment). The status, code and repair text are unchanged.
  • marrow_think no longer fails on cached warnings. When the think answer had no intelligence object, the tool failed after the decision was created and the agent never saw its decision id. The tool now returns the backend's answer as it came.

These behaviors shipped in 3.9.109 and still apply.

v3.9.109 adds several security fixes and hook fixes. The full entry is in CHANGELOG.md.

  • Turning Marrow control off needs the owner. A shell command that runs the installer to disable or uninstall Marrow is held for the account owner, and refused when no person is at the prompt (auto, bypassPermissions, dontAsk, headless). Held forms: npx @getmarrow/install control disable (also uninstall, control off, --disable), pnpm dlx, bunx, npm exec, node on the installer, marrow-install, chained, on a new line, inside bash -c, quoted, with control, disable or uninstall in upper case, or with a zero-width character inside disable or off after control. Not recognised yet: a wrapper with options before the installer (sudo -u root, env -u X), a package word given by a variable or with an escape, an upper-case NPX or package word, a zero-width character inside --disable, a full-width, soft-hyphen or look-alike spelling of the package word or of uninstall, eval, and other package runners. While Marrow is switched off, the bypass record is sent at the first hook call of a session (names only), not at the first protected action.
  • Hook settings, ~/.marrow and shell start-up files are protected from every tool. A write by Edit, Write, a redirect, tee, sed -i, cp, mv, crontab and the like is held.
  • A keyless hook says so once per Claude Code session.
  • A resumed host session under another Marrow agent works. Each agent has its own Marrow session id (<host session id>.m<16 hex>). A hold open under 3.9.108 at the upgrade is not matched by the 3.9.109 hooks, and the loop guard state starts again for that session.
  • A damaged control file no longer switches the hooks off. If ~/.marrow/control.json cannot be read or is invalid, the hooks keep running as if control were on and the prompt hook tells you once per session. Only a valid file that says disabled stops them.
  • The pre-action hook leaves as soon as it has answered. An unanswered request can no longer keep it running past the host's time limit. The answer is the same.
  • Test keys and live keys never share an approval. The same action with a test key and with a live key is a different approval.
  • patch, git apply and git am are checked for what they write. A patch that would write a protected file is held; so are six git am forms that used to pass (--continue, --skip, --abort, --quit, --resolved, --show-current-patch).
  • Windows groundwork. The seatbelt reads Windows program names and paths, and the session loop guard on Windows checks the access list of its folder. That last check is the one change that is looser than 3.9.108, on Windows only and by the owner's decision (3.9.108 denied every loop-guarded call there). Native Windows is still not supported; use WSL.
  • IPv4 first. The pre-action hook tries IPv4 first when it dials Marrow, so a broken IPv6 route cannot stall it.

These behaviors shipped in 3.9.108 and still apply.

v3.9.108 adds Codex plugin pins on 3.9.107. The full entry is in CHANGELOG.md.

  • Codex plugins marrow and marrow-advisory 0.1.3 are recognised. The SHA-256 digests of their six pinned files are now listed next to the 0.1.1 digests. A Codex with 0.1.3 installed and enabled, and those six files unchanged, is recognised as running the official Marrow server, the same as 0.1.1 is; any other change to them is checked like any other server. The digests of the 0.1.2 drafts, which were never released, are removed. Nothing changes for an installed 0.1.1.

These behaviors shipped in 3.9.107 and still apply.

v3.9.107 is a security hotfix on 3.9.106. The full entries are in CHANGELOG.md.

  • Every text hash is keyed per install. The command_sha256 and input_sha256 of every hooked tool (Bash, Monitor, PowerShell, Agent, Edit, Write, WebFetch, MCP tools, and any tool name Marrow does not know, among others), on Claude Code, Codex and Cursor, are now HMAC-SHA256 under a key derived from the per-install device key (~/.marrow/seatbelt/salt), with the tool name and kind inside the MAC. A free-text field can hold a value the redactor cannot see, and a plain hash of it could be guessed offline. The same call on the same install gets the same hash, so a hold still resumes and a learned approval still matches there. A deploy command Marrow sends in clear (sst deploy --stage production) keeps its plain hash. exact_hmac moves to a v2 domain. The hold correlation and target in ~/.marrow/host-approvals/state.json and the lifecycle correlation_id follow.
  • Upgrade note: some approvals are asked once more. A hold or a learned approval made before this update never matches again, and an approval learned on one machine does not match on another. A learned approval, an automatic approval or the memory of an earlier decline that the service keyed on a text hash does not carry across machines, or from before this update: the action is asked again, never allowed on a match it no longer has.
  • A machine with no usable device key can still resume a hold. With no usable device key (a read-only home, an unsafe, corrupt or missing key file, Windows) the exact-action hashes and the hold target are keyed with a fallback key (HMAC-SHA256 of the secret of ~/.marrow/host-approvals/state.json) instead of a new random value per call. A held action then resumes, is reported and is committed as on a usable key. When the approval state is unusable too, the action is held and asked every time, with one stderr note. Only a hook with a Marrow key makes that state when it does not exist; a machine with no key never creates it.
  • Less text is sent in programs[]. The first word of a pipeline stage that feeds a password program ("pw" | smbpasswd -s) is no longer sent or stored when it may be the value itself: it is named only when it is a known program (a stage with other words) or one of cat, yes, pbpaste (alone); any other word becomes the fixed marker unlisted-feeder and the action is never bound. A tool that does not run shell text (ToolSearch's query, a prompt, a path, an unknown tool's command) names a first word only when it is a known program; any other word becomes unlisted-program. Bash, Monitor, PowerShell, Codex exec and Cursor Shell are unchanged.
  • A secret in an edit path is replaced. A known-format secret inside the path of an edit tool (Edit, Write, NotebookEdit, MultiEdit, an apply_patch header) is replaced in normalized_action.paths[] as a span: /p/ghp_...X.txt is sent as /p/[secret].txt. An action whose path held a span is never bound (it is asked each time). Not covered: a plain word that is not key-shaped, a token split across /, and a prefix written in another case.
  • More commands that print the environment are stopped. The environment-dump stop (the keyless S4 stop, and the keyed protected action) now also covers /proc/<pid>/task/<tid>/environ read by an input redirect, the Read and Grep tools, a glob, a variable default, a cd into a process folder or find /proc -name environ -exec, and a bare env or printenv run by awk, by code passed with -e, -c or -r, or by an sh -c positional parameter. It only adds stops. It is a known list of forms, not every command a shell can run; the known gaps are listed in CHANGELOG.md.
  • The approvals state file is protected like the receipts salt. Reading ~/.marrow/host-approvals/state.json (with its temp copy and any backup beside it) now gets the decision a read of the receipts salt gets: a keyless S4 stop, a protected keyed action and an outage hold. Listing or stat of the folder and words that only mention the folder are unchanged.
  • Keyed mode stops secret-file reads hidden in nested shell code. In keyed mode a read of a secret file (.env, .env.local, .env.<name>, .npmrc, .netrc, .dev.vars, a key file) hidden in bash -c, eval, sudo -n sh -c, env -S, xargs, ssh, a chain, a variable default, a glob or a symbolic link is now a protected action, as the keyless seatbelt already stops it. Keyed mode also treats .env.dist and .env.defaults as secret files, like keyless mode. Side effect: a grep .env README.md or jq '.env' package.json inside bash -c, eval, ssh or sudo -n sh -c is now stopped in keyed mode.
  • awk programs that run a stopped action are stopped (keyless). The keyless seatbelt now stops an awk-family program (awk, gawk, mawk, nawk, busybox awk, and any other program whose name contains awk) that runs a stopped action built at run time. A command made only of string literals is judged as a nested shell; a command with any other part (ARGV, ENVIRON, a -v variable, a field, a value read by getline, a function call) is the new dynamic-command stop dynamic_awk_command. An awk command that builds its command string from ARGV, a -v value or a field is now stopped even when it is harmless. Keyed mode is unchanged.
  • command looks a name up only as a leading -v or -V. For every program, command npm publish -v, command git push -v --force origin main and command rm -rf ~ -v passed the keyless seatbelt before and now stop. command -v node, command -V git and command node -v are unchanged.
  • Installer runtime core (loosens one check). The installer's next runtime core is now accepted next to the 0.1.70-0.1.74 core, so a HOME behind a symlinked parent installs. On Cursor and Codex, a marrow server launched by that new core now proves the official server as the old core's launch does. A launch is still proven only when it is exactly the loader that started the hook, and any other core is not proven. An installer with the new core and an older MCP is not proven and its own tools are held. Release the MCP first, then the installer.

These behaviors shipped in 3.9.106 and still apply.

v3.9.104 and v3.9.105 were not published to npm; their changes shipped in 3.9.106 and are listed in CHANGELOG.md.

Documentation truncated — see the full README on GitHub.

Reviews

No reviews yet

Be the first to review this server!