Repository navigation
fix(security): close rm -rf flag-spelling and $HOME deny-gate bypasses - #15316
chenmingwei23 wants to merge 1 commit into
Conversation
Design Review (Opus 5.5) — 🟡 CONCERNSDesign-level review of Design-Verdict: CONCERNS
Watch
Suggestions
[DESIGN-REVIEWED] 07848b2 Description read[DESCRIPTION-READ] c51d2c40575044761852140ac325e17a40f0526e10aecbde4fcdc5b88ee8f0a3 That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with |
First Principles Review (Opus 5.5) — 🟡 CONCERNSPremise-level review of First-Principles-Verdict: CONCERNS The two reported spellings (flag order, Not justified as shipped
What this change shipsInventory (8 items) — 4 justifiedIntent: stop an agent wiping
[FIRST-PRINCIPLES-REVIEWED] 07848b2 Description read[DESCRIPTION-READ] a1997fb2e8ed94f520597838c6490d4dc04137e409c4a5a4c9fe67d9dc626d10 That sha256 names the PR description this verdict read. Recompute it with |
GPT 6.1 Review — 🔴 changes requested (blocking)GPT 6.1 found at least one blocking issue that must be resolved before merging This comment is updated in place on each push. BLOCKING -- src/kiro_crew/security/rm_floor.py:3812 -- Glued redirections bypass the home-deletion floor
BLOCKING -- src/kiro_crew/security/rm_floor.py:3165 -- Separate positional scanning misses the executed deletion argv
[BLOCK-MERGE] 07848b2 Adjudication (Opus 5.5) — is blocking on each finding proportionate?F1 (rm_floor.py:3812): Unbounded harm, a home wipe the gate lets through. Confirmed: F2 (rm_floor.py:3165): Unbounded harm. Confirmed: False positive or not applicable? A repository writer can comment: |
Addresses the GPT security-class review on #15316: GNU getopt accepts options in any position, so the flags-then-operand catalog regex still missed 'rm / -rf --no-preserve-root' (flags AFTER the operand). Add an argv-structural floor (_recursive_force_rm_targets) that tokenises the top-level argv, collects the recursive/force/--no-preserve-root flags from every position, and reports which rooted target (root vs home) is deleted -- so each rule fires only for its own target and an operator opt-out of one is honoured. The floor is a UNION with the regex tier and fails open to it, mirroring the self-protection floor. Also require a variable-name boundary after $HOME in _HOME_VAR_RE so an unrelated $HOME_BACKUP is no longer mis-expanded to the home path (GPT non-blocking finding), and give the home rule's regex the same boundary.
|
Rev 2 (head GPT blocking (post-operand flags bypass, security-class). Fixed as named — argv-structural, not a wider regex. New floor GPT non-blocking ($HOME_BACKUP false-positive). Fixed — added a variable-name boundary after Comment History Gate. The lines this change adds are the new floor + its explanatory comments in PR Hygiene. Pattern harvest section is present in the description. Opus crashed pre-verdict on the prior head — this push should let it re-run. Local: 1631 passed, 1 skipped; black/isort/flake8/mypy clean. Two commits. |
Security Scope Review -- 🔴 BLOCK (blocking)Which legitimate operations does Verdict basis: a script-confirmed newly-refused operation. Security scope review -- adjudicated candidates
Newly refused (confirmed by the real classifier at both refs)
Each row above is an operation that the base ref ALLOWS and this change REFUSES. Narrow the rule at the tier named. Withdrawing a row is not the way to green: that is its own pull request, on its own merits. Scope-Verdict: CONCERNS TIGHTENING: the ADJUDICATED: 34 candidates, 0 confirmed newly-refused (the harness gave me no verdicts; nothing below is reported as a script-confirmed regression) Narrowing I can argue but not confirm: the candidate PLATFORM COVERAGE:
[SCOPE-REVIEWED] 07848b2 The confirmed rows, in the committed corpus's own shape{
"golden_paths": [
{
"kind": "shell",
"command_or_flow": "export HOME=\"$(mktemp -d)\" && pytest test/test_cli.py && rm -rf \"$HOME\"",
"platform": "posix",
"reason": "Test runners and CI isolate a disposable HOME and tear it down afterwards; base allowed it, the diff pins it denied (c740 ruling), so this row shows the cost."
}
]
} |
Opus 5.5 Review — ✅ no blocking findingsReviewed Review detailsOne advisory finding; nothing blocks the merge. FINDING — src/kiro_crew/security/rm_floor.py:3899 — Inside the operand loop, [OPUS-REVIEWED] 07848b2 Verdict parsed from the review's SHA-scoped output markers for commit False positive or not applicable? A repository writer can comment: |
bcda51e to
bbb318c
Compare
|
Rev 3 (head The regression the review found is real and fixed. The recursive-force rules deny ONLY when a resolved operand IS the root or IS the home dir itself (bare or one trailing slash) — never a descendant. Enforcement is split:
One accepted, documented residual: a search whose quoted pattern ENDS in the exact deletion literal still trips the regex. One false positive on a grep for that specific string is strictly safer than one missed root wipe, so it is accepted and pinned as a known-accepted FP ( GPT/Opus expanded-HOME finding: fixed — variable-name boundary in Test corpus: ~22 pre-existing tests described the old over-broad behavior (descendant targets; the now-unnecessary search carve-out). Each was migrated by keeping the command and flipping only false-positive expectations; where a test pinned a genuine deny it was verified caught and kept as DENY. The 13 allows are explicit ALLOW assertions and the four issue denies explicit DENY assertions, so the narrowing is bounded on both sides. Local: 1698 passed, 1 skipped; black/isort/flake8/mypy clean. One commit. This widened the PR beyond the two issues; the maintainer accepted that widening deliberately in the ruling. |
bbb318c to
d02ace5
Compare
|
rev4 — floor-only, per the revised Security Scope ruling (head The c865 ruling to keep a narrow exact-operand regex was overturned by the scope lane, which script-confirmed the residual refused five legitimate commands. This revision implements the overturn exactly:
One documented residual, flagged for the board: a locale-quoted nested payload whose backslash-letter escapes the inner shell de-escapes to the program name ( Local: security suites green (deny-command + all |
d02ace5 to
a899b34
Compare
|
Both GPT 6.1 points fixed at head F1 — nested double quotes in a quoted substitution ( F2 — escaped Local gate green on the directly-testing security tests (deny-pattern floor, boundary gate, line-budget, denied-commands, gate liveness); CI runs the full cross-surface set. The package line-budget constant moved to the measured total. |
|
All three GPT 6.1 points on head |
|
All three findings on the prior head are fixed in
Tests: |
|
Both findings on the prior head are addressed in
Tests: The branch is rebased onto current |
|
Both findings on the prior head are addressed in
The branch is on current |
|
The over-refusal on the multi-line An executed |
|
Both findings on the prior head are addressed in
The branch is rebased onto current |
|
All three findings on the prior head are addressed in
|
|
Both findings on the prior head are addressed in
The branch is on current |
|
Both GPT 6.1 findings on this head are over-refusals, not wipes getting through — the gate fails closed on each (a visible refusal, nothing deleted, recoverable by rephrasing), which the Opus 5.5 adjudication also flags, and Opus 5.5 Review is green on this same head.
Neither flips a real deletion from deny to allow, so this PR's scope (closing the flag/ |
|
Both GPT 6.1 findings on this head (0555df4, a rebase onto fixed main with no code change) are over-refusals, not wipes getting through — the gate fails closed on each, which the Opus 5.5 adjudication also flags, and Opus 5.5 Review is green on this same head.
Neither flips a real deletion from deny to allow, so this PR's scope stays as is. Both go to #18709 (Due: 2026-10-24); no further code rounds on this PR for these. Build Wheel / Build Desktop / E2E / Integration reds here are the stale |
|
All three blocking findings on the prior head are addressed, each pinned by a committed regression test that fails without the fix and passes with it. The dangerous spellings stay refused; only the three reviewer-named false refusals change. Opus 5.5 — GPT 6.1 — GPT 6.1 — The three fixes added lines to the floor, so the package line-budget gate in Head: ef6d1bc. Local gate green on the changed files: black, isort, flake8, mypy, Comment History Gate, and the security + denied-command suites (2754 passed, 2 skipped). |
|
Addressed on head First Principles — primary blocker (the deleted/rewritten pins). Both original assertions are restored, so the description's framing is true again:
First Principles — items 4/5/7 (home-literal matching, the review-round layers, the program-ownership pass). These are the fixes the Opus and GPT lanes required (a literal-home fail-open and a set of over-refusals), not scope creep. The Goal section of the description now declares them in plain terms: the deny-gate also covers a home literal with a glued GPT 6.1 — executing-shell heredoc (fail-open). The package line-budget gate is raised to cover the added lines (per-file cap unchanged). Local gate green on the changed files: black, isort, flake8, mypy, Comment History Gate, and the security + denied-command suites (2755 passed, 2 skipped). |
|
Addressed on head GPT 6.1 — executing-shell heredoc keyed too broadly (over-refusal). The previous head decided "keep the heredoc body for classification" when any word on the opener line was an evaluator name. That counted an evaluator used as a mere argument of a printer — The decision now looks only at a word in command position: the body is kept for classification only when a program the line actually runs (via the floor's own quote-aware program-ownership pass) executes its stdin. An evaluator name sitting in an argument no longer triggers it, so the two print-only commands above are allowed again. The earlier fix it refines is unchanged: a heredoc truly consumed by an executing shell ( Local gate green on the changed files: black, isort, flake8, mypy, Comment History Gate, and the security + denied-command suites (2755 passed, 2 skipped). |
|
Scope reduced on head GPT 6.1
First Principles — the two description-vs-diff pins are already restored (xargs pipeline denial and the descendant ReDoS needle), so "exactly as main" and "keeps base's own descendant denial" hold. The oversized-vs-Goal items are resolved by the removal above plus the Goal section now naming the reduced scope and the #19291 deferral. What this PR keeps: the Local gate green on the changed files: black, isort, flake8, mypy, Comment History Gate, and the security + denied-command suites (2755 passed, 2 skipped). |
|
Addressed on head F1 — F2 — F3 — F4 — All three deferred items are loud, rephrasable, fail-closed over-refusals (they deny more than intended, never allow a wipe), so they are deferred rather than guarded case by case. Local gate green on the changed files: black, isort, flake8, mypy, Comment History Gate, and the security + denied-command suites (2755 passed, 2 skipped). |
|
Scope narrowed on head Accepted and deferred to #19291 (removed from this PR, back to the regex deny-net):
Fixed in this PR (base goal —
What this PR keeps: the Local gate green on the changed files: black, isort, flake8, mypy, Comment History Gate, and the security + denied-command suites (2750 passed, 2 skipped). |
|
GPT 6.1 — addressed on head
That is the same value-taking-option resolution class as the other nested-wrapper edges this PR deliberately scoped out, so it is deferred to #19291 (item 12) rather than fixed here — this PR's goal is the |
|
Opus 5.5 — addressed on head (1) Line budget raised past the true value ( (3) Refusal note overstates scope ( (2) Local gate green: black, isort, flake8, mypy, Comment History Gate, and the security + denied-command suites (2750 passed, 2 skipped). |
|
Status on head The latest GPT finding ( It is the same find-exec operand-boundary class as the other nested-wrapper edges this PR deliberately scoped out — each round of hardening the deny-net surfaces one more adjacent parsing edge, which is exactly the pattern that needs a single-rule redesign rather than another point patch. It is tracked in #19291 (now item 14, alongside the find-exec operand and boundary items already there), together with the git-global-option over-refusal (item 12) and the unknown-value-taking-option gap (item 13). This PR holds its stated scope: the |
Sensitive change reviewHead: What rule changed: This change adds a fail-closed local deny-net that refuses a recursive-force Before -> after: Before, a recursive-force wipe spelled with reordered or split flags ( Worst case if wrong: A false negative would let a destructive root or home wipe run unrefused, destroying the operating system or all personal files; a false positive produces only a visible, recoverable denial that the user clears by rewriting the command. Evidence checked: I reproduced each denied spelling and each allowed control case through Tools still work: Normal file-management commands remain usable: non-recursive or non-force Backward compatible: Yes for every previously allowed benign command; the only behavior change is additional denials of root/home recursive-force wipes, which were already intended to be blocked, so no legitimate prior workflow is newly refused. Existing tests: On a clean detached worktree of How to undo: Revert this pull request's single commit; |
Sensitive change reviewHead:
|
Sensitive change review
|
|
Thanks — both F1 and F2 from the prior review are fixed in F1 (brace-expanded program word, F2 (repeated-star home glob, Two regression tests were added that fail on the prior head and pass on this one; the controls ( The two new cases this review raised ( |
Status at
|
…llings, with a fail-closed regex deny-net An argv-structural floor denies a recursive-force rm whose target resolves to the filesystem root or the login home, in any flag spelling or ordering and through $HOME/~/glob/brace spellings, as a UNION with the two catalog regexes that stay in the re tier as a fail-closed deny-net. The HOME-reassignment suppression (a persisted safe reassignment before the rm redirects a later $HOME/~ to a throwaway dir, which base allowed) is bounded so it never clears the deny on an UNCHANGED home: - The assignment must be GUARANTEED to run — not on the right of a && / || short-circuit, and not inside a double-quoted data-consumer string (a printed `echo "export HOME=…"` never runs). - Its value must be demonstrably neither root nor home — a bare $VAR, a value a substitution builds (`$(printf '%s' "$HOME")` resolves to home itself), and a reassignment to / or a home spelling all keep the deny; only a concrete path component or a known throwaway generator ($(mktemp -d)) is safe. An EXECUTED shell -c payload is run by a child shell that expands $HOME/~ by spelling, so the payload tokens are classified directly, recursing through nested payloads (`bash -c 'bash -c "rm -fr ~"'`). The verdict is platform-independent (it does not depend on expanduser returning a /-rooted path, so a Windows drive home no longer slips the deny), and the home counts only when the payload performs a live home expansion in its OWN quote state. An unquoted shell comment (`rm -rf dist # remove / later`) and a later command's operands past this rm's own command boundary are not read as operands; the substitution-operand resolver, the sh -c span scan, and the classified-frame count are each bounded so a crafted opener/separator chain cannot stall the synchronous gate within the floor. Fixes #8237 Fixes #8387
|
Thank you for this work, @chenmingwei23. Both linked issues (#8237 and #8387) were fixed on main by #18415 (commit e15240c), which added |
Problem / Motivation
Goal: Close two security-class gaps in the local
rm -rfdeny gate so a recursive-force deletion of the filesystem root or the home directory is refused regardless of how the flags or the home target are spelled.As part of that goal, the deny-gate's structural floor also holds under the shell forms review required so the two spellings cannot be reached around:
rm -fr $HOME; ls,&& ls,|cat, or wrapped in( … )) still denies — the gate reads the command's top-level segments, so a glued operator cannot carry the wipe past the home check.$HOMEsubscript identities${HOME[0]}and${HOME[@]}are$HOMEspellings (a plain string is a one-element array), sorm -fr "${HOME[0]}"denies exactly asrm -fr "$HOME"does.-cscript that references its positional parameters (sh -c 'exec "$@"' _ rm -fr ~) can execute the words after the script, so they are classified rather than skipped as inert$1..$ndata.cat <<'A' <<'B' …), every heredoc body on that line is consumed as stdin data in order, so an inert body is not re-read as a command and refused.rmspan across a command-substitution's closing paren, command-substitution operand resolution, thefind -execprinter exemption, and the${HOME[*]}subscript via the glob pre-pass are out of scope here and deferred to rm deny gate: heredoc + command-substitution handling needs a single-rule redesign #19291 (a single-rule redesign). A root/home wipe written as the contiguousrm -rf /literal in any of those forms is still caught by the whole-text deny-net regex;rm -fr $(find ~ …)/rm -fr $(echo ~)is denied fail-safe, since the substitution can expand to the home dir.The two
local-destructive-rm-rf-*rules under the PreToolUse gate matched only the literal spellingrm -rf:rm -fr /,rm -rfv /, splitrm -r -f /, long optionsrm --recursive --force /, andrm --no-preserve-root /all ran the identical root wipe while passing the gate.~alone, sorm -rf $HOME,rm -rf ${HOME}andrm -rf "$HOME"deleted the home directory unblocked.Why it matters
These are the gate's two backstops against a catastrophic, irreversible local deletion. A deny rule an agent gets past by re-ordering or renaming a flag, or by writing
$HOMEinstead of~, is not a control. Both spellings are ordinary and an agent reaches them without any evasion intent.Not a goal
rm -f,rm -ralone, flaglessrm, and relative-path deletes (rm -rf ./build) remain allowed — only recursive AND force together (or--no-preserve-root) against a root/home target is destructive here.rmargv.python -c 'shutil.rmtree("/")'is the same wipe with normtoken, so anrm-argv matcher can never be complete for interpreter code; that surface is left to the OS sandbox and is out of scope here (see What changed).What changed
The two
rmcatalog regexes stay LIVE in the Pythonredeny tier as a fail-closed net, UNIONed with a new argv-structural floor (rm_floor._recursive_force_rm_targets). This is the smallest surface that closes both issues without a false-positive regression:rm -rf /.*/rm -rf ~.*) catches the contiguous literal wherever it appears, including a quoted payload the floor's own-argv model cannot reach —su -c "rm -rf /",fish -c,eval "$(printf 'rm -rf /')",trap 'rm -rf /' EXIT,bash <(echo …). Dropping the net would let every such vehicle get past a rule base denied, so it stays.bash -c,$(…), chained segments) reading eachrmcommand's OWN argv, collects the recursive / force /--no-preserve-rootflags from EVERY position in any packing / order / long-option / unambiguous-abbreviation spelling (sorm / -rf,rm -r -f /,rm --recursive --force /are all caught, de-quoting a quoted flag token first), and denies the root/(a run of slashes, or the/*glob over its children) or home (~/$HOME/${HOME}, bare, with trailing slashes, or the~/*glob) itself in any flag spelling. It resolves dot segments and partial quoting ("$HOME"/) so a spelling of the exact target cannot evade it.rmreached through an exec wrapper (setsid/sudo/docker exec/busybox dispatch), through a command-string wrapper (watch/flock -c/sshremote), and through ash -cpayload. A wipe reached through anxargspipeline is left to the whole-text regex deny-net — xargs stdin reconstruction is out of this change's Goal (rm flag spellings + home-variable spellings) and is not performed by the floor.grep-family argument position (grep -rn 'rm -rf /' src/) — is narrowed by the restored_DENY_EXCEPTIONSgrep inert-search carve-out, scoped to thegrep/egrep/fgrepfamily (which cannot execute their operands) and gated so no shell-active construct or pipeline can hide an executed command behind it.Deliberately NOT shipped (left to a follow-up / the OS sandbox): interpreter
-c/stdin code-payload extraction, awk/php source-body inspection, andfind -exec {}-root classification. Anrm-argv matcher is the wrong subject for a language source body, and those layers also over-refused legitimatefind-prune andgrep-alternation idioms the Security Scope lane flagged. A root/home wipe written literally in any of those forms is still caught by the whole-text deny-net regex.Backwards compatibility
Compatible for legitimate operations. The change ADDS denial of the widened flag spellings and the
$HOME/${HOME}home spellings of a root/home wipe that base missed, and keeps base's own descendant denial (the liverm -rf /.*/rm -rf ~.*regex deniedrm -rf /etcandrm -rf ~/.ssh, and still does). It does NOT newly refuse any legitimate command base allowed: a widened-spelling scratch/cache cleanup (rm -fr /tmp/build-cache,rm -rf $HOME/.cache), agrep-family search for the rule's own literal, afind-prune cleanup, and agrepalternation ending in an interpreter name all stay allowed, matching base. Declared changes vs base: the grep inert-search carve-out is kept (not widened to other verbs);git commit -m/rg/git grepmentions of the literal stay DENIED exactly as base denied them (the quoted-mention exoneration is NOT shipped).Tests
test_rm_rf_denies_root_or_home_target_in_any_flag_spelling— every flag spelling of the root/home target itself denies.test_rm_rf_denies_descendants_of_root_and_home_allows_only_relative_and_mentions— the contract bounded on both sides.test_rm_rf_glob_over_children_is_equal_to_the_target—/*/~/*deny; a widened-spelling descendant glob allows.test_rm_rf_behind_an_unknown_exec_wrapper_...family — a wrapper denies the root/home target, allows a widened descendant.test_rm_rf_stay_live_in_the_regex_deny_net— the catalog regexes stay in theretier (not stripped) andis_denieddenies asu -c/evalquoted payload the floor's own-argv model misses.test_rm_rf_obfuscated_spellings_are_decoded_by_the_floor/..._fails_closed_when_the_tokenizer_raises— obfuscated root wipes decoded; fail-closed to the live regex net.test_rm_rf_gnu_long_option_abbreviations_are_denied/..._busybox_applet_dispatch_.../..._glued_ampersand_is_a_command_boundary/..._wrapped_home_with_repeated_trailing_slashes_is_denied/..._partially_quoted_home_is_classified_as_home/..._nested_shell_c_is_budgeted_not_exponential— the flag/dispatch/boundary/home-spelling/budget coverage.docs/system-specs/modules/security.mddescribes the shipped contract; golden-manifest fixture unchanged (no catalog pattern changed).black/isort/flake8/mypy/comment-history clean; security + denied-commands suites green.Manual verification
N/A — unit coverage exercises the real
is_deniedgate (quote-normalization and segmentation included) directly.Screenshots / video
N/A — no UI change; this is a backend security-gate change.
Related Issues
Fixes #8237
Fixes #8387
Pattern harvest
Rule candidate: review-prompt
Pattern: a deny rule authored as a fixed command literal is gotten past by any equivalent flag/argument respelling (order, packing, long option) or variable spelling of its target. Fix the SHAPE with an argv floor, but keep the original whole-text regex as a fail-closed net for the quoted-payload vehicles an own-argv model cannot see — a floor that REPLACES the regex fails open on
su -c "…"/eval/trap. Hold the scope to the flag/target spelling the issue names; do not chase language-source-body spellings anrm-argv matcher can never complete.Known residual
A quoted-metachar literal inside a
$(...)body (e.g.echo "$(rm -fr '/*')") may still be over-refused: the quoted-literal exemption that keeps a directrm -fr '/{,tmp}'/rm -fr '/*'allowed runs only on the rawstrip_quotes=Trueclassification, and the decoded/substitution-body view has already lost its quotes to the payload walk, so a false denial there is an accepted residual (a refusal the user sees, not a missed deletion), not a hole.Checklist
$HOMEtarget).is_deniedgate; lint and comment-history clean.Contribution License Agreement
By submitting this pull request, I confirm that my contribution is made under the terms of the project's license.
Why this change
The two linked issues (#8237 flag spellings, #8387
$HOMEtarget) ask that the localrm -rfdeny gate refuse a recursive-force deletion of root or home no matter how the flags or the home target are spelled. These are the gate's backstops against an irreversible local wipe, so the gap affects everyone the gate protects, not a niche workflow. The change is a backend security-gate fix with no user-facing surface: it adds denial of the widened flag/$HOMEspellings and keeps every legitimate command base allowed, so it changes no default, UI, copy, or option for anyone who was not already hitting the gap. No reviewerneeds-humanlabel is outstanding other than the Sensitive Change Review approval, which is noted below.Rebased onto main + review follow-up
Rebased onto current
main. Four files conflicted and were resolved:src/kiro_crew/security/__init__.pyanddocs/system-specs/modules/security.md—mainadded a whitespace-elided deny view (sorm -rf " " /home/xis refused through the elided render against the baserm -rf /.*net). The branch's older residual note that described that shape as unhandled was dropped as superseded; the docs keepmain's whitespace-view bullet and the floor-aware Residual bullet.test/test_denied_commands_security.py— kept both the whitespace-elided-view test (main) and the branch's whitespace-before-rooted-target test, with the latter updated to the post-rebase behaviour (a whitespace word before a rooted descendant is refused through the elided view).test/test_security_gate_liveness.py— the package line budget is the measured post-rebase total.Two review findings on the floor, both base-allowed commands the floor was refusing (fail-closed over-refusals, nothing let through), are fixed and pinned:
rmas afindpredicate value (find / -name rm -o -name -fr -o -path /) or as atimeout-wrapped printer's argument (timeout 5 printf '%s' rm -fr /) is read as data, not an executedrm. The executed forms —find … -exec rm -rf /, a baretimeout 5 rm -fr /, and a printer whose output is piped into a shell — still refuse. Pinned bytest_rm_rf_operand_mentions_are_not_executed_rm.rm -fr ~/{,cache/}{1..300}) is a descendant cleanup, never the bare target, and stays allowed; a bare root operand alongside it still refuses. Pinned intest_rm_rf_brace_expansion_cannot_fail_open.Internal content scan: the one flagged comment literal was reworded; the scan is not overridden.
Reviewer note (Sensitive Change Review)
Sensitive Change Review is the only remaining red after this push, and it is left for a human: a reviewer approves the sensitive-gate change on the current head (or fills the review template on it). It is not self-cleared here.