Repository navigation
fix(security): narrow the credential-mint and self-kill argv floors to what a command names - #10236
Conversation
|
Intent: Stop the two argv-floor predicates ( |
Design Review (Fable 5) — 🟡 CONCERNSDesign-level review of Design-Verdict: CONCERNS A fail-closed security pin is deliberately overturned: opaque inline dynamic-exec payloads ( Watch
[DESIGN-REVIEWED] 50bb1b9 |
First Principles Review (Fable 5) — ✅ PASSPremise-level review of First-Principles-Verdict: PASS Verify the reversed opaque-deny pin is accepted: inline dynamic-exec payloads naming nothing of the product are now allowed, coverage resting on the naming-convention tests plus the sensitive-path floor. What this change shipsInventory (10 items) — 10 justifiedIntent: stop the bash gate falsely denying ordinary inline-Python and brace/glob commands as credential mints or self-kills, without dropping the real denials — a FIX. Provenance: the allowed-fixture tests this PR adds fail on base, and the base-commit pin
[FIRST-PRINCIPLES-REVIEWED] 50bb1b9 |
GPT 5.6 Review — ✅ no blocking findingsGPT 5.6 completed its review of This comment is updated in place on each push. Review detailsFINDING -- src/kiro_crew/security/inline_payload.py:509 -- False positive or not applicable? A repository writer can comment: |
Opus 4.8 Review — ✅ no blocking findingsReviewed Review detailsAdvisory only — the new inline-mint gate has one residual over-match; nothing blocks. FINDING — src/kiro_crew/security/inline_payload.py:509 — [OPUS-REVIEWED] 50bb1b9 Verdict parsed from the review's SHA-scoped output markers for commit False positive or not applicable? A repository writer can comment: |
ed8457a to
5a3ef83
Compare
|
976c63330168 — fixed
c3649a97172a — fixed
9b4b8f6c5b14 — rebutted
b744a8fbdf15 — fixed
|
Security Scope Review -- ✅ PASSWhich legitimate operations does Verdict basis: adjudicated, zero confirmed regressions. Security scope review -- adjudicated candidates
No candidate flipped from allowed to refused. Scope-Verdict: PASS TIGHTENING: The inline-interpreter credential-mint gate (new ADJUDICATED: 37 candidates, 0 confirmed newly-refused PLATFORM COVERAGE: posix (28 rows) -- [SCOPE-REVIEWED] 50bb1b9 |
5a3ef83 to
aea1ed2
Compare
|
|
|
|
|
|
self-added: yes
|
|
self-added: yes
|
|
self-added: yes
|
|
/ai-review override gpt da586a3: The displayed blocking verdict is stale — it was produced on |
|
AI-review override not recorded: keep the reason to 500 characters or fewer. |
|
/ai-review override gpt da586a3: Verdict is stale: it was produced on 1148ff2 and cites |
Human judgment recorded@iamwhatever marked the gpt AI finding as false positive, not applicable, or explicitly accepted for
This decision applies only to this commit. A new push requires a new judgment. |
|
self-added: yes
|
Disposition —
|
| spelling | main |
ae2e12932a |
now |
|---|---|---|---|
"<enc>" / b"<enc>" |
deny | deny | deny |
"a" "b" (2 pieces) |
deny | deny | deny |
b"a" b"b" (2 pieces) |
deny | allow | deny |
"a" + "b" / b"a" + b"b" |
deny | allow (bytes) | deny |
"a" "b" "c" "d" "e" (5 pieces) |
deny | allow | deny |
b"a" … b"e" (5 pieces) |
deny | allow | deny |
"a" + … + "e" (5 pieces) |
deny | allow | deny |
b"a" + b"b" b"c" (mixed joiners) |
deny | allow | deny |
r"a" r"b" |
deny | allow | deny |
("a" "b") |
deny | allow | deny |
"".join([...]), "<rev>"[::-1] |
deny | allow | allow (residual) |
Ten of the fifteen were open on the reviewed head, not one. Two causes beyond the reported
prefix: the fast path required an 8+ character base64 literal to exist before folding
could run, so a payload split into short enough pieces was skipped before the fold; and a
folded value still wrapped in the call's own parentheses failed the value matcher, because
a constant span excludes the parentheses around it.
The fix, and why it ends this class rather than this instance
Rounds 1–6 on this span were each a new spelling: how a callable is named
(getattr(m,"f"), an import alias, __dict__[k]) and how a call head is written
((f)(x)). Those closed into a static binding table because the set of static bindings is
finite. Round 8 is a different axis — how the payload's bytes are written — and that set
is not finite while the reader is a regex over tokens: b/r/u prefixes, implicit
concatenation, +, parentheses, piece length, and every combination.
_constant_text reads the parse instead, where the case list is the grammar's and is
closed: an ast.Constant (into which the parser has already merged implicit concatenation
and every literal prefix) and + over two of them. Parentheses are not nodes, so a grouped
literal folds for free. There is no piece-count or chain-depth limit — total work is bounded
by the payload's own length, and nesting deep enough to matter is refused by the parse — so
a payload cannot stay unfolded by being long. A payload the parser rejects (a carrier the
shell truncated) keeps the lexical fold, which tolerates a malformed prefix; that path is
pinned by its own test.
A folded value carrying a newline, or both quote characters, stays as written: emitting it
would let the fold manufacture a statement boundary the payload never wrote, which the
product-import anchor would read as an import. Pinned by
test_a_folded_value_cannot_manufacture_a_statement_boundary.
Residual, stated rather than claimed covered
A computed input — "".join([...]), a slice, bytes.fromhex, an f-string, a name — is
outside a static floor's reach, the same residual a callable named at run time gets
(getattr(m, input())). test_a_computed_input_is_the_documented_residual pins all five so
that resolving one later is a deliberate widening rather than a surprise. Closing it would
mean denying every decode whose input a static reader cannot evaluate; that is a wider
refusal than this PR's goal, so it is named here instead of taken silently.
Verification
- 3039 passed / 5 skipped across the security suite at the rebased head (19 files,
includingtest_security_gate_liveness.py); 23 new tests in
TestTheFoldIsClosedOverConstantExpressions. deny_diff.py --base origin/main --head HEAD: no regressions, 41 classified golden paths
allowed at both refs.argv_floor.pystays at 4499 lines, under_MODULE_LINE_CAP.- black 26.3.1 / isort / flake8 / mypy clean on the three changed files; comment-history and
docs-lint gates pass.
Two existing assertions moved, both pinned to the old mechanism rather than to behaviour:
the 500-piece fold test (a depth cap broke a property it deliberately pins, so the cap is
gone) and the scan-once test (it pinned the payload's length; it now pins the folded view's,
keeping the "once" property).
|
/ai-review override gpt 5ca8ab7: verdict is stamped ae2e129 and its byte-literal fold finding is fixed at this head by folding on the AST (Constant | BinOp(Add)), where 13 of 15 constant spellings now deny and the two computed ones are pinned as the documented residual; the provider refused to re-review this sha. |
Human judgment recorded@iamwhatever marked the gpt AI finding as false positive, not applicable, or explicitly accepted for
This decision applies only to this commit. A new push requires a new judgment. |
|
/ai-review override scope 5ca8ab7: attempt 2 of this head returned VERDICT PASS with all five upstream jobs green (Fable 5 candidates, candidate validation, and adjudication on ubuntu, macos and windows); the per-head monotonic floor holds it at attempt 1's failure, which was a 30-minute queue-load timeout in the candidates lane rather than a scope finding. |
Human judgment recorded@iamwhatever marked the scope AI finding as false positive, not applicable, or explicitly accepted for
This decision applies only to this commit. A new push requires a new judgment. |
|
/ai-review override gpt 85bb017: this head is a no-conflict rebase of 5ca8ab7 onto main 90ff928 with a byte-identical diff (index lines stripped, sha256 4ac200f69110c4cb at both heads); the prior head carried a recorded GPT override (5672959473) after its byte-literal fold finding was fixed by folding on the AST (Constant | BinOp(Add)), 13 of 15 constant spellings deny and the two computed ones are pinned as the documented residual. Rebased only to pick up #10895, which repairs the three pod stop-race tests main had broken via #10586. |
|
/ai-review override scope 85bb017: this head is a no-conflict rebase of 5ca8ab7 onto main 90ff928 with a byte-identical diff (index lines stripped, sha256 4ac200f69110c4cb at both heads); the prior head carried a recorded scope override (5673605557) after attempt 2 returned VERDICT PASS with all five upstream jobs green and only the per-head monotonic floor held it at a queue-load timeout. No security-scope content changed in the rebase. |
|
AI-review override not recorded: keep the reason to 500 characters or fewer. |
Human judgment recorded@iamwhatever marked the scope AI finding as false positive, not applicable, or explicitly accepted for
This decision applies only to this commit. A new push requires a new judgment. |
|
Human judgment recorded, but the following reviewer lane(s) could not be re-run automatically: Security Scope Review. Re-run the lane's latest workflow run for |
|
/ai-review override gpt 85bb017: no-conflict rebase of 5ca8ab7 onto main 90ff928, diff byte-identical (index lines stripped, sha256 4ac200f69110c4cb at both heads). 5ca8ab7 carried GPT override 5672959473 for the same finding: byte-literal fold fixed by folding on the AST (Constant | BinOp(Add)); 13/15 constant spellings deny, the two computed inputs are the pinned residual. Rebased only to pick up #10895. |
Human judgment recorded@iamwhatever marked the gpt AI finding as false positive, not applicable, or explicitly accepted for
This decision applies only to this commit. A new push requires a new judgment. |
|
Disposition of the GPT 5.6 finding on Confirmed real, not a false positive: against a clean Fix: Pinned by The one probe shape still allowed on both main and this head, |
UX Review (Fable 5) — ⏭️ skippedRevision |
|
Disposition of the GPT 5.6 finding on Probed 10 shapes against a clean
Fix: One note for the record: a single-backslash spelling such as |
…o what a command names The `credential-exfil-kirocrew-token` floor denied any inline Python that merely mentioned the product package, so ordinary `python -c` commands that named `kiro_crew` in a string, a path or a comment were refused. The floor now denies a payload that names the mint surface -- the CLI module, the token module, or a product import next to a credential verb -- and lets every other mention through. String literals are folded on the AST before matching, so an encoded mint reads the same however its literal is spelled (adjacent pieces, `+`, byte and raw prefixes); a computed input the parse cannot evaluate is the documented residual. A product import is read at every statement boundary the grammar has: start of input, `;`, newline, and the `:` that closes a compound header. A package path names the mint whether its separators are spelled `.`, `/` or the Windows `\`. Golden paths: 0 regressions across 41 classified commands.
bolichen97
left a comment
There was a problem hiding this comment.
Approved. Tier 2 deep review: security argv-floor narrowing verified. Denial Differential and inline_payload matcher logic confirmed. No credential-mint or self-kill leaks.
Problem / Motivation
The bash gate refuses ordinary developer commands as credential mints and self-kills. Eight days of
~/.kiro/crew/security_events.jsonlon one host hold 179 bash-gate denials. 156 of them come from two argv-floor predicates. None of the 156 was the action the predicate exists to stop._is_credential_mintdenies every inline Python program (python -c,python - <<'PY') that mentionskiro_crewanywhere, or that usesgetattr,eval,importliborb64decodeat all. A patch script that editssrc/kiro_crew/x.py, a one-liner importingkiro_crew.platform.governance, orpython3 -c "print(getattr(json, 'dumps'))"next to a product path are all "credential mints". 143 denials; one command contained the wordtoken; zero minted._is_self_killreads every brace group as a word that "could expand topkill". A quoted jq filter (--jq '{state}'), an awk program ('{print $1}'), or a glob argument (ls -d dir/*) followed by a product-named path in the same argv is a "self-kill". 13 denials; 8 of the commands contained nokillat all.Why it matters
An agent hit by one of these denials stops mid-task. It then either asks the user to run the command by hand, or rewrites the command until it slips past the gate. Both are worse than the rule firing on a real mint. A gate that is wrong 87% of the time also trains people to disable the rule, and the rule covers a real escalation path (
kirocrew tokenprints a signed dashboard URL).What changed (motivation → approach → change)
An inline program is now judged by what it names, not by whether it mentions the product.
_inline_payload_reaches_cli(new modulesrc/kiro_crew/security/inline_payload.py: it answers one question — what an inline payload NAMES — and imports only the vocabulary, so it sits belowargv_floor.py, which decides WHICH argv tokens are a payload; the two folds and the decode are unit-tested through it without standing up the floor) denies a payload that names the mint surface: the CLI dispatch (kiro_crew.cli,kiro_crew.__main__, the console-script entrykiro_crew._bootstrap,from kiro_crew import cli), the module implementing thetokensubcommand (kiro_crew.cli_server), a product module whose path names a token producer (kiro_crew.dashboard.token_auth,kiro_crew.instances.token_mint), a product import statement (the package anywhere in animportlist —import os, kiro_crew.instances.run_marker as rimports it too) together with a credential word,tokenorsecret, anywhere in the payload (from kiro_crew.slack.gateway import generate_token,import kiro_crew.slack.gateway as g; g.generate_token(), and the second credential:from kiro_crew.config.loader import read_local_secretreads the internal secret/api/token/localaccepts through product code, past the sensitive-path floor that fences.local_secretitself; every reader of it carriessecretas every producer carriestoken), or the bare package name handed to a dynamic module runner (runpy.run_module('kiro_crew', run_name='__main__')ispython -m kiro_crewspelled as a call;importlib.import_module('kiro_crew')and__import__('kiro_crew')reach the same dispatch). A runner handed any other name (__import__('os').environnext to a product import) is generic code. The installed console script run through a code loader is the same dispatch spelled through the entry point:exec(open(shutil.which('kirocrew')).read()),exec(open('/venv/bin/kirocrew').read())orrunpy.run_path(shutil.which('kirocrew'))runs_bootstrap.main()against asys.argvthe payload chose, so a loader (exec,eval,compile,run_path) next to the program name — a whole word and the last path component — is denied; a loader on any other file (exec(open('patch.py').read()),runpy.run_path('/home/dev/kirocrew/scripts/gen_docs.py'), wherekirocrewis a directory) is a patch-script idiom and stays allowed. Which callable a call reaches is decided ONCE, by what the payload's own static bindings resolve it to, and the runner, loader and decoder gates all read that one table (_resolved_calls): a name written at the call, a module alias (import runpy as rp; rp.run_module(…)), a from-import with or without an alias (from runpy import run_module as r), an assignment (r = runpy.run_module), and a head that names the callable in a string and is called or bound (getattr(runpy, "run_module"),runpy.__dict__["run_module"]) all resolve to the same runner. Reading the word written at the call instead is one alias away from missing, and closing each spelling per gate is how the decoder gate came to resolve its own import aliases while the runner gate did not. Resolution is static and its vocabulary is fixed, so a binding is only read when the payload's text binds one of these callables:from mypkg import compileis not the builtin, an object attribute is not a bare alias (obj.d(…)), a binding written inside a string binds nothing, and a name computed at run time (getattr(m, input()), a subscript by variable) resolves to nothing — the residual, noted rather than claimed covered. What the resolved call is HANDED is then the same question the written name is asked, sofrom runpy import run_path as rp; rp('patch.py')is a file load andgetattr(json, 'dumps')is generic code. A product import inside a code loader's string (exec('from kiro_crew.config.loader import read_local_secret; …')) runs exactly as the bare statement does and is read the same way; a quoted statement with no loader (print('from kiro_crew.acp import x')) is prose. Before matching,_fold_inline_literalsjoins'a' + 'b'and implicitly concatenated'a' 'b'string pieces to a fixed point (every adjacent pair per pass, so no count of pieces outruns it) and_decoded_b64_literal_sourcesdecodes the literals a decoder call is actually HANDED, read from the command as submitted (no count cap a payload could pad past), so__import__('kiro_crew.c'+'li'),os.system(b64decode('a2lyb2NyZXcgdG9rZW4='))and a base64 literal split across pieces are read as what they hide. A decoded literal is asked the same questions as the payload — mint surface, product import plus credential word, dynamic runner handed the package — since anexec(b64decode(…))body is a payload one decode away. An encoded literal a program only CARRIES stays data: a patch script's base64 fixtures are decoded by nobody, so they are decoded here by nobody either. Each decoding is paired with the literal it came from and a payload borrows one only for bytes it carries, so one command's decoder call does not lend its result to the next command's payload (python -c 'print(b64decode("aGVsbG8="))'beside an unrelatedprintfof encoded text is not a mint). The pool is read from every program text the shell can hand an interpreter — the command itself for an unquoted heredoc body, its shell words for a quoted-coperand, here-string or pipe producer, and one nested shell level — because a quoted payload keeps its decoder call inside a single token, where the tokenizer cannot see it; a text is only split when it names an interpreter or a shell, so Python's own quotes are never stripped and printed syntax never reads as a call.is_deniedhands the mint predicateraw_text=for this: base64 is case-sensitive and the floor otherwise reads a lower-cased view. A payload that only mentions the package, imports an unrelated product module with notokenorsecretsymbol (secrets, the stdlib module or the product modulehandlers/secrets.py, is neither), or usesgetattr/eval/importlibwith no product name in reach is not a mint. The verb-gated-m kiro_crew ... tokencheck and the interpreter-argv companion rule are untouched.Path("src/kiro_crew/x.py")in a patch scriptfrom kiro_crew.acp import x; print(x)print(getattr(json, "dumps"))next to a product pathimport kiro_crew.cli as c; c.main()import kiro_crew.slack.gateway as g; g.generate_token()os.system(b64decode("a2lyb2NyZXcgdG9rZW4="))exec(open("/tmp/x").read())with no product name🟩 added · 🟨 changed · 🟥 removed · 🟦 unchanged
A program that names the token mint is still refused; a program that only lives near the product is not.
A brace group now expands to what bash expands it to.
_glob_to_regextranslates{a,b}to one word per alternative,{c..c}and{a..z}to the sequence, and leaves a group with no top-level comma and no..({state},{print $1}) literal, braces included. Nesting is capped at_BRACE_NESTING_CAP = 8; past it the group reads as.*, the fail-closed direction, so a word built hundreds of levels deep is judged instead of raisingRecursionError. Brace pairs are resolved once per word in one linear pass (_brace_pairs); the old per-brace scan to the end of the word was quadratic, so a word of 12,000 unbalanced braces stalled the synchronous gate for tens of seconds. The regex the translation produces is bounded too: a word spends at most_BRACE_GROUP_BUDGET = 6alternation groups (past it a group reads as.*), identical alternatives ({*,*}) collapse to one branch before the budget is charged, and consecutive.*pieces collapse to one. Without that,{*,*}fifteen times over gavere2^15 ways to fail a five-letter name and took 8.8 s per protected name. Two argv facts complete the kill fix: the filesystem inspectors (ls,stat,file,du,readlink,realpath,dirname,basename) and movers (cp,mv,ln,rm,mkdir,rmdir,touch,chmod,chown; nottar, whose-Iruns a program) join_DATA_CONSUMER_PROGRAMS, so a glob among their arguments is a filename, not a program; and_data_consumer_exemptkeeps that exemption for an argument glued to a trailing operator (cp $dir/*;), since the operator starts no program inside the token, and refuses it for a token that opens with a command substitution (ls $(kirocrew update),cat \kirocrew token`), since the word's basename reading is the body's program, which runs. A substitution later in the word (cp report_$(hostname)*.log) or inside a brace group (mv {$(date +%F),current}.log) keeps the exemption: the word is a filename around a body, and the body is judged on its own by the payload walk, which descends into every substitution wherever it sits (echo foo$(pkill -f kirocrew)andls {$(pkill -f kirocrew),y}are denied for the body). The glob reader itself reads only glob and brace syntax: a command substitution is literal text to it, as onmain, because what it prints is outside a static floor (at program position$(printf pk)ill -fis the documented residual, unchanged here) and its body is the walk's business. Parameter expansion (${X},$X) is literal for the same reason: reading it as anything denied awk field lists ({print $6,$7}) and prose heredocs naming${name}. The exemption stays gated on the program being a data consumer: these tokens have had their quotes removed, so a trailing operator at program position ('/tmp/kirocrew;' token, a symlink literally so named) is never read as an argv boundary and the verb after it is still scanned.x;pkill -f kirocrewstill runspkill` and is still denied.Replayed against the 204 denied commands in the log, the gate on
origin/mainstill denies 179 and this branch denies 32 (the breakdown is under Testing).security/__init__.pyalso drops_MINT_SURFACE_RE,_fold_inline_literalsand_decoded_b64_literalsfrom the facade andEXPORTED_NAMES: no caller reaches them through the facade, and the tests importinline_payloaddirectly. It leaves.github/black-baseline.txt: the hunk this diff adds made the file black-clean, and the baseline gate prunes a graduated entry rather than keep it.Tests
test/test_argv_floor_inline_and_brace_scope.py(new, 195 tests) pins each narrowed question. A payload that only mentions the package is allowed and one that names the mint surface is denied, in-c, heredoc, here-string, pipe and file-redirect forms; therunpy/import_module/__import__spellings ofpython -m kiro_crew tokenare denied, including with the package name spelled in pieces, and the same runners handed another name are allowed.test_the_mint_surface_covers_every_token_producer_in_the_treederives the producers from the tree rather than a list: the seed is the function that namestoken_signing.keyand opens a file, the reach follows the import graph one hop into the modules that define the producers (closed over their own calls) and then the re-export chain to a fixed point (a module that imports a producer name is an import source for that name, however deep; only the re-export relation is closed, since closing the call graph at every hop pulls in the whole dashboard), and every (module, imported name) pair on that path must be a reach in both spellings (from M import f;import M as mthenm.f), with the three key touchers that produce nothing (warm_auth_singletons,extract_numeric_claim,revoke_access_cookie) listed with their reason; everypyproject.tomlconsole-script entry module must be a reach too.test_the_credential_word_covers_every_local_secret_reader_in_the_treedoes the same for the internal secret: the seed is every function that names.local_secretor the.secretsidecar suffix (the read may sit in a generic helper, asrun_marker.read_secretdelegates to_read_sidecar), the four namers that hand no credential to a caller (the two gateway starters that write it, the CLI and MCP cron dispatchers that present it) are listed with their reason, and every other one must be a reach in both spellings. The whole route GPT described (importread_local_secret, present it to/api/token/local), the reader spelled in pieces (getattr(loader, 'read_local_' + 'secret')), and the price of the word (a product import next to a variable namedsecret) are denied;secrets(stdlib orhandlers/secrets.py) next to a product import and a.local_secretmention with no import are allowed. Base64 literals decode from the raw command and not from the lower-cased view, and a literal split across+pieces decodes after folding;'a' + 'b'folds and a+ namedoes not; a 500-piece name folds whole, a bare list of 200 encoded literals is data no decoder is handed, and an encoded mint behind 200 decoys is still read when a decoder call is handed it; the encoded mint is denied through each carrier that can reach an interpreter (-c, heredoc, here-string, pipe producer, nestedbash -c), and a neighbouring command's decoding cannot travel to an unrelated payload; a product import insideexec('…')/eval(compile('…'))is denied and the same text in aprintis not.{state}is literal,{a,b}is its alternatives,{c..c}isc, a 600-deep brace word is judged and not crashed, a 12,000-brace unbalanced word is judged in under two seconds and read literally, seventeen{*,*}/{*,**}/{*,a*}groups in a row are judged in milliseconds and fail closed; a command substitution in a glob word is literal text and its body is walked ({$(pkill -f kirocrew),x} yandtar czf x_$(pkill -f kirocrew).tgzare denied for the body;{$(date +%F),current}.logundermv,rsyncorcpwith a product-named path later is not a kill), and{$((e-1)),d},{print $6,$7,$8,$9},{${name},%name%}and{$X,-f}are not verbs; a glob underls/stat/du/cp(with or without a glued trailing;) is not a kill program, a quoted'/tmp/kirocrew;' tokenor'pkill;' -f kirocrewis still denied, and so arex;pkill -f kirocrewandsudo pkill -f kirocrew.test/test_denied_commands_security.py: the 43 stdin-carrier fixtures useimport kiro_crew.clias the minimal reach (the bare package import reaches nothing;kiro_crew/__init__imports no CLI). The quote-gluedex""ec(open(...))case still opens the perf gate but is no longer a mint. The base64-wrapped mint is denied by decoding, and a base64 literal decoding tohello worldis allowed. The pipe over-block test pins that the left side ofa | b; python -is still yielded as program text and is denied only when it names the mint surface.test_refusal_inband_notice.pyandtest_security.pyuseimport kiro_crew.clias the floor-denial fixture.Manual verification
Replayed the 204-command denial corpus from this host's SEL log against
is_deniedonorigin/main(179 denied) and on this branch (32 denied); read every one of the 32 — 26 are other rules (rm -rf,git pushbrace refspecs,git reset --hard, curl uploads,env | grep), 3 are awc -l $dir/*;inside a command whose jq filter contains| "…", which the pre-existing awk/sed script-executes guard reads as a pipe-to-command for the whole call, 1 is a heredoc quoting an earlier review finding about killing a process tree next to the product name, and 1 is agreppattern that spells the mint rule's own id, and 1 is a product import next to a variable namedsecret(the price of the credential word; a rename away); all six are denied onmainas well. Ran the GPT and Opus local review lanes and a verifier on the RecursionError fix (600-deep literal and alternative brace words, unbalanced braces, 19,000-character words: no exception). Full backend suite: the 85 remaining failures are identical on a cleanorigin/maincheckout.Related Issues
no linked issue: found from this host's audit log, not from a filed report.
Pattern harvest
Rule candidate: review-prompt
Pattern: a security predicate whose evidence is "the input mentions our name" (or "uses a dynamic-exec verb") rather than "the input names the protected action" — check the predicate's own audit log for its true-positive rate before adding another such branch.
Checklist
feat|fix|docs|refactor|perf|test|chore|ci|build|revert: ...)