simplicio-loop 3.38.16__tar.gz → 3.38.28__tar.gz

{simplicio_loop-3.38.16/simplicio_loop.egg-info → simplicio_loop-3.38.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.38.16
+Version: 3.38.28
 Summary: The Universal Looping AI Orchestrator — a runtime-agnostic super-plugin (7 skills) that drains any queue of work end-to-end on any LLM/runtime.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License: MIT

{simplicio_loop-3.38.16 → simplicio_loop-3.38.28}/pyproject.toml

@@ -1,92 +1,93 @@
-[build-system]
-requires = ["setuptools>=68", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "simplicio-loop"
-version = "3.38.16"
-description = "The Universal Looping AI Orchestrator — a runtime-agnostic super-plugin (7 skills) that drains any queue of work end-to-end on any LLM/runtime."
-readme = "PYPI.md"
-requires-python = ">=3.11"
-license = { text = "MIT" }
-authors = [{ name = "Wesley Simplicio", email = "wesleybob4@gmail.com" }]
-keywords = ["ai", "agent", "orchestrator", "llm", "claude", "cursor", "automation", "ralph-loop", "token-economy", "cli"]
-classifiers = [
-  "Development Status :: 4 - Beta",
-  "Intended Audience :: Developers",
-  "License :: OSI Approved :: MIT License",
-  "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3 :: Only",
-  "Programming Language :: Python :: 3.11",
-  "Programming Language :: Python :: 3.12",
-  "Programming Language :: Python :: 3.13",
-  "Topic :: Software Development :: Build Tools",
-  "Topic :: Utilities",
-  "Operating System :: OS Independent",
-]
-# The loop ships with both bound operators as direct runtime dependencies.  Do not rely on
-# simplicio-cli's transitive dependency alone: partial/no-deps installations must be diagnosed
-# explicitly and the normal `pip install simplicio-loop` closure must request both distributions.
-dependencies = [
-  "simplicio-cli>=0.18.1",
-  "simplicio-mapper>=0.26.1",
-  "simplicio-fast>=2.0.18",
-  "tiktoken>=0.12.0,<1",
-]
-
-# Optional: the real embedding backend for `simplicio-cli semantic --ml` / `simplicio-cli rag --ml`.
-# The native engine itself is stdlib-only; this only enables embedding-based semantic dedup +
-# meaning retrieval. `pip install "simplicio-loop[ml]"`.
-[project.optional-dependencies]
-# Dev/test dependencies used by the local quality gate and secure-transport fixtures.
-dev = ["pytest>=7", "pytest-cov>=4", "cryptography>=42,<50", "jsonschema>=4,<5"]
-ml = ["model2vec>=0.3", "numpy>=1.21"]
-uvloop = ["uvloop>=0.19; platform_system != 'Windows'"]
-
-[project.urls]
-Homepage = "https://github.com/wesleysimplicio/simplicio-loop"
-Repository = "https://github.com/wesleysimplicio/simplicio-loop"
-Issues = "https://github.com/wesleysimplicio/simplicio-loop/issues"
-
-[project.scripts]
-simplicio-loop = "simplicio_loop.cli:main"
-simplicio-ecosystem-doctor = "simplicio_loop.ecosystem_doctor:main"
-simplicio-loop-tools = "simplicio_loop.consumer_cli:main"
-simplicio-hub = "simplicio_loop.hub_daemon:main"
-# issue #286 step 11: the multi-device remote-worker protocol's server + worker + supervisor
-# are genuinely installable binaries, not source that only runs from a git checkout.
-simplicio-remote-queue-server = "simplicio_loop.remote_queue_server_cli:main"
-simplicio-remote-worker = "simplicio_loop.remote_worker_cli:main"
-simplicio-remote-worker-supervisor = "simplicio_loop.remote_worker_supervisor_cli:main"
-# issue #516: observability/enforcement CLI for the #498 process-supervisor contract
-# (status/top/queue/cancel/drain/reports over the #514 ProcessSpec/Lease/Result adapter).
-simplicio-process-supervisor = "simplicio_loop.process_enforcement_cli:main"
-
-[tool.setuptools]
-packages = ["simplicio_loop"]
-include-package-data = true
-
-[tool.setuptools.package-data]
-simplicio_loop = ["_bundle/**/*", "_contracts/**/*.json"]
-
-[tool.coverage.run]
-source = ["simplicio_loop"]
-omit = [
-  "simplicio_loop/_bundle/*",
-]
-
-[tool.coverage.report]
-exclude_lines = [
-  "pragma: no cover",
-  "if __name__ == .__main__.:",
-]
-
-[tool.pytest.ini_options]
-addopts = ["--import-mode=importlib"]
-markers = [
-  "external_integration: installed or network-backed lane excluded from the hermetic core gate",
-  "satellite: opt-in satellite functionality excluded from the mandatory core gate",
-]
-# The bundle/plugin trees mirror source files and are validated by mirror-parity.
-# Collect the canonical tests once instead of executing mirrored probes repeatedly.
-testpaths = ["tests"]
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "simplicio-loop"
+version = "3.38.28"
+description = "The Universal Looping AI Orchestrator — a runtime-agnostic super-plugin (7 skills) that drains any queue of work end-to-end on any LLM/runtime."
+readme = "PYPI.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "Wesley Simplicio", email = "wesleybob4@gmail.com" }]
+keywords = ["ai", "agent", "orchestrator", "llm", "claude", "cursor", "automation", "ralph-loop", "token-economy", "cli"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Build Tools",
+  "Topic :: Utilities",
+  "Operating System :: OS Independent",
+]
+# The loop ships with both bound operators as direct runtime dependencies.  Do not rely on
+# simplicio-cli's transitive dependency alone: partial/no-deps installations must be diagnosed
+# explicitly and the normal `pip install simplicio-loop` closure must request both distributions.
+dependencies = [
+  "simplicio-cli>=0.18.1",
+  "simplicio-mapper>=0.26.1",
+  "simplicio-fast>=2.0.18",
+  "tiktoken>=0.12.0,<1",
+]
+
+# Optional: the real embedding backend for `simplicio-cli semantic --ml` / `simplicio-cli rag --ml`.
+# The native engine itself is stdlib-only; this only enables embedding-based semantic dedup +
+# meaning retrieval. `pip install "simplicio-loop[ml]"`.
+[project.optional-dependencies]
+# Dev/test dependencies used by the local quality gate and secure-transport fixtures.
+dev = ["pytest>=7", "pytest-cov>=4", "cryptography>=42,<50", "jsonschema>=4,<5"]
+ml = ["model2vec>=0.3", "numpy>=1.21"]
+uvloop = ["uvloop>=0.19; platform_system != 'Windows'"]
+
+[project.urls]
+Homepage = "https://github.com/wesleysimplicio/simplicio-loop"
+Repository = "https://github.com/wesleysimplicio/simplicio-loop"
+Issues = "https://github.com/wesleysimplicio/simplicio-loop/issues"
+
+[project.scripts]
+simplicio-loop = "simplicio_loop.cli:main"
+issue-factory = "simplicio_loop.issue_factory_cli:main"
+simplicio-ecosystem-doctor = "simplicio_loop.ecosystem_doctor:main"
+simplicio-loop-tools = "simplicio_loop.consumer_cli:main"
+simplicio-hub = "simplicio_loop.hub_daemon:main"
+# issue #286 step 11: the multi-device remote-worker protocol's server + worker + supervisor
+# are genuinely installable binaries, not source that only runs from a git checkout.
+simplicio-remote-queue-server = "simplicio_loop.remote_queue_server_cli:main"
+simplicio-remote-worker = "simplicio_loop.remote_worker_cli:main"
+simplicio-remote-worker-supervisor = "simplicio_loop.remote_worker_supervisor_cli:main"
+# issue #516: observability/enforcement CLI for the #498 process-supervisor contract
+# (status/top/queue/cancel/drain/reports over the #514 ProcessSpec/Lease/Result adapter).
+simplicio-process-supervisor = "simplicio_loop.process_enforcement_cli:main"
+
+[tool.setuptools]
+packages = ["simplicio_loop"]
+include-package-data = true
+
+[tool.setuptools.package-data]
+simplicio_loop = ["_bundle/**/*", "_contracts/**/*.json"]
+
+[tool.coverage.run]
+source = ["simplicio_loop"]
+omit = [
+  "simplicio_loop/_bundle/*",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+  "pragma: no cover",
+  "if __name__ == .__main__.:",
+]
+
+[tool.pytest.ini_options]
+addopts = ["--import-mode=importlib"]
+markers = [
+  "external_integration: installed or network-backed lane excluded from the hermetic core gate",
+  "satellite: opt-in satellite functionality excluded from the mandatory core gate",
+]
+# The bundle/plugin trees mirror source files and are validated by mirror-parity.
+# Collect the canonical tests once instead of executing mirrored probes repeatedly.
+testpaths = ["tests"]

{simplicio_loop-3.38.16 → simplicio_loop-3.38.28}/simplicio_loop/__init__.py

@@ -1,18 +1,18 @@
-"""simplicio-loop — The Universal Looping AI Orchestrator.
-
-A runtime-agnostic super-plugin (7 skills + loop/token hooks) that drains any
-queue of work end-to-end on any LLM/runtime. This package ships the skills and
-hooks and installs them into a runtime's skills location.
-"""
-
-# Single source of truth = the package metadata (pyproject `version`); the literal is only a
-# fallback for an editable/source checkout that was never installed. No more version drift.
-try:
-    from importlib.metadata import version as _v, PackageNotFoundError
-
-    try:
-        __version__ = _v("simplicio-loop")
-    except PackageNotFoundError:
-        __version__ = "3.38.16"
-except Exception:  # pragma: no cover
-        __version__ = "3.38.16"
+"""simplicio-loop — The Universal Looping AI Orchestrator.
+
+A runtime-agnostic super-plugin (7 skills + loop/token hooks) that drains any
+queue of work end-to-end on any LLM/runtime. This package ships the skills and
+hooks and installs them into a runtime's skills location.
+"""
+
+# Single source of truth = the package metadata (pyproject `version`); the literal is only a
+# fallback for an editable/source checkout that was never installed. No more version drift.
+try:
+    from importlib.metadata import version as _v, PackageNotFoundError
+
+    try:
+        __version__ = _v("simplicio-loop")
+    except PackageNotFoundError:
+        __version__ = "3.38.28"
+except Exception:  # pragma: no cover
+    __version__ = "3.38.28"

{simplicio_loop-3.38.16 → simplicio_loop-3.38.28}/simplicio_loop/_bundle/scripts/flow_audit.py

@@ -207,7 +207,12 @@ def relpath(path: Path, root: Path) -> str:
 
 def iter_files(root: Path) -> Iterable[Path]:
     for current, dirs, names in os.walk(root):
-        dirs[:] = [d for d in dirs if d not in EXCLUDED_DIRS and not d.startswith(".cache")]
+        dirs[:] = [
+            d for d in dirs
+            if d not in EXCLUDED_DIRS
+            and not d.startswith(".cache")
+            and not d.startswith(".pytest-")
+        ]
         cur = Path(current)
         for name in names:
             path = cur / name

{simplicio_loop-3.38.16 → simplicio_loop-3.38.28}/simplicio_loop/_bundle/skills/simplicio-loop/SKILL.md

@@ -28,6 +28,39 @@ merge only through the repository's approved PR path, and re-query live state be
 silently substitute another tracker or local scratchpad for GitHub; use another system only when the
 user explicitly requests it or the repository's documented workflow requires it.
 
+## Bounded delivery policy
+
+Keep delivery finite and ownership explicit; a repository may set stricter limits, never looser
+ones without a recorded human decision.
+
+- **Bounded WIP:** one implementation issue and one delivery PR per worker/session. Finish,
+  hand off, or mark the item blocked before claiming another; reviews do not transfer ownership.
+- **Live intake and frozen scope:** immediately before freezing, re-query the canonical source and
+  record its revision plus provenance in the anchor. Freeze that exact issue goal and acceptance
+  criteria before mutation. A review finding may prove an AC incomplete, but cannot add an AC
+  silently; source drift or scope changes require a fresh query, re-anchoring, and an explicit
+  owner decision.
+- **Finding categories:** classify every finding as `AC_BLOCKER` (violates a frozen AC),
+  `REGRESSION_BLOCKER` (security, correctness, compatibility, or evidence regression caused by the
+  patch), or `FOLLOW_UP` (valuable but outside the frozen scope). Only blockers hold the current
+  delivery; follow-ups become separate work and are never smuggled into its diff.
+- **Review limits:** use one implementation review and one final independent verification, with at
+  most two AC-scoped repair rounds. If a blocker remains, stop `BLOCKED` with evidence and ownership
+  instead of opening an unbounded review/fix loop.
+- **Ownership and integration:** only the active owner mutates the delivery branch. Reviewers are
+  read-only unless ownership is explicitly handed off. Before the first mutation, acquire and
+  confirm the cross-session claim/lease/fence against the live source; a stale or conflicting
+  authority blocks mutation. A handoff must update the authority record and the receiver must
+  confirm the new claim/lease/fence before continuing. Rebase once onto the current canonical base
+  immediately before final verification/merge; after any rebase, rerun the affected gates and
+  prove ancestry/patch scope.
+- **Release boundary:** merge, issue closure, packaging, and release are separate states. Do not
+  close the issue before merged evidence satisfies the frozen ACs, and do not tag/publish a release
+  unless the task or an authorized release owner explicitly includes it; re-query the canonical
+  branch and release state immediately before publication.
+
+Rationale and rollout: `docs/adr/0008-bounded-delivery-policy.md`.
+
 ## Normative contract (non-negotiable)
 
 **Design principle (issue #526): always route to the fastest path the project's structure

simplicio_loop-3.38.28/simplicio_loop/behavior_loop.py

@@ -0,0 +1,120 @@
+"""Explicit, gated skill-behavior feedback loop (issue #902).
+
+Observation and measurement are local and deterministic. Promotion is always an
+explicit Action Gate decision; feedback can archive a weak proposal but cannot
+silently create or activate a skill.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from pathlib import Path
+from typing import Any, Mapping
+
+SCHEMA = "simplicio.loop-behavior-loop/v1"
+STATES = frozenset({"proposed", "promoted", "archived"})
+
+
+class BehaviorLoopError(ValueError):
+    """The behavior loop input or lifecycle transition is invalid."""
+
+
+def _hash(value: Any) -> str:
+    raw = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+    return "sha256:" + hashlib.sha256(raw.encode("utf-8")).hexdigest()
+
+
+class BehaviorLoop:
+    def __init__(self, path: str | Path, *, archive_threshold: float = 0.5,
+                 minimum_samples: int = 3) -> None:
+        if not 0 <= archive_threshold <= 1 or minimum_samples < 1:
+            raise ValueError("invalid behavior loop thresholds")
+        self.path = Path(path)
+        self.archive_threshold = float(archive_threshold)
+        self.minimum_samples = int(minimum_samples)
+
+    def _append(self, event: Mapping[str, Any]) -> dict[str, Any]:
+        row = {"schema": SCHEMA, **dict(event), "recorded_at": time.time()}
+        row["event_hash"] = _hash({key: value for key, value in row.items()
+                                    if key != "event_hash"})
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with self.path.open("a", encoding="utf-8") as stream:
+            stream.write(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n")
+        return row
+
+    def events(self) -> list[dict[str, Any]]:
+        if not self.path.exists():
+            return []
+        rows = []
+        for line in self.path.read_text(encoding="utf-8").splitlines():
+            if line.strip():
+                row = json.loads(line)
+                if row.get("schema") != SCHEMA:
+                    raise BehaviorLoopError("unsupported behavior loop schema")
+                rows.append(row)
+        return rows
+
+    def propose(self, pattern: str, skill_digest: str, *, source: str = "feedback") -> dict[str, Any]:
+        pattern = str(pattern or "").strip()
+        skill_digest = str(skill_digest or "").strip()
+        if not pattern or not skill_digest:
+            raise BehaviorLoopError("pattern and skill_digest are required")
+        proposal_id = _hash({"pattern": pattern, "skill_digest": skill_digest})
+        existing = [row for row in self.events()
+                    if row.get("event") == "proposal" and row.get("proposal_id") == proposal_id]
+        if existing:
+            return dict(existing[-1])
+        return self._append({"event": "proposal", "proposal_id": proposal_id,
+                             "pattern": pattern, "skill_digest": skill_digest,
+                             "source": str(source), "state": "proposed",
+                             "action_gate": "required_for_promotion"})
+
+    def promote(self, proposal_id: str, *, action_gate: bool = False,
+                authorization_digest: str = "") -> dict[str, Any]:
+        proposal = self._proposal(proposal_id)
+        if not action_gate:
+            raise BehaviorLoopError("action gate required for promotion")
+        if not authorization_digest:
+            raise BehaviorLoopError("authorization digest required for promotion")
+        return self._append({"event": "promotion", "proposal_id": proposal_id,
+                             "state": "promoted", "skill_digest": proposal["skill_digest"],
+                             "authorization_digest": authorization_digest})
+
+    def feedback(self, proposal_id: str, *, accepted: bool,
+                 evidence_digest: str) -> dict[str, Any]:
+        self._proposal(proposal_id)
+        if not evidence_digest:
+            raise BehaviorLoopError("evidence digest required")
+        return self._append({"event": "feedback", "proposal_id": proposal_id,
+                             "accepted": bool(accepted), "evidence_digest": evidence_digest})
+
+    def evaluate(self, proposal_id: str) -> dict[str, Any]:
+        proposal = self._proposal(proposal_id)
+        feedback = [row for row in self.events() if row.get("event") == "feedback"
+                    and row.get("proposal_id") == proposal_id]
+        accepted = sum(bool(row.get("accepted")) for row in feedback)
+        rate = accepted / len(feedback) if feedback else None
+        archived = len(feedback) >= self.minimum_samples and rate is not None and rate < self.archive_threshold
+        state = "archived" if archived else ("promoted" if any(
+            row.get("event") == "promotion" and row.get("proposal_id") == proposal_id
+            for row in self.events()) else "proposed")
+        if archived and proposal.get("state") != "archived":
+            self._append({"event": "archive", "proposal_id": proposal_id, "state": "archived",
+                         "acceptance_rate": rate, "reason_code": "acceptance_below_threshold"})
+        result = {"schema": SCHEMA, "proposal_id": proposal_id, "state": state,
+                  "samples": len(feedback), "accepted": accepted,
+                  "acceptance_rate": rate, "archive_threshold": self.archive_threshold,
+                  "minimum_samples": self.minimum_samples}
+        result["receipt_hash"] = _hash(result)
+        return result
+
+    def _proposal(self, proposal_id: str) -> dict[str, Any]:
+        rows = [row for row in self.events() if row.get("event") == "proposal"
+                and row.get("proposal_id") == proposal_id]
+        if not rows:
+            raise BehaviorLoopError("unknown behavior proposal")
+        return rows[-1]
+
+
+__all__ = ["BehaviorLoop", "BehaviorLoopError", "SCHEMA", "STATES"]

{simplicio_loop-3.38.16 → simplicio_loop-3.38.28}/simplicio_loop/checkpoint_lifecycle.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import hashlib
 import json
+import re
 import os
 import shutil
 import tempfile
@@ -74,6 +75,21 @@ class CandidateSpec:
     stalled: bool = False
 
 
+_PATH_COMPONENT_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}\Z")
+
+
+def validate_path_component(value: Any, name: str) -> str:
+    if not isinstance(value, str) or value != value.strip():
+        raise LifecycleError(f"unsafe {name}")
+    if not _PATH_COMPONENT_RE.fullmatch(value) or value in {".", ".."}:
+        raise LifecycleError(f"unsafe {name}")
+    return value
+
+
+def validate_candidate_id(value: Any) -> str:
+    return validate_path_component(value, "candidate_id")
+
+
 class CheckpointLifecycle:
     """Owns immutable base + isolated candidate overlays for one resumable attempt."""
 
@@ -88,8 +104,8 @@ class CheckpointLifecycle:
         base_path: str | Path,
     ) -> None:
         self.root = Path(root)
-        self.task_id = _require(task_id, "task_id")
-        self.attempt_id = _require(attempt_id, "attempt_id")
+        self.task_id = validate_path_component(task_id, "task_id")
+        self.attempt_id = validate_path_component(attempt_id, "attempt_id")
         self.source_commit = _require(source_commit, "source_commit")
         self.fast_generation = _require(fast_generation, "fast_generation")
         self.base_path = Path(base_path).resolve()
@@ -101,7 +117,7 @@ class CheckpointLifecycle:
         self.fence_path = self.attempt / "promotion-fence.json"
 
     def create_overlay(self, candidate_id: str) -> Path:
-        candidate = _require(candidate_id, "candidate_id")
+        candidate = validate_candidate_id(candidate_id)
         target = self.overlays / candidate
         if target.exists():
             marker = self._read_marker(target)
@@ -142,8 +158,8 @@ class CheckpointLifecycle:
         work_units: int = 0,
         previous_digest: str | None = None,
     ) -> dict[str, Any]:
-        candidate = _require(candidate_id, "candidate_id")
-        shard = _require(shard_id, "shard_id")
+        candidate = validate_candidate_id(candidate_id)
+        shard = validate_path_component(shard_id, "shard_id")
         normalized_state = _require(state, "state").upper()
         if normalized_state not in ACTIVE_STATES | TERMINAL_STATES:
             raise LifecycleError(f"unsafe checkpoint state: {normalized_state}")
@@ -193,7 +209,7 @@ class CheckpointLifecycle:
         return item
 
     def load(self, candidate_id: str, shard_id: str) -> dict[str, Any]:
-        path = self.checkpoints / _require(candidate_id, "candidate_id") / f"{_require(shard_id, 'shard_id')}.json"
+        path = self.checkpoints / validate_candidate_id(candidate_id) / f"{validate_path_component(shard_id, 'shard_id')}.json"
         try:
             return self.verify(json.loads(path.read_text(encoding="utf-8")))
         except (OSError, json.JSONDecodeError) as exc:
@@ -209,7 +225,7 @@ class CheckpointLifecycle:
         cancelled: list[str] = []
         errors: list[dict[str, str]] = []
         for raw in sorted(set(candidate_ids)):
-            candidate = _require(raw, "candidate_id")
+            candidate = validate_candidate_id(raw)
             try:
                 if cancel_callback:
                     cancel_callback(candidate)
@@ -356,7 +372,7 @@ class CheckpointLifecycle:
         cancel_callback: Callable[[str], None] | None = None,
     ) -> dict[str, Any]:
         winner = _require(winner_id, "winner_id")
-        candidates = sorted(set(_require(value, "candidate_id") for value in candidate_ids))
+        candidates = sorted(set(validate_candidate_id(value) for value in candidate_ids))
         if winner not in candidates:
             raise LifecycleError("selected winner is not a candidate")
         checkpoints = [self.load(candidate, shard_id) for candidate in candidates]
@@ -391,7 +407,7 @@ class CheckpointLifecycle:
         }
 
     def lease(self, candidate_id: str, *, expires_ns: int) -> dict[str, Any]:
-        candidate = _require(candidate_id, "candidate_id")
+        candidate = validate_candidate_id(candidate_id)
         value = {
             "schema": SCHEMA,
             "candidate_id": candidate,
@@ -431,9 +447,15 @@ class CheckpointLifecycle:
         removed: list[str] = []
         if apply:
             for candidate in eligible:
-                shutil.rmtree(self.overlays / candidate, ignore_errors=False)
-                shutil.rmtree(self.checkpoints / candidate, ignore_errors=False)
-                (self.cancellations / f"{candidate}.json").unlink()
+                overlay = self.overlays / candidate
+                checkpoints = self.checkpoints / candidate
+                cancellation = self.cancellations / f"{candidate}.json"
+                if overlay.exists():
+                    shutil.rmtree(overlay, ignore_errors=False)
+                if checkpoints.exists():
+                    shutil.rmtree(checkpoints, ignore_errors=False)
+                cancellation.unlink(missing_ok=True)
+                (self.leases / f"{candidate}.json").unlink(missing_ok=True)
                 removed.append(candidate)
         return {
             "schema": SCHEMA,