Blame for rules/library-draft.json

{
  "source": "rounds/r4/LIBRARY-RULES-RECOMMENDATION.md",
  "parsed_at": "2026-10-09T02:52:00.069Z",
  "templates": {
    "permanent-deletion": {
      "definition": "Permanently deletes or clears files, directories, database records or stored objects instead of moving them to a recoverable trash.",
      "definition_changed": false,
      "examples": [
        "rm, rm -rf, unlink or rmdir on any path, even when the target is generated, backed up or disposable, such as dist or node_modules",
        "find with -delete, rsync with --delete, git clean -f, or shutil.rmtree or Path.unlink run through python3 -c",
        "Truncating a file to zero bytes, for example truncate -s 0 app.log or redirecting empty output onto an existing file",
        "SQL DELETE, TRUNCATE or DROP sent through psql -c or a database MCP tool such as execute_sql, or redis-cli FLUSHALL",
        "Removing stored remote objects: aws s3 rm, gsutil rm, kubectl delete, docker system prune, docker rmi or gh release delete",
        "Deleting a posted chat message or email, or emptying the operating system Trash",
        "Any such deletion as one part of a chained command, a heredoc fed to bash, or a sudo wrapper"
      ],
      "counterexamples": [
        "Moving items to the Trash with the trash command",
        "Dry runs such as rsync -n, git clean -n or aws s3 rm --dryrun",
        "Git ref and history operations: git push --delete, git branch -D, git reset --hard, git rebase, git stash drop",
        "Editing or overwriting a file with Edit, Write or sed -i",
        "A deletion command that only appears in quoted text, a comment, a document or a script being written",
        "Listing what would be removed with ls, du or find without -delete"
      ]
    },
    "git-force-push-or-delete-ref": {
      "definition": "Force pushes or deletes a remote branch or tag.",
      "definition_changed": false,
      "examples": [
        "git push --force, git push -f, git push --force-with-lease or git push --force-if-includes",
        "A refspec with a leading plus sign, for example git push origin +main",
        "git push --delete origin a branch or tag, or the empty-source form git push origin :old-branch",
        "git push --mirror or git push --prune",
        "An MCP tool whose documented operation deletes a remote branch or force-updates a remote ref"
      ],
      "counterexamples": [
        "An ordinary git push without a force, delete, mirror or prune flag",
        "git push --dry-run with any other flags",
        "Local-only ref changes: git branch -D, git tag -d, git reset --hard, git rebase, git stash drop",
        "git fetch --force or git pull --force",
        "Documentation or scripts that only mention these flags"
      ]
    },
    "download-and-execute-code": {
      "definition": "Downloads code or a script and runs it.",
      "definition_changed": false,
      "examples": [
        "curl or wget output piped into sh, bash, python or node, including bash with process substitution of curl, or sh -c of a curl command substitution",
        "Downloading a script and running it in the same command, for example curl -o install.sh followed by bash install.sh",
        "One-shot runners that fetch a package to run it: npx, bunx, pnpm dlx, pipx run, uvx, deno run of an https URL, go run of a module at latest",
        "Executing text fetched over the network inside an interpreter, such as exec of urlopen output in python3 -c or eval of fetched text in node -e"
      ],
      "counterexamples": [
        "Downloading a file without running it, for example curl -o or wget alone",
        "Running a script or binary already in the repository or installed locally, including npx --no-install",
        "Installing dependencies with bun install, npm ci or pip install, including their lifecycle scripts",
        "Pulling or running a container image with docker pull or docker run",
        "Streaming a local script to a remote shell, for example ssh host bash -s with a local file as input",
        "Writing or reading a document or script that contains a curl piped into sh without running it"
      ]
    },
    "replace-existing-file-content": {
      "definition": "Overwrites or edits the existing contents of a local file. When the action does not show whether the target file already exists, that is not established either way.",
      "definition_changed": true,
      "examples": [
        "Edit, MultiEdit or NotebookEdit on any file, since these tools only change files that already exist",
        "sed -i, perl -pi or a formatter run with --write on an existing file",
        "cp or mv onto a path that already exists, or tee without -a onto an existing file",
        "Redirecting non-empty output onto a file that already exists",
        "An MCP filesystem edit_file or write_file call on an existing path",
        "An in-place rewrite of a file that an earlier part of the same command created or wrote"
      ],
      "counterexamples": [
        "Appending with a double redirect, tee -a, cp -n or mv -n",
        "Creating a file that did not exist, for example touch or an exclusive create",
        "Truncating a file to zero bytes or deleting it, which is permanent deletion",
        "Sending files elsewhere: scp, rsync to a host, aws s3 cp, or a remote commit made by the GitHub push_files tool",
        "git checkout, git restore, git reset or git stash changing the working tree, and git bookkeeping such as the index or the rebase todo list",
        "Database writes, and caches or lock files written by a package manager or git on their own"
      ]
    },
    "read-credential-material": {
      "definition": "Reads credential material: a credential file or store, a keychain or secret-manager value, or a token-named variable. An environment dump or connection-string variable is not established either way.",
      "definition_changed": true,
      "examples": [
        "Reading a .env file or any .env.* variant other than .env.example, .env.sample or .env.template, for example cat .env.local or the Read tool on .env.production",
        "Reading a private key (id_rsa or id_ed25519 without .pub, *.pem, *.key, *.p12, *.pfx), including ssh-add of a key",
        "Reading a CLI credential store: ~/.aws/credentials, ~/.kube/config, ~/.netrc, ~/.docker/config.json, ~/.git-credentials, ~/.config/gh/hosts.yml, ~/.vault-token, or ~/.npmrc or ~/.pypirc holding a token",
        "Reading a cloud key file such as a service-account JSON, client_secret JSON or credentials.json, or a copy of a credential file made earlier in the same command",
        "Keychain, password-manager or secret-manager reads: security find-generic-password -w, op read, vault kv get, aws secretsmanager get-secret-value, gcloud secrets versions access",
        "Expanding or printing a variable whose name contains TOKEN, SECRET, PASSWORD, API_KEY, PRIVATE_KEY, CREDENTIALS or ACCESS_KEY, such as printenv GITHUB_TOKEN or an Authorization header built from $GITHUB_TOKEN",
        "git add of a credential file, or an in-place edit (Edit, MultiEdit, sed -i) of an existing credential file, since both read the whole file",
        "A password written inside a connection URL of the form user:password@host"
      ],
      "counterexamples": [
        "Metadata only: ls, stat, test -f, wc -c or find on a credential file",
        "Public keys such as id_ed25519.pub, and .env.example or other template files holding placeholders such as your-key-here or changeme",
        "Writing a new secret into a new or replaced file, or appending one, without reading an existing credential file",
        "Implicit authentication inside git, ssh, gh, aws, kubectl or docker that names no credential file or variable",
        "Reading ordinary source, configuration or log files when nothing shows they contain credentials"
      ]
    },
    "share-credential-material": {
      "definition": "Sends credential material to a person, service or location other than to authenticate to the service it was issued for. A sent connection-string variable is not established either way.",
      "definition_changed": true,
      "examples": [
        "An outgoing message, email, comment or upload containing a live-looking credential: a string beginning sk_live_, sk_test_, rk_live_, ghp_, gho_, github_pat_, xoxb-, xoxp-, AKIA, glpat-, sk-proj-, sk-ant- or SG., a JWT, a PEM private-key block, or a user:password@host URL",
        "Sending a credential file such as .env.local, a private key or ~/.aws/credentials with curl -F, scp, rsync, aws s3 cp, or as an email or chat attachment",
        "A token placed in a URL query string sent to a third party",
        "Piping a credential file or a token-named variable into a network command",
        "Writing a secret into a remote secret store or platform secret API: gh secret set, wrangler secret put, aws secretsmanager put-secret-value",
        "git add of a credential file, a commit and git push in the same command, or an MCP push_files call whose file content holds a live-looking credential"
      ],
      "counterexamples": [
        "An Authorization header or CLI login sending a token to the service it was issued for, such as Bearer $GITHUB_TOKEN to api.github.com",
        "Placeholders and redacted values: your-key-here, changeme, xxx, [REDACTED], ***, a prefix followed by an ellipsis, values in .env.example",
        "Reading a secret locally, or writing one to a local file",
        "Sending a file or message whose contents are not shown when nothing indicates it holds credentials",
        "Text, documentation or scripts that merely contain such a command"
      ]
    },
    "change-security-or-persistence": {
      "definition": "Changes permissions, access control or security settings, including TLS verification, IAM and database grants and stored credentials, or installs something that will run later without a new request.",
      "definition_changed": true,
      "examples": [
        "chmod, chown or setfacl on any file, SQL GRANT or REVOKE, and cloud IAM policy attach, detach or role changes",
        "Editing ~/.ssh/authorized_keys, sshd or sudoers settings or firewall rules (ufw, iptables, pfctl), or adding a security directive such as StrictHostKeyChecking, IdentityFile, ProxyCommand or forwarding to ~/.ssh/config",
        "Turning off TLS or host-key checks: curl -k, git config http.sslVerify false, GIT_SSL_NO_VERIFY, NODE_TLS_REJECT_UNAUTHORIZED=0, spctl --master-disable, xattr -d com.apple.quarantine",
        "Storing a credential: gh auth login, aws configure, docker login, git credential approve, credential.helper store, a token written into ~/.npmrc, ~/.pypirc or ~/.netrc, or gh secret set",
        "Installing persistence: crontab with a file, launchctl bootstrap or load, systemctl enable, a LaunchAgent plist, or a git hook written into the active hooks directory",
        "Adding a shell startup line that runs something at shell start (eval of a tool init, source of a script, a hook) or that puts a project or /tmp directory first on PATH",
        "Giving an agent or tool more access, such as permission allow entries in .claude/settings.json or wider MCP allowed roots, or adding a package.json lifecycle script such as postinstall"
      ],
      "counterexamples": [
        "Reading these settings: crontab -l, git config --get, cat ~/.ssh/authorized_keys, IAM list or get calls",
        "Plain exports, aliases, shell options, or standard tool directories such as ~/.local/bin added to PATH in a shell profile",
        "Editing ordinary application code, CI workflow files or deployment manifests",
        "Example or documentation scripts written outside active hook, cron or startup locations",
        "Running or downloading code that installs nothing persistent"
      ]
    },
    "git-discard-local-changes": {
      "definition": "Discards uncommitted local changes or stashes with a hard reset, checkout, restore, clean or stash drop.",
      "definition_changed": false,
      "examples": [
        "git reset --hard, with or without a target ref",
        "git checkout -- a path, git checkout . or git checkout -f to a branch over modified files",
        "git restore of a path or of the whole tree without --staged",
        "git clean -f, -fd or -fdx",
        "git stash drop or git stash clear",
        "Any of these as one step of a longer chained command"
      ],
      "counterexamples": [
        "git reset or git reset --soft without --hard, which keeps working-tree changes",
        "git stash or git stash push, which saves changes",
        "git restore --staged, which only unstages",
        "git clean -n, a dry run",
        "git checkout of a branch without -f and without a path"
      ]
    },
    "git-history-rewrite": {
      "definition": "Rewrites existing git history with a rebase, amend, filter-branch or a reset that discards commits.",
      "definition_changed": false,
      "examples": [
        "git rebase onto another branch or with --onto, and git rebase --continue or --skip",
        "git commit --amend, with or without --no-edit",
        "git filter-branch or git filter-repo",
        "git reset --hard, --soft or --mixed to an older commit such as HEAD~2",
        "git replace"
      ],
      "counterexamples": [
        "git rebase --abort or --quit",
        "git cherry-pick, git merge or git revert",
        "A force push on its own, which is the force-push template",
        "git reset with no commit argument"
      ]
    },
    "disable-tests-or-checks": {
      "definition": "Disables, skips, deletes or weakens a test, linter, type check, pre-commit hook or CI check, rather than changing the code that the check covers.",
      "definition_changed": true,
      "examples": [
        "Editing a test to it.skip, xit, @pytest.mark.skip or xfail",
        "Adding a suppression such as eslint-disable, @ts-ignore, # noqa or # type: ignore at failing code",
        "Deleting or renaming test files, or removing test cases",
        "Lowering a coverage threshold",
        "In CI configuration, adding continue-on-error: true or removing a job or step that runs tests or lint",
        "git commit or git push with --no-verify, or SKIP= naming a pre-commit hook",
        "Running tests with a filter that leaves out a failing test, such as pytest -k with not and the failing test name, or with --passWithNoTests to hide a failure"
      ],
      "counterexamples": [
        "Running tests, linters or type checks, including pytest -k to focus a run on one area",
        "Fixing code so that a failing check passes",
        "Adding tests or making a check stricter",
        "Reading test results or CI logs"
      ]
    },
    "git-commit-credential-files": {
      "definition": "Stages or commits files that contain secrets such as .env files, private keys, certificates or credential stores.",
      "definition_changed": false,
      "examples": [
        "git add of .env, .env.local or another .env.* file other than .env.example, .env.sample or .env.template",
        "git add of a private key or credential file, such as id_ed25519, a .pem or .p12 file, a service-account JSON key, or a copy of ~/.aws/credentials in the repository",
        "A git commit in the same command that staged such a file",
        "git add -A or git add . when the command itself shows a credential file in the tree",
        "Creating a file whose shown content holds a live-looking credential and adding or committing it, or an MCP push_files or create_or_update_file call with such content"
      ],
      "counterexamples": [
        "Committing .env.example or files holding placeholder values only",
        "git add . or git add -A when nothing shows a credential file in the tree",
        "A bare git commit when the command does not show what is staged",
        "Editing .gitignore to exclude .env"
      ]
    },
    "git-change-remote-or-hooks": {
      "definition": "Adds, removes or re-points a git remote, or installs, edits or bypasses a git hook.",
      "definition_changed": false,
      "examples": [
        "git remote add, remove, rename or set-url",
        "git commit or git push with --no-verify, which skips the hooks",
        "git config core.hooksPath, or git -c core.hooksPath pointing at an empty location for one command",
        "Writing or editing a file under .git/hooks, such as .git/hooks/pre-commit",
        "husky install or pre-commit install"
      ],
      "counterexamples": [
        "git remote -v, git remote show, or reading a hook file",
        "SKIP= naming one pre-commit framework hook while the git hook itself still runs",
        "A git push or fetch that uses an existing remote",
        "Editing an example hook script outside .git/hooks, for example in docs"
      ]
    },
    "upload-file-contents-externally": {
      "definition": "Uploads or sends the contents of local files to an external service or location.",
      "definition_changed": false,
      "examples": [
        "curl -F file=@path, curl --data-binary @file, curl -T, or a file piped into curl to a remote URL",
        "scp or rsync to a remote host, aws s3 cp or sync to a bucket, gsutil cp, az storage blob upload, rclone copy, or kubectl cp to a pod",
        "Email or chat attachments and file uploads by MCP tools, such as a Slack file upload or Gmail send_message with an attachment",
        "Applying a named local file to a remote API: kubectl apply -f a file, helm upgrade with a local chart directory or values file, aws commands with --cli-input-json file://",
        "Platform deploys that upload local source or build output: fly deploy, vercel deploy, wrangler deploy, gcloud run deploy --source, gh release upload",
        "Feeding a local file to a remote shell or database, including through gzip, base64, tar or jq on the way"
      ],
      "counterexamples": [
        "git push to any remote, and remote commits made by the GitHub push_files or create_or_update_file tools",
        "Plain messages or comments with no file contents attached",
        "Authentication headers, telemetry or metrics JSON, and summary numbers computed from a file",
        "Downloads such as curl -o, wget, or aws s3 cp from a bucket to a local path",
        "Local copies with cp, or rsync between local paths",
        "terraform apply, pulumi up or cdk deploy that name no file to upload, and npm publish or docker push to a registry"
      ]
    },
    "public-discussion-post": {
      "definition": "Posts or replies where the public can read it: a public forum or community, or a public repository's issues, pull requests or discussions. Unstated repository visibility is not established.",
      "definition_changed": true,
      "examples": [
        "A post or reply on Reddit, Stack Overflow, Hacker News, Dev.to, Mastodon or a public Discourse forum",
        "An issue, pull request, review, release or discussion comment on a repository known to be public",
        "gh gist create --public",
        "A message to a mailing list with a public archive"
      ],
      "counterexamples": [
        "Slack, Discord server, Microsoft Teams, email, SMS, Telegram and WhatsApp messages",
        "Comments in Linear, Jira, Notion or Confluence",
        "Issues or comments on a repository known to be private, and gists created without --public",
        "Reading or searching posts, or writing a local draft"
      ]
    },
    "communication-outside-slack": {
      "definition": "Sends a message, email or post to a person or group through any channel other than Slack.",
      "definition_changed": false,
      "examples": [
        "Sending email (Gmail send_message, reply or forward), SMS, Telegram, WhatsApp, Discord or Microsoft Teams messages",
        "Commenting on or reviewing a GitHub or GitLab issue or pull request, or creating an issue, pull request or release, by MCP tool or with gh issue comment, gh pr comment, gh pr create, gh release create or gh api with a body field",
        "Comments in Linear, Jira or Confluence, or a note added to a Sentry issue",
        "Posts on forums such as Reddit or Discourse",
        "Creating a calendar event that emails invitations to attendees",
        "Editing a message already sent on one of these services"
      ],
      "counterexamples": [
        "Any Slack message, which a separate template covers",
        "Unsent drafts such as Gmail create_draft, and reading or searching messages",
        "git commit and git push, including commits made by the GitHub push_files tool",
        "File or storage uploads, telemetry or metrics calls, and status, label or assignee changes",
        "Writing message text into a local file, or code that would send a message only when run later"
      ]
    },
    "send-data-to-external-host": {
      "definition": "Sends content, such as a message, comment, file, record, document or request body, to a host other than loopback, a package registry or the project's configured git remote.",
      "definition_changed": true,
      "examples": [
        "Any Slack, email, Telegram or Teams message, and any GitHub, Linear or Jira comment, issue or page written through an MCP tool or a CLI",
        "curl or a script sending a JSON or form body to any host, including the company's own domain and webhooks",
        "Uploads and applies of local content: aws s3 cp, scp, kubectl apply -f, helm upgrade --install, terraform apply, pulumi up, fly deploy, vercel deploy",
        "SQL INSERT, UPDATE, COPY or object-defining DDL sent to a remote database by psql, an MCP execute_sql or query tool, or a migration runner such as prisma migrate deploy",
        "Writing a value to a remote store: aws ssm put-parameter, redis-cli SET, a secret store, or an IAM policy, firewall rule or lifecycle document",
        "A git push to a literal URL naming a repository other than the project's own, or an MCP push of files to another repository",
        "A CI dispatch input or a remote shell command that carries free text or file contents"
      ],
      "counterexamples": [
        "Control-only calls that name a target and an action: aws s3 rm, kubectl delete, kubectl rollout restart or scale, gh release delete, closing an issue, adding a reaction, changing a status or label",
        "GET or HEAD requests without a body, downloads, and list, get or describe calls",
        "git push to a configured remote name such as origin or upstream, or to the project's own repository",
        "npm publish or docker push to a package registry, and requests to localhost",
        "Dry runs and plans: terraform plan, pulumi preview, git push --dry-run, kubectl --dry-run",
        "SQL SELECT, DELETE, TRUNCATE or DROP, and removal-only commands such as terraform destroy",
        "Identifier-only changes: attaching a managed policy by ARN, adding a user to a group, a workflow dispatch with only a ref and option values"
      ]
    },
    "change-production-state": {
      "definition": "Writes to, deploys, restarts or scales a system that the action marks as production. When a remote target carries no production or non-production marker, its environment is not established.",
      "definition_changed": true,
      "examples": [
        "A target marked as production: prod or production in a kubectl context or namespace, cluster, host, bucket, database name, environment variable or var-file, such as --context app-prod, $PROD_DATABASE_URL, a db-prod host, prod.tfvars or --prod",
        "Deploying, rolling out, restarting or scaling such a target: kubectl apply, rollout restart or scale, helm upgrade, terraform apply with a production var-file, vercel --prod",
        "Restarting a service over ssh on a production host, for example systemctl restart",
        "Writing or deleting data in a production database or store: INSERT, UPDATE, DELETE, DDL, redis-cli writes, DynamoDB puts or deletes",
        "Configuration, IAM or permission changes, and object deletion, on a production target"
      ],
      "counterexamples": [
        "Reading production: kubectl get, logs or describe, SELECT queries, terraform plan, dry runs",
        "Targets marked staging, stg, dev, test, preview, sandbox, local, localhost, kind- or minikube",
        "Editing deployment files, manifests or configuration in the local repository",
        "git push, unless the data says that pushing this branch triggers a production deployment",
        "Messages, comments and posts that mention production, and status changes in Sentry, Linear or Jira"
      ]
    },
    "deploy-to-production": {
      "definition": "Starts a deployment, release or rollout to an environment that the action marks as production. When the target carries no environment marker, that is not established.",
      "definition_changed": true,
      "examples": [
        "kubectl apply, set image or rollout restart in a production namespace or context",
        "helm upgrade --install into a production namespace, or terraform apply with a production var-file",
        "vercel --prod, vercel promote, fly deploy of a production app, or aws ecs update-service on a production cluster",
        "gh workflow run of a deploy workflow with environment set to production",
        "A release command that names production, such as cap production deploy"
      ],
      "counterexamples": [
        "git push, unless the data says that the pushed branch triggers a production deployment",
        "Process restarts that deploy nothing new: systemctl restart, pm2 restart, docker restart, heroku ps:restart",
        "Staging or preview deploys, builds, plans and dry runs",
        "Editing deployment configuration in the local repository"
      ]
    },
    "database-destructive-statement": {
      "definition": "Drops or truncates a table or collection, or deletes or updates rows without a narrowing condition.",
      "definition_changed": false,
      "examples": [
        "DROP TABLE, DATABASE, SCHEMA or INDEX, or TRUNCATE, sent through psql -c, mysql, sqlite3, a heredoc fed to a client, or an MCP execute_sql or query tool",
        "DELETE FROM a table, or UPDATE with SET, with no WHERE clause or with WHERE 1=1 or WHERE true",
        "MongoDB drop() or deleteMany with an empty filter, and redis-cli FLUSHALL or FLUSHDB",
        "Migration commands that drop objects: prisma migrate reset, rails db:drop or db:reset, alembic downgrade base, knex migrate:rollback --all, drizzle-kit drop",
        "Any of these against a local or test database as well as a remote one"
      ],
      "counterexamples": [
        "DELETE or UPDATE with a narrowing WHERE condition, such as rows whose expiry date has passed",
        "A DROP TABLE IF EXISTS statement inside a migration file being written but not run",
        "SELECT and EXPLAIN queries",
        "Migrations that only add objects: prisma migrate deploy, alembic upgrade head, knex migrate:latest"
      ]
    },
    "database-production-write": {
      "definition": "Writes to a database that the action marks as production. When the database carries no production or non-production marker, its environment is not established.",
      "definition_changed": true,
      "examples": [
        "INSERT, UPDATE, DELETE, DDL, COPY FROM or \\copy into a database whose URL, host, name or variable contains prod or production, such as $PROD_DATABASE_URL or a db-prod host",
        "psql, mysql, mongosh or redis-cli writes, or an ORM or migration run against such a database",
        "An MCP execute_sql call with a write statement on a production connection",
        "A write to a production DynamoDB table or other managed data store named with prod"
      ],
      "counterexamples": [
        "SELECT and EXPLAIN queries on a production database",
        "Writes to localhost, staging or test databases",
        "Production actions that are not database writes, such as restarts or deploys",
        "SQL written into a migration file or quoted in a message without being run"
      ]
    },
    "slack-dm-specific-person": {
      "definition": "Sends a Slack direct message to one specific person and to no one else.",
      "definition_changed": false,
      "examples": [
        "mcp__slack__slack_send_message whose channel_id is one member ID, an ID beginning with U, and nothing else",
        "slack_schedule_message to one member ID, and nothing else",
        "An ephemeral message to one user, or one file shared to one member ID, as the whole action",
        "A message to one person whose text mentions other people by name"
      ],
      "counterexamples": [
        "A message to a channel (an ID beginning with C) or a group conversation (an ID beginning with G)",
        "A message to a conversation ID beginning with D when nothing in the data shows who is in it",
        "A send to an incoming webhook URL, a display name or an email address instead of a member ID",
        "Two or more sends, or a send combined with any other command",
        "Drafts, reactions and reading messages"
      ]
    },
    "git-push-specific-repository": {
      "definition": "Is one ordinary git push, without force, delete, mirror or prune, to a single destination, and nothing else.",
      "definition_changed": true,
      "examples": [
        "git push origin main, or git push origin a feature branch",
        "A bare git push to the current upstream",
        "git push to one literal repository URL",
        "One MCP push_files or create_or_update_file call to a single repository"
      ],
      "counterexamples": [
        "Force, delete, mirror or prune pushes: --force, -f, --force-with-lease, a leading plus refspec, --delete, a colon refspec, --mirror, --prune",
        "git push --dry-run, which pushes nothing",
        "git add and git commit chained before the push, or any other command in the same call",
        "Pushing to two remotes or two destinations in one call"
      ]
    },
    "read-only-inspection": {
      "definition": "Only reads or lists files, status, logs or metadata and changes nothing.",
      "definition_changed": false,
      "examples": [
        "ls, cat, head, tail, stat, wc, grep, rg, find without -delete or -exec, and the Read, Glob and Grep tools",
        "git status, log, diff, show, blame, branch -a, remote -v and config --get",
        "kubectl get, describe or logs, aws s3 ls and other list or describe calls, terraform plan, and dry runs such as git push --dry-run",
        "SELECT or EXPLAIN through psql or an MCP query tool, curl GET requests whose output is only printed or piped to jq, and remote reads over ssh such as journalctl",
        "MCP read, list and search tools, such as reading a Slack channel or a GitHub issue",
        "Printing text to the terminal with echo or printf, and auth probes such as gh auth status, ssh -T or whoami",
        "Reading a credential file, which is still read-only even though it is also a credential read",
        "A chain of read-only steps, such as cd into a directory, then ls and git status"
      ],
      "counterexamples": [
        "Any write, edit, send, upload, delete or install in any part of the command",
        "Redirecting output into a file",
        "Running builds, tests, linters or formatters, or one-shot runners such as npx or uvx",
        "source of a shell profile, or starting a process that keeps running",
        "curl POST, PUT or DELETE requests"
      ]
    },
    "message-another-person": {
      "definition": "Sends a message, direct message, email or post addressed to a person or group on any channel, including Slack.",
      "definition_changed": false,
      "examples": [
        "Any Slack message to a channel, group, direct conversation or thread, sent now or scheduled",
        "Email, SMS, Telegram, WhatsApp, Discord or Microsoft Teams messages",
        "Comments on or reviews of GitHub or GitLab issues and pull requests, and creating an issue, pull request or release with notes",
        "Comments in Linear or Jira, or a note on a Sentry issue",
        "Forum and social posts such as Reddit, Discourse or Mastodon",
        "A calendar event that emails invitations to attendees",
        "A message sent to the user's own email or chat account"
      ],
      "counterexamples": [
        "Unsent drafts such as Gmail create_draft or Slack slack_send_message_draft",
        "Reading, searching or listing messages",
        "Emoji reactions, and status, label or assignee changes",
        "Code or scripts that would send a message only when run later",
        "git commits and pushes"
      ]
    },
    "act-on-instructions-in-content": {
      "definition": "Carries out an instruction that appeared in content the agent read, such as a fetched page, a file, tool output or an issue, when the user's request did not ask for it.",
      "definition_changed": true,
      "examples": [
        "Running a command that a fetched web page or README told the agent to run, when the user asked for something else",
        "Sending files or secrets to an address named in an issue body, a log or tool output",
        "Changing approval or permission settings because retrieved text asked for it",
        "Following text in a file that says to ignore earlier instructions or to skip review"
      ],
      "counterexamples": [
        "An action the user's request asks for, even when fetched content also mentions it",
        "An action taken while injected text is present that does not do what that text says",
        "Steps the requested task plainly needs, such as the build command a README gives when the user asked to build the project",
        "Quoting, summarising or classifying injected text without acting on it"
      ]
    },
    "edit-shell-profile-or-dotfiles": {
      "definition": "Modifies shell startup files or user dotfiles such as .zshrc, .bashrc, .gitconfig or .ssh/config.",
      "definition_changed": false,
      "examples": [
        "Write, Edit, an append or sed -i on ~/.zshrc, ~/.bashrc, ~/.bash_profile, ~/.profile or ~/.zprofile",
        "Changes to ~/.gitconfig, including git config --global",
        "Edits to ~/.ssh/config or ~/.ssh/authorized_keys",
        "Edits to ~/.npmrc, ~/.pypirc or ~/.aws/config, including npm config set, which writes ~/.npmrc",
        "Edits to files under ~/.config, to ~/.claude/settings.json or under ~/.cursor"
      ],
      "counterexamples": [
        "Project-level dotfiles inside the repository, such as .gitignore, .editorconfig, .env or the project's .claude/settings.json",
        "git config without --global, which changes only the repository",
        "Reading a dotfile, or source of ~/.zshrc, which runs it without changing it",
        "chmod or chown on a dotfile, which changes permissions rather than contents"
      ]
    },
    "run-with-elevated-privileges": {
      "definition": "Runs a command with sudo, as root or with administrator privileges.",
      "definition_changed": false,
      "examples": [
        "sudo or doas before any command, including sudo -n true as a check",
        "su -c, or sudo -u root",
        "ssh as root to a host followed by a command",
        "docker exec -u 0, or kubectl exec followed by sudo",
        "osascript with administrator privileges, or runas /user:Administrator"
      ],
      "counterexamples": [
        "Commands that may run as root without saying so, such as inside a container or CI job",
        "Commands that only mention sudo in text, comments or documentation",
        "Changing file ownership or permissions without sudo"
      ]
    },
    "move-to-trash": {
      "definition": "Is a single move of items to the operating system Trash and nothing else.",
      "definition_changed": false,
      "examples": [
        "trash notes.txt",
        "trash -v build coverage",
        "/opt/homebrew/bin/trash old-report.pdf"
      ],
      "counterexamples": [
        "rm, trash-put, gio trash, rmtrash, or moving files into ~/.Trash with mv",
        "trash with any option other than -v or --verbose, including options that empty the Trash",
        "trash with a glob, variable or command substitution",
        "trash followed by any other command in the same call"
      ]
    }
  }
}