Prioritize matching parentheses

I’m writing a grammar for a language where a variable can be declared with the structure of: ‘let variable_name value’, where ‘variable_name’ is the name of the variable and ‘value’ is the value, and the value can be any literal, constant, etc., but it cannot be a built-in command/primitive. Parentheses are allowed around the value, it shouldn’t make a difference. However, if I try to test something like ‘let variable_name (command)’ (where ‘command’ is a built-in command/primitive), then ‘(’ is parsed as part of the value, and ‘command)’ is parsed as the next command in the program, and the apparent error is the lack of matching parentheses.
I would like the parentheses to be matched as much as possible, so ‘let variable_name (command)’ would be parsed as two command statements: ‘let variable_name’ and ‘(command)’, and then I can lint that the first is missing an argument.
Is there a way to prioritize grammar rules that only sometimes overlap, such as giving matching parentheses priority over ensuring command statements have enough arguments? I’ve tried precedence, but I can’t get it to work, so the relevant rules from my grammar file at this point are:

@precedence {
  paren @left,
  lastArgs @left
NewVariableDeclaration {
  Let newVariableName !lastArgs Value
Value {
  Parenthetical<Value> |
  List |
  CodeBlock |
  VariableName |
Parenthetical<content> {
  OpenParen !paren content !paren CloseParen

I don’t see how the parentheses could ever be parsed in a non-matching way, for any reasonable set of rules. Unless you somehow include them in a bigger token? I can’t see what’s going on from the rules you pasted, in any case.

I named the tokens in the @token part of the grammar, but otherwise they are never by themselves. When I look at some examples, ‘let variable_name command’ is parsed correctly as two separate CommandStatements, with the first one missing an argument (Value), but it seems like because both CommandStatements and Values can have parentheses, the parser would prefer to have two malformed components (e.g. a Parenthetical missing all but the OpenParen, and a Parenthetical missing an OpenParen), rather than no malformed pieces and a missing part, and I wasn’t sure if there was a way to prioritize that, or if there were any other pieces of advice that might help with the grammar?
My grammar is pretty big at this point, so I’m trying to only share relevant things, but perhaps these would also help to see?

@top Program {
Embedded {
(CommandStatement | Parenthetical)+ ~global
CommandStatement {
Command0Args | NewVariableDeclaration

@tokens {
OpenParen { “(” }
CloseParen { “)” }

So this is about how the parser parses content with syntax errors in it? There’s not much you can do to influence that.