fix: keep the agnostic scan inside its own tree

A filename-agnostic core accepts any name for its BIOS, so the builder
scans the directory holding the candidates. It picked that directory
from a first-hit lookup by name, the one piece of evidence that lands
in another emulator's tree: five files answer to GameIndex.yaml and one
belongs to an Android package, rom1.bin is a PS2 ROM and a Roland
SC-55 ROM. One wrong match became every file beside it, flattened into
the BIOS root of platforms that do not run that emulator: 45 files in
the Recalbox pack, 170 in the RetroArch one.

Four things decide it now. A destination and the repo layout meet on a
tail, so the path index is tried from the longest tail down and never
to the bare filename; that alone corrects seven files, among them the
Japanese GameCube slot, which held the US dump. A seed has to declare
the shape it is looking for, since no shape means the whole directory.
An ambiguous name needs the profile's other files to agree before the
scan walks anywhere. What the scan emits carries the SHA-1 it selected,
so packing never resolves it by name again.

scripts/common.py

@@ -664,15 +664,24 @@ def resolve_local_file(
     # is identity evidence only when no content hash was declared.  A stale
     # or incorrect destination can therefore never mask a hash mismatch.
     if dest_hint and by_path_suffix:
-        for match_sha1 in by_path_suffix.get(dest_hint, []):
-            if match_sha1 in files_db:
+        # A destination is written from the emulator's point of view
+        # ("pcsx2/resources/GameIndex.yaml") and the index from the repo's
+        # layout, so the two meet on a tail rather than on the whole string.
+        # Longest tail first, and never down to the bare filename: that is the
+        # weaker step below, and five files answer to GameIndex.yaml.
+        hint_parts = dest_hint.split("/")
+        for start in range(len(hint_parts) - 1):
+            for match_sha1 in by_path_suffix.get("/".join(hint_parts[start:]), []):
+                if match_sha1 not in files_db:
+                    continue
                 path = files_db[match_sha1]["path"]
-                if os.path.exists(path):
-                    if not has_strong_hash:
-                        return path, "path_exact"
-                    status = _record_match_status(match_sha1)
-                    if status:
-                        return path, status
+                if not os.path.exists(path):
+                    continue
+                if not has_strong_hash:
+                    return path, "path_exact"
+                status = _record_match_status(match_sha1)
+                if status:
+                    return path, status
 
     # 3. No MD5 = any file with that name or alias (existence check)
     def _size_ok(match_sha1: str) -> bool:

scripts/generate_pack.py

@@ -861,44 +861,57 @@ def _collect_emulator_extras(
             if not any(f.get("agnostic") for f in profile.get("files", [])):
                 continue
 
+        # Where each of this profile's files resolves.  A scan anchored on one
+        # filename walks into whatever tree that name happens to hit: rom1.bin
+        # is a PS2 ROM and a Roland SC-55 ROM, GameIndex.yaml belongs to four
+        # PS2 profiles and to an Android package.  One match is not evidence
+        # of a directory; two files of the same profile agreeing is.
+        resolved_dirs: dict[int, str] = {}
+        named_only: set[int] = set()
+        agnostic_votes: dict[str, int] = {}
+        for candidate in profile.get("files", []):
+            if not isinstance(candidate, dict):
+                continue
+            local, status = resolve_local_file(
+                candidate, db, dest_hint=candidate.get("path", "")
+            )
+            if not local or "/" not in local:
+                continue
+            directory = local.rsplit("/", 1)[0]
+            if directory.endswith("/.variants"):
+                directory = directory[: -len("/.variants")]
+            resolved_dirs[id(candidate)] = directory + "/"
+            if not (resolution_is_hash_exact(status) or status == "path_exact"):
+                named_only.add(id(candidate))
+            agnostic_votes[directory + "/"] = (
+                agnostic_votes.get(directory + "/", 0) + 1
+            )
+
         for f in profile.get("files", []):
             if not is_profile_agnostic and not f.get("agnostic"):
                 continue
             fname = f.get("name", "")
             if not fname:
                 continue
+            # An agnostic BIOS mode says the BIOS filename is free, not that
+            # every file the emulator loads is.  A free filename still has a
+            # known shape, and that shape is what identifies a candidate: an
+            # entry declaring no size takes the whole directory, which is how
+            # the flag icons of an Android package walked into a PS2 pack.
+            if f.get("category", "bios") != "bios":
+                continue
+            if not (f.get("size") or f.get("min_size") or f.get("max_size")):
+                continue
 
-            # Derive path prefix from the representative file in the DB
-            path_prefix = None
-            sha1_list = by_name.get(fname, [])
-            for sha1 in sha1_list:
-                entry = files_db.get(sha1, {})
-                path = entry.get("path", "")
-                if path:
-                    parts = path.rsplit("/", 1)
-                    if len(parts) == 2:
-                        path_prefix = parts[0] + "/"
-                    break
-
-            if not path_prefix:
-                # Fallback: try other files in the profile for the same system
-                for other_f in profile.get("files", []):
-                    if other_f is f:
-                        continue
-                    other_name = other_f.get("name", "")
-                    for sha1 in by_name.get(other_name, []):
-                        entry = files_db.get(sha1, {})
-                        path = entry.get("path", "")
-                        if path:
-                            parts = path.rsplit("/", 1)
-                            if len(parts) == 2:
-                                path_prefix = parts[0] + "/"
-                            break
-                    if path_prefix:
-                        break
-
+            path_prefix = resolved_dirs.get(id(f), "")
             if not path_prefix:
                 continue
+            # A name matching one file identifies it. A name matching several
+            # identifies nothing on its own, so the profile's other files have
+            # to agree on the directory before the scan walks it.
+            ambiguous = id(f) in named_only and len(by_name.get(fname, [])) > 1
+            if ambiguous and agnostic_votes.get(path_prefix, 0) < 2:
+                continue
 
             # Size criteria from the file entry
             min_size = f.get("min_size", 0)
@@ -928,6 +941,12 @@ def _collect_emulator_extras(
                     {
                         "name": scan_name,
                         "destination": dest,
+                        # The scan already holds the entry it selected, so it
+                        # names it by content.  Emitting the filename alone
+                        # sent the packing step back to a by-name lookup, and
+                        # three PS2 resources came back from another
+                        # emulator's copy of the same filename.
+                        "sha1": sha1,
                         "required": False,
                         "hle_fallback": False,
                         "source_emulator": profile.get("emulator", emu_name),