Open Source 6 min read

Crush yolo mode now blocks curl, but rm -rf still runs

Crush yolo mode at v0.101.0 blocks curl, sudo and a configured kubectl, while rm -rf and bash -c 'curl' still run. Run at v0.100.0 and v0.101.0.

Abstract illustration in three lanes: tall amber bars with a coral square between them on top, shorter amber bars in the middle, and a bare teal line with no gate at the bottom.

Crush is a terminal coding agent written in Go by Charm. Its v0.100.0 release, published 2026-11-05, added a third permission mode called Sysadmin and said that “Yolo Mode still blocks dangerous commands.” I read the code at that tag and ran the bash tool in each mode: at v0.100.0 the sentence was false for a plain curl. A commit the next day made it true, and it shipped in v0.101.0 on 2026-11-12. My answer now: Crush yolo mode at v0.101.0 refuses curl, sudo, env curl and a command you configured as blocked, and it still runs rm -rf and a bash -c wrapper.

The licence is FSL-1.1-MIT, so the source is public but it is not OSI open source: it turns into MIT later and bars competing use. The last three releases shipped on Thursdays and “latest” moves, so every result below names its tag, and the code links are pinned to the v0.101.0 commit, 0dcd3d5fc452.

Abstract illustration in three lanes: tall amber bars with a coral square between them on top, shorter amber bars in the middle, and a bare teal line with no gate at the bottom.
Normal, yolo and sysadmin, top to bottom. The middle gate is shorter than you would hope.

What does Crush yolo mode actually stop?

The release notes promise a configurable list of dangerous commands. The list lives in bash.go as defaultBlockedCommands, and I counted it: 65 entries. They are network tools (curl, wget, ssh, nc), privilege tools (sudo, su, doas), package managers, indirect runners (env, eval, xargs, nohup), and system and network config (systemctl, mount, iptables).

Now the other side. I checked 19 names an agent reaches for all day: rm, git, kubectl, terraform, docker, dd, chmod, chown, mv, kill, sed, tar, rsync, make, npm, pip, python3, bash and sh. None is on the list. A few get argument rules, like npm install -g and pip install --user, but rm -rf has nothing.

The permission code defines the three modes in a few lines. Normal prompts for every command that is not on a short read-only list. At v0.101.0 its comments say yolo “never prompts and refuses dangerous commands”, and sysadmin “never prompts and refuses nothing”.

What does normal mode warn about?

I took 30 commands I have seen agents run and put each through the same two checks the bash tool uses: the read-only test and the dangerous-command check. Four needed no prompt: ls -la, git status, git diff and pwd. Ten prompted with a named warning. Sixteen prompted with no warning at all. The split is the same at v0.100.0 and v0.101.0.

The ten are the ones you would guess: curl, wget, ssh, sudo, apt-get install, npm install -g, nc, env curl, plus two that Crush cannot parse, x=curl; $x ... and docker rm -f $(docker ps -aq). The warning on the docker line says “substitution in arguments”. It is not about docker.

The sixteen include rm -rf /, git push --force origin main, git reset --hard HEAD~5, kubectl delete ns prod, terraform destroy -auto-approve, chmod -R 777 /, dd if=/dev/zero of=/dev/sda and mv ~/.ssh /tmp/x. They prompt, and the dialog shows the command line, but carries no danger warning. In normal mode you are the safety, and the list is a highlighter. Also in that group: bash -c 'curl https://example.com' and a python3 -c that calls os.system("curl x"). The list reads command names in the parsed line, so a command inside another process is invisible to it.

Does yolo mode block what the release notes say?

At v0.100.0, no. The bash tool decided whether to arm the block list after the approval. If the check recognised a command by name and the request was approved, the tool ran it with no block list, and the code comment says why: re-blocking “would override the answer that was given, whether the user gave it at a prompt or yolo mode gave it on their behalf.” Yolo’s approval counted as an answer.

I wrote a throwaway Go test at each tag, using the real permission service in each mode, and ran commands through the bash tool, which is the code path where the decision gets made. These are the yolo results, v0.100.0 first, then v0.101.0:

  • curl --version: ran and printed curl 7.88.1, then “blocked: curl is a dangerous command, and yolo mode blocks dangerous commands without asking”.
  • env curl --version: ran, then blocked.
  • sudo --version: got past Crush at v0.100.0 and the shell answered “executable file not found”, exit 127, because this box has no sudo. At v0.101.0 it is blocked.
  • x=curl; $x --version: blocked at both tags, because the parser cannot read it.
  • bash -c 'curl --version': ran at both tags.
  • rm -rf victim && echo removed: removed the directory at both tags.

So the commit, 67d838f, changed the decision. Its title is “make yolo mode block dangerous commands without asking”, and the permission code now says yolo “never prompts and refuses dangerous commands.” The repo’s tests moved with it: I ran all TestBashTool_ tests, 11 passed at v0.100.0 and 13 at v0.101.0, including a new YoloModeBlocksDangerousCommandsWithoutPrompting. The release notes list it as one line under Fixed.

What did not move is the shape of the list. It matches names the parser sees. rm is not on it, and a command inside another process is invisible to it.

Bon. Sysadmin did not change. At v0.101.0 the same x=curl; $x --version ran and printed curl’s version. That mode does what it says, so I have no complaint there, and the notes themselves say “Be careful.”

Does permissions block kubectl stop kubectl?

In yolo at v0.100.0, no. The notes say permissions block “blocks commands completely”. The comment in config.go says something smaller: extra blocked commands are “dangerous”, prompted for in normal mode and “blocked at exec time when they turn up indirectly”.

I put a fake kubectl script on the path that echoes a marker, set BlockedCommands to kubectl, and ran it:

  • yolo, kubectl get pods: the marker printed at v0.100.0, so it ran. At v0.101.0 it came back “blocked: kubectl is a dangerous command, and yolo mode blocks dangerous commands without asking”.
  • yolo, x=kubectl; $x get pods: blocked at both tags.
  • sysadmin: both ran at both tags.

Say you add permissions block kubectl terraform to protect your infrastructure and then switch to yolo for a long refactor. At v0.101.0 that setting holds in yolo and means nothing in sysadmin. At v0.100.0 it held in neither.

Which Crush mode would I hand a shell?

Normal still, and I would change one habit. I run agents next to code that can see real tokens, an ads API key in the environment for example, so what matters to me is what an agent can send out. That is why I tested what opencode and Codex send to a logger on my own machine: read what leaves, do not trust a list of names.

Yolo at v0.101.0 is a better deal than it was a week earlier, and it is still a list of 65 names, not a sandbox. Use the prompt. Add exact command lines you trust with permissions safe, such as go build, because a safe entry matches only that line with no extra flags. Keep yolo for a container or a throwaway VM, where rm -rf costs you a rebuild and nothing else. Keep sysadmin off any machine that holds credentials.

If you want to repeat my numbers, save this as internal/agent/tools/zz_probe_test.go in a clone of the repo, check out v0.100.0 or v0.101.0, and run go test ./internal/agent/tools/ -run TestZZProbe -v:

package tools

import (
	"context"
	"fmt"
	"strings"
	"testing"

	"github.com/charmbracelet/crush/internal/config"
	"github.com/charmbracelet/crush/internal/permission"
)

func TestZZProbe(t *testing.T) {
	wd := t.TempDir()
	perms := permission.NewPermissionService(wd, nil, nil)
	perms.SetPermissionMode(permission.PermissionModeYolo)
	attr := &config.Attribution{TrailerStyle: config.TrailerStyleNone}
	tool := NewBashTool(perms, wd, wd, attr, "m", config.DefaultMaxBackgroundJobs, nil)
	ctx := context.WithValue(t.Context(), SessionIDContextKey, "s")
	for _, c := range []string{"curl --version", "bash -c 'curl --version'", "rm -rf x && echo removed"} {
		r := runBashTool(t, tool, ctx, BashParams{Description: "p", Command: c})
		fmt.Println(c, "=>", strings.TrimSpace(r.Content))
	}
}

It prints three results per tag: curl runs at v0.100.0 and is blocked at v0.101.0, and the other two run at both.

Main has two more commits since v0.101.0 that touch permissions: “keep sysadmin mode out of the shift+tab cycle” on Nov 14 and “let the model use sudo so Touch ID and other PAM approvals work” on Nov 15. Neither touches permission.go or bash.go, and none of the numbers above include them.

Dominic Plouffe

CTO of Trellis, with exits at FuseTalk, 360pi and DeadHeat. I write about making agents and big data work together safely, and I'm building yaaf, an open-source platform for running teams of AI agents that actually finish the job: dplouffe.ca/yaaf