topos-node 1.3.57__tar.gz → 1.4.1__tar.gz

{topos_node-1.3.57/topos_node.egg-info → topos_node-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.57
+Version: 1.4.1
 Summary: Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://topos.dialogues.ai
@@ -63,6 +63,7 @@ Provides-Extra: dev
 Requires-Dist: pytest~=9.0.3; extra == "dev"
 Requires-Dist: pytest-asyncio~=1.3.0; extra == "dev"
 Requires-Dist: httpx~=0.28.1; extra == "dev"
+Requires-Dist: hypothesis<7,>=6.100; extra == "dev"
 Dynamic: license-file
 
 <div align="center">

{topos_node-1.3.57 → topos_node-1.4.1}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "topos-node"
-version = "1.3.57"
+version = "1.4.1"
 description = "Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client"
 readme = "README.md"
 license = "Apache-2.0"
@@ -109,6 +109,7 @@ dev = [
   "pytest~=9.0.3",
   "pytest-asyncio~=1.3.0",
   "httpx~=0.28.1",
+  "hypothesis>=6.100,<7",
 ]
 
 [project.scripts]
@@ -168,6 +169,8 @@ markers = [
   "bhlr: black-hole leak-rate probe (entity black hole); tier-1 CI gate, must find zero leaks",
   "eval_nightly: statistical privacy eval (attacker advantage, minimality, latency); nightly",
   "eval_release: release-tier privacy eval (negotiation A/B, Pareto); run per release",
+  "fuzz: the permissions v2 property-based lane (Hypothesis; confidence program C5)",
+  "ordinal_ids_retired: run with p2a-v1/v2 releases refused, as the node does (tests/permissions_v2/conftest.py)",
 ]
 pythonpath = ["tests/gap/p3/engine", "tests/gap/p4/engine", "tests/gap/qq/engine", "tests/acceptance/wiki_mvp", "tests/evals/time_signal"]
 testpaths = ["tests"]

{topos_node-1.3.57 → topos_node-1.4.1}/shared/filtering.py

@@ -5,7 +5,7 @@ from datetime import datetime
 from enum import Enum
 from typing import Any, Dict, Iterable, List, Literal, Optional
 
-from pydantic import BaseModel, Field, field_validator, model_validator
+from pydantic import BaseModel, Field, StrictStr, field_validator, model_validator
 
 
 class FilterCategory(str, Enum):
@@ -530,6 +530,31 @@ class FilterManifest(BaseModel):
     manifest_version: int = Field(1, ge=1)
     filters: List[FilterInstance] = Field(default_factory=list)
     provenance: Optional[FilterManifestProvenance] = None
+    access_mode_ceiling: Optional[Literal["summary", "inference", "raw"]] = None
+    scope_table_allowlist: Optional[Dict[StrictStr, List[StrictStr]]] = None
+
+    @field_validator("access_mode_ceiling", mode="before")
+    @classmethod
+    def normalize_ceiling(cls, value: Any) -> Any:
+        # Mirror of the control plane's validator (ported from the held sharing
+        # hotfix 1dd65995; BEFORE_PROD_REVIEW P0-10). The query lane decodes stored
+        # grant envelopes through this model (topos/uma_filters.query_filter_manifest),
+        # so a stored ceiling whose spelling differs would otherwise raise here and
+        # fail that grant's reads instead of being read as the ceiling it names.
+        if isinstance(value, str):
+            value = value.strip().lower()
+            return value or None
+        return value
+
+    @field_validator("scope_table_allowlist")
+    @classmethod
+    def validate_scope_table_allowlist(cls, value):
+        if value is None:
+            return None
+        for scope, tables in value.items():
+            if not scope or scope != scope.strip() or any(not table or table != table.strip() for table in tables):
+                raise ValueError("scope/table IDs must be nonempty canonical strings")
+        return {scope: sorted(set(tables)) for scope, tables in value.items()}
 
     def to_storage_dict(self) -> Dict[str, Any]:
         return self.model_dump(exclude_none=True, mode="json")
@@ -591,21 +616,11 @@ def _merge_param_values(filter_id: str, existing: Dict[str, Any], incoming: Dict
             if end is None or str(incoming_end) < str(end):
                 merged["end"] = incoming_end
         return merged
-    if filter_id == "source_filter":
-        current = set(str(item) for item in merged.get("source_ids", []))
-        incoming_values = set(str(item) for item in incoming.get("source_ids", []))
-        if current and incoming_values:
-            merged["source_ids"] = sorted(current & incoming_values)
-        elif incoming_values:
-            merged["source_ids"] = sorted(incoming_values)
-        return merged
-    if filter_id == "column_allowlist":
-        current = set(str(item) for item in merged.get("fields", []))
-        incoming_values = set(str(item) for item in incoming.get("fields", []))
-        if current and incoming_values:
-            merged["fields"] = sorted(current & incoming_values)
-        elif incoming_values:
-            merged["fields"] = sorted(incoming_values)
+    if filter_id in {"source_filter", "column_allowlist"}:
+        key = "source_ids" if filter_id == "source_filter" else "fields"
+        # These are validated, required lists. Missing the entire filter means
+        # unrestricted; a present empty list is bottom and absorbs every meet.
+        merged[key] = sorted(set(merged[key]) & set(incoming[key]))
         return merged
     if filter_id == "column_blocklist":
         current = set(str(item) for item in merged.get("fields", []))
@@ -650,9 +665,20 @@ def merge_filter_manifests(
     provenance: Optional[FilterManifestProvenance] = None,
 ) -> FilterManifest:
     merged_instances: Dict[str, FilterInstance] = {}
+    ceiling = None
+    table_allowlist = None
     for manifest in manifests:
         if manifest is None:
             continue
+        if manifest.access_mode_ceiling is not None:
+            ranks = {"summary": 0, "inference": 1, "raw": 2}
+            if ceiling is None or ranks[manifest.access_mode_ceiling] < ranks[ceiling]:
+                ceiling = manifest.access_mode_ceiling
+        if manifest.scope_table_allowlist is not None:
+            if table_allowlist is None:
+                table_allowlist = {}
+            for scope, tables in manifest.scope_table_allowlist.items():
+                table_allowlist[scope] = sorted(set(tables) & set(table_allowlist[scope])) if scope in table_allowlist else sorted(set(tables))
         for item in manifest.filters:
             key = _manifest_merge_key(item)
             existing = merged_instances.get(key)
@@ -667,4 +693,6 @@ def merge_filter_manifests(
     return FilterManifest(
         filters=sorted(merged_instances.values(), key=lambda item: (_manifest_merge_key(item), item.filter_id)),
         provenance=provenance,
+        access_mode_ceiling=ceiling,
+        scope_table_allowlist=table_allowlist,
     )

topos_node-1.4.1/tests/test_hub_pipeline_offline_first.py

@@ -0,0 +1,210 @@
+"""A cached model loads with no Hub request; only a cache miss talks to the Hub.
+
+The boot of 2026-09-25 sat for hours in a Hub GET that carries no timeout
+(transformers' tokenizer loader listing chat templates), with the tray on
+"preparing models (0 of 2)" and every later caller of the privacy-filter slot
+waiting behind it. These tests pin the shape that avoids the request entirely:
+tokenizer and model built with `local_files_only=True` first, handed to
+`pipeline()` as objects, and the Hub consulted only after that attempt fails
+the way transformers fails a cache miss. They drive a fake `transformers` so no
+weights are needed; the real loads were measured at zero requests.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+import types
+
+import pytest
+
+from topos.sanitization import hub_pipeline
+
+REPO = "example/some-classifier"
+CACHE_MISS = OSError(
+    "We couldn't connect to 'https://huggingface.co' to load the files, "
+    "and couldn't find them in the cached files."
+)
+
+
+class Calls:
+    def __init__(self) -> None:
+        self.from_pretrained: list[tuple[str, str, dict]] = []
+        self.pipeline: list[tuple[str, object, dict]] = []
+
+
+def fake_transformers(
+    calls: Calls, *, cached: bool = True, model_error: BaseException | None = None
+):
+    """The four names load_pipeline touches, recording every call.
+
+    `cached=False` is an empty cache: every `local_files_only` load raises the
+    OSError transformers raises for one. `model_error` is raised by the model
+    head's loader on top of that.
+    """
+    mod = types.ModuleType("transformers")
+
+    def _auto(name: str, error: BaseException | None = None):
+        class Auto:
+            @classmethod
+            def from_pretrained(cls, model_id: str, **kwargs):
+                calls.from_pretrained.append((name, model_id, kwargs))
+                if not cached and kwargs.get("local_files_only"):
+                    raise CACHE_MISS
+                if error is not None:
+                    raise error
+                return (name, model_id)
+
+        Auto.__name__ = name
+        return Auto
+
+    mod.AutoTokenizer = _auto("AutoTokenizer")
+    mod.AutoModelForTokenClassification = _auto("AutoModelForTokenClassification", model_error)
+    mod.AutoModelForSequenceClassification = _auto("AutoModelForSequenceClassification", model_error)
+
+    def pipeline(task: str, model, **kwargs):
+        calls.pipeline.append((task, model, kwargs))
+        return ("pipeline", task, model, kwargs)
+
+    mod.pipeline = pipeline
+    return mod
+
+
+@pytest.fixture
+def calls(monkeypatch):
+    calls = Calls()
+    monkeypatch.setitem(sys.modules, "transformers", fake_transformers(calls))
+    return calls
+
+
+def _load(model_class: str = "AutoModelForTokenClassification", **kwargs):
+    return hub_pipeline.load_pipeline(
+        "token-classification", REPO, model_class=model_class, **kwargs
+    )
+
+
+def test_a_cached_model_loads_both_parts_offline_and_hands_pipeline_objects(calls):
+    handle = _load(device="cpu")
+
+    assert calls.from_pretrained == [
+        ("AutoTokenizer", REPO, {"local_files_only": True}),
+        ("AutoModelForTokenClassification", REPO, {"local_files_only": True}),
+    ]
+    # pipeline() gets objects, so it has nothing left to resolve against the Hub.
+    assert calls.pipeline == [
+        (
+            "token-classification",
+            ("AutoModelForTokenClassification", REPO),
+            {"tokenizer": ("AutoTokenizer", REPO), "device": "cpu"},
+        )
+    ]
+    assert handle[0] == "pipeline"
+
+
+def test_a_cold_cache_fails_the_offline_attempt_and_loads_through_the_hub(
+    monkeypatch, caplog
+):
+    calls = Calls()
+    monkeypatch.setitem(sys.modules, "transformers", fake_transformers(calls, cached=False))
+
+    with caplog.at_level(logging.INFO, logger="topos.sanitization.hub_pipeline"):
+        _load(device="cpu")
+
+    # The tokenizer is the first thing asked for, and the first to refuse.
+    assert calls.from_pretrained == [("AutoTokenizer", REPO, {"local_files_only": True})]
+    assert calls.pipeline == [("token-classification", REPO, {"device": "cpu"})]
+    assert "loading from the Hub" in caplog.text
+
+
+def test_a_file_the_loader_wants_but_the_cache_lacks_is_a_cache_miss_too(monkeypatch):
+    """A newer transformers may ask for a file an older download never fetched."""
+    calls = Calls()
+    monkeypatch.setitem(
+        sys.modules, "transformers", fake_transformers(calls, model_error=CACHE_MISS)
+    )
+
+    _load()
+
+    assert [name for name, _repo, _kw in calls.from_pretrained] == [
+        "AutoTokenizer",
+        "AutoModelForTokenClassification",
+    ]
+    assert calls.pipeline == [("token-classification", REPO, {})]
+
+
+def test_a_failure_that_is_not_a_cache_miss_propagates_without_a_hub_retry(monkeypatch):
+    """A wedged torch load is not fixed by a download; the retry would reopen the hang."""
+    calls = Calls()
+    monkeypatch.setitem(
+        sys.modules, "transformers", fake_transformers(calls, model_error=RuntimeError("mps wedged"))
+    )
+
+    with pytest.raises(RuntimeError, match="mps wedged"):
+        _load()
+
+    assert calls.pipeline == []
+
+
+def test_an_unknown_model_class_fails_before_anything_loads(calls):
+    with pytest.raises(AttributeError):
+        _load(model_class="AutoModelForNoSuchHead")
+
+    assert calls.from_pretrained == []
+    assert calls.pipeline == []
+
+
+class _PassThroughCache:
+    """The slot cache without residency bookkeeping: run the loader, hand back its result."""
+
+    def acquire(self, slot, model_id, loader):
+        return loader(), False
+
+
+def test_the_privacy_filter_loads_through_the_cache_first(calls, monkeypatch):
+    from topos.engine import model_cache
+    from topos.sanitization import privacy_filter
+
+    repo = privacy_filter.PRIVACY_FILTER_MODEL_ID
+    monkeypatch.setattr(privacy_filter, "_resolve_device", lambda: "cpu")
+    monkeypatch.setattr(model_cache, "get_model_cache", lambda: _PassThroughCache())
+
+    privacy_filter._get_pipeline(repo)
+
+    assert [(name, kw) for name, _repo, kw in calls.from_pretrained] == [
+        ("AutoTokenizer", {"local_files_only": True}),
+        ("AutoModelForTokenClassification", {"local_files_only": True}),
+    ]
+    ((task, model, kwargs),) = calls.pipeline
+    assert task == "token-classification"
+    assert model == ("AutoModelForTokenClassification", repo)
+    assert kwargs == {"tokenizer": ("AutoTokenizer", repo), "device": "cpu"}
+
+
+def test_the_nsfw_classifier_loads_through_the_cache_first_and_keeps_every_label(
+    calls, monkeypatch
+):
+    from topos.engine import model_cache
+    from topos.sanitization import nsfw_classifier
+
+    repo = nsfw_classifier.DEFAULT_NSFW_CLASSIFIER_MODEL
+    monkeypatch.setattr(model_cache, "get_model_cache", lambda: _PassThroughCache())
+
+    nsfw_classifier._get_pipeline(repo)
+
+    assert [(name, kw) for name, _repo, kw in calls.from_pretrained] == [
+        ("AutoTokenizer", {"local_files_only": True}),
+        ("AutoModelForSequenceClassification", {"local_files_only": True}),
+    ]
+    ((task, model, kwargs),) = calls.pipeline
+    assert task == "text-classification"
+    assert model == ("AutoModelForSequenceClassification", repo)
+    # top_k=None is what makes the classifier return both labels, not only the top one.
+    assert kwargs == {"tokenizer": ("AutoTokenizer", repo), "top_k": None}
+
+
+def test_settings_switch_off_the_safetensors_conversion_probe():
+    """The `.bin` conversion thread is four un-timed Hub GETs `local_files_only` does not stop."""
+    import topos.config.settings  # noqa: F401  (set at import, like the progress-bar default)
+
+    assert os.environ.get("DISABLE_SAFETENSORS_CONVERSION") == "1"

topos_node-1.4.1/tests/test_lane_shards.py

@@ -0,0 +1,219 @@
+"""CI runs the public lane as slices; together they must still be the whole lane.
+
+ci.yml's job matrix runs one job per slice of tests/lane_shards.py. Ways that
+silently stop testing something, none of which turns anything red on its own:
+- a slice defined in the table but missing from the matrix: its tests never
+  run anywhere;
+- a matrix `exclude:`/`include:`, a `continue-on-error`, or an `if:` on the lane
+  step: a slice is skipped, or its red is forgiven;
+- the packaging job skipped behind a red lane: GitHub counts "skipped" as
+  passing for a required check;
+- a prefix that no longer names a real path after a rename: its tests fall to
+  `rest`, which still runs them, but the balance the table was measured for is
+  gone and nobody is told.
+This file fails on each. It runs in every slice (lane_shards.EVERY_SLICE), so no
+one slice's removal takes it along. It also pins the ownership rule that makes
+the slices a partition.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from tests import lane_shards
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+CI_WORKFLOW = REPO_ROOT / ".github" / "workflows" / "ci.yml"
+
+
+def _ci_text() -> str:
+    return CI_WORKFLOW.read_text(encoding="utf-8")
+
+
+def _ci_matrix_shards() -> list[str]:
+    """The `shard: [...]` list in ci.yml, textually, like its sibling guard
+    tests/test_local_gate_composition.py reads the `run:` lines."""
+    found = re.findall(r"^\s*shard:\s*\[([^\]]*)\]\s*$", _ci_text(), re.MULTILINE)
+    assert len(found) == 1, f"expected one `shard: [...]` matrix in {CI_WORKFLOW}, found {found}"
+    return [name.strip() for name in found[0].split(",") if name.strip()]
+
+
+def test_the_ci_matrix_names_every_slice_exactly_once() -> None:
+    names = _ci_matrix_shards()
+    assert sorted(names) == sorted(lane_shards.SHARDS), (
+        f"ci.yml's matrix {names} and tests/lane_shards.py's slices "
+        f"{sorted(lane_shards.SHARDS)} disagree. A slice missing from the matrix "
+        "is a slice of the lane that CI never runs."
+    )
+
+
+def test_the_ci_lane_step_runs_the_matrix_slice() -> None:
+    """Without the flag every job would run the whole lane: nothing lost, four times the minutes."""
+    lane_lines = [
+        line for line in _ci_text().splitlines()
+        if re.match(r"^\s*run:\s*uv run pytest tests\s", line)
+    ]
+    assert lane_lines, f"no `run: uv run pytest tests ...` line in {CI_WORKFLOW}"
+    assert all(f"{lane_shards.OPTION} ${{{{ matrix.shard }}}}" in line for line in lane_lines), lane_lines
+
+
+def _ci_job(name: str) -> str:
+    """One job of ci.yml, textually: from its key to the next job key."""
+    match = re.search(
+        rf"^  {re.escape(name)}:\s*\n(.*?)(?=^  [A-Za-z0-9_-]+:\s*$|\Z)",
+        _ci_text(), re.MULTILINE | re.DOTALL,
+    )
+    assert match is not None, f"no `{name}` job in {CI_WORKFLOW}"
+    return match.group(1)
+
+
+def _ci_step(job: str, step_name: str) -> str:
+    match = re.search(
+        rf"- name: {re.escape(step_name)}\s*\n(.*?)(?=^\s*- name:|\Z)", job, re.MULTILINE | re.DOTALL,
+    )
+    assert match is not None, f"no `{step_name}` step"
+    return match.group(1)
+
+
+def test_nothing_in_the_lane_job_skips_a_slice_or_forgives_its_red() -> None:
+    job = _ci_job("public-lane")
+    for word in ("exclude:", "include:", "continue-on-error"):
+        assert word not in job, (
+            f"ci.yml's public-lane job now says `{word}`. That can skip a slice or turn a red "
+            "slice green while the matrix list still names it; the slices are the lane."
+        )
+    lane_step = _ci_step(job, "Run public test lane")
+    assert not re.search(r"^\s*if:", lane_step, re.MULTILINE), (
+        "the lane step has an `if:`, so some slice can skip its tests and still pass"
+    )
+
+
+def test_the_package_job_goes_red_with_the_lane() -> None:
+    """Not merely skipped: a skipped job reports as passing to a required check."""
+    job = _ci_job("test-and-package")
+    assert re.search(r"^\s*needs:\s*public-lane\s*$", job, re.MULTILINE), job
+    assert re.search(r"^    if:\s*\$\{\{\s*!cancelled\(\)\s*\}\}\s*$", job, re.MULTILINE), (
+        "test-and-package must run when a slice is red (and only skip on cancel), so that its "
+        "check goes red with the lane instead of reporting `skipped`"
+    )
+    first_step = re.search(r"^\s*steps:\s*\n\s*- name: ([^\n]+)\n(.*?)(?=^\s*- name:)", job,
+                           re.MULTILINE | re.DOTALL)
+    assert first_step is not None, job
+    body = first_step.group(2)
+    assert "needs.public-lane.result != 'success'" in body and "exit 1" in body, (
+        f"the first step of test-and-package ({first_step.group(1)!r}) must fail the job when "
+        "the lane did not pass, before any gated step runs"
+    )
+
+
+def test_every_prefix_still_names_tests() -> None:
+    for name, prefixes in lane_shards.SHARDS.items():
+        for prefix in prefixes:
+            if prefix.endswith("/"):
+                held = list((REPO_ROOT / prefix).rglob("test_*.py"))
+            else:
+                parent = (REPO_ROOT / prefix).parent
+                held = list(parent.glob(Path(prefix).name + "*.py"))
+            assert held, (
+                f"slice {name!r} claims {prefix!r}, which holds no test files any more. "
+                "Its tests now run in `rest`; move the prefix and re-measure the balance "
+                "(tests/lane_shards.py says how)."
+            )
+
+
+def test_no_prefix_is_claimed_twice() -> None:
+    """A tie would go to whichever slice the dict lists first, silently."""
+    claimed = [p for prefixes in lane_shards.SHARDS.values() for p in prefixes]
+    assert len(claimed) == len(set(claimed)), claimed
+
+
+@pytest.mark.parametrize(
+    ("nodeid", "owner"),
+    [
+        ("tests/permissions_v2/test_evidence.py::test_x", "permissions_v2"),
+        # the longer prefix wins over tests/permissions_v2/
+        ("tests/permissions_v2/test_message_search_index.py::test_x", "message_search_gap"),
+        ("tests/gap/p3/engine/test_x.py::TestY::test_z[a-b]", "message_search_gap"),
+        ("tests/features/test_x.py::test_y", "features_topos_core"),
+        ("tests/topos/test_x.py::test_y", "features_topos_core"),
+        ("tests/core/test_x.py::test_y", "features_topos_core"),
+        ("tests/query/test_x.py::test_y", "rest"),
+        ("tests/test_profiles.py::test_x", "rest"),
+        # a directory prefix does not claim a sibling that merely shares its name
+        ("tests/topos_home_pin_test.py::test_x", "rest"),
+        # added after the table was written: runs in `rest`, never dropped
+        ("tests/a_directory_added_later/test_x.py::test_y", "rest"),
+    ],
+)
+def test_the_most_specific_prefix_owns_an_item(nodeid: str, owner: str) -> None:
+    assert lane_shards.shard_of(nodeid) == owner
+
+
+class _Config:
+    def __init__(self, shard):
+        self._shard = shard
+        self.deselected: list = []
+        self.hook = SimpleNamespace(pytest_deselected=lambda items: self.deselected.extend(items))
+
+    def getoption(self, name):
+        assert name == "lane_shard"
+        return self._shard
+
+
+def _items(*nodeids):
+    return [SimpleNamespace(nodeid=n) for n in nodeids]
+
+
+def test_a_slice_keeps_what_it_owns_and_deselects_the_rest() -> None:
+    items = _items(
+        "tests/permissions_v2/test_evidence.py::test_x",
+        "tests/permissions_v2/test_message_search_state.py::test_x",
+        "tests/query/test_x.py::test_y",
+    )
+    config = _Config("rest")
+    lane_shards.deselect_other_shards(config, items)
+    assert [i.nodeid for i in items] == ["tests/query/test_x.py::test_y"]
+    assert len(config.deselected) == 2
+
+
+def test_without_the_option_nothing_is_deselected() -> None:
+    items = _items("tests/permissions_v2/test_evidence.py::test_x", "tests/query/test_x.py::test_y")
+    config = _Config(None)
+    lane_shards.deselect_other_shards(config, items)
+    assert len(items) == 2 and config.deselected == []
+
+
+def test_the_slices_partition_any_set_of_items() -> None:
+    """Every item goes to exactly one slice, so running every slice runs every item
+    once; the only exception is the guard in EVERY_SLICE, which runs in each."""
+    guard = "tests/test_lane_shards.py::test_the_ci_matrix_names_every_slice_exactly_once"
+    nodeids = [
+        "tests/permissions_v2/test_evidence.py::test_x",
+        "tests/permissions_v2/test_message_search_state.py::test_x",
+        "tests/gap/p1/engine/test_x.py::test_y",
+        "tests/features/test_x.py::test_y",
+        "tests/query/test_x.py::test_y",
+        "tests/test_profiles.py::test_x",
+        "tests/a_directory_added_later/test_x.py::test_y",
+    ]
+    kept = []
+    for shard in lane_shards.SHARDS:
+        items = _items(*nodeids, guard)
+        lane_shards.deselect_other_shards(_Config(shard), items)
+        assert guard in [i.nodeid for i in items], shard
+        kept.extend(i.nodeid for i in items if i.nodeid != guard)
+    assert sorted(kept) == sorted(nodeids)
+
+
+def test_this_guard_runs_in_every_slice() -> None:
+    """Placed in one slice, it could not see that slice taken out of the matrix."""
+    here = f"tests/{Path(__file__).name}::test_this_guard_runs_in_every_slice"
+    assert here.startswith(lane_shards.EVERY_SLICE)
+    for shard in lane_shards.SHARDS:
+        items = _items(here)
+        lane_shards.deselect_other_shards(_Config(shard), items)
+        assert len(items) == 1, shard