test(inspector): cover every plain-first-stage outcome on both resolvers (#381)

The frontend coverage gate found local-resolver-stages.mjs branches at 92.44%
(< 93). Each way an earlier stage stops being a plain first stage (no latent,
literal, missing or cyclic latent, a sampler-shaped node, a detailer) is now a
resolver test and an anchor-first-stage-* parity vector.

tests/fixtures/local-inspect/legacy-agreement.json

@@ -33,6 +33,7 @@
   "f23"
  ],
  "local_resolver": [
+  "anchor-first-stage-no-latent",
   "anchor-same-links",
   "anchor-same-links-unanchored",
   "built-chars",

tests/local_resolver_cases.py

@@ -924,7 +924,7 @@ def golden_cases():
         from tests import saver_anchor_graphs as anchor
     except ImportError:  # pragma: no cover - discover -s tests puts tests/ first
         import saver_anchor_graphs as anchor
-    for name, graph, file_name in (
+    for name, graph, file_name in [
         ("branch-3", anchor.branch_bench(), "s45_branch_3_00002_.png"),
         ("branch-unanchored", anchor.branch_bench(), None),
         ("branch-no-match", anchor.branch_bench(), "photo_00001_.png"),
@@ -948,7 +948,17 @@ def golden_cases():
             anchor.hidden_earlier_prompt(override=True),
             "out_00001_.png",
         ),
-    ):
+    ] + [
+        (f"first-stage-{kind}", anchor.first_stage_variant(kind), "final_00003_.png")
+        for kind in (
+            "no-latent",
+            "literal-latent",
+            "missing-latent",
+            "cyclic-latent",
+            "stage-shaped",
+            "detailer",
+        )
+    ]:
         cases[f"anchor-{name}"] = {"prompt": _dump(graph)}
         if file_name is not None:
             cases[f"anchor-{name}"][FILE_NAME] = file_name

tests/saver_anchor_graphs.py

@@ -179,3 +179,38 @@ def deep_prefixes(chain):
         previous = f"p{index}"
     graph["q"] = {"class_type": "DisplayText", "inputs": {"text": ["p0", 0]}}
     return graph
+
+
+def first_stage_variant(kind):
+    """``two_stage_same_conditioning`` whose first stage (63) is not plain.
+
+    ``no-latent`` drops its latent input (still plain); ``literal-latent``,
+    ``missing-latent``, ``cyclic-latent``, ``stage-shaped`` and ``detailer``
+    each make it something other than a plain first stage, so the later
+    stage stays unattributed.
+    """
+    graph = two_stage_same_conditioning()
+    inputs = graph["63"]["inputs"]
+    if kind == "no-latent":
+        del inputs["latent_image"]
+    elif kind == "literal-latent":
+        inputs["latent_image"] = "latent"
+    elif kind == "missing-latent":
+        inputs["latent_image"] = ["999", 0]
+    elif kind == "cyclic-latent":
+        graph["70"] = {"class_type": "VendorLatentOp", "inputs": {"samples": ["63", 0]}}
+        inputs["latent_image"] = ["70", 0]
+    elif kind == "stage-shaped":
+        graph["70"] = {
+            "class_type": "VendorSampler",
+            "inputs": {
+                "model": ["1", 0],
+                "positive": ["90", 0],
+                "latent_image": ["2", 0],
+            },
+        }
+        inputs["latent_image"] = ["70", 0]
+    elif kind == "detailer":
+        graph["63"]["class_type"] = "FaceDetailer"
+        inputs["image"] = ["30", 0]
+    return graph

tests/test_resolver_saver_anchor.py

@@ -133,3 +133,19 @@ class TestReviewFindings(unittest.TestCase):
                     file_name="dup_00001_.png",
                 )
                 self.assertNotEqual(result["state"], "resolved")
+
+
+class TestPlainFirstStage(unittest.TestCase):
+    def test_only_a_plain_first_stage_is_skipped(self):
+        expected = {
+            "no-latent": "resolved",
+            "literal-latent": "unresolved",
+            "missing-latent": "unresolved",
+            "cyclic-latent": "unresolved",
+            "stage-shaped": "unresolved",
+            "detailer": "unresolved",
+        }
+        for kind, state in expected.items():
+            with self.subTest(kind=kind):
+                result = _inspect(shapes.first_stage_variant(kind), "final_00003_.png")
+                self.assertEqual(result["state"], state, result["reason"])