@@ -138,8 +138,18 @@ def add(self, record: dict[str, Any], path: str, manufacturer: str) -> None:
             return
         if not isinstance(slug, str) or not slug:
             return
-        self.slugs.setdefault(slug, path)
-        self.keys.setdefault(self._key(slug), path)
+        names: list[object] = [slug]
+        if self.category == "smartphone":
+            # A variant record (".../2022/galaxy-m33-5g/sm-m336b.json") names
+            # its phone in base_model_slug and in its folder.
+            names.append(record.get("base_model_slug"))
+            parts = path.split("/")
+            if len(parts) == 5:
+                names.append(parts[3])
+        for name in names:
+            if isinstance(name, str) and name:
+                self.slugs.setdefault(name, path)
+                self.keys.setdefault(self._key(name), path)
         if self.category == "gpu":
             self.families.setdefault(gpu_family_key(slug), path)
 
 
@@ -5,6 +5,12 @@
 SoC catalog, and emit candidates only for phones whose SoC is already
 curated — the validator enforces ``smartphone.soc`` foreign-key integrity
 so unknown SoCs would otherwise tank the whole dataset.
+
+A row is a phone only when it names one model and at least one spec parses.
+Captions, year dividers, legends and the attribute rows of transposed
+comparison tables name no phone; "iPhone 13 Pro / 13 Pro Max" names two.
+Records go to ``smartphone/<brand>/<year>/<slug>.json``, so a row without a
+release date is never written.
 """
 
 from __future__ import annotations
@@ -13,7 +19,7 @@
 from collections.abc import Iterator
 from pathlib import Path
 
-from bs4 import BeautifulSoup
+from bs4 import BeautifulSoup, Tag
 
 from app.coverage.curated import curated_slugs
 from app.coverage.normalize import slugify
@@ -25,16 +31,16 @@
     parse_date_period,
     parse_ram_gb,
     parse_weight_g,
+    release_date_of,
 )
 from .base import IngestCandidate
-from .wikitable import parse_table
+from .wikitable import _detect_headers, _table_to_grid
 
 PAGES: list[tuple[str, str]] = [
     ("samsung", "List_of_Samsung_Galaxy_smartphones"),
     ("apple", "List_of_iPhone_models"),
     ("google", "Pixel_(smartphone)"),
     ("oneplus", "List_of_OnePlus_products"),
-    ("xiaomi", "List_of_Xiaomi_smartphones"),
 ]
 
 # Brand keys are stored lowercase; these are their display forms used to
@@ -59,6 +65,13 @@
 # product family (Snapdragon / Dimensity / Exynos / Tensor / Kirin) and drop
 # only the company name. Apple is the exception — "Apple A17 Pro" slugs as
 # ``a17-pro`` because "Apple" is the family identifier, not a vendor prefix.
+# Citation markers left in model cells ("Galaxy Ace 3 [ 35 ]").
+_FOOTNOTE_RE = re.compile(r"\s*\[\s*[\w\s]{1,6}\]")
+# A product word named twice means two phones in one cell ("iPhone 5 iPhone 5c").
+_PRODUCT_WORD_RE = re.compile(r"\b(?:iphone|galaxy|pixel|oneplus|redmi|poco)\b", re.IGNORECASE)
+# Without one of these the row is not a phone (a caption, a legend, a spec label).
+_SPEC_FIELDS = ("soc", "release_date", "ram_gb", "battery_mah", "weight_g")
+
 _SOC_VENDOR_PREFIXES = (
     "qualcomm",
     "mediatek",
@@ -110,19 +123,64 @@ def _extract(
         soup = BeautifulSoup(html, "html.parser")
         source_url = f"https://en.wikipedia.org/wiki/{page}"
         for table in soup.select("table.wikitable"):
-            for row in parse_table(table, HEADER_RULES):
-                model = row.cells.get("model", "")
+            for cells in _rows(table):
+                model = _FOOTNOTE_RE.sub("", cells.get("model", "")).strip()
+                if "/" in model or len(_PRODUCT_WORD_RE.findall(model)) > 1:
+                    continue  # two phones in one cell; splitting would guess the names
                 slug = slugify(model, manufacturer=brand)
                 if len(slug) < 3:
                     continue
-                yield _build_candidate(
+                candidate = _build_candidate(
                     brand=brand,
                     model=model,
                     slug=slug,
-                    row=row.cells,
+                    row=cells,
                     source_url=source_url,
                     known_socs=known_socs,
                 )
+                if any(candidate.record.get(field) is not None for field in _SPEC_FIELDS):
+                    yield candidate
+
+
+def _rows(table: Tag) -> Iterator[dict[str, str]]:
+    """Body rows of ``table`` keyed by field, the way ``wikitable.parse_table``
+    reads them, and also through a two-row header: under "Release(d)" spanning
+    "With OS" and "Date", the release date is the "Date" column, and the
+    second header row is not a phone.
+    """
+    grid = _table_to_grid(table)
+    detected = _detect_headers(grid, HEADER_RULES) if grid else None
+    if detected is None:
+        return
+    header, mapping = detected
+    model_column = min(column for column, field in mapping.items() if field == "model")
+    start = header + 1
+    if (
+        start < len(grid)
+        and model_column < len(grid[start])
+        and grid[start][model_column] == grid[header][model_column]
+    ):
+        leaves = grid[start]
+        dates = {
+            column
+            for column, field in mapping.items()
+            if field == "release_date" and column < len(leaves) and "date" in leaves[column].lower()
+        }
+        if dates:
+            mapping = {
+                column: field
+                for column, field in mapping.items()
+                if field != "release_date" or column in dates
+            }
+        start += 1
+    for row in grid[start:]:
+        cells: dict[str, str] = {}
+        for column, text in enumerate(row):
+            field = mapping.get(column)
+            if field and text:
+                cells.setdefault(field, text)
+        if cells:
+            yield cells
 
 
 def soc_text_to_slug(text: str) -> str:
@@ -157,7 +215,7 @@ def _build_candidate(
     known_socs: set[str],
 ) -> IngestCandidate:
     release_period = parse_date_period(row.get("release_date", ""))
-    release_date = release_period[0] if release_period else None
+    release_date = release_date_of(release_period)
     soc_text = row.get("soc", "")
     soc_slug = soc_text_to_slug(soc_text)
     soc_value = soc_slug if soc_slug in known_socs else None
@@ -191,7 +249,11 @@ def _build_candidate(
     required = ("soc", "release_date", "ram_gb", "battery_mah", "weight_g", "os")
     missing = tuple(field for field in required if record.get(field) in (None, ""))
 
-    output_path = Path("smartphone") / brand / f"{slug}.json"
+    year = release_date.year if release_date else "unknown"
+    output_path = Path("smartphone") / brand / str(year) / f"{slug}.json"
+    # The layout files a phone under its release year; without one there is no
+    # folder to put it in, even as a draft.
+    problems = () if release_date else ("no release date to file it under",)
 
     return IngestCandidate(
         category="smartphone",
@@ -201,5 +263,6 @@ def _build_candidate(
         source_url=source_url,
         output_path=output_path,
         missing_fields=missing,
+        problems=problems,
         released_by=release_period[1] if release_period else None,
     )
@@ -126,3 +126,25 @@ def test_rows_sharing_a_slug_that_only_fill_different_fields_do_not_conflict(
     assert result.written == [first]
     assert result.skipped_same_run == [second]
 
+
+def test_smartphone_variant_folder_and_base_model_count_as_on_file(tmp_path: Path) -> None:
+    variant = tmp_path / "smartphone" / "samsung" / "2022" / "galaxy-m33-5g" / "sm-m336b.json"
+    variant.parent.mkdir(parents=True)
+    variant.write_text(
+        json.dumps({"slug": "sm-m336b", "base_model_slug": "galaxy-m33"}), encoding="utf-8"
+    )
+
+    def phone(slug: str) -> IngestCandidate:
+        return IngestCandidate(
+            category="smartphone",
+            manufacturer="samsung",
+            slug=slug,
+            record={"slug": slug, "name": slug},
+            source_url="https://example.test/phones",
+            output_path=Path("smartphone/samsung/2022") / f"{slug}.json",
+        )
+
+    folder, base = phone("galaxy-m33-5g"), phone("galaxy-m33")
+    result = run([folder, base], data_root=tmp_path)
+    assert not result.written
+    assert result.skipped_existing == [folder, base]
@@ -7,7 +7,7 @@
 
 import pytest
 
-from app.ingest.sources.wikipedia_smartphone import WikipediaSmartphoneIngest
+from app.ingest.sources.wikipedia_smartphone import PAGES, WikipediaSmartphoneIngest
 
 _HTML = """
 <html><body>
@@ -76,7 +76,7 @@ def test_extracts_phone_with_known_soc(
     assert ultra.record["os"] == "Android 15"
     assert ultra.record["verified"] is False
     assert ultra.is_complete
-    assert ultra.output_path.as_posix() == "smartphone/samsung/galaxy-s25-ultra.json"
+    assert ultra.output_path.as_posix() == "smartphone/samsung/2025/galaxy-s25-ultra.json"
 
 
 def test_unknown_soc_renders_candidate_incomplete() -> None:
@@ -93,3 +93,48 @@ def test_unknown_soc_renders_candidate_incomplete() -> None:
     assert ultra.record["soc"] is None
     assert "soc" in ultra.missing_fields
     assert not ultra.is_complete
+
+
+def _phones(html: str) -> dict[str, object]:
+    candidates = WikipediaSmartphoneIngest._extract(
+        html, "apple", "List_of_iPhone_models", known_socs=set()
+    )
+    return {c.slug: c for c in candidates}
+
+
+_IPHONE_HTML = """
+<table class="wikitable">
+  <tr><th rowspan="2">Model</th><th colspan="2">Release</th><th rowspan="2">RAM</th></tr>
+  <tr><th>With OS</th><th>Date</th></tr>
+  <tr><td>iPhone 5s [ 12 ]</td><td>iOS 7</td><td>September 20, 2013</td><td>1 GB</td></tr>
+  <tr><td>iPhone 13 Pro / 13 Pro Max</td><td>iOS 15</td><td>September 24, 2021</td>
+      <td>6 GB</td></tr>
+  <tr><td>iPhone 5 iPhone 5c</td><td>iOS 6</td><td>September 21, 2012</td><td>1 GB</td></tr>
+  <tr><td>iPhone 2027 lineup</td><td></td><td></td><td></td></tr>
+  <tr><td>iPhone SE (2nd gen)</td><td>iOS 13</td><td>2020</td><td>3 GB</td></tr>
+</table>
+"""
+
+
+def test_two_row_release_header_reads_the_date_leaf() -> None:
+    phones = _phones(_IPHONE_HTML)
+    five_s = phones["iphone-5s"]
+    assert five_s.record["release_date"] == "2013-09-20"  # type: ignore[attr-defined]
+    assert five_s.output_path.as_posix() == (  # type: ignore[attr-defined]
+        "smartphone/apple/2013/iphone-5s.json"
+    )
+
+
+def test_rows_naming_two_phones_or_no_spec_are_dropped() -> None:
+    phones = _phones(_IPHONE_HTML)
+    assert set(phones) == {"iphone-5s", "iphone-se-2nd-gen"}
+
+
+def test_phone_without_a_release_date_is_never_written() -> None:
+    se = _phones(_IPHONE_HTML)["iphone-se-2nd-gen"]
+    assert se.record["release_date"] is None  # type: ignore[attr-defined]
+    assert se.problems == ("no release date to file it under",)  # type: ignore[attr-defined]
+
+
+def test_missing_list_pages_are_not_fetched() -> None:
+    assert "List_of_Xiaomi_smartphones" not in {page for _, page in PAGES}