syncade 0.7.3__tar.gz → 0.7.5__tar.gz

{syncade-0.7.3/src/syncade.egg-info → syncade-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncade
-Version: 0.7.3
+Version: 0.7.5
 Summary: External blind multi-judge review orchestrator for AI-assisted coding
 Author-email: Syncade <build@syncade.ai>
 License-Expression: Apache-2.0

{syncade-0.7.3 → syncade-0.7.5}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "syncade"
-version = "0.7.3"
+version = "0.7.5"
 description = "External blind multi-judge review orchestrator for AI-assisted coding"
 readme = "README.md"
 requires-python = ">=3.11"

{syncade-0.7.3 → syncade-0.7.5}/src/syncade/__init__.py

@@ -1,3 +1,3 @@
 """Syncade — external blind multi-judge review orchestrator."""
 
-__version__ = "0.7.3"
+__version__ = "0.7.5"

{syncade-0.7.3 → syncade-0.7.5}/src/syncade/cli/update_mode.py

@@ -21,6 +21,7 @@ import site
 import subprocess
 import sys
 from dataclasses import dataclass
+from importlib.metadata import Distribution
 from pathlib import Path
 
 import syncade
@@ -29,9 +30,6 @@ from syncade.process import SubprocessError, run_subprocess
 from syncade.update_check import _parse, _text, manifest_once
 
 _UPGRADE_TIMEOUT = 300.0
-#: Reading one version string out of a fresh interpreter. Generous, because a cold venv
-#: import is slower than it looks; short, because we already hold the operator's terminal.
-_VERSION_TIMEOUT = 60.0
 #: How far up from ``syncade/__init__.py`` an install marker can sit. A venv layout is
 #: ``<root>/lib/python3.x/site-packages/syncade/__init__.py`` — five parents to the root; the
 #: extra headroom costs nothing and covers layouts that nest one deeper.
@@ -59,6 +57,21 @@ def _in_user_site() -> bool:
     return user_site in Path(syncade.__file__).resolve().parents
 
 
+def _scoped_dist_infos() -> list[Path]:
+    """The dist-info directories beside the package that supplied this process's code."""
+    try:
+        site_packages = Path(syncade.__file__).resolve().parent.parent
+        return sorted(
+            entry
+            for entry in site_packages.iterdir()
+            if entry.name.casefold().startswith("syncade-")
+            and entry.name.casefold().endswith(".dist-info")
+            and entry.is_dir()
+        )
+    except (OSError, RuntimeError, TypeError):
+        return []
+
+
 def _read_scoped_installer() -> str:
     """Read INSTALLER from the dist-info directory that BELONGS to this syncade install.
 
@@ -71,27 +84,44 @@ def _read_scoped_installer() -> str:
     is empty string — the same as not found.  First-match would misclassify in that state,
     which contradicts the PROVE-or-refuse posture the rest of this module maintains.
     """
-    site_packages = Path(syncade.__file__).resolve().parent.parent
     found: list[str] = []
-    try:
-        for entry in site_packages.iterdir():
-            if (
-                entry.name.startswith("syncade-")
-                and entry.name.endswith(".dist-info")
-                and entry.is_dir()
-            ):
-                try:
-                    found.append((entry / "INSTALLER").read_text(encoding="utf-8").strip())
-                except OSError:
-                    pass  # No INSTALLER file — this dist-info cannot prove anything.
-    except OSError:
-        pass
+    for entry in _scoped_dist_infos():
+        try:
+            found.append((entry / "INSTALLER").read_text(encoding="utf-8").strip())
+        except OSError:
+            pass  # No INSTALLER file — this dist-info cannot prove anything.
     if not found:
         return ""
     # Contradictory entries in a broken packaging state are not proof of anything.
     return found[0] if len(set(found)) == 1 else ""
 
 
+def _read_scoped_version() -> str | None:
+    """Read ``Version`` from this syncade install's one adjacent dist-info.
+
+    The package directory is already the authoritative identity: it supplied the code running
+    this function. Reading its sibling metadata after the package manager returns sees the new
+    on-disk version without resolving the name ``syncade`` through ``sys.path`` again. A missing,
+    malformed, or duplicate dist-info is ambiguous and therefore unverifiable, never first-match.
+    """
+    candidates = _scoped_dist_infos()
+    if len(candidates) != 1:
+        return None
+    try:
+        if not (candidates[0] / "METADATA").is_file():
+            return None
+        metadata = Distribution.at(candidates[0]).metadata
+        names = metadata.get_all("Name") or []
+        versions = metadata.get_all("Version") or []
+    except Exception:  # noqa: BLE001 — broken install metadata degrades to "unverifiable".
+        return None
+    if len(names) != 1 or names[0].strip().casefold() != "syncade":
+        return None
+    if len(versions) != 1:
+        return None
+    return versions[0].strip()
+
+
 def _pip_or_unknown(where: Path | None) -> InstallMethod:
     """``pip`` when the distribution records pip as its installer, else ``unknown``.
 
@@ -239,49 +269,14 @@ def _installed_version() -> str | None:
     """The version on disk NOW, or ``None`` when it cannot be established.
 
     It CANNOT be ``syncade.__version__``: this process imported that before the upgrade ran, so
-    it is by definition the old number. A fresh interpreter re-reads the metadata the upgrade
-    just rewrote, and ``sys.executable`` is the tool venv's own python under both uv and pipx —
-    precisely the environment that changed.
+    it is by definition the old number. The value is read from the dist-info tree that belongs
+    to this install, so the answer follows the package on disk instead of any ambient metadata
+    discovery or subprocess import state.
 
     ``None`` means "could not verify", which is deliberately NOT the same as "did not change":
     the caller must not turn an unreadable version into a failure report.
     """
-    try:
-        result = run_subprocess(
-            # `-I` (isolated) is load-bearing, not tidiness. Without it the probe inherits
-            # PYTHONPATH and the user site dir, so a `sitecustomize` on that path runs inside
-            # the answer and can emit stdout before OR after the version print.
-            # `-I` keeps the venv's own site-packages, so `importlib.metadata` still finds
-            # the install (verified) — but it does NOT suppress `sitecustomize.py` that lives
-            # in those site-packages. An atexit hook registered there (syncade ships such a
-            # shim for worktree imports) can append a version-shaped line AFTER the real one.
-            # `os._exit(0)` bypasses all atexit handlers: the process terminates immediately
-            # after `os.write`, so nothing can append to our stdout (reproduced: a hostile
-            # sitecustomize turned "0.7.0" into "0.7.0\n99.0.0" before this fix).
-            # `os.write` is used instead of `print` because `os._exit` skips stdio flushing;
-            # an unbuffered syscall guarantees the version byte reaches the pipe.
-            [
-                sys.executable,
-                "-I",
-                "-c",
-                "import importlib.metadata as m, os; "
-                "os.write(1, (m.version('syncade') + '\\n').encode()); "
-                "os._exit(0)",
-            ],
-            timeout=_VERSION_TIMEOUT,
-        )
-    except SubprocessError:
-        return None
-    if result.returncode != 0:
-        return None
-    raw = result.stdout.strip()
-    if not raw:
-        return None
-    # sitecustomize from PYTHONPATH (suppressed by -I) could emit noise before -c runs;
-    # the venv's own sitecustomize can still do so. Take the LAST line — atexit is now
-    # impossible (os._exit), so the last line is what os.write put there — and validate it
-    # parses as a version. Noise that accidentally ends in a dotted string still fails _parse.
-    candidate = raw.splitlines()[-1].strip()
+    candidate = _read_scoped_version()
     return candidate if _parse(candidate) is not None else None
 
 

{syncade-0.7.3 → syncade-0.7.5}/src/syncade/config.py

@@ -327,6 +327,11 @@ def _default_reviewers() -> list[ReviewerConfig]:
     #                  model="claude-opus-4-6", adversarial_lens=True)
 
 
+def _default_worktree_base() -> Path:
+    """Resolve the worktree default when a config instance is created."""
+    return DEFAULT_WORKTREE_BASE
+
+
 class SyncadeConfig(BaseModel):
     """Top-level ``.syncade/config.toml`` schema.
 
@@ -363,7 +368,7 @@ class SyncadeConfig(BaseModel):
     # ``[worktree]`` block — Q5); default reproduces worktree.DEFAULT_WORKTREE_BASE.
     # ``--worktree-base`` overrides per-invocation; threaded into the review run and doctor preview.
     worktree_base: Path = Field(
-        default=DEFAULT_WORKTREE_BASE,
+        default_factory=_default_worktree_base,
         description=(
             "Base directory under which each run's per-reviewer/producer/test git worktrees are "
             f"created (default ``{DEFAULT_WORKTREE_BASE}``). Overridable per-run with "

{syncade-0.7.3 → syncade-0.7.5/src/syncade.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncade
-Version: 0.7.3
+Version: 0.7.5
 Summary: External blind multi-judge review orchestrator for AI-assisted coding
 Author-email: Syncade <build@syncade.ai>
 License-Expression: Apache-2.0

{syncade-0.7.3 → syncade-0.7.5}/src/syncade.egg-info/SOURCES.txt

@@ -277,6 +277,7 @@ tests/cli/test_update_mode.py
 tests/cli/test_update_notice.py
 tests/cli/test_update_post_condition.py
 tests/cli/test_validate_before_mutate.py
+tests/cli/test_version_probe.py
 tests/config/__init__.py
 tests/config/test_auth_enforcement.py
 tests/config/test_auth_modes.py

{syncade-0.7.3 → syncade-0.7.5}/tests/cli/test_update_post_condition.py

@@ -15,7 +15,6 @@ that finally held is to validate a value as the thing it claims to be, at the po
 
 from __future__ import annotations
 
-import sys
 from pathlib import Path
 
 import pytest
@@ -23,7 +22,6 @@ import pytest
 import syncade
 from syncade.cli import update_mode
 from syncade.exit_codes import SUCCESS, WORKTREE_ERROR
-from syncade.process import SubprocessError, SubprocessResult
 from tests.cli.test_update_mode import (
     _install_tree,
     _point_syncade_at,
@@ -90,62 +88,6 @@ def test_an_unverifiable_version_is_not_reported_as_failure(tmp_path, monkeypatc
     assert "updated to" not in out, "no version may be named when none was established"
 
 
-def test_the_version_probe_reads_a_fresh_interpreter_not_this_one(monkeypatch) -> None:
-    """It must not answer from `syncade.__version__`, which this process imported BEFORE the
-    upgrade and is therefore the old number by construction."""
-    seen: list[list[str]] = []
-
-    def spy(cmd, **kw):
-        seen.append(cmd)
-        return SubprocessResult(returncode=0, stdout="1.2.3\n", stderr="", duration_seconds=0.0)
-
-    monkeypatch.setattr(update_mode, "run_subprocess", spy)
-    assert update_mode._installed_version() == "1.2.3"
-    assert seen and seen[0][0] == sys.executable, "must re-invoke the interpreter, not import"
-    assert "importlib.metadata" in seen[0][-1]
-
-
-def test_an_unreadable_probe_degrades_to_none(monkeypatch) -> None:
-    for outcome in (
-        lambda *a, **k: (_ for _ in ()).throw(SubprocessError("no python")),
-        lambda *a, **k: SubprocessResult(returncode=1, stdout="", stderr="x", duration_seconds=0.0),
-        lambda *a, **k: SubprocessResult(
-            returncode=0, stdout="  \n", stderr="", duration_seconds=0.0
-        ),
-    ):
-        monkeypatch.setattr(update_mode, "run_subprocess", outcome)
-        assert update_mode._installed_version() is None
-
-
-def test_startup_noise_before_version_line_is_stripped(monkeypatch) -> None:
-    """sitecustomize imported from PYTHONPATH can emit stdout before the version print.
-
-    The old code returned the full stdout verbatim, so "noise\\n0.7.0" != "0.7.0" and
-    run_update treated the install as having moved — a false success on an unchanged version.
-    """
-    monkeypatch.setattr(
-        update_mode,
-        "run_subprocess",
-        lambda *a, **k: SubprocessResult(
-            returncode=0, stdout="startup noise\n1.2.3\n", stderr="", duration_seconds=0.0
-        ),
-    )
-    assert update_mode._installed_version() == "1.2.3"
-
-
-def test_non_version_stdout_degrades_to_none(monkeypatch) -> None:
-    """stdout that doesn't end with a parseable version string means 'could not verify'."""
-    for stdout in ("not a version\n", "noise only\n", "1.2\n", "1.2.3.4\n"):
-        monkeypatch.setattr(
-            update_mode,
-            "run_subprocess",
-            lambda *a, stdout=stdout, **k: SubprocessResult(
-                returncode=0, stdout=stdout, stderr="", duration_seconds=0.0
-            ),
-        )
-        assert update_mode._installed_version() is None, f"should be None for {stdout!r}"
-
-
 def test_an_already_current_install_is_not_reported_as_a_failed_upgrade(
     tmp_path, monkeypatch, capsys
 ) -> None:
@@ -358,71 +300,6 @@ def test_is_newest_cannot_certify_an_unparseable_installed_version(monkeypatch)
     assert update_mode._is_newest("not-a-version") is None
 
 
-def test_the_probe_is_isolated_from_ambient_interpreter_state(monkeypatch) -> None:
-    """`-I` is load-bearing: without it the probe inherits PYTHONPATH and the user site dir.
-
-    A `sitecustomize` on that path runs INSIDE the answer — an atexit hook printing a version
-    number becomes the last stdout line, so a no-op upgrade reads as a move. Reproduced live: a
-    hostile PYTHONPATH turned the probe's `"0.7.0"` into `"0.7.0\\n99.0.0"`. Syncade ships such a
-    shim itself for worktree imports, so this is not purely adversarial.
-
-    `-I` suppresses PYTHONPATH but NOT the venv's own site-packages, where a `sitecustomize.py`
-    can still register atexit hooks. The probe must call `os._exit(0)` to bypass atexit entirely —
-    the only guarantee against a venv-local hook appending to stdout after the version line.
-    `os.write` is asserted alongside it: `os._exit` skips stdio flushing, so `print()` would lose
-    the version; the unbuffered syscall guarantees delivery before the process exits.
-
-    Pinned as flag assertions because the behavioural twin below cannot run the failure case
-    without installing a real adversarial sitecustomize.
-    """
-    seen: list[list[str]] = []
-    monkeypatch.setattr(
-        update_mode,
-        "run_subprocess",
-        lambda cmd, **kw: (
-            seen.append(cmd)
-            or SubprocessResult(returncode=0, stdout="1.2.3\n", stderr="", duration_seconds=0.0)
-        ),
-    )
-    update_mode._installed_version()
-    assert seen and "-I" in seen[0], (
-        "the version probe must run isolated; without -I a sitecustomize on PYTHONPATH can "
-        "append a version number to its stdout and fake a successful upgrade"
-    )
-    assert seen[0].index("-I") < seen[0].index("-c"), "-I must precede -c to take effect"
-    c_arg = seen[0][seen[0].index("-c") + 1]
-    assert "os._exit(0)" in c_arg, (
-        "the probe must call os._exit(0) to bypass atexit handlers; a venv-local "
-        "sitecustomize can register atexit hooks that append a fake version line after the real one"
-    )
-    assert "os.write" in c_arg, (
-        "the probe must use os.write (unbuffered) not print; os._exit skips stdio flushing "
-        "so print output would be lost before reaching the pipe"
-    )
-
-
-def test_the_isolated_probe_still_resolves_the_real_install() -> None:
-    """The behavioural twin: `-I` must not break what the probe is FOR.
-
-    It drops PYTHONPATH and the user site dir but keeps the environment's own site-packages, so
-    `importlib.metadata` still finds the package. Runs the real subprocess — a flag assertion
-    alone would happily pin an isolation level that returns None for everyone.
-
-    We assert the result is a parseable, non-None version, NOT that it equals
-    `syncade.__version__`. In a dev worktree the source version and the installed distribution
-    version legitimately differ (e.g. 0.7.0 in source, 0.1.0 in site-packages); asserting
-    equality would make this test prove the ambient installation, not the probe's behaviour.
-    """
-    from syncade.update_check import _parse
-
-    result = update_mode._installed_version()
-    assert result is not None, (
-        "the probe must find the installed package under -I "
-        "(drops PYTHONPATH but keeps the environment's own site-packages)"
-    )
-    assert _parse(result) is not None, f"result {result!r} must be a parseable version string"
-
-
 # ------------------------------------------------- unreachable manifest is not a pin (field-09)
 
 
@@ -654,3 +531,6 @@ def test_doctor_skips_the_check_under_ci(monkeypatch) -> None:
     check = _check_update_manifest(enabled=True)
     assert check.status == "skip"
     assert "CI" in check.detail
+
+
+# ------------------------------------- the probe must see a user-site install (pr-h-field-10)

syncade-0.7.5/tests/cli/test_version_probe.py

@@ -0,0 +1,158 @@
+"""The post-update version comes from the exact install tree running syncade.
+
+The old probe spawned another interpreter and asked which distribution the name ``syncade``
+resolved to. Isolation could hide a user-site install; relaxing it let CWD, user-site metadata,
+``sitecustomize``, and shutdown hooks influence the answer. These tests pin the re-derived
+property instead: read fresh metadata beside ``syncade.__file__`` and never resolve the name.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+from syncade.cli import update_mode
+from syncade.exit_codes import SUCCESS
+from syncade.process import SubprocessResult
+
+
+def _metadata(version: str, *, name: str = "syncade") -> str:
+    return f"Metadata-Version: 2.1\nName: {name}\nVersion: {version}\n"
+
+
+def _install_tree(
+    tmp_path: Path, version: str = "1.2.3", *, installer: str | None = None
+) -> tuple[Path, Path]:
+    site_packages = tmp_path / "site-packages"
+    package_file = site_packages / "syncade" / "__init__.py"
+    package_file.parent.mkdir(parents=True)
+    package_file.write_text("__version__ = 'loaded-before-the-update'\n", encoding="utf-8")
+    dist_info = site_packages / f"syncade-{version}.dist-info"
+    dist_info.mkdir()
+    (dist_info / "METADATA").write_text(_metadata(version), encoding="utf-8")
+    if installer is not None:
+        (dist_info / "INSTALLER").write_text(installer, encoding="utf-8")
+    return package_file, dist_info
+
+
+def _point_syncade_at(monkeypatch: pytest.MonkeyPatch, package_file: Path) -> None:
+    monkeypatch.setattr(update_mode.syncade, "__file__", str(package_file))
+
+
+def test_reads_fresh_version_from_the_running_install_tree(tmp_path, monkeypatch) -> None:
+    package_file, dist_info = _install_tree(tmp_path, "1.2.3")
+    _point_syncade_at(monkeypatch, package_file)
+
+    assert update_mode._installed_version() == "1.2.3"
+
+    replacement = dist_info.with_name("syncade-1.2.4.dist-info")
+    dist_info.rename(replacement)
+    (replacement / "METADATA").write_text(_metadata("1.2.4"), encoding="utf-8")
+    assert update_mode._installed_version() == "1.2.4", "the post-condition must not be cached"
+
+
+def test_ambient_python_state_and_shutdown_hooks_are_not_probe_channels(
+    tmp_path, monkeypatch
+) -> None:
+    package_file, _ = _install_tree(tmp_path / "real", "1.2.3")
+    _point_syncade_at(monkeypatch, package_file)
+
+    hostile_path = tmp_path / "hostile-pythonpath"
+    hostile_path.mkdir()
+    (hostile_path / "sitecustomize.py").write_text(
+        "import atexit\nprint('98.0.0')\natexit.register(lambda: print('99.0.0'))\n",
+        encoding="utf-8",
+    )
+    cwd = tmp_path / "cwd"
+    cwd.mkdir()
+    cwd_dist = cwd / "syncade-97.0.0.dist-info"
+    cwd_dist.mkdir()
+    (cwd_dist / "METADATA").write_text(_metadata("97.0.0"), encoding="utf-8")
+    monkeypatch.chdir(cwd)
+    monkeypatch.setenv("PYTHONPATH", str(hostile_path))
+    monkeypatch.setenv("PYTHONUSERBASE", str(tmp_path / "unrelated-user-base"))
+    monkeypatch.setattr(
+        update_mode,
+        "run_subprocess",
+        lambda *a, **k: pytest.fail("reading an installed version must not spawn a subprocess"),
+    )
+
+    assert update_mode._installed_version() == "1.2.3"
+
+
+@pytest.mark.parametrize(
+    "metadata_bytes",
+    [
+        None,
+        b"\xff",
+        b"Metadata-Version: 2.1\nVersion: 1.2.3\n",
+        b"Metadata-Version: 2.1\nName: other\nVersion: 1.2.3\n",
+        b"Metadata-Version: 2.1\nName: syncade\n",
+        b"Metadata-Version: 2.1\nName: syncade\nVersion: 1.2\n",
+        b"Metadata-Version: 2.1\nName: syncade\nName: syncade\nVersion: 1.2.3\n",
+        b"Metadata-Version: 2.1\nName: syncade\nVersion: 1.2.3\nVersion: 9.9.9\n",
+    ],
+)
+def test_missing_or_malformed_metadata_is_unverifiable(
+    tmp_path, monkeypatch, metadata_bytes
+) -> None:
+    package_file, dist_info = _install_tree(tmp_path)
+    metadata_path = dist_info / "METADATA"
+    if metadata_bytes is None:
+        metadata_path.unlink()
+    else:
+        metadata_path.write_bytes(metadata_bytes)
+    _point_syncade_at(monkeypatch, package_file)
+
+    assert update_mode._installed_version() is None
+
+
+def test_duplicate_adjacent_dist_info_is_unverifiable(tmp_path, monkeypatch) -> None:
+    package_file, _ = _install_tree(tmp_path, "1.2.3")
+    site_packages = package_file.parent.parent
+    stale = site_packages / "syncade-9.9.9.dist-info"
+    stale.mkdir()
+    (stale / "METADATA").write_text(_metadata("9.9.9"), encoding="utf-8")
+    _point_syncade_at(monkeypatch, package_file)
+
+    assert update_mode._installed_version() is None
+
+
+def test_non_adjacent_metadata_and_editable_metadata_are_ignored(tmp_path, monkeypatch) -> None:
+    package_file = tmp_path / "checkout" / "src" / "syncade" / "__init__.py"
+    package_file.parent.mkdir(parents=True)
+    package_file.write_text("__version__ = '0.0.0'\n", encoding="utf-8")
+    egg_info = package_file.parent.parent / "syncade.egg-info"
+    egg_info.mkdir()
+    (egg_info / "PKG-INFO").write_text(_metadata("8.8.8"), encoding="utf-8")
+    _install_tree(tmp_path / "other-install", "9.9.9")
+    _point_syncade_at(monkeypatch, package_file)
+
+    assert update_mode._installed_version() is None
+
+
+def test_user_site_noop_update_reports_already_current(tmp_path, monkeypatch, capsys) -> None:
+    current = update_mode.syncade.__version__
+    package_file, _ = _install_tree(tmp_path, current, installer="pip")
+    site_packages = package_file.parent.parent.resolve()
+    _point_syncade_at(monkeypatch, package_file)
+    monkeypatch.setattr(update_mode.site, "getusersitepackages", lambda: str(site_packages))
+    monkeypatch.setattr(update_mode, "live_run", lambda cwd: None)
+    monkeypatch.setattr(update_mode, "_resync_skills", lambda out: True)
+    monkeypatch.setattr(update_mode, "manifest_once", lambda *, enabled=True: {"latest": current})
+    monkeypatch.delenv("CI", raising=False)
+    commands: list[list[str]] = []
+
+    def successful_package_manager(cmd, **kwargs):
+        commands.append(cmd)
+        return SubprocessResult(returncode=0, stdout="", stderr="", duration_seconds=0.0)
+
+    monkeypatch.setattr(update_mode, "run_subprocess", successful_package_manager)
+
+    assert update_mode.run_update(cwd=tmp_path) == SUCCESS
+    assert commands == [[sys.executable, "-m", "pip", "install", "-U", "--user", "syncade"]]
+    out = capsys.readouterr().err
+    assert f"already up to date ({current})" in out
+    assert "[syncade] updated." not in out

{syncade-0.7.3 → syncade-0.7.5}/tests/conftest.py

@@ -79,7 +79,7 @@ def _isolate_global_config(monkeypatch, tmp_path_factory):
 
 
 @pytest.fixture(autouse=True)
-def _isolated_worktree_base(request, tmp_path):
+def _isolated_worktree_base(request, tmp_path, monkeypatch):
     """No test may touch the SHARED worktree base — PR-h-12 item 1b.
 
     Moved here from ``tests/orchestrator/conftest.py``, where it was package-scoped. Its own
@@ -89,12 +89,12 @@ def _isolated_worktree_base(request, tmp_path):
     worktrees leaked — so the brief's original 4.4 GB attribution was wrong, exactly as it later
     corrected itself to say. The gap was real; the magnitude was not.
 
-    ``run_review`` falls back to ``config.worktree_base`` (PR-v2-9), so the PYDANTIC FIELD DEFAULT
-    is what must move: a bare ``SyncadeConfig()`` has to inherit the per-test path too.
-    ``model_rebuild(force=True)`` recompiles the core schema after the patch, and both are
-    restored at teardown so no schema state bleeds between tests.
+    ``run_review`` falls back to ``config.worktree_base`` (PR-v2-9), so the config default is what
+    must move: a bare ``SyncadeConfig()`` has to inherit the per-test path too. The field uses a
+    default factory so patching its module-level source works across the supported Pydantic range
+    without mutating Pydantic's compiled schema.
     """
-    from syncade.config import SyncadeConfig
+    from syncade import config as config_module
 
     # A DRIFT TEST must be able to see the real default. Two of them assert exactly that
     # (`SyncadeConfig().worktree_base == DEFAULT_WORKTREE_BASE`, "byte-identical"), and this
@@ -105,13 +105,12 @@ def _isolated_worktree_base(request, tmp_path):
         yield
         return
 
-    field = SyncadeConfig.model_fields["worktree_base"]
-    old_default = field.default
-    field.default = tmp_path / "syncade-worktrees"
-    SyncadeConfig.model_rebuild(force=True)
+    monkeypatch.setattr(
+        config_module,
+        "DEFAULT_WORKTREE_BASE",
+        tmp_path / "syncade-worktrees",
+    )
     yield
-    field.default = old_default
-    SyncadeConfig.model_rebuild(force=True)
 
 
 @pytest.fixture(autouse=True)

{syncade-0.7.3 → syncade-0.7.5}/tests/test_worktree_base_isolation.py

@@ -23,8 +23,8 @@ _ROOT = Path(__file__).resolve().parent
 
 
 def test_a_bare_config_never_resolves_to_the_shared_base(tmp_path: Path) -> None:
-    """The fixture patches the PYDANTIC FIELD DEFAULT, because `run_review` falls back to
-    `config.worktree_base` (PR-v2-9). Patching only an explicit argument would leave
+    """The fixture patches the default factory's source, because `run_review` falls back to
+    `config.worktree_base` (PR-v2-9). Patching only an explicit argument would leave a bare
     `SyncadeConfig()` pointing at the shared base — which is how six packages kept reaching it.
     """
     assert SyncadeConfig().worktree_base != DEFAULT_WORKTREE_BASE