test(core): reproduce the two shapes the canonical ingest refuses on real code

A frozen 21-repository benchmark could not run: the ingest oracle refused
18 of them, on documents this CLI produced. Neither shape existed in any
fixture, which is why the path was never proven on data -- the wire-freeze
corpus itself records that segment groups stayed 0 in the very corpus built
to stop families rotting at zero rows.

Both shapes now have a fixture and a pin. The singleton segment group is
not a group the producer never made: all 378 measured singletons came from
two or more raw windows that merge_overlapping_items folded, and the 67
groups that survived are exactly the gap-separated ones. The wire keeps no
trace of the fold. The namespace-package endpoint refuses in the live
producer-native path too, not only in the oracle, so the owner is the
identity index rather than the grammar.

Two markers stay strict-xfail: which of the two contracts is right is the
maintainer's call, and the pins hold the refusal messages verbatim until
it is made.

Author: orenlab

tests/conftest.py

@@ -80,6 +80,33 @@
 # containers at once.
 _WIRE_FREEZE_CORPUS_F8 = Path(__file__).parent / "fixtures" / "wire_freeze_corpus_f8"
 
+# The F8-singleton distinguishing stage (its own tree, its own CLI run).
+# Measured 2026-09-05 on 21 frozen external repositories: the segment lane
+# emits clone groups carrying exactly ONE item -- 378 of them, across 17 of
+# the 21 members -- and ``CloneGroupRow`` refuses a group of one, so those
+# documents cannot be ingested at all.  No fixture in this suite had ever
+# carried the shape: the base corpus pins segment groups at zero and this
+# repository emits no clones family whatsoever, so the segment path was
+# never proven on data.  The stage carries BOTH merge branches that produce
+# the shape -- overlapping windows and adjacent windows -- because
+# ``merge_overlapping_items`` reaches them through different comparisons and
+# a stage carrying one would leave the other unproven.
+_WIRE_FREEZE_CORPUS_F8_SINGLETON = (
+    Path(__file__).parent / "fixtures" / "wire_freeze_corpus_f8_singleton"
+)
+
+# The F7-namespace distinguishing stage (its own tree, its own CLI run).
+# Measured 2026-09-05: the dependency lane emits an edge whose endpoint is a
+# NAMESPACE PACKAGE -- ``packaging`` in kivy, ``pyglet.experimental`` in
+# pyglet -- which ``metrics.dependencies._is_internal_target`` admits as
+# internal precisely because it is a ``package_prefixes`` node, while
+# ``build_identity_index`` is assembled from file-bearing ``(path, module)``
+# pairs alone and so cannot resolve it.  ``nsp/`` carries no ``__init__.py``:
+# that absence is the whole point of the stage, and adding one erases it.
+_WIRE_FREEZE_CORPUS_F7_NAMESPACE = (
+    Path(__file__).parent / "fixtures" / "wire_freeze_corpus_f7_namespace"
+)
+
 # The post-baseline stage: materialized only after the baseline is written,
 # so its clone pair is the corpus's one genuinely NEW novelty row.
 _WIRE_FREEZE_POST_BASELINE = "pkg/clones_three.py"
@@ -218,6 +245,42 @@ def corpus_f5_report(
     return _corpus_document(report_path)
 
 
+@pytest.fixture(scope="session")
+def corpus_f8_singleton_report(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> dict[str, object]:
+    """One single-stage F8-singleton corpus run (no baseline: the segment
+    lane is an analysis-tier fact of the current run).
+
+    The stage exists to carry the one clone-group shape the ingest oracle
+    refuses, so that the refusal is measured on a document this project's
+    own CLI produced rather than on an external checkout.
+    """
+    root = tmp_path_factory.mktemp("wire_freeze_corpus_f8_singleton")
+    report_path = root / "corpus.report.json"
+    _materialize_corpus_tree(_WIRE_FREEZE_CORPUS_F8_SINGLETON, root)
+    _run_corpus_cli([str(root), "--json", str(report_path), "--no-progress"])
+    return _corpus_document(report_path)
+
+
+@pytest.fixture(scope="session")
+def corpus_f7_namespace_report(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> dict[str, object]:
+    """One single-stage F7-namespace corpus run (no baseline: the dependency
+    lane is an analysis-tier fact of the current run).
+
+    ``_materialize_corpus_tree`` copies ``*.txt`` carriers only, so the
+    namespace package stays a directory without ``__init__.py`` -- the
+    condition the stage measures.
+    """
+    root = tmp_path_factory.mktemp("wire_freeze_corpus_f7_namespace")
+    report_path = root / "corpus.report.json"
+    _materialize_corpus_tree(_WIRE_FREEZE_CORPUS_F7_NAMESPACE, root)
+    _run_corpus_cli([str(root), "--json", str(report_path), "--no-progress"])
+    return _corpus_document(report_path)
+
+
 # ---------------------------------------------------------------------------
 # The run-store serving corpus: what an MCP execution serves from RAM beside
 # the canonical run the same execution published.

tests/fixtures/wire_freeze_corpus_f7_namespace/nsp/leaf.py.txt

@@ -0,0 +1,5 @@
+"""A module inside a namespace package: ``nsp/`` carries no ``__init__``."""
+
+
+def leaf_value() -> int:
+    return 1

tests/fixtures/wire_freeze_corpus_f7_namespace/pyproject.toml.txt

@@ -0,0 +1,4 @@
+[tool.codeclone]
+# The full-run ingest oracle refuses a document whose ``source_facts.semantic``
+# is null, so every stage meant to be ingested whole carries the switch.
+semantic_authority = true

tests/fixtures/wire_freeze_corpus_f7_namespace/user.py.txt

@@ -0,0 +1,13 @@
+"""Imports the namespace package itself.
+
+``metrics.dependencies._is_internal_target`` admits the target because it
+is a ``package_prefixes`` node, so the producer emits the edge; the module
+registry has no file-bearing entry for ``nsp`` because a namespace package
+owns no ``__init__.py``.
+"""
+
+from nsp import leaf
+
+
+def use_leaf() -> int:
+    return leaf.leaf_value()

tests/fixtures/wire_freeze_corpus_f8_singleton/pkg/__init__.py.txt

@@ -0,0 +1 @@
+"""Two segment hosts whose repeated run is no longer than the sliding window."""

tests/fixtures/wire_freeze_corpus_f8_singleton/pkg/adjacent_host.py.txt

@@ -0,0 +1,29 @@
+"""A six-statement run repeated back-to-back: period == window size.
+
+The two windows that carry one segment hash are ADJACENT (the second starts
+on the line after the first ends), so ``merge_overlapping_items`` folds them
+into one span too -- adjacency and overlap are separate merge branches, and
+a stage carrying only one of them would leave the other unproven.
+"""
+
+
+def adjacent_host(base: int) -> int:
+    seed = base * 2
+    limit = seed + 3
+    scale = limit - 1
+    step = scale + 4
+    acc = step + 1
+    if acc > 0:
+        acc = acc - 1
+    values = [acc]
+    values.append(acc + 2)
+    total = sum(values)
+    label = str(total)
+    acc = step + 1
+    if acc > 0:
+        acc = acc - 1
+    values = [acc]
+    values.append(acc + 2)
+    total = sum(values)
+    label = str(total)
+    return len(label)

tests/fixtures/wire_freeze_corpus_f8_singleton/pkg/overlap_host.py.txt

@@ -0,0 +1,28 @@
+"""A three-statement run repeated three times: period < window size.
+
+The two windows that carry one segment hash OVERLAP (the second starts
+inside the first), so ``merge_overlapping_items`` folds them into one span
+and the emitted group reaches the document carrying a single item.
+"""
+
+
+def overlap_host(base: int) -> int:
+    seed = [base, base]
+    limit = len(seed) + 3
+    scale = max(limit, 1)
+    values = list(seed)
+    count = len(values)
+    width = count * 2
+    acc = scale + 1
+    if acc > 0:
+        acc = acc - 1
+    values.append(acc)
+    acc = scale + 1
+    if acc > 0:
+        acc = acc - 1
+    values.append(acc)
+    acc = scale + 1
+    if acc > 0:
+        acc = acc - 1
+    values.append(acc)
+    return len(values) + count + width

tests/fixtures/wire_freeze_corpus_f8_singleton/pyproject.toml.txt

@@ -0,0 +1,4 @@
+[tool.codeclone]
+# The full-run ingest oracle refuses a document whose ``source_facts.semantic``
+# is null, so every stage meant to be ingested whole carries the switch.
+semantic_authority = true