Skip to content
Agentic Control Plane

Stop a force-push and ask before risky commands in Muse Code (Meta)

TL;DR:

npm install -g @agenticcontrolplane/muse-code
MUSE_EXPERIMENTAL_PLUGINS=1 muse plugins install "$(npm root -g)/@agenticcontrolplane/muse-code" --scope user
MUSE_EXPERIMENTAL_PLUGINS=1 muse plugins approve acp

From the next session, every tool call Muse Code makes goes through your ACP workspace before it runs. If you already ran the installer, it detected Muse Code and installed the plugin for you.

Muse Code is in beta and Meta has promised breaking changes. The plugin tracks it, and this page records the sharp edges we’ve hit.

Why a plugin behind a flag

Meta’s docs describe a muse hooks CLI and a .muse/hooks.json file. The shipped 0.2.1 binary doesn’t have that CLI, and a project hooks.json is silently ignored. What does work is a native plugin system behind the MUSE_EXPERIMENTAL_PLUGINS flag. Hooks register as part of a plugin (.muse-plugin/plugin.json), which you install and trust with muse plugins install and approve. The flag only gates those management commands. Once the plugin is approved, the hooks fire in ordinary sessions without it.

This package is a Muse native plugin bundle, and the three commands above install and approve it. The full reverse-engineering is in the launch post.

How it works

Muse event ACP endpoint What happens
PreToolUse POST /govern/tool-use allow / ask / deny before the tool runs
PermissionRequest POST /govern/tool-use a policy deny settles Muse’s own approval prompt; an ask shows as a block and is held for your approval on the console Approvals page or by email (then ask Muse to retry); allow lets it proceed
PostToolUse POST /govern/tool-output output scanning; a server block becomes feedback the model sees
Stop none one session receipt with a link to the session timeline

The wire format is Claude Code’s hook schema: a snake_case payload in, a camelCase hookSpecificOutput decision back. We checked every path above with Muse Code’s own muse plugins hook test runner, and the PreToolUse deny path against the live production gateway.

Credentials: Muse clears the environment

Muse Code runs hooks with a cleared environment. That is a deliberate hardening choice, and it means an exported ACP_BEARER_TOKEN does not reach the hook. The plugin reads its credential from a file instead:

  • ~/.acp/credentials, written once by the installer. Free up to 5 agents.

Optional overrides live in ~/.acp/config.json:

{
  "govern_base": "https://govern.agenticcontrolplane.com",
  "agent_tier": "interactive",
  "check_timeout_ms": 4000,
  "shadow": "off"
}

What happens when ACP is unreachable

An unreachable ACP must not brick your session, and it must not look like a working one:

  • Interactive sessions fail open, loudly. The call proceeds, a systemMessage warns [ACP] ⚠ UNGOVERNED, and a line goes to ~/.acp/lapse.log.
  • Unattended runs fail closed. CI, MUSE_HEADLESS or a permission_mode of never marks a run as unattended, and a call that policy can’t check stays blocked.
  • An explicit agent_tier sets the tier directly. Set it in the config or with ACP_AGENT_TIER. background fails closed and interactive fails open, so the example config above is an interactive run.
  • A policy deny is blocked either way. This only covers the case where ACP can’t be asked.

Sharp edges

  • Experimental flag. muse plugins install and approve need MUSE_EXPERIMENTAL_PLUGINS=1. The installed hooks run without it. Expect this to move to the documented muse hooks CLI in a later beta.
  • Hooks run outside the sandbox. Muse runs hook commands directly through your shell, outside the OS sandbox, with a cleared environment as the only hardening. That is why the plugin has no dependencies. See the control model for the full picture.
  • Beta churn. 0.2.1 promises breaking changes.

Uninstall

MUSE_EXPERIMENTAL_PLUGINS=1 muse plugins reject acp
npm uninstall -g @agenticcontrolplane/muse-code

Source and issues: github.com/agentic-control-plane/muse-code-acp-plugin.

Protected in 3 steps

Out of the box, ACP records every tool call your agents make. A short safety floor applies in every mode: catastrophic commands (rm -rf on your home or system folders, disk wipes) are always blocked, and force-push, destructive SQL, piping a download into a shell, and deleting outside your project are held for your approval. Your own rules (ask first / never) start applying when you turn on enforce. No rule can loosen the floor; a workspace owner or admin can switch it off on the Policies page (you were asked at install). With --local the always-blocked list is narrower: rm -rf on your home or root, disk wipes, fork bombs.

  1. 1
    Install. One command, then approve this machine in the browser. curl -fsSL https://agenticcontrolplane.com/install.sh | bash
  2. 2
    Turn on your rules. Run /acp-enforce in your agent. The starter rules start applying: rm and keychain reads are held for your approval (you approve on the console Approvals page or from the approval email); everything else keeps running and is recorded. Add your own with /acp-ask Bash.curl, /acp-deny Bash.git.push, /acp-allow Bash.npm, or on the Policies page. With --local there is no mode switch: the rules in ~/.acp/policy.json apply from the first call, and the starter file asks before rm, curl, git push, chmod and chown.
  3. 3
    See it work. Ask your agent to do something risky, for example git push --force on a scratch repo. ACP holds the call for your approval; the call and your answer land in the audit log (/acp-why for the last hold, the console Activity page, or ~/.acp/audit.jsonl with --local). In Muse Code, a held call shows as a block in the agent; approve it on the console Approvals page or from the approval email, then ask the agent to retry.

Copy-paste rules for the things people are most afraid of (force-push, prod database, rm -rf, a secret in a curl, overnight runs, a cost cap): Rules that stop the scary things.