fix: backslash prototype precedence for tied/tie/untie with glob arguments

PerlOnJava parsed `tied *STDOUT && expr` as `tied(*STDOUT && expr)` instead
of `(tied *STDOUT) && expr`. This caused Capture::Tiny to skip its
`local(*STDOUT)` call when STDOUT was tied by Test2::Plugin::IOEvents,
corrupting the selectedHandle and breaking print output capture.

The fix adds parseBackslashArgWithComma() which parses backslash prototype
arguments at named-unary precedence (level 15, same as isa) instead of comma
precedence (level 5). This matches Perl 5 behavior where comparison/logical
operators are NOT consumed but arithmetic operators ARE consumed.

App::perlbrew: 65/73 -> 66/73 tests pass.

Generated with Devin (https://cli.devin.ai/docs)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: fglock

dev/modules/app_perlbrew.md

@@ -1,6 +1,6 @@
 # App::perlbrew CPAN Installation Plan
 
-## Status: Phase 7.1 complete — 65/73 tests pass (2026-04-07)
+## Status: Phase 7.4 complete — 66/73 tests pass (2026-04-07)
 
 ## Goal
 
@@ -621,3 +621,27 @@ than `stat(STDOUT)`, or a redesign of how `selectedHandle` interacts with tied h
 
 Remaining tests: `command-info.t`, `12.destdir.t`, `12.sitecustomize.t`, `installation2.t`,
 `installation-perlbrew.t`
+
+- [x] Phase 7.4: Fix backslash prototype precedence for `tied *GLOB && expr` (2026-04-07)
+  - **Root cause**: PerlOnJava parsed `tied *STDOUT && $] >= 5.008` as `tied(*STDOUT && $] >= 5.008)`
+    instead of `(tied *STDOUT) && ($] >= 5.008)`. This caused Capture::Tiny to skip
+    `local(*STDOUT)` when STDOUT was tied (by IOEvents), corrupting `selectedHandle`.
+  - **Fix**: `PrototypeArgs.java` — Added `parseBackslashArgWithComma()` that parses backslash
+    prototype arguments at named-unary precedence (level 15, same as `isa`) instead of comma
+    precedence (level 5). This matches Perl 5's parsing behavior where `\[$@%*]` prototypes
+    consume the variable term but not comparison/logical operators.
+  - **Effect**: Capture::Tiny's `local(*STDOUT)` now fires correctly when STDOUT is tied,
+    `selectedHandle` is properly saved/restored through `local(*STDOUT)` scopes
+  - Also cleaned up `RuntimeGlob.java` debug logging
+  - **66/73 pass** (up from 65/73)
+
+### Remaining 7 failures (Phase 7.4)
+| Test | Root Cause |
+|------|-----------|
+| `t/command-info.t` | `Compiled at:` field empty — PerlOnJava doesn't provide compile date |
+| `t/installation2.t` | Test2::Mock + Capture::Tiny crash |
+| `t/command-env.t` | Missing `local::lib` dependency |
+| `t/command-exec.t` | Missing `local::lib` dependency |
+| `t/command-make-shim.t` | Missing `local::lib` dependency |
+| `t/command-help.t` | Subprocess can't find dependencies (needs PERL5LIB) |
+| `t/09.exit_status.t` | Missing `Path::Class` dependency |

src/main/java/org/perlonjava/core/Configuration.java

@@ -33,7 +33,7 @@ public final class Configuration {
      * Automatically populated by Gradle/Maven during build.
      * DO NOT EDIT MANUALLY - this value is replaced at build time.
      */
-    public static final String gitCommitId = "f65300dfd";
+    public static final String gitCommitId = "98a17e401";
 
     /**
      * Git commit date of the build (ISO format: YYYY-MM-DD).

src/main/java/org/perlonjava/frontend/parser/PrototypeArgs.java

@@ -209,7 +209,7 @@ static ListNode consumeArgsWithPrototype(Parser parser, String prototype, boolea
 //                element.setAnnotation("context", "LIST");
 //            }
         } else {
-            parsePrototypeArguments(parser, args, prototype);
+            parsePrototypeArguments(parser, args, prototype, hasParentheses);
 
             // Check for too many arguments without parentheses only if prototype expects 2+ args
             if (!hasParentheses && countPrototypeArgs(prototype) >= 2) {
@@ -328,8 +328,9 @@ private static boolean handleOpeningParenthesis(Parser parser) {
      * @param parser    The parser instance
      * @param args      The argument list to populate
      * @param prototype The prototype string to parse
+     * @param hasParentheses Whether the function was called with explicit parentheses
      */
-    private static void parsePrototypeArguments(Parser parser, ListNode args, String prototype) {
+    private static void parsePrototypeArguments(Parser parser, ListNode args, String prototype, boolean hasParentheses) {
         boolean isOptional = false;
         boolean needComma = false;
         int skipCount = 0;  // Number of prototype characters to skip (for flattened my/our/state)
@@ -382,7 +383,7 @@ private static void parsePrototypeArguments(Parser parser, ListNode args, String
                     needComma = true;
                 }
                 case '\\' -> {
-                    i = handleBackslashArgument(parser, args, prototype, i + 1, isOptional, needComma);
+                    i = handleBackslashArgument(parser, args, prototype, i + 1, isOptional, needComma, hasParentheses);
                     needComma = true;
                 }
                 case ',' -> {
@@ -747,7 +748,7 @@ private static Node unwrapUnaryPlus(Node arg, char refType) {
     }
 
     private static int handleBackslashArgument(Parser parser, ListNode args, String prototype, int prototypeIndex,
-                                               boolean isOptional, boolean needComma) {
+                                               boolean isOptional, boolean needComma, boolean hasParentheses) {
         if (prototypeIndex >= prototype.length()) {
             parser.throwError("syntax error, incomplete backslash reference in prototype");
         }
@@ -762,7 +763,22 @@ private static int handleBackslashArgument(Parser parser, ListNode args, String
             parser.parsingTakeReference = true;
         }
 
-        Node referenceArg = parseArgumentWithComma(parser, isOptional, needComma, expectedType);
+        // Parse the backslash-prototype argument.
+        // With parentheses: always parse at comma precedence (level 5).
+        // Without parentheses:
+        //   - Single-arg prototypes (e.g. \[$@%*], \$): parse at named-unary precedence
+        //     so operators like && and == are NOT consumed. Example:
+        //     tied *STDOUT && $cond  →  (tied *STDOUT) && $cond
+        //   - Multi-arg prototypes (e.g. \$$, \$;$): parse at comma precedence
+        //     so assignment and other operators ARE consumed. Example:
+        //     sreftest my $a = 'val', $i++  →  sreftest(\(my $a = 'val'), $i++)
+        Node referenceArg;
+        boolean useNamedUnary = !hasParentheses && countPrototypeArgs(prototype) <= 1;
+        if (useNamedUnary) {
+            referenceArg = parseBackslashArgWithComma(parser, isOptional, needComma, expectedType);
+        } else {
+            referenceArg = parseArgumentWithComma(parser, isOptional, needComma, expectedType);
+        }
 
         // Restore flag
         parser.parsingTakeReference = oldParsingTakeReference;
@@ -867,6 +883,50 @@ private static Node parseRequiredArgument(Parser parser, boolean isOptional) {
         return expr;
     }
 
+    /**
+     * Parses a backslash-prototype argument at named-unary precedence.
+     *
+     * <p>Backslash prototypes like {@code \[$@%*]} expect a single variable term.
+     * In Perl, these parse at named-unary precedence (between "isa" and shift operators),
+     * so operators like {@code &&}, {@code ||}, {@code ==}, {@code <} are NOT consumed,
+     * but arithmetic operators like {@code +}, {@code *}, {@code >>} ARE consumed.</p>
+     *
+     * @param parser       The parser instance
+     * @param isOptional   Whether the argument is optional
+     * @param needComma    Whether a comma is required before the argument
+     * @param expectedType Description of the expected argument type for error messages
+     * @return The parsed argument node, or null if parsing failed and the argument was optional
+     */
+    private static Node parseBackslashArgWithComma(Parser parser, boolean isOptional, boolean needComma, String expectedType) {
+        if (isArgumentTerminator(parser)) {
+            if (!isOptional) {
+                throwNotEnoughArgumentsError(parser);
+            }
+            return null;
+        }
+
+        if (needComma && !consumeCommaIfPresent(parser, isOptional)) {
+            return null;
+        }
+
+        if (isArgumentTerminator(parser)) {
+            if (isOptional) {
+                return null;
+            }
+            throwNotEnoughArgumentsError(parser);
+        }
+
+        // Parse at named-unary precedence (level 15, same as "isa")
+        // This ensures that comparison and logical operators are NOT consumed as part of the argument
+        Node expr = parser.parseExpression(parser.getPrecedence("isa"));
+        if (expr == null) {
+            if (!isOptional) {
+                throwNotEnoughArgumentsError(parser);
+            }
+        }
+        return expr;
+    }
+
     /**
      * Checks if there are consecutive commas (like ", ,") which should be a syntax error.
      *