Fix argdump mutex group variant names and empty descriptors

Argdump's mutex code synthesized inner names from `dest` (underscored), but
the path terminal already carried a name from `preferredName` (hyphenated
long flag). The mismatch caused the solver's variant struct field key to
diverge from the path binding's name, and the Boutiques backend emitted
empty variants. Use the existing deep terminal name when available so the
seq, path, and binding stay aligned.

The solver also stripped literal alternatives unconditionally
(`--fs-no-reconall` -> `fs-no-reconall`), ignoring any meta.name attached
by the mutex code. Prefer alt.meta.name first, fall back to literal
stripping or `variant_${i}`. This avoids value-key collisions when an
argparse dest differs from the flag.

Author: nx10

packages/core/src/backend/boutiques/boutiques.test.ts

@@ -645,6 +645,76 @@ describe("argdump -> Boutiques validity", () => {
     expect(variantNames).toContain("input_file");
   });
 
+  it("emits a populated descriptor for store-action variants in a mutex group", () => {
+    // Regression: when the mutex code synthesized seq.meta.name from `dest`
+    // (underscored), it diverged from the path terminal's name (hyphenated,
+    // from preferredName), so findStructNode could not match the binding and
+    // the variant emitted empty (just name+id, no command-line/inputs).
+    const bt = emitFromArgdump({
+      prog: "mytool",
+      actions: [
+        {
+          option_strings: ["--input-file"],
+          dest: "input_file",
+          action_type: "store",
+          type_info: { name: "Path", module: "pathlib" },
+        },
+        {
+          option_strings: ["--no-input"],
+          dest: "no_input",
+          action_type: "store_true",
+        },
+      ],
+      mutually_exclusive_groups: [
+        { required: false, actions: ["input_file", "no_input"] },
+      ],
+    });
+    const inputs = bt.inputs as Record<string, unknown>[];
+    const parent = inputs.find((i) => i.id === "input_file_or_no_input");
+    expect(parent).toBeDefined();
+    const variants = parent!.type as Record<string, unknown>[];
+    const storeVariant = variants.find((v) => v.id === "input_file");
+    expect(storeVariant).toBeDefined();
+    expect(storeVariant!["command-line"]).toBe("--input-file [INPUT_FILE]");
+    const subInputs = storeVariant!.inputs as Record<string, unknown>[];
+    expect(subInputs).toHaveLength(1);
+    expect(subInputs[0]?.id).toBe("input_file");
+    expect(subInputs[0]?.type).toBe("File");
+  });
+
+  it("uses meta.name for literal alternatives (e.g. mutex store_false dest)", () => {
+    // Regression: solver always stripped the literal value (`--fs-no-reconall`
+    // -> `fs-no-reconall`) and ignored alt.meta.name set by the mutex code,
+    // which caused value-key collisions when the dest differed from the flag.
+    const bt = emitFromArgdump({
+      prog: "petprep",
+      actions: [
+        {
+          option_strings: ["--fs-subjects-dir"],
+          dest: "fs_subjects_dir",
+          action_type: "store",
+          type_info: { name: "Path", module: "pathlib" },
+        },
+        {
+          option_strings: ["--fs-no-reconall"],
+          dest: "run_reconall",
+          action_type: "store_false",
+        },
+      ],
+      mutually_exclusive_groups: [
+        { required: false, actions: ["fs_subjects_dir", "run_reconall"] },
+      ],
+    });
+    const inputs = bt.inputs as Record<string, unknown>[];
+    const parent = inputs.find((i) => i.id === "fs_subjects_dir_or_run_reconall");
+    expect(parent).toBeDefined();
+    const variants = parent!.type as Record<string, unknown>[];
+    // The literal variant should use the dest from meta.name, not the
+    // stripped-flag fallback.
+    const variantIds = variants.map((v) => v.id).sort();
+    expect(variantIds).toEqual(["fs_subjects_dir", "run_reconall"]);
+  });
+
   it("sanitizes ids when source names contain illegal characters", () => {
     // Boutiques requires id ~ /^[0-9A-Za-z_]+$/. Argparse subparser command
     // names commonly contain hyphens (e.g. `do-thing`).

packages/core/src/frontend/argdump/parser.test.ts

@@ -935,6 +935,60 @@ describe("ArgdumpParser", () => {
       expect(nodes[0]?.meta?.name).toBe("output_format");
     });
 
+    it("inner store action keeps the deep terminal name (matches solver binding)", () => {
+      // Regression: setting inner.meta.name to dest (underscored) instead of
+      // the existing terminal name (hyphenated, from preferredName) caused the
+      // variant struct field key to drift from the path binding's name, which
+      // broke findStructNode in the Boutiques backend (variants emitted empty).
+      const result = parse(
+        minimalDescriptor({
+          actions: [
+            {
+              dest: "fs_subjects_dir",
+              action_type: "store",
+              option_strings: ["--fs-subjects-dir"],
+              type_info: { name: "Path", module: "pathlib" },
+            },
+            {
+              dest: "run_reconall",
+              action_type: "store_false",
+              option_strings: ["--fs-no-reconall"],
+            },
+          ],
+          mutually_exclusive_groups: [
+            { required: false, actions: ["fs_subjects_dir", "run_reconall"] },
+          ],
+        }),
+      );
+      const opt = actionNodes(result)[0] as Optional;
+      const alt = opt.attrs.node as Alternative;
+      // First member is the seq for --fs-subjects-dir; its name should match
+      // the inner terminal's name ("fs-subjects-dir") rather than dest.
+      const seqAlt = alt.attrs.alts[0] as Sequence;
+      expect(seqAlt.kind).toBe("sequence");
+      expect(seqAlt.meta?.name).toBe("fs-subjects-dir");
+      const pathTerminal = seqAlt.attrs.nodes[1];
+      expect(pathTerminal?.meta?.name).toBe("fs-subjects-dir");
+    });
+
+    it("falls back to dest when no deep terminal name exists", () => {
+      // Two store_true alts: the inner is a bare literal, so there is no
+      // deeper name to inherit and we should still synthesize one from dest.
+      const result = parse(
+        minimalDescriptor({
+          actions: [
+            { dest: "json", action_type: "store_true", option_strings: ["--json"] },
+            { dest: "xml", action_type: "store_true", option_strings: ["--xml"] },
+          ],
+          mutually_exclusive_groups: [{ required: false, actions: ["json", "xml"] }],
+        }),
+      );
+      const opt = actionNodes(result)[0] as Optional;
+      const alt = opt.attrs.node as Alternative;
+      expect(alt.attrs.alts[0]?.meta?.name).toBe("json");
+      expect(alt.attrs.alts[1]?.meta?.name).toBe("xml");
+    });
+
     it("required group -> alt() without optional wrapper", () => {
       const result = parse(
         minimalDescriptor({

packages/core/src/frontend/argdump/parser.ts

@@ -19,6 +19,24 @@ import type {
   SourceLocation,
 } from "../frontend.js";
 
+// Find the deepest existing name in a subtree, mirroring solver semantics.
+// Used by the mutex code so the synthesized inner name matches the binding
+// name the solver will produce for the same subtree.
+function findDeepName(node: Expr): string | undefined {
+  if (node.meta?.name) return node.meta.name;
+  if (node.kind === "optional" || node.kind === "repeat") {
+    return findDeepName(node.attrs.node);
+  }
+  if (node.kind === "sequence") {
+    for (const child of node.attrs.nodes) {
+      if (child.kind === "literal") continue;
+      const name = findDeepName(child);
+      if (name) return name;
+    }
+  }
+  return undefined;
+}
+
 // Type guards
 
 function isObject(x: unknown): x is Record<string, unknown> {
@@ -744,7 +762,11 @@ export class ArgdumpParser implements Frontend {
         inner.meta = {
           ...outerMeta,
           ...inner.meta,
-          name: inner.meta?.name ?? dest,
+          // Prefer the deepest existing name in the subtree so the synthesized
+          // name matches the binding the solver derives for the same node.
+          // Otherwise findDeepName short-circuits on the inner's new name and
+          // the variant struct's field key drifts from the binding name.
+          name: inner.meta?.name ?? findDeepName(inner) ?? dest,
         };
         altMembers.push(inner);
         excluded.add(dest);

packages/core/src/solver/solver.ts

@@ -144,9 +144,10 @@ export function solve(expr: Expr, options?: SolveOptions): SolveResult {
             (alt.kind === "literal" ? literalFromNode(alt) : { kind: "bool" as const });
 
           const name =
-            alt.kind === "literal"
+            alt.meta?.name ??
+            (alt.kind === "literal"
               ? alt.attrs.str.replace(/^-+/, "")
-              : (alt.meta?.name ?? `variant_${i}`);
+              : `variant_${i}`);
 
           return { name, type: childType, node: alt };
         });