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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.4.0
+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

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

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "topos-node"
-version = "1.4.0"
+version = "1.4.1"
 description = "Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client"
 readme = "README.md"
 license = "Apache-2.0"

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

{topos_node-1.4.0 → topos_node-1.4.1}/tests/test_topos_home_hermeticity.py

@@ -163,6 +163,125 @@ def test_conftest_pins_every_topos_home_default_outside_any_home() -> None:
     )
 
 
+# -- the session defaults: what a hop that outlives its test's pin resolves --------
+
+
+def test_between_tests_the_session_defaults_hold_not_an_unset_variable(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """``monkeypatch.undo()`` takes back every autouse pin at once (they share this
+    one monkeypatch), which is the state between two tests. At module event-loop
+    scope the pipeline worker's last sweep hop runs there, and it opens and
+    migrates whatever database path it finds (2026-09-24). Until then that was
+    the variable's absence.
+    """
+    from tests import topos_home_pin
+    from topos.config.settings import settings
+    from topos.core import state
+    from topos.storage.db.paths import DATABASE_FILENAME, active_base
+
+    monkeypatch.undo()
+    session = topos_home_pin.session_values()
+    assert set(session) == set(topos_home_pin.SESSION_DEFAULT_ENV)
+    real_topos = os.path.realpath(os.path.join(live_db_watch.REAL_HOME, ".topos"))
+    for name, value in session.items():
+        assert os.environ.get(name) == value, f"{name} was left {os.environ.get(name)!r}"
+        assert not os.path.realpath(value).startswith(real_topos + os.sep), (name, value)
+    database = Path(session["TOPOS_DATABASE_PATH"])
+    assert settings.topos_database_path == str(database)
+    assert state._resolve_database_path_from_settings() == database
+    if str(database) == topos_home_pin.session_default_paths()["TOPOS_DATABASE_PATH"]:
+        # Nothing exported: the settings route and the active_base route name ONE file.
+        assert active_base() / DATABASE_FILENAME == database
+
+
+def test_per_test_pins_win_over_the_session_defaults_inside_a_test(
+    _live_db_guard_path: str, _scope_shadow_guard_dir: Path
+) -> None:
+    """The session defaults must never reach INTO a test: one shared database let
+    tests poison each other (see ``_live_db_guard_path``). Moving them into
+    ``PINNED_ENV`` would do exactly that, because ``repin_env`` runs after
+    ``_no_live_db_guard`` at setup; this is the test that fails then.
+    """
+    from tests import topos_home_pin
+    from topos.config.settings import settings
+    from topos.core import state
+    from topos.query import scope_shadow
+    from topos.storage.db.migrations.backup import backup_dir_for
+
+    session = topos_home_pin.session_values()
+    own_db = Path(_live_db_guard_path)
+    assert os.environ["TOPOS_DATABASE_PATH"] == str(own_db) != session["TOPOS_DATABASE_PATH"]
+    assert settings.topos_database_path == str(own_db)
+    assert state._resolve_database_path_from_settings() == own_db
+    assert backup_dir_for(own_db) == own_db.parent / "backups" != Path(session["TOPOS_BACKUP_DIR"])
+    assert scope_shadow.default_log_path() == _scope_shadow_guard_dir / "scope_shadow.jsonl"
+    assert scope_shadow.default_log_path() != Path(session["TOPOS_SCOPE_SHADOW_LOG"])
+
+
+def test_an_exported_path_is_kept_unless_it_points_into_owner_data(tmp_path: Path) -> None:
+    """``just test-owner-db-eval`` exports its snapshot and the lane's modules read
+    it at collection, so an export is kept. One into ``~/.topos`` is replaced.
+    Against a throwaway root armed as owner data, never the real one.
+    """
+    from tests import topos_home_pin
+
+    owner = tmp_path / "pretend-home" / ".topos"
+    owner.mkdir(parents=True)
+    pinned = {
+        name: str(tmp_path / "session" / rel)
+        for name, rel in topos_home_pin.SESSION_DEFAULT_ENV.items()
+    }
+    snapshot = str(tmp_path / "topos-owner-snapshot-x.db")
+    with live_db_watch.watching_root(owner):
+        chosen, replaced = topos_home_pin._choose_session_defaults(
+            {
+                "TOPOS_DATABASE_PATH": snapshot,
+                "TOPOS_BACKUP_DIR": str(owner / "backups"),
+                "TOPOS_SCOPE_SHADOW_LOG": "  ",
+            },
+            pinned,
+        )
+        into_owner, replaced_db = topos_home_pin._choose_session_defaults(
+            {"TOPOS_DATABASE_PATH": str(owner / "database.db")}, pinned
+        )
+    assert chosen == {
+        "TOPOS_DATABASE_PATH": snapshot,
+        "TOPOS_BACKUP_DIR": pinned["TOPOS_BACKUP_DIR"],
+        "TOPOS_SCOPE_SHADOW_LOG": pinned["TOPOS_SCOPE_SHADOW_LOG"],
+    }
+    assert replaced == {"TOPOS_BACKUP_DIR": str(owner / "backups")}  # blank is unset
+    assert into_owner["TOPOS_DATABASE_PATH"] == pinned["TOPOS_DATABASE_PATH"]
+    assert replaced_db == {"TOPOS_DATABASE_PATH": str(owner / "database.db")}
+
+
+def test_a_session_default_changed_without_monkeypatch_is_put_back_after_teardown(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """A raw change would otherwise become the NEXT test's "original": its
+    monkeypatch records the leaked value and restores it after every later test.
+    """
+    import inspect
+
+    from tests import conftest, topos_home_pin
+    from topos.config.settings import settings
+
+    monkeypatch.undo()
+    session = topos_home_pin.session_values()
+    try:
+        os.environ.pop("TOPOS_BACKUP_DIR", None)
+        os.environ["TOPOS_SCOPE_SHADOW_LOG"] = "/elsewhere/scope_shadow.jsonl"
+        settings.topos_database_path = None
+        topos_home_pin.restore_session_defaults()
+        assert {name: os.environ.get(name) for name in session} == session
+        assert settings.topos_database_path == session["TOPOS_DATABASE_PATH"]
+    finally:
+        topos_home_pin.restore_session_defaults()
+    assert "topos_home_pin.restore_session_defaults()" in inspect.getsource(
+        conftest.pytest_runtest_logfinish
+    ), "nothing calls it after teardown, so the property above is untested where it matters"
+
+
 @pytest.mark.asyncio
 async def test_presence_lifespan_with_a_control_plane_leaves_home_untouched(
     scratch_home: Path, tmp_path: Path, monkeypatch: pytest.MonkeyPatch

{topos_node-1.4.0 → topos_node-1.4.1}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.4.0"
-__version_info__ = (1, 4, 0)
+__version__ = "1.4.1"
+__version_info__ = (1, 4, 1)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.4.0 → topos_node-1.4.1}/topos/config/settings.py

@@ -12,6 +12,12 @@ from topos.config.local_model_builds import tag_for_this_machine
 
 # Set before any huggingface_hub import during app/route loading.
 os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1")
+# A `.bin` checkpoint makes transformers start a background thread that asks the
+# Hub for a safetensors conversion PR: four GETs with no timeout, past every
+# `local_files_only` guard (topos/sanitization/hub_pipeline.py has the boot that
+# hung in a Hub call). The node never asks the Hub to convert checkpoints for it.
+# setdefault: an operator who wants the probe exports "0".
+os.environ.setdefault("DISABLE_SAFETENSORS_CONVERSION", "1")
 
 
 DEFAULT_TOPOS_CONTROL_PLANE_URL = "wss://cp.logu3s.com/ws/engine"

{topos_node-1.4.0 → topos_node-1.4.1}/topos/permissions_v2/release.py

@@ -171,12 +171,16 @@ def source_message_decision(policy: PolicyV2, evidence: QualifiedEvidence) -> De
         missing_context_codes=["classification"] if verdict == "indeterminate" else [])
 
 
-def _file_shadow_index(ledger, *, request_id, grant_id, records, record_key, now) -> None:
+def _file_shadow_index(ledger, *, request_id, grant_id, records, identities, record_key, now) -> None:
     """File this release in the node's shadow index, if the node keeps one. Never raises into a release.
 
     Placed here rather than inside `_checkpoint` because the grant's record key lives on this side: the ledger
     has no key and must not grow one. A release whose index write fails is counted by `shadow_index.failures()`
-    and shows up later as an `records_unavailable` re-score, which is the visible form of the hole.
+    and shows up later as a `records_unavailable_*` re-score, which is the visible form of the hole.
+
+    `identities` are the released rows' canonical identities, in the records' order. They are what the sealed
+    pointer must hold: under p2a-v3 a record's own id is the opaque one, and a pointer to that could never find
+    its row again (every p2a-v3 re-score at e848f512 answered `records_unavailable`).
     """
     from . import shadow_index
     if not shadow_index.enabled():
@@ -184,7 +188,7 @@ def _file_shadow_index(ledger, *, request_id, grant_id, records, record_key, now
     try:
         with ledger._transaction() as conn:
             shadow_index.record_release(conn, request_id=request_id, grant_id=grant_id, records=records,
-                                        record_key=record_key, now=now)
+                                        identities=identities, record_key=record_key, now=now)
     except Exception:  # noqa: BLE001 -- an unauditable read is still a correct read
         shadow_index._count_failure()
 
@@ -262,21 +266,23 @@ class SourceMessageRelease:
                                   now=self.clock())
                     raise PolicyError("permission_denied")
                 key = self._record_key(signed) if signed.capability_version == CAPABILITY_OPAQUE else None
-                records = []
+                released = []
                 for ref in qualified.snapshot.leaves:
                     row = rows[_key(ref.identity)]
                     identity = ref.identity
                     record_id = identity.record_id if key is None else opaque_record_id(key, grant_id=signed.grant_id,
                         table=identity.table, source_id=identity.source_id, dataset_id=identity.dataset_id,
                         record_id=identity.record_id)
-                    records.append({"record_id": record_id, "source_id": identity.source_id,
-                                    "canonical_table": identity.table, "content": row.get("content")})
+                    released.append(({"record_id": record_id, "source_id": identity.source_id,
+                                      "canonical_table": identity.table, "content": row.get("content")}, identity))
                 if key is not None:
                     # The canonical ids are gone from the ids, but the LIST was still ordered by
                     # them (the snapshot sorts leaves by their canonical identity), which ranks
                     # the records the owner's store holds. Under an opaque view the order is the
-                    # opaque one, which says nothing a recipient did not already hold.
-                    records.sort(key=lambda record: record["record_id"])
+                    # opaque one, which says nothing a recipient did not already hold. Each record
+                    # keeps its own identity through the sort: the shadow index seals that.
+                    released.sort(key=lambda pair: pair[0]["record_id"])
+                records = [record for record, _identity in released]
                 output = disclosure.parse({"family": "canonical_record", "operation": "read", "view_id": view, "records": records})
                 if not records or len(canonical_bytes(output.model_dump())) > MAX_DISCLOSURE_BYTES:
                     raise PolicyError("disclosure_budget")
@@ -292,7 +298,8 @@ class SourceMessageRelease:
                 # (permissions_v2/shadow_index.py). Ids and a sealed pointer, never content; off unless the node
                 # is told otherwise; and inside its own try, so a release is never a casualty of being auditable.
                 _file_shadow_index(ledger, request_id=request_id, grant_id=signed.grant_id, records=output.records,
-                                   record_key=key, now=self.clock())
+                                   identities=[identity for _record, identity in released], record_key=key,
+                                   now=self.clock())
                 checked_at = self.clock()
                 verify_current_signature(signed, trusted_keys=ledger.trusted_keys, now=checked_at)
                 result = sign_node_result(ReleaseBody(version="topos-node-disclosure/v1",