The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Plugin survival + upgrade contracts (mnemosyne-oss/mnemosyne#859).
Hermes-side contracts an external memory-provider wrapper can hold us to,
exercised through PUBLIC paths (no source inspection, no network — uv
resolves offline local path-source fixtures):
1. Sidecar isolation. A wrapper plugin exposes NO dependency surface at
the scanned plugin root (no pyproject.toml, no legacy dep keys); a
pyproject belonging to a nested or external sidecar dir must NOT
join the pm workspace union, because pm scans only plugin roots.
2. Conflict admission. Through the PUBLIC admission authority
(hermes_cli.plugins_admission.admit_plugin_set_change — the one path
`hermes plugins enable/install` use), a candidate union with no
valid solution is REFUSED before anything is published: the
candidate stays unenabled (so the loader never imports it), the
plugin trees and every home's config.yaml survive untouched, the
refusal message carries the plugin identity + the resolver's
reason, and a machine-readable pm receipt records the failure.
The retry path — re-admitting only the resolvable candidate —
commits through the same public function.
3. Active-home propagation. The active CONTEXT home
(hermes_constants.set_hermes_home_override) is what wrapper/sidecar
subprocess launches must inherit through build_subprocess_env.
"""
from __future__ import annotations
import json
import os
import shutil
import subprocess
import sys
from pathlib import Path
import pytest
import hermes_yaml as yaml
import pm.workspace as ws
from pm.plugin_inputs import Members
from tests.pm import _fixtures
def _write_enabled(home: Path, enabled: list, provider: str | None = None) -> None:
home.mkdir(parents=True, exist_ok=True)
cfg: dict = {"plugins": {"enabled": enabled}}
if provider:
cfg["memory"] = {"provider": provider}
with (home / "config.yaml").open("w", encoding="utf-8") as f:
yaml.safe_dump(cfg, f)
def _uv_available() -> bool:
return shutil.which("uv") is not None
# 1. Sidecar with no root dependency surface never joins the union
def test_sidecar_no_root_pyproject_excludes_nested_and_external(tmp_path, monkeypatch):
"""The mnemosyne-wrapper shape: plugin root has ONLY plugin.yaml +
marker; its runtime lives in sidecar dirs with their own pyprojects.
Neither the nested subdir pyproject nor the external one may join
the workspace union."""
home = tmp_path / "home"
_write_enabled(home, ["mnemosyne-wrapper"])
plugins_dir = home / "plugins"
wrapper = plugins_dir / "mnemosyne-wrapper"
wrapper.mkdir(parents=True)
(wrapper / "plugin.yaml").write_text("name: mnemosyne-wrapper\n", encoding="utf-8")
(wrapper / "mnemosyne-wrapper.json").write_text('{"wrapper": true}\n', encoding="utf-8")
# a nested pyproject INSIDE the plugin dir (below the scanned root)
nested = wrapper / "runtime"
nested.mkdir()
(nested / "pyproject.toml").write_text(
'[project]\nname = "mnemosyne-runtime"\nversion = "1.0.0"\n', encoding="utf-8"
)
# an EXTERNAL sidecar next to the plugin (the wrapper's own venv project)
external = plugins_dir / ".mnemosyne-sidecar"
external.mkdir()
(external / "pyproject.toml").write_text(
'[project]\nname = "mnemosyne-sidecar"\nversion = "1.0.0"\n', encoding="utf-8"
)
monkeypatch.setattr(Path, "home", lambda: tmp_path)
monkeypatch.setenv("HERMES_HOME", str(home))
assert ws._is_member_candidate(wrapper) is False, (
"a wrapper root without pyproject/dep keys must never be a member candidate"
)
members = ws.enabled_member_dirs()
member_names = [p.name for p in members]
assert "mnemosyne-wrapper" not in member_names
assert "mnemosyne-sidecar" not in member_names, (
"an external sidecar pyproject must not join the union — pm scans "
"only plugin roots, and the wrapper owns its runtime"
)
assert all("runtime" not in str(p) for p in members)
# 2. Conflict through the PUBLIC admission path: refused, preserved, retry
def _local_conflict_members(home: Path) -> tuple[Path, Path, Path, Path]:
"""plug-a and plug-b both need a local project named sharedlib, but
map it to DIFFERENT path sources (v1 vs v2) — a union with NO valid
solution, resolvable by uv fully OFFLINE."""
shared1 = home / "sidecars" / "sharedlib-v1"
shared2 = home / "sidecars" / "sharedlib-v2"
for path, version in ((shared1, "1.0.0"), (shared2, "2.0.0")):
path.mkdir(parents=True)
(path / "pyproject.toml").write_text(
"[project]\nname = \"sharedlib\"\n"
f'version = "{version}"\nrequires-python = ">=3.11"\n',
encoding="utf-8",
)
plugins_dir = home / "plugins"
members = []
for name, pin, shared in (("plug-a", "1.0.0", shared1), ("plug-b", "2.0.0", shared2)):
plug = plugins_dir / name
plug.mkdir(parents=True)
(plug / "plugin.yaml").write_text(f"name: {name}\n", encoding="utf-8")
(plug / "pyproject.toml").write_text(
"[project]\n"
f'name = "{name}"\nversion = "0.1.0"\n'
'requires-python = ">=3.11"\n'
f'dependencies = ["sharedlib=={pin}"]\n'
"\n[tool.uv.sources]\n"
f'sharedlib = {{ path = "{shared.as_posix()}" }}\n',
encoding="utf-8",
)
members.append(plug)
return members[0], members[1], shared1, shared2
@pytest.fixture
def admission_env(tmp_path, monkeypatch):
"""Fake core repo + temp HERMES_HOME so the REAL pm.install.sync_venv
transaction (lock, receipts, config publication) runs entirely under
tmp — the production path, temp homes."""
core = tmp_path / "core"
core.mkdir()
(core / "pyproject.toml").write_text(
"[project]\n"
'name = "fake-core"\nversion = "0.1.0"\n'
'requires-python = ">=3.11"\ndependencies = []\n',
encoding="utf-8",
)
# the venv package's stamp digest + lock seed read core/uv.lock —
# produce a real one (no deps: uv lock resolves offline)
subprocess.run(
[shutil.which("uv"), "lock"], cwd=core, check=True,
capture_output=True, text=True, timeout=120,
)
home = tmp_path / "home"
_write_enabled(home, []) # nothing enabled yet — the candidate must move it
import importlib
ensure = importlib.import_module("pm.install")
import pm.paths
monkeypatch.setattr(Path, "home", lambda: tmp_path)
monkeypatch.setenv("HERMES_HOME", str(home))
monkeypatch.setattr(pm.paths, "repo_root", lambda: core)
monkeypatch.setattr(ws.paths, "repo_root", lambda: core)
monkeypatch.setattr(ensure, "lazy_installs_allowed", lambda: True)
monkeypatch.setenv("HERMES_RUNTIME_DIR", str(tmp_path / "tools"))
# Exercise the real dependency transaction in-process so the local uv
# fixture owns provisioning; worker transport is covered separately. The
# facade's project_root selects a foreign checkout for the worker; this
# fixture's repo_root already IS the core under test.
def in_process_sync(*args, project_root=None, **kwargs):
assert project_root is None or Path(project_root).resolve() == core.resolve()
return ensure.sync_venv(*args, **kwargs)
monkeypatch.setattr("pm.client.sync_venv", in_process_sync)
monkeypatch.setattr("pm._uv._toolchain", lambda **kwargs: (Path(shutil.which("uv")), Path(sys.executable)))
return tmp_path, home
def _latest_receipt(home: Path) -> dict:
from pm.receipt import latest
receipt = latest()
assert receipt is not None, f"no pm receipt written for {home}"
return receipt
@pytest.mark.skipif(not _uv_available(), reason="uv not on PATH")
def test_conflicting_candidate_refused_unenabled_and_unimported(admission_env):
"""Public admission of an unsatisfiable union: AdmissionRefused with
plugin identity + resolver reason; the candidate is NOT published to
config (so the plugin loader never imports it); plugin trees and
configs survive; the receipt records the failure."""
from hermes_cli import plugins_admission as admission
tmp_path, home = admission_env
plug_a, plug_b, *_ = _local_conflict_members(home)
_write_enabled(home, [], provider="plug-a")
admission.admit_plugin_set_change(set(), set(), active_plugins_dir=home / "plugins")
from pm.environments import selected_venv
working = selected_venv(tmp_path / "core")
config_before = (home / "config.yaml").read_bytes()
tree_before = {p: sorted(str(f) for f in p.rglob("*")) for p in (plug_a, plug_b)}
wrapper = home / "plugins/mnemosyne-wrapper"
wrapper.mkdir()
marker = wrapper / "mnemosyne-wrapper.json"
marker.write_bytes(b'{"wrapper":true}\n')
sidecar = tmp_path / "external-sidecar"
subprocess.run([shutil.which("uv"), "venv", "--python", sys.executable, str(sidecar)], check=True, capture_output=True, timeout=60)
sidecar_python = sidecar / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
before = marker.read_bytes()
with pytest.raises(admission.AdmissionRefused) as excinfo:
admission.admit_plugin_set_change(
{"plug-a", "plug-b"}, set(), active_plugins_dir=home / "plugins"
)
message = str(excinfo.value)
assert "plug-b" in message or "plug-a" in message, (
f"refusal must carry the plugin identity, got: {message}"
)
assert "sharedlib" in message.lower() or "conflict" in message.lower(), (
f"refusal must carry the resolver's reason, got: {message}"
)
# unenabled → unimported: the candidate never reached the enabled list
with (home / "config.yaml").open(encoding="utf-8-sig") as f:
cfg = yaml.safe_load(f)
assert cfg["plugins"]["enabled"] == [], (
"a refused candidate must stay unenabled — config published a set that never resolved"
)
assert (home / "config.yaml").read_bytes() == config_before
assert cfg["memory"]["provider"] == "plug-a"
assert selected_venv(tmp_path / "core") == working
# no plugin tree was deleted or mutated by the failed resolution
for plug, listing in tree_before.items():
assert plug.is_dir(), f"failed resolution deleted plugin tree {plug}"
assert sorted(str(f) for f in plug.rglob("*")) == listing
# the machine-readable receipt records the failed sync
receipt = _latest_receipt(home)
assert receipt.get("outcome") == "failed"
flattened = json.dumps(receipt)
assert "plug-b" in flattened or "sharedlib" in flattened, (
"receipt must carry the conflict identity/reason"
)
# retry: drop the conflicting candidate, keep the good one
admission.admit_plugin_set_change(
{"plug-a"}, set(), active_plugins_dir=home / "plugins"
)
with (home / "config.yaml").open(encoding="utf-8-sig") as f:
cfg = yaml.safe_load(f)
assert cfg["plugins"]["enabled"] == ["plug-a"]
assert "plug-b" not in cfg["plugins"]["enabled"], (
"the conflicting candidate must remain unenabled after the retry"
)
assert marker.read_bytes() == before
child = subprocess.run([str(sidecar_python), "-c", "import sys; print(sys.prefix)"], check=True, capture_output=True, text=True, timeout=30)
assert Path(child.stdout.strip()) == sidecar
from pm.environments import selected_venv
selected = selected_venv(tmp_path / "core")
assert selected.is_dir() and selected != sidecar
# A declared version range remains a member across the next managed rebuild.
project = plug_a / "pyproject.toml"
project.write_text(project.read_text(encoding="utf-8").replace("sharedlib==1.0.0", "sharedlib>=1,<2"), encoding="utf-8")
admission.admit_plugin_set_change({"plug-a"}, set(), active_plugins_dir=home / "plugins")
assert selected_venv(tmp_path / "core") != selected
assert marker.read_bytes() == before
subprocess.run([str(sidecar_python), "-c", "import sys; assert sys.prefix != sys.base_prefix"], check=True, timeout=30)
@pytest.mark.skipif(not _uv_available(), reason="uv not on PATH")
def test_malformed_secondary_cannot_evict_recorded_member(admission_env, monkeypatch, caplog):
"""A→B→A: passive inspection survives bad config; A's recorded graph does not shrink."""
from pm.environments import runtime_facts_path, selected_venv
from pm.install import sync_venv, venv_is_current
from pm.lock import Facts
tmp_path, home_a = admission_env
core = tmp_path / "core"
profile = home_a / "profiles" / "work"
profile.mkdir(parents=True)
_write_enabled(profile, ["profile-dep"])
_fixtures.installing_member(profile / "plugins" / "profile-dep", "profile-dep", tmp_path / "wheels")
sync_venv(explicit=True)
recorded = Facts(runtime_facts_path(core), strict=True).get("venv")
selected = selected_venv(core)
assert recorded["stamp"] and selected.is_dir()
assert "profile-dep" in (Path(recorded["resolved_lock"]).parent / "pyproject.toml").read_text()
bad = profile / "config.yaml"
bad.write_text("plugins: [broken]\n", encoding="utf-8")
_fixtures.installing_member(home_a / "plugins" / "new-dep", "new-dep", tmp_path / "wheels")
_write_enabled(home_a, ["new-dep"])
assert venv_is_current(project_root=core) is False
assert str(bad) in caplog.text
with pytest.raises(ValueError, match="config.yaml"):
sync_venv(explicit=True)
assert Facts(runtime_facts_path(core), strict=True).get("venv") == recorded
assert selected_venv(core) == selected
# Even a precomputed member list cannot bypass a newly broken profile.
with pytest.raises(ValueError, match="config.yaml"):
sync_venv(explicit=True, plugins=Members([]))
assert Facts(runtime_facts_path(core), strict=True).get("venv") == recorded
home_b = tmp_path / "home-b"
_write_enabled(home_b, [])
monkeypatch.setenv("HERMES_HOME", str(home_b))
sync_venv(explicit=True)
assert selected_venv(core).is_dir()
assert Facts(runtime_facts_path(core), strict=True).get("venv")["stamp"] != recorded["stamp"]
monkeypatch.setenv("HERMES_HOME", str(home_a))
with pytest.raises(ValueError, match="config.yaml"):
sync_venv(explicit=True)
assert selected_venv(core) == selected
_write_enabled(profile, ["profile-dep"])
sync_venv(explicit=True)
restored = Facts(runtime_facts_path(core), strict=True).get("venv")
assert selected_venv(core).is_dir()
assert restored["stamp"] != recorded["stamp"]
assert "profile-dep" in (Path(restored["resolved_lock"]).parent / "pyproject.toml").read_text()
@pytest.mark.skipif(not _uv_available(), reason="uv not on PATH")
def test_plugin_whose_pyproject_installs_nothing_keeps_the_environment(admission_env):
"""``dependencies = []`` (the official agent-importers plugin) puts nothing in the environment:
enabling that plugin, and each later change to its files, keeps the selected generation instead
of locking and syncing a new one. A plugin with a real dependency still joins the workspace."""
import tomllib
from hermes_cli import plugins_admission as admission
from pm.environments import runtime_facts_path, selected_venv
from pm.install import sync_venv, venv_is_current
from pm.lock import Facts
tmp_path, home = admission_env
core = tmp_path / "core"
sync_venv(explicit=True)
selected = selected_venv(core)
recorded = Facts(runtime_facts_path(core), strict=True).get("venv")
plugin = home / "plugins" / "importers"
plugin.mkdir(parents=True)
(plugin / "plugin.yaml").write_text("name: importers\n", encoding="utf-8")
(plugin / "__init__.py").write_text("VERSION = 1\n", encoding="utf-8")
(plugin / "pyproject.toml").write_text(
'[project]\nname="importers"\nversion="1"\nrequires-python=">=3.11"\ndependencies=[]\n', encoding="utf-8")
admission.admit_plugin_set_change({"importers"}, set(), active_plugins_dir=home / "plugins")
assert yaml.safe_load((home / "config.yaml").read_text(encoding="utf-8"))["plugins"]["enabled"] == ["importers"]
assert selected_venv(core) == selected
assert Facts(runtime_facts_path(core), strict=True).get("venv") == recorded
(plugin / "__init__.py").write_text("VERSION = 2\n", encoding="utf-8") # what an update changes
assert venv_is_current(project_root=core) is True
real = home / "plugins" / "real"
_fixtures.installing_member(real, "real", tmp_path / "wheels")
(real / "plugin.yaml").write_text("name: real\n", encoding="utf-8")
admission.admit_plugin_set_change({"importers", "real"}, set(), active_plugins_dir=home / "plugins")
workspace = Path(Facts(runtime_facts_path(core), strict=True).get("venv")["resolved_lock"]).parent
members = tomllib.loads((workspace / "pyproject.toml").read_text(encoding="utf-8"))["tool"]["uv"]["workspace"]["members"]
assert [Path(member).name.split("-")[0] for member in members] == ["real"]
assert selected_venv(core) != selected
assert venv_is_current(project_root=core) is True
@pytest.mark.skipif(not _uv_available(), reason="uv not on PATH")
def test_update_sync_disables_plugin_excluded_by_requires_python(admission_env):
"""An update never fails because of a plugin: a member whose requires-python excludes the
interpreter core now runs on is disabled in every home that enables it (plugins.enabled in
one, memory.provider in another), the rest build, and the next boot sees a current venv.
The provider selection survives, and the update after the plugin fits again undoes the edit."""
from pm.environments import runtime_facts_path, selected_venv
from pm.install import sync_venv, venv_is_current
from pm.lock import Facts
from pm.package import InstallError
tmp_path, home = admission_env
core = tmp_path / "core"
for name, requires in (("fits", ">=3.11"), ("too-old", f"<{sys.version_info[0]}.{sys.version_info[1]}")):
_fixtures.installing_member(home / "plugins" / name, name, tmp_path / "wheels", requires_python=requires)
(home / "config.yaml").write_text("# operator note\nplugins:\n enabled: [fits, too-old]\n", encoding="utf-8")
profile = home / "profiles" / "work"
_write_enabled(profile, [], provider="too-old")
(profile / "plugins" / "too-old").mkdir(parents=True)
(profile / "plugins" / "too-old" / "pyproject.toml").write_bytes(
(home / "plugins" / "too-old" / "pyproject.toml").read_bytes().replace(b'name="too-old"', b'name="too-old-work"'))
with pytest.raises(InstallError, match="Python requirement"):
sync_venv(explicit=True) # admission semantics stay: an ordinary sync refuses
sync_venv(explicit=True, evict_incompatible_plugins=True)
workspace = Path(Facts(runtime_facts_path(core), strict=True).get("venv")["resolved_lock"]).parent
assert selected_venv(core).is_dir()
assert "fits" in (workspace / "pyproject.toml").read_text()
assert "too-old" not in (workspace / "pyproject.toml").read_text()
text = (home / "config.yaml").read_text(encoding="utf-8")
assert "# operator note" in text
assert "too-old" in yaml.safe_load(text)["plugins"]["disabled"]
assert yaml.safe_load(text)["plugins"]["enabled"] == ["fits"]
work = yaml.safe_load((profile / "config.yaml").read_text(encoding="utf-8"))
assert work["memory"]["provider"] == "too-old" and work["plugins"]["disabled"] == ["too-old"]
assert "too-old" in json.dumps(_latest_receipt(home).get("warnings"))
assert "hermes plugins enable too-old" in json.dumps(_latest_receipt(home).get("warnings"))
assert venv_is_current(project_root=core) is True
for plugin in (home / "plugins" / "too-old", profile / "plugins" / "too-old"):
manifest = plugin / "pyproject.toml"
manifest.write_text(manifest.read_text(encoding="utf-8").replace(
f'"<{sys.version_info[0]}.{sys.version_info[1]}"', '">=3.11"'), encoding="utf-8")
sync_venv(explicit=True, evict_incompatible_plugins=True)
root = yaml.safe_load((home / "config.yaml").read_text(encoding="utf-8"))["plugins"]
assert root["enabled"] == ["fits", "too-old"] and not root.get("disabled") and "disabled_by_update" not in root
work = yaml.safe_load((profile / "config.yaml").read_text(encoding="utf-8"))
assert work["memory"]["provider"] == "too-old" and not work["plugins"].get("enabled")
assert not work["plugins"].get("disabled") and "disabled_by_update" not in work["plugins"]
workspace = Path(Facts(runtime_facts_path(core), strict=True).get("venv")["resolved_lock"]).parent
assert "too-old" in (workspace / "pyproject.toml").read_text()
assert venv_is_current(project_root=core) is True
@pytest.mark.skipif(not _uv_available(), reason="uv not on PATH")
def test_plugin_the_user_disables_after_an_update_stays_disabled(admission_env):
"""Disabling a plugin an update turned off takes the decision back: later updates stop
retrying it, even once it fits again."""
from pm.install import sync_venv
from pm.plugin_inputs import Selection
_, home = admission_env
_local_conflict_members(home)
_write_enabled(home, ["plug-a", "plug-b"])
sync_venv(explicit=True, evict_incompatible_plugins=True)
assert "plug-b" in yaml.safe_load((home / "config.yaml").read_text(encoding="utf-8"))["plugins"]["disabled_by_update"]
sync_venv(explicit=True, plugins=Selection({"home": str(home.resolve()), "enabled": ["plug-a"],
"disabled": ["plug-b"], "settled": ["plug-b"]}))
cfg = yaml.safe_load((home / "config.yaml").read_text(encoding="utf-8"))
cfg["plugins"]["enabled"] = [] # without plug-a, plug-b would fit again
(home / "config.yaml").write_text(yaml.safe_dump(cfg), encoding="utf-8")
sync_venv(explicit=True, evict_incompatible_plugins=True)
plugins = yaml.safe_load((home / "config.yaml").read_text(encoding="utf-8"))["plugins"]
assert plugins["disabled"] == ["plug-b"] and "disabled_by_update" not in plugins
def test_provider_only_record_is_retried_only_while_it_is_still_the_provider(admission_env):
"""A provider an update parked that was never in plugins.enabled rejoins only as the provider:
once the user picks another provider, updates stop installing it (its rejoin would leave the
environment holding a plugin no selection names)."""
from pm.plugin_eviction import recorded_evictions
_, home = admission_env
(home / "plugins" / "parked").mkdir(parents=True)
record = "plugins:\n disabled: [parked]\n disabled_by_update:\n parked: {enabled: false, reason: r}\n"
(home / "config.yaml").write_text(record + "memory:\n provider: parked\n", encoding="utf-8")
assert [name for _, name, _ in recorded_evictions()] == ["parked"]
(home / "config.yaml").write_text(record + "memory:\n provider: other\n", encoding="utf-8")
assert not recorded_evictions()
@pytest.mark.skipif(not _uv_available(), reason="uv not on PATH")
def test_recorded_plugin_is_retried_only_when_changed_and_never_displaces_an_enabled_one(admission_env, monkeypatch):
"""A plugin an update disabled on a resolver verdict is not built again while neither it, core
nor the enabled plugins beside it changed. Once it changed, it is tried only on top of the
enabled plugins, so even a download failure hitting an enabled plugin in that update can never
swap the two; once only the plugin it conflicted with changes, it comes back."""
from pm.install import sync_venv, venv_is_current
from pm.package import InstallError
from pm.packages import Venv
tmp_path, home = admission_env
plug_a, plug_b, _, _ = _local_conflict_members(home)
_write_enabled(home, ["plug-a", "plug-b"])
sync_venv(explicit=True, evict_incompatible_plugins=True)
builds: list[list[str]] = []
offline = {"plug-a": False}
real_apply = Venv.apply
def watched_apply(self, extras, *, plugin_dirs=None, **kwargs):
names = [Path(plugin_dir).name for plugin_dir in plugin_dirs or ()]
builds.append(names)
if offline["plug-a"] and names == ["plug-a"]:
raise InstallError("plug-a", "network unreachable")
return real_apply(self, extras, plugin_dirs=plugin_dirs, **kwargs)
monkeypatch.setattr(Venv, "apply", watched_apply)
sync_venv(explicit=True, evict_incompatible_plugins=True)
assert not any("plug-b" in names for names in builds)
manifest = plug_b / "pyproject.toml"
manifest.write_text(manifest.read_text(encoding="utf-8") + "# 0.1.1, still sharedlib 2\n", encoding="utf-8")
offline["plug-a"] = True
sync_venv(explicit=True, evict_incompatible_plugins=True)
plugins = yaml.safe_load((home / "config.yaml").read_text(encoding="utf-8"))["plugins"]
assert "plug-b" not in (plugins.get("enabled") or []) and "plug-b" in plugins["disabled"]
offline["plug-a"] = False
sync_venv(explicit=True, evict_incompatible_plugins=True)
plugins = yaml.safe_load((home / "config.yaml").read_text(encoding="utf-8"))["plugins"]
assert plugins["enabled"] == ["plug-a"] and plugins["disabled"] == ["plug-b"]
assert venv_is_current(project_root=tmp_path / "core") is True
# Only the enabled plugin it conflicted with changes, and the conflict is gone: it comes back.
manifest = plug_a / "pyproject.toml"
manifest.write_text(manifest.read_text(encoding="utf-8").replace('"sharedlib==1.0.0"', '"sharedlib>=1"').replace(
"sharedlib-v1", "sharedlib-v2"), encoding="utf-8")
sync_venv(explicit=True, evict_incompatible_plugins=True)
plugins = yaml.safe_load((home / "config.yaml").read_text(encoding="utf-8"))["plugins"]
assert plugins["enabled"] == ["plug-a", "plug-b"] and not plugins.get("disabled")
@pytest.mark.skipif(not _uv_available(), reason="uv not on PATH")
def test_update_sync_disables_later_plugin_of_unresolvable_union(admission_env):
"""Core moved under two admitted plugins that no longer co-resolve: the update keeps the
first in config order, disables the one that breaks the build, and completes."""
from pm.install import sync_venv, venv_is_current
tmp_path, home = admission_env
_local_conflict_members(home)
_write_enabled(home, ["plug-a", "plug-b"])
sync_venv(explicit=True, evict_incompatible_plugins=True)
cfg = yaml.safe_load((home / "config.yaml").read_text(encoding="utf-8"))
assert cfg["plugins"]["disabled"] == ["plug-b"]
assert cfg["plugins"]["enabled"] == ["plug-a"]
assert venv_is_current(project_root=tmp_path / "core") is True
@pytest.mark.skipif(not _uv_available(), reason="uv not on PATH")
def test_update_sync_survives_unreadable_secondary_profile(admission_env):
"""A secondary profile's broken config.yaml cannot fail an update: its plugins sit out
(reported), the rest build, and the next boot sees a current venv."""
from pm.environments import runtime_facts_path
from pm.install import sync_venv, venv_is_current
from pm.lock import Facts
tmp_path, home = admission_env
core = tmp_path / "core"
_fixtures.installing_member(home / "plugins" / "primary-dep", "primary-dep", tmp_path / "wheels")
_write_enabled(home, ["primary-dep"])
broken = home / "profiles" / "work" / "config.yaml"
broken.parent.mkdir(parents=True)
broken.write_text("plugins: [broken]\n", encoding="utf-8")
with pytest.raises(ValueError, match="config.yaml"):
sync_venv(explicit=True) # an ordinary sync still refuses to shrink the graph
sync_venv(explicit=True, evict_incompatible_plugins=True)
workspace = Path(Facts(runtime_facts_path(core), strict=True).get("venv")["resolved_lock"]).parent
assert "primary-dep" in (workspace / "pyproject.toml").read_text()
assert broken.read_text(encoding="utf-8") == "plugins: [broken]\n"
assert str(broken.parent) in json.dumps(_latest_receipt(home).get("warnings"))
assert venv_is_current(project_root=core) is True
@pytest.mark.skipif(not _uv_available(), reason="uv not on PATH")
def test_plugin_our_version_rejects_sits_out_without_being_disabled(admission_env, monkeypatch):
"""requires_hermes is judged against our version identity, which can lag (an untagged
source checkout reads as an older release). Such a plugin sits out: config untouched,
boot's currency check neither raises nor loops, and it rejoins once the verdict flips."""
from pm.environments import runtime_facts_path
from pm.install import sync_venv, venv_is_current
from pm.lock import Facts
from hermes_cli import plugins_manifest
tmp_path, home = admission_env
core = tmp_path / "core"
# A tagless checkout (CI's) has no parseable version, which makes requires_hermes permissive.
monkeypatch.setattr(plugins_manifest, "running_hermes_version", lambda: "1.0.0")
for name in ("fits", "needs-newer"):
_fixtures.installing_member(home / "plugins" / name, name, tmp_path / "wheels")
manifest = home / "plugins" / "needs-newer" / "plugin.yaml"
manifest.write_text("name: needs-newer\nrequires_hermes: '>=999'\n", encoding="utf-8")
_write_enabled(home, ["fits", "needs-newer"])
before = (home / "config.yaml").read_bytes()
assert venv_is_current(project_root=core) is False # boot probes it before any sync
sync_venv(explicit=True, evict_incompatible_plugins=True)
assert (home / "config.yaml").read_bytes() == before
assert "Left plugin 'needs-newer'" in json.dumps(_latest_receipt(home).get("warnings"))
workspace = Path(Facts(runtime_facts_path(core), strict=True).get("venv")["resolved_lock"]).parent
assert "needs-newer" not in (workspace / "pyproject.toml").read_text()
assert venv_is_current(project_root=core) is True
manifest.write_text("name: needs-newer\nrequires_hermes: '>=0'\n", encoding="utf-8")
assert venv_is_current(project_root=core) is False
sync_venv(explicit=True, evict_incompatible_plugins=True)
workspace = Path(Facts(runtime_facts_path(core), strict=True).get("venv")["resolved_lock"]).parent
assert "needs-newer" in (workspace / "pyproject.toml").read_text()
@pytest.mark.skipif(not _uv_available(), reason="uv not on PATH")
def test_update_sync_retries_a_fetch_failure_once_before_disabling(admission_env, monkeypatch):
"""Build evidence disables a plugin at once. A fetch failure could be the moment, so it
gets one more try first. Either way the recorded state is the one boot expects."""
from pm.install import sync_venv, venv_is_current
from pm.packages import Venv
trials: list[str] = []
real_apply = Venv.apply
def counting_apply(self, extras, *, plugin_dirs=None, **kwargs):
if plugin_dirs:
trials.append(Path(plugin_dirs[-1]).name)
return real_apply(self, extras, plugin_dirs=plugin_dirs, **kwargs)
monkeypatch.setattr(Venv, "apply", counting_apply)
tmp_path, home = admission_env
monkeypatch.setenv("UV_HTTP_RETRIES", "0")
broken = tmp_path / "broken-lib"
broken.mkdir()
(broken / "pyproject.toml").write_text(
'[project]\nname="broken-lib"\ndynamic=["version"]\n'
'[build-system]\nrequires=[]\nbuild-backend="backend"\nbackend-path=["."]\n', encoding="utf-8")
(broken / "backend.py").write_text(
"def get_requires_for_build_wheel(config=None): return []\n"
"def prepare_metadata_for_build_wheel(directory, config=None): raise SystemExit('no build')\n"
"def build_wheel(directory, config=None, metadata=None): raise SystemExit('no build')\n", encoding="utf-8")
# Plugin requirements are index-only; local and remote inputs come through tool.uv.sources.
for name, dependency, source in (("wont-build", "broken-lib", f'{{ path = "{broken.as_posix()}" }}'),
("offline-dep", "gone", '{ url = "https://127.0.0.1:9/gone-1.0-py3-none-any.whl" }')):
plugin = home / "plugins" / name
plugin.mkdir(parents=True)
(plugin / "pyproject.toml").write_text(
f'[project]\nname="{name}"\nversion="1"\nrequires-python=">=3.11"\n'
f'dependencies=["{dependency}"]\n[tool.uv]\npackage=false\n'
f'[tool.uv.sources]\n{dependency} = {source}\n', encoding="utf-8",
)
_write_enabled(home, ["wont-build", "offline-dep"])
sync_venv(explicit=True, evict_incompatible_plugins=True)
cfg = yaml.safe_load((home / "config.yaml").read_text(encoding="utf-8"))
assert cfg["plugins"]["disabled"] == ["wont-build", "offline-dep"]
# After the full selection's own attempt: build evidence once, the fetch failure twice.
assert trials[1:] == ["wont-build", "offline-dep", "offline-dep"]
assert "could not be prepared, twice" in json.dumps(_latest_receipt(home).get("warnings"))
assert venv_is_current(project_root=tmp_path / "core") is True
def test_active_context_home_exported_to_wrapper_subprocess(monkeypatch, tmp_path):
from hermes_constants import reset_hermes_home_override, set_hermes_home_override
from tools.environments.local import build_subprocess_env
monkeypatch.setenv("HERMES_HOME", str(tmp_path / "ambient"))
active = tmp_path / "custom-root/profiles/worker"
active.mkdir(parents=True)
token = set_hermes_home_override(active)
try:
child_env = build_subprocess_env()
child = subprocess.run(
[sys.executable, "-c", "import os; print(os.environ['HERMES_HOME'], end='')"],
env=child_env, capture_output=True, text=True, check=True, timeout=60,
)
assert child.stdout == str(active)
finally:
reset_hermes_home_override(token)