@codyswann/lisa 4.40.0 → 4.41.0

package/dist/opencode/plugin-templates/block-managed-file-edits.sh

@@ -719,6 +719,20 @@ def shell_script_operand(args):
             # not a script file.
             if not token.startswith("--") and "c" in token[1:]:
                 return None
+            # `-n` is noexec: the shell READS and parses the file, then exits
+            # without executing a line of it. `bash -n <file>` is the one shape
+            # that puts a path at a command position while provably running
+            # nothing — the exact seam between reading and running, and this
+            # walk got it wrong (CodySwannGT/lisa#3781). Here that meant a
+            # syntax check of any script mentioning a managed path was refused
+            # as though it were about to write one.
+            #
+            # `bash <file>` still executes and is still refused. Noexec is the
+            # distinction, not the program.
+            if token == "--noexec" or (
+                not token.startswith("--") and "n" in token[1:]
+            ):
+                return None
             continue
         return token
     return None

package/dist/opencode/plugin-templates/block-no-verify.sh

@@ -24,6 +24,13 @@
 #      `source`, `.`, `bash < nv.sh`, and an interpreter a `find -exec` or
 #      `xargs` puts at a command position.
 #
+# NOT vector 11: `bash -n nv.sh`. `-n` is noexec — the shell reads and parses
+# the file, then exits without running a line — so a syntax check is the one
+# shape that puts a path at a command position while executing nothing. It used
+# to be refused, which made `bash -n` unusable on this file, on every husky
+# hook, and on most of this repository (#3781). The distinction is noexec, not
+# the program: `bash nv.sh` still executes and is still refused.
+#
 # The line below is what lets `lisa apply` tell a downstream copy of this guard
 # that is BEHIND from one that is AHEAD. Byte comparison cannot: both look like
 # "differs from mine", and guessing "behind" is how a fork's stronger guard gets
@@ -1031,6 +1038,10 @@ def resolve_script(token):
 
 SHELL_COMMAND_STRING = object()
 SHELL_STDIN = object()
+# `-n` / `--noexec`: the shell READS and parses its operand, then exits without
+# executing a line of it. Distinct from the two above because nothing runs at
+# all — there is no payload to scan and no stdin script to wait for.
+SHELL_NOEXEC = object()
 
 
 def shell_execution_operand(args):
@@ -1061,12 +1072,25 @@ def shell_execution_operand(args):
             index += 1
             continue
         if token.startswith("--"):
+            if token == "--noexec":
+                return SHELL_NOEXEC
             if token not in SHELL_LONG_OPTIONS_NO_VALUE:
                 opaque_option_seen = True
             index += 1
             continue
         if "c" in token[1:]:
             return SHELL_COMMAND_STRING
+        # `-n` is noexec. `bash -n <file>` is the one shape that puts a path at
+        # a command position while provably executing nothing, so it is the
+        # exact seam between reading and running — and reach got it wrong in
+        # BOTH directions (CodySwannGT/lisa#3781). Here it meant a syntax check
+        # of any file merely DISCUSSING the bypass was refused, which is most of
+        # this repository's own guards and every husky hook.
+        #
+        # `bash <file>` still executes and is still refused. Noexec is the
+        # distinction, not the program: this is not a read-only exemption.
+        if "n" in token[1:]:
+            return SHELL_NOEXEC
         index += 1
     return args[index] if index < len(args) else SHELL_STDIN
 
@@ -1111,6 +1135,10 @@ def executed_scripts(tokens):
                     continue
                 if operand is SHELL_COMMAND_STRING:
                     continue
+                if operand is SHELL_NOEXEC:
+                    # Nothing runs, so there is nothing to follow and nothing
+                    # to fail closed about.
+                    continue
             else:
                 continue
             if operand is None:

package/package.json

@@ -171,7 +171,7 @@
     "zod-validation-error": "^4.0.0"
   },
   "name": "@codyswann/lisa",
-  "version": "4.40.0",
+  "version": "4.41.0",
   "description": "Claude Code governance framework that applies guardrails, guidance, and automated enforcement to projects",
   "main": "dist/index.js",
   "exports": {
@@ -319,7 +319,7 @@
     "test": "tests"
   },
   "types": "./dist/index.d.ts",
-  "lisaReleaseCommit": "7b2e6ab5ac33dee1c4e21b0d55012f3b16f6587d",
-  "gitHead": "7b2e6ab5ac33dee1c4e21b0d55012f3b16f6587d",
-  "lisaReleaseTag": "v4.40.0"
+  "lisaReleaseCommit": "620ec616954b878092b32a9a356cc20d6972a334",
+  "gitHead": "620ec616954b878092b32a9a356cc20d6972a334",
+  "lisaReleaseTag": "v4.41.0"
 }

package/plugins/lisa/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "4.40.0",
+  "version": "4.41.0",
   "description": "Universal governance — agents, skills, commands, hooks, and rules for all projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "4.40.0",
+  "version": "4.41.0",
   "description": "Universal governance: agents, skills, commands, hooks, and rules for all projects.",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa/hooks/block-direct-issue-create.sh

@@ -1708,6 +1708,23 @@ def executed_operand(argv):
                 # ordinary shell options and do not consume the script path.
                 if not head.startswith("--") and "c" in head[1:]:
                     return None
+                # `-n` is noexec: the shell READS and parses the file and then
+                # exits without running a line of it. `bash -n <file>` is the
+                # one shape that puts a path at a command position while
+                # provably executing nothing, so it is the exact seam between
+                # reading and running — and this walk got it wrong in BOTH
+                # directions (CodySwannGT/lisa#3781). A creation-shaped file
+                # earned a false refusal; a file carrying a human-gate marker
+                # earned a false ALLOW, adjudicating as "declared" a command
+                # that filed nothing. The silent direction is the worse one.
+                #
+                # Not a read-only-command exemption: `bash <file>` still runs
+                # the file and is still refused. The distinction is noexec, not
+                # the program.
+                if head == "--noexec" or (
+                    not head.startswith("--") and "n" in head[1:]
+                ):
+                    return None
             elif head in NO_SCRIPT_OPTIONS.get(program, set()):
                 return None
             takes_value = head in INTERPRETER_VALUE_OPTIONS.get(program, set())

package/plugins/lisa/hooks/block-managed-file-edits.sh

@@ -719,6 +719,20 @@ def shell_script_operand(args):
             # not a script file.
             if not token.startswith("--") and "c" in token[1:]:
                 return None
+            # `-n` is noexec: the shell READS and parses the file, then exits
+            # without executing a line of it. `bash -n <file>` is the one shape
+            # that puts a path at a command position while provably running
+            # nothing — the exact seam between reading and running, and this
+            # walk got it wrong (CodySwannGT/lisa#3781). Here that meant a
+            # syntax check of any script mentioning a managed path was refused
+            # as though it were about to write one.
+            #
+            # `bash <file>` still executes and is still refused. Noexec is the
+            # distinction, not the program.
+            if token == "--noexec" or (
+                not token.startswith("--") and "n" in token[1:]
+            ):
+                return None
             continue
         return token
     return None

package/plugins/lisa/hooks/block-no-verify.agy.sh

@@ -961,6 +961,10 @@ def resolve_script(token):
 
 SHELL_COMMAND_STRING = object()
 SHELL_STDIN = object()
+# `-n` / `--noexec`: the shell READS and parses its operand, then exits without
+# executing a line of it. Distinct from the two above because nothing runs at
+# all — there is no payload to scan and no stdin script to wait for.
+SHELL_NOEXEC = object()
 
 
 def shell_execution_operand(args):
@@ -991,12 +995,25 @@ def shell_execution_operand(args):
             index += 1
             continue
         if token.startswith("--"):
+            if token == "--noexec":
+                return SHELL_NOEXEC
             if token not in SHELL_LONG_OPTIONS_NO_VALUE:
                 opaque_option_seen = True
             index += 1
             continue
         if "c" in token[1:]:
             return SHELL_COMMAND_STRING
+        # `-n` is noexec. `bash -n <file>` is the one shape that puts a path at
+        # a command position while provably executing nothing, so it is the
+        # exact seam between reading and running — and reach got it wrong in
+        # BOTH directions (CodySwannGT/lisa#3781). Here it meant a syntax check
+        # of any file merely DISCUSSING the bypass was refused, which is most of
+        # this repository's own guards and every husky hook.
+        #
+        # `bash <file>` still executes and is still refused. Noexec is the
+        # distinction, not the program: this is not a read-only exemption.
+        if "n" in token[1:]:
+            return SHELL_NOEXEC
         index += 1
     return args[index] if index < len(args) else SHELL_STDIN
 
@@ -1041,6 +1058,10 @@ def executed_scripts(tokens):
                     continue
                 if operand is SHELL_COMMAND_STRING:
                     continue
+                if operand is SHELL_NOEXEC:
+                    # Nothing runs, so there is nothing to follow and nothing
+                    # to fail closed about.
+                    continue
             else:
                 continue
             if operand is None:

package/plugins/lisa/hooks/block-no-verify.sh

@@ -24,6 +24,13 @@
 #      `source`, `.`, `bash < nv.sh`, and an interpreter a `find -exec` or
 #      `xargs` puts at a command position.
 #
+# NOT vector 11: `bash -n nv.sh`. `-n` is noexec — the shell reads and parses
+# the file, then exits without running a line — so a syntax check is the one
+# shape that puts a path at a command position while executing nothing. It used
+# to be refused, which made `bash -n` unusable on this file, on every husky
+# hook, and on most of this repository (#3781). The distinction is noexec, not
+# the program: `bash nv.sh` still executes and is still refused.
+#
 # The line below is what lets `lisa apply` tell a downstream copy of this guard
 # that is BEHIND from one that is AHEAD. Byte comparison cannot: both look like
 # "differs from mine", and guessing "behind" is how a fork's stronger guard gets
@@ -1031,6 +1038,10 @@ def resolve_script(token):
 
 SHELL_COMMAND_STRING = object()
 SHELL_STDIN = object()
+# `-n` / `--noexec`: the shell READS and parses its operand, then exits without
+# executing a line of it. Distinct from the two above because nothing runs at
+# all — there is no payload to scan and no stdin script to wait for.
+SHELL_NOEXEC = object()
 
 
 def shell_execution_operand(args):
@@ -1061,12 +1072,25 @@ def shell_execution_operand(args):
             index += 1
             continue
         if token.startswith("--"):
+            if token == "--noexec":
+                return SHELL_NOEXEC
             if token not in SHELL_LONG_OPTIONS_NO_VALUE:
                 opaque_option_seen = True
             index += 1
             continue
         if "c" in token[1:]:
             return SHELL_COMMAND_STRING
+        # `-n` is noexec. `bash -n <file>` is the one shape that puts a path at
+        # a command position while provably executing nothing, so it is the
+        # exact seam between reading and running — and reach got it wrong in
+        # BOTH directions (CodySwannGT/lisa#3781). Here it meant a syntax check
+        # of any file merely DISCUSSING the bypass was refused, which is most of
+        # this repository's own guards and every husky hook.
+        #
+        # `bash <file>` still executes and is still refused. Noexec is the
+        # distinction, not the program: this is not a read-only exemption.
+        if "n" in token[1:]:
+            return SHELL_NOEXEC
         index += 1
     return args[index] if index < len(args) else SHELL_STDIN
 
@@ -1111,6 +1135,10 @@ def executed_scripts(tokens):
                     continue
                 if operand is SHELL_COMMAND_STRING:
                     continue
+                if operand is SHELL_NOEXEC:
+                    # Nothing runs, so there is nothing to follow and nothing
+                    # to fail closed about.
+                    continue
             else:
                 continue
             if operand is None:

package/plugins/lisa-agy/hooks/block-direct-issue-create.sh

@@ -1708,6 +1708,23 @@ def executed_operand(argv):
                 # ordinary shell options and do not consume the script path.
                 if not head.startswith("--") and "c" in head[1:]:
                     return None
+                # `-n` is noexec: the shell READS and parses the file and then
+                # exits without running a line of it. `bash -n <file>` is the
+                # one shape that puts a path at a command position while
+                # provably executing nothing, so it is the exact seam between
+                # reading and running — and this walk got it wrong in BOTH
+                # directions (CodySwannGT/lisa#3781). A creation-shaped file
+                # earned a false refusal; a file carrying a human-gate marker
+                # earned a false ALLOW, adjudicating as "declared" a command
+                # that filed nothing. The silent direction is the worse one.
+                #
+                # Not a read-only-command exemption: `bash <file>` still runs
+                # the file and is still refused. The distinction is noexec, not
+                # the program.
+                if head == "--noexec" or (
+                    not head.startswith("--") and "n" in head[1:]
+                ):
+                    return None
             elif head in NO_SCRIPT_OPTIONS.get(program, set()):
                 return None
             takes_value = head in INTERPRETER_VALUE_OPTIONS.get(program, set())

package/plugins/lisa-agy/hooks/block-managed-file-edits.sh

@@ -719,6 +719,20 @@ def shell_script_operand(args):
             # not a script file.
             if not token.startswith("--") and "c" in token[1:]:
                 return None
+            # `-n` is noexec: the shell READS and parses the file, then exits
+            # without executing a line of it. `bash -n <file>` is the one shape
+            # that puts a path at a command position while provably running
+            # nothing — the exact seam between reading and running, and this
+            # walk got it wrong (CodySwannGT/lisa#3781). Here that meant a
+            # syntax check of any script mentioning a managed path was refused
+            # as though it were about to write one.
+            #
+            # `bash <file>` still executes and is still refused. Noexec is the
+            # distinction, not the program.
+            if token == "--noexec" or (
+                not token.startswith("--") and "n" in token[1:]
+            ):
+                return None
             continue
         return token
     return None

package/plugins/lisa-agy/hooks/block-no-verify.agy.sh

@@ -961,6 +961,10 @@ def resolve_script(token):
 
 SHELL_COMMAND_STRING = object()
 SHELL_STDIN = object()
+# `-n` / `--noexec`: the shell READS and parses its operand, then exits without
+# executing a line of it. Distinct from the two above because nothing runs at
+# all — there is no payload to scan and no stdin script to wait for.
+SHELL_NOEXEC = object()
 
 
 def shell_execution_operand(args):
@@ -991,12 +995,25 @@ def shell_execution_operand(args):
             index += 1
             continue
         if token.startswith("--"):
+            if token == "--noexec":
+                return SHELL_NOEXEC
             if token not in SHELL_LONG_OPTIONS_NO_VALUE:
                 opaque_option_seen = True
             index += 1
             continue
         if "c" in token[1:]:
             return SHELL_COMMAND_STRING
+        # `-n` is noexec. `bash -n <file>` is the one shape that puts a path at
+        # a command position while provably executing nothing, so it is the
+        # exact seam between reading and running — and reach got it wrong in
+        # BOTH directions (CodySwannGT/lisa#3781). Here it meant a syntax check
+        # of any file merely DISCUSSING the bypass was refused, which is most of
+        # this repository's own guards and every husky hook.
+        #
+        # `bash <file>` still executes and is still refused. Noexec is the
+        # distinction, not the program: this is not a read-only exemption.
+        if "n" in token[1:]:
+            return SHELL_NOEXEC
         index += 1
     return args[index] if index < len(args) else SHELL_STDIN
 
@@ -1041,6 +1058,10 @@ def executed_scripts(tokens):
                     continue
                 if operand is SHELL_COMMAND_STRING:
                     continue
+                if operand is SHELL_NOEXEC:
+                    # Nothing runs, so there is nothing to follow and nothing
+                    # to fail closed about.
+                    continue
             else:
                 continue
             if operand is None:

package/plugins/lisa-agy/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "4.40.0",
+  "version": "4.41.0",
   "description": "Universal governance — agents, skills, commands, hooks, and rules for all projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-cdk/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-cdk",
-  "version": "4.40.0",
+  "version": "4.41.0",
   "description": "AWS CDK-specific plugin",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-cdk/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-cdk",
-  "version": "4.40.0",
+  "version": "4.41.0",
   "description": "AWS CDK-specific Lisa plugin.",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-cdk-agy/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-cdk",
-  "version": "4.40.0",
+  "version": "4.41.0",
   "description": "AWS CDK-specific plugin",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-cdk-copilot/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-cdk",
-  "version": "4.40.0",
+  "version": "4.41.0",
   "description": "AWS CDK-specific plugin",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-cdk-cursor/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-cdk",
-  "version": "4.40.0",
+  "version": "4.41.0",
   "description": "AWS CDK-specific plugin",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-copilot/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "4.40.0",
+  "version": "4.41.0",
   "description": "Universal governance — agents, skills, commands, hooks, and rules for all projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-copilot/hooks/block-direct-issue-create.sh

@@ -1708,6 +1708,23 @@ def executed_operand(argv):
                 # ordinary shell options and do not consume the script path.
                 if not head.startswith("--") and "c" in head[1:]:
                     return None
+                # `-n` is noexec: the shell READS and parses the file and then
+                # exits without running a line of it. `bash -n <file>` is the
+                # one shape that puts a path at a command position while
+                # provably executing nothing, so it is the exact seam between
+                # reading and running — and this walk got it wrong in BOTH
+                # directions (CodySwannGT/lisa#3781). A creation-shaped file
+                # earned a false refusal; a file carrying a human-gate marker
+                # earned a false ALLOW, adjudicating as "declared" a command
+                # that filed nothing. The silent direction is the worse one.
+                #
+                # Not a read-only-command exemption: `bash <file>` still runs
+                # the file and is still refused. The distinction is noexec, not
+                # the program.
+                if head == "--noexec" or (
+                    not head.startswith("--") and "n" in head[1:]
+                ):
+                    return None
             elif head in NO_SCRIPT_OPTIONS.get(program, set()):
                 return None
             takes_value = head in INTERPRETER_VALUE_OPTIONS.get(program, set())

package/plugins/lisa-copilot/hooks/block-managed-file-edits.sh

@@ -719,6 +719,20 @@ def shell_script_operand(args):
             # not a script file.
             if not token.startswith("--") and "c" in token[1:]:
                 return None
+            # `-n` is noexec: the shell READS and parses the file, then exits
+            # without executing a line of it. `bash -n <file>` is the one shape
+            # that puts a path at a command position while provably running
+            # nothing — the exact seam between reading and running, and this
+            # walk got it wrong (CodySwannGT/lisa#3781). Here that meant a
+            # syntax check of any script mentioning a managed path was refused
+            # as though it were about to write one.
+            #
+            # `bash <file>` still executes and is still refused. Noexec is the
+            # distinction, not the program.
+            if token == "--noexec" or (
+                not token.startswith("--") and "n" in token[1:]
+            ):
+                return None
             continue
         return token
     return None

package/plugins/lisa-copilot/hooks/block-no-verify.sh

@@ -24,6 +24,13 @@
 #      `source`, `.`, `bash < nv.sh`, and an interpreter a `find -exec` or
 #      `xargs` puts at a command position.
 #
+# NOT vector 11: `bash -n nv.sh`. `-n` is noexec — the shell reads and parses
+# the file, then exits without running a line — so a syntax check is the one
+# shape that puts a path at a command position while executing nothing. It used
+# to be refused, which made `bash -n` unusable on this file, on every husky
+# hook, and on most of this repository (#3781). The distinction is noexec, not
+# the program: `bash nv.sh` still executes and is still refused.
+#
 # The line below is what lets `lisa apply` tell a downstream copy of this guard
 # that is BEHIND from one that is AHEAD. Byte comparison cannot: both look like
 # "differs from mine", and guessing "behind" is how a fork's stronger guard gets
@@ -1031,6 +1038,10 @@ def resolve_script(token):
 
 SHELL_COMMAND_STRING = object()
 SHELL_STDIN = object()
+# `-n` / `--noexec`: the shell READS and parses its operand, then exits without
+# executing a line of it. Distinct from the two above because nothing runs at
+# all — there is no payload to scan and no stdin script to wait for.
+SHELL_NOEXEC = object()
 
 
 def shell_execution_operand(args):
@@ -1061,12 +1072,25 @@ def shell_execution_operand(args):
             index += 1
             continue
         if token.startswith("--"):
+            if token == "--noexec":
+                return SHELL_NOEXEC
             if token not in SHELL_LONG_OPTIONS_NO_VALUE:
                 opaque_option_seen = True
             index += 1
             continue
         if "c" in token[1:]:
             return SHELL_COMMAND_STRING
+        # `-n` is noexec. `bash -n <file>` is the one shape that puts a path at
+        # a command position while provably executing nothing, so it is the
+        # exact seam between reading and running — and reach got it wrong in
+        # BOTH directions (CodySwannGT/lisa#3781). Here it meant a syntax check
+        # of any file merely DISCUSSING the bypass was refused, which is most of
+        # this repository's own guards and every husky hook.
+        #
+        # `bash <file>` still executes and is still refused. Noexec is the
+        # distinction, not the program: this is not a read-only exemption.
+        if "n" in token[1:]:
+            return SHELL_NOEXEC
         index += 1
     return args[index] if index < len(args) else SHELL_STDIN
 
@@ -1111,6 +1135,10 @@ def executed_scripts(tokens):
                     continue
                 if operand is SHELL_COMMAND_STRING:
                     continue
+                if operand is SHELL_NOEXEC:
+                    # Nothing runs, so there is nothing to follow and nothing
+                    # to fail closed about.
+                    continue
             else:
                 continue
             if operand is None:

package/plugins/lisa-cursor/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "4.40.0",
+  "version": "4.41.0",
   "description": "Universal governance — agents, skills, commands, hooks, and rules for all projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-cursor/hooks/block-direct-issue-create.sh

@@ -1708,6 +1708,23 @@ def executed_operand(argv):
                 # ordinary shell options and do not consume the script path.
                 if not head.startswith("--") and "c" in head[1:]:
                     return None
+                # `-n` is noexec: the shell READS and parses the file and then
+                # exits without running a line of it. `bash -n <file>` is the
+                # one shape that puts a path at a command position while
+                # provably executing nothing, so it is the exact seam between
+                # reading and running — and this walk got it wrong in BOTH
+                # directions (CodySwannGT/lisa#3781). A creation-shaped file
+                # earned a false refusal; a file carrying a human-gate marker
+                # earned a false ALLOW, adjudicating as "declared" a command
+                # that filed nothing. The silent direction is the worse one.
+                #
+                # Not a read-only-command exemption: `bash <file>` still runs
+                # the file and is still refused. The distinction is noexec, not
+                # the program.
+                if head == "--noexec" or (
+                    not head.startswith("--") and "n" in head[1:]
+                ):
+                    return None
             elif head in NO_SCRIPT_OPTIONS.get(program, set()):
                 return None
             takes_value = head in INTERPRETER_VALUE_OPTIONS.get(program, set())

package/plugins/lisa-cursor/hooks/block-managed-file-edits.sh

@@ -719,6 +719,20 @@ def shell_script_operand(args):
             # not a script file.
             if not token.startswith("--") and "c" in token[1:]:
                 return None
+            # `-n` is noexec: the shell READS and parses the file, then exits
+            # without executing a line of it. `bash -n <file>` is the one shape
+            # that puts a path at a command position while provably running
+            # nothing — the exact seam between reading and running, and this
+            # walk got it wrong (CodySwannGT/lisa#3781). Here that meant a
+            # syntax check of any script mentioning a managed path was refused
+            # as though it were about to write one.
+            #
+            # `bash <file>` still executes and is still refused. Noexec is the
+            # distinction, not the program.
+            if token == "--noexec" or (
+                not token.startswith("--") and "n" in token[1:]
+            ):
+                return None
             continue
         return token
     return None