simplicio-loop 3.38.7__tar.gz → 3.38.8__tar.gz

{simplicio_loop-3.38.7/simplicio_loop.egg-info → simplicio_loop-3.38.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.38.7
+Version: 3.38.8
 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.7 → simplicio_loop-3.38.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simplicio-loop"
-version = "3.38.7"
+version = "3.38.8"
 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"

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/simplicio_loop/__init__.py

@@ -13,6 +13,6 @@ try:
     try:
         __version__ = _v("simplicio-loop")
     except PackageNotFoundError:
-        __version__ = "3.38.7"
+        __version__ = "3.38.8"
 except Exception:  # pragma: no cover
-        __version__ = "3.38.7"
+        __version__ = "3.38.8"

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/simplicio_loop/ecosystem_doctor.py

@@ -92,25 +92,25 @@ COMPONENTS: dict[str, dict[str, Any]] = {
 # for full-stack execution while still being a valid standalone installation.
 PROFILES: dict[str, dict[str, dict[str, Any]]] = {
     "standalone": {
-        "simplicio-loop": {"min_version": "3.38.5", "required": True,
+        "simplicio-loop": {"min_version": "3.38.7", "required": True,
                             "capabilities": ("plan", "orient", "run")},
-        "simplicio-mapper": {"min_version": "0.19.0", "required": True,
+        "simplicio-mapper": {"min_version": "0.26.0", "required": True,
                               "capabilities": ("orient", "recall")},
-        "simplicio-dev-cli": {"min_version": "0.11.0", "required": True,
+        "simplicio-dev-cli": {"min_version": "0.18.0", "required": True,
                                "capabilities": ("execute", "validate")},
-        "simplicio-fast": {"min_version": "2.0.14", "required": False,
+        "simplicio-fast": {"min_version": "2.0.16", "required": False,
                             "capabilities": ("understand", "plan")},
         "simplicio-runtime": {"min_version": "3.5.0", "required": False,
                                "capabilities": ("contracts",)},
     },
     "full-stack": {
-        "simplicio-loop": {"min_version": "3.38.5", "required": True,
+        "simplicio-loop": {"min_version": "3.38.7", "required": True,
                             "capabilities": ("plan", "orient", "run")},
-        "simplicio-mapper": {"min_version": "0.19.0", "required": True,
+        "simplicio-mapper": {"min_version": "0.26.0", "required": True,
                               "capabilities": ("orient", "recall")},
-        "simplicio-dev-cli": {"min_version": "0.11.0", "required": True,
+        "simplicio-dev-cli": {"min_version": "0.18.0", "required": True,
                                "capabilities": ("execute", "validate")},
-        "simplicio-fast": {"min_version": "2.0.14", "required": True,
+        "simplicio-fast": {"min_version": "2.0.16", "required": True,
                             "capabilities": ("understand", "plan", "apply")},
         "simplicio-runtime": {"min_version": "3.5.0", "required": True,
                                "capabilities": ("execute", "contracts")},

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/simplicio_loop/github_drain_admission.py

@@ -14,6 +14,7 @@ from .github_drain_intake import (
     INTENT_SCHEMA,
     MAP_SCHEMA,
     PLAN_SCHEMA,
+    PLANNING_RECEIPT_SCHEMA,
     PLANNED_NOT_EXECUTED_EXIT,
     PLANNER_REVISION,
     _digest,
@@ -39,6 +40,7 @@ _JOB_KEYS = {
 _ITEM_KEYS = {
     "number", "title", "url", "labels", "source_revision", "observed_at",
     "dependencies", "external_dependencies_closed", "risk", "state",
+    "acceptance_criteria", "planning_receipt",
 }
 _CANONICAL_MAP_REQUIRED = {"schema", "status", "mode", "repository", "cache_key"}
 _CANONICAL_MAP_ALLOWED = _CANONICAL_MAP_REQUIRED | {
@@ -107,6 +109,54 @@ def _utc_timestamp(value: Any) -> bool:
         return False
 
 
+def _valid_planning_evidence(item: Mapping[str, Any], number: int) -> bool:
+    criteria = item.get("acceptance_criteria")
+    receipt = item.get("planning_receipt")
+    if (
+        not isinstance(criteria, list) or not 1 <= len(criteria) <= 100
+        or not isinstance(receipt, Mapping)
+        or set(receipt) != {
+            "schema", "planner_revision", "item_number", "source_revision",
+            "acceptance_criteria_hash", "plan_hash", "receipt_hash", "created_at",
+        }
+    ):
+        return False
+    seen = set()
+    for criterion in criteria:
+        if (
+            not isinstance(criterion, Mapping)
+            or set(criterion) != {"id", "text", "origin", "state"}
+            or not _identifier(criterion.get("id"), maximum=128)
+            or criterion.get("id") in seen
+            or not _safe_text(criterion.get("text"), maximum=MAX_JOB_TEXT_LENGTH)
+            or criterion.get("origin") not in {"source", "derived"}
+            or criterion.get("state") != "pending"
+        ):
+            return False
+        seen.add(criterion["id"])
+    source_revision = item.get("source_revision")
+    ac_hash = _digest({"acceptance_criteria": criteria})
+    return (
+        receipt.get("schema") == PLANNING_RECEIPT_SCHEMA
+        and receipt.get("planner_revision") == PLANNER_REVISION
+        and receipt.get("item_number") == number
+        and receipt.get("source_revision") == source_revision
+        and receipt.get("acceptance_criteria_hash") == ac_hash
+        and receipt.get("plan_hash") == _digest({
+            "number": number,
+            "source_revision": source_revision,
+            "acs": ac_hash,
+        })
+        and receipt.get("receipt_hash") == _digest({
+            "planner_revision": PLANNER_REVISION,
+            "number": number,
+            "source_revision": source_revision,
+            "acs": ac_hash,
+        })
+        and _utc_timestamp(receipt.get("created_at"))
+    )
+
+
 def _github_issue_url(value: Any, repository: str, number: int) -> bool:
     return (
         isinstance(value, str) and len(value) <= 2048
@@ -220,6 +270,7 @@ def validate_projected_job(job: Mapping[str, Any]) -> None:
             or any(dependency not in dependencies for dependency in external_closed)
             or raw_item.get("risk") not in {"high", "medium", "low"}
             or raw_item.get("state") not in {"planned", "remote_closed"}
+            or not _valid_planning_evidence(raw_item, number)
         ):
             raise DrainAdmissionProjectionError(
                 "projected item values are invalid", reason_code="job_items_invalid"

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/simplicio_loop/installed_artifact.py

@@ -37,7 +37,10 @@ def query_installed_artifact(
         "'path':str(p.resolve()),'sha256':hashlib.sha256(p.read_bytes()).hexdigest()},"
         "sort_keys=True))"
     )
-    argv = list(command or (python_executable, "-I", "-c", probe))
+    # Keep the probe in a separate interpreter while allowing the core
+    # no-network guard to propagate through sitecustomize.  Isolation flags
+    # such as -I/-S intentionally suppress that guard and are rejected.
+    argv = list(command or (python_executable, "-c", probe))
     process = subprocess.run(
         argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=False
     )

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/simplicio_loop/operator_bootstrap.py

@@ -20,7 +20,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Mapping, Optional, Sequence
 
 SCHEMA = "simplicio.operator-bootstrap/v1"
-PACKAGE_SPECS = ("simplicio-cli>=0.16.3", "simplicio-mapper>=0.19.0")
+PACKAGE_SPECS = ("simplicio-cli>=0.18.0", "simplicio-mapper>=0.26.0")
 REQUIRED_BINARIES = ("simplicio-mapper", "simplicio-dev-cli")
 RECEIPT_NAME = "operator-bootstrap.json"
 AUTO_BOOTSTRAP_ENV = "SIMPLICIO_LOOP_AUTO_BOOTSTRAP_OPERATORS"

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/simplicio_loop/runner.py

@@ -4322,6 +4322,19 @@ def _fanout_execution_route(item: Mapping[str, Any], run_dir: Path) -> Dict[str,
     return record
 
 
+def _operator_dispatch_run_dir(item: Mapping[str, Any]) -> Path:
+    """Resolve canonical run storage, with isolated storage for synthetic dispatches."""
+    status = read_status(item["repo"], item["run_id"])
+    if status.get("run_dir"):
+        return Path(status["run_dir"])
+
+    repo_path = Path(item["repo"]).resolve()
+    run_scope = hashlib.sha256(str(item["run_id"]).encode("utf-8")).hexdigest()[:16]
+    run_dir = repo_path / ".simplicio" / "orchestrator" / "dispatch-routes" / run_scope
+    run_dir.mkdir(parents=True, exist_ok=True)
+    return run_dir
+
+
 def _operator_dispatch_attempt(item: Mapping[str, Any]) -> Dict[str, Any]:
     """Call the production operator and reduce its status to a durable worker record."""
     started = _now()
@@ -4344,7 +4357,7 @@ def _operator_dispatch_attempt(item: Mapping[str, Any]) -> Dict[str, Any]:
         "agent": dict(item.get("agent_identity") or {}),
         "context_pack": dict(item.get("context_pack") or {}),
     }
-    run_dir = Path(read_status(item["repo"], item["run_id"])["run_dir"])
+    run_dir = _operator_dispatch_run_dir(item)
     execution_route = _fanout_execution_route(item, run_dir)
     common["execution_route"] = execution_route
     common["route_receipt_sha"] = execution_route["receipt_sha"]

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/simplicio_loop/slot_lease.py

@@ -77,7 +77,27 @@ class LeaseStore:
 
     def _initialize(self) -> None:
         with self._connect() as connection:
-            connection.execute("PRAGMA journal_mode=WAL")
+            # SQLite does not consistently apply busy_timeout while changing
+            # journal_mode. Multiple first-start workers can therefore race
+            # before the database header records WAL. Read first and retry only
+            # the bounded header transition; once one worker wins, all others
+            # observe WAL without issuing another write.
+            deadline = time.monotonic() + 30.0
+            while True:
+                try:
+                    current = connection.execute("PRAGMA journal_mode").fetchone()
+                    if current is None or str(current[0]).lower() != "wal":
+                        connection.execute("PRAGMA journal_mode=WAL")
+                    break
+                except sqlite3.OperationalError as exc:
+                    detail = str(exc).lower()
+                    remaining = deadline - time.monotonic()
+                    if (
+                        ("locked" not in detail and "busy" not in detail)
+                        or remaining <= 0
+                    ):
+                        raise
+                    time.sleep(min(0.01, remaining))
             connection.executescript(
                 """
                 CREATE TABLE IF NOT EXISTS lease_counters (

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8/simplicio_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.38.7
+Version: 3.38.8
 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.7 → simplicio_loop-3.38.8}/tests/test_cli_dispatch_unit.py

@@ -135,9 +135,29 @@ def test_main_run_dispatches_all_positional_and_flags(monkeypatch):
 
 
 def test_run_wraps_conduct_run_and_prints_json(monkeypatch, capsys):
-    monkeypatch.setattr(cli, "conduct_run", lambda repo, task_path, delivery, max_iterations: {"ok": True})
-    rc = cli.run("/r", "t.md", "verified", 3)
+    captured = {}
+
+    def fake_conduct_run(repo, task_path, delivery, max_iterations, *,
+                         quality_provider, quality_policy):
+        captured.update(
+            quality_provider=quality_provider,
+            quality_policy=quality_policy,
+        )
+        return {"ok": True, "outcome": {"exit_code": 0}}
+
+    monkeypatch.setattr(cli, "conduct_run", fake_conduct_run)
+    rc = cli.run(
+        "/r",
+        "t.md",
+        "verified",
+        3,
+        quality_provider="simplicio_loop_quality",
+    )
     assert rc == 0
+    assert captured == {
+        "quality_provider": "simplicio_loop_quality",
+        "quality_policy": "strict-default",
+    }
     assert json.loads(capsys.readouterr().out)["ok"] is True
 
 

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/tests/test_cli_preflight_status_json_unit.py

@@ -114,22 +114,25 @@ class DirectCallCoverageTest(TestCase):
             "simplicio-dev-cli": "simplicio-dev-cli 0.16.1",
             "simplicio-py": "simplicio-py 0.16.1",
             "simplicio": "simplicio-runtime 1.0.0",
+            "simplicio-fast": "simplicio-fast 2.0.16",
         }
         return subprocess.CompletedProcess(command, 0, stdout=names[command[0]] + "\n", stderr="")
 
     def test_preflight_direct_call_text(self):
-        from simplicio_loop import cli
+        from simplicio_loop import cli, strict_mode
         buf = io.StringIO()
         with patch.object(cli.subprocess, "run", side_effect=self._present_operator_run), \
+             patch.object(strict_mode.shutil, "which", side_effect=lambda name: name), \
              contextlib.redirect_stdout(buf):
             rc = cli.preflight(str(REPO), as_json=False)
         self.assertEqual(rc, 0)
         self.assertIn("simplicio-loop preflight", buf.getvalue())
 
     def test_preflight_direct_call_json(self):
-        from simplicio_loop import cli
+        from simplicio_loop import cli, strict_mode
         buf = io.StringIO()
         with patch.object(cli.subprocess, "run", side_effect=self._present_operator_run), \
+             patch.object(strict_mode.shutil, "which", side_effect=lambda name: name), \
              contextlib.redirect_stdout(buf):
             rc = cli.preflight(str(REPO), as_json=True)
         self.assertEqual(rc, 0)
@@ -137,7 +140,7 @@ class DirectCallCoverageTest(TestCase):
         self.assertEqual(doc["schema"], "simplicio.preflight/v1")
 
     def test_preflight_direct_call_missing_core_operator_blocks(self):
-        from simplicio_loop import cli, finding_router
+        from simplicio_loop import cli, finding_router, strict_mode
 
         def missing_mapper(command: list[str], **_kwargs: object) -> subprocess.CompletedProcess[str]:
             if command[0] == "simplicio-mapper":
@@ -146,6 +149,7 @@ class DirectCallCoverageTest(TestCase):
 
         buf = io.StringIO()
         with patch.object(cli.subprocess, "run", side_effect=missing_mapper), \
+             patch.object(strict_mode.shutil, "which", side_effect=lambda name: name), \
              patch.object(finding_router, "route_finding"), \
              contextlib.redirect_stdout(buf):
             rc = cli.preflight(str(REPO), as_json=True)

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/tests/test_code_hub_transport.py

@@ -47,7 +47,7 @@ def _request_raw(stream, reader, request_id, method, payload):
     return json.loads(line)
 
 
-def test_code_client_contract_uses_one_hub_identity_and_replays_lifecycle():
+def test_code_client_contract_uses_one_hub_identity_and_replays_lifecycle(require_af_unix):
     with tempfile.TemporaryDirectory() as directory:
         lock = str(Path(directory) / "hub.lock")
         endpoint, transport = _endpoint(directory)
@@ -94,7 +94,7 @@ def test_code_client_contract_uses_one_hub_identity_and_replays_lifecycle():
             daemon.stop()
 
 
-def test_code_runtime_execute_is_forwarded_to_hub_owned_runtime_bridge():
+def test_code_runtime_execute_is_forwarded_to_hub_owned_runtime_bridge(require_af_unix):
     class RecordingRuntime:
         def __init__(self):
             self.calls = []
@@ -143,7 +143,7 @@ def test_code_runtime_execute_is_forwarded_to_hub_owned_runtime_bridge():
             daemon.stop()
 
 
-def test_code_runtime_call_is_forwarded_to_hub_owned_runtime_bridge():
+def test_code_runtime_call_is_forwarded_to_hub_owned_runtime_bridge(require_af_unix):
     class RecordingRuntime:
         def __init__(self):
             self.calls = []
@@ -330,7 +330,7 @@ def test_code_runtime_call_reaches_real_runtime_fs_stat():
             daemon.stop()
 
 
-def test_external_worker_contract_is_durable_idempotent_and_cancel_fail_closed():
+def test_external_worker_contract_is_durable_idempotent_and_cancel_fail_closed(require_af_unix):
     with tempfile.TemporaryDirectory() as directory:
         lock = str(Path(directory) / "hub.lock")
         endpoint, transport = _endpoint(directory)

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/tests/test_completion_auditor_431_unit.py

@@ -586,7 +586,7 @@ def test_cli_blocks_when_anchor_file_missing(tmp_path, monkeypatch):
 
     fake_repo = tmp_path / "repo"
     (fake_repo / ".simplicio/orchestrator" / "loop").mkdir(parents=True)
-    (fake_repo / ".simplicio").mkdir(parents=True)
+    (fake_repo / ".simplicio").mkdir(parents=True, exist_ok=True)
     (fake_repo / ".simplicio/orchestrator" / "loop" / "stage_instances.json").write_text("[]", encoding="utf-8")
     (fake_repo / ".simplicio/orchestrator" / "loop" / "stage_receipts.json").write_text("[]", encoding="utf-8")
 

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/tests/test_ecosystem_doctor_805.py

@@ -9,7 +9,7 @@ def _fake_dist(version="1.0.0", installed=True):
             "path": "/tmp/site-packages", "entrypoints": ["fake-entry"]}
 
 
-def _probe(monkeypatch, *, component="simplicio-mapper", version="0.19.0",
+def _probe(monkeypatch, *, component="simplicio-mapper", version="0.26.0",
            help_text="orient recall", executable="/usr/local/bin/simplicio-mapper",
            installed=True):
     monkeypatch.setattr(doctor, "_distribution", lambda _: _fake_dist(version, installed))
@@ -23,7 +23,7 @@ def _probe(monkeypatch, *, component="simplicio-mapper", version="0.19.0",
 
 
 def test_probe_reports_available_with_identity_version_capabilities_and_shas(monkeypatch):
-    row = _probe(monkeypatch, help_text="simplicio-mapper 0.19.0 orient recall")
+    row = _probe(monkeypatch, help_text="simplicio-mapper 0.26.0 orient recall")
     assert row["status"] == doctor.STATUS_AVAILABLE
     assert row["git_sha"] is None
     assert row["sha_source"] == "unavailable"
@@ -33,7 +33,7 @@ def test_probe_reports_available_with_identity_version_capabilities_and_shas(mon
 
 
 def test_loop_sha_is_only_reported_for_the_loop_checkout(monkeypatch, tmp_path):
-    monkeypatch.setattr(doctor, "_distribution", lambda _: _fake_dist("3.38.5", True))
+    monkeypatch.setattr(doctor, "_distribution", lambda _: _fake_dist("3.38.7", True))
     monkeypatch.setattr(doctor.shutil, "which", lambda _: None)
     monkeypatch.setattr(doctor, "_git_sha", lambda _: "a" * 40)
     monkeypatch.setattr(doctor, "_submodule_shas", lambda _: {})
@@ -62,7 +62,7 @@ def test_probe_distinguishes_missing_incompatible_disabled_and_degraded(monkeypa
     assert disabled["status"] == doctor.STATUS_DISABLED
     assert disabled["reason_code"] == "disabled"
 
-    monkeypatch.setattr(doctor, "_distribution", lambda _: _fake_dist("2.0.14", installed=True))
+    monkeypatch.setattr(doctor, "_distribution", lambda _: _fake_dist("2.0.16", installed=True))
     monkeypatch.setattr(doctor.shutil, "which", lambda _: None)
     degraded = doctor._probe_component("simplicio-fast", doctor.COMPONENTS["simplicio-fast"],
                                        tmp_path, doctor.PROFILES["standalone"]["simplicio-fast"])

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/tests/test_evidence_receipt_unit.py

@@ -49,6 +49,32 @@ def test_evidence_receipt_built_from_run_and_watcher_reads_it(tmp_path):
     (src / "app.py").write_text("def main():\n    return 'ok'\n", encoding="utf-8")
     task = tmp_path / "task.md"
     task.write_text(TASK, encoding="utf-8")
+    operator_bin = tmp_path / "bin"
+    operator_bin.mkdir()
+    mapper = operator_bin / "simplicio-mapper"
+    mapper.write_text(
+        """#!/usr/bin/env python3
+import json
+import sys
+
+if len(sys.argv) > 1 and sys.argv[1] == "inspect":
+    print(json.dumps({
+        "status": {"artifacts_present": True, "fresh": True},
+        "evidence": {"artifacts": {"snapshot": {"exists": True}}},
+    }))
+elif len(sys.argv) > 1 and sys.argv[1] == "handoff":
+    print(json.dumps({
+        "context_pack": {
+            "pack_hash": "test-evidence-receipt",
+            "files": [{"path": "src/app.py"}],
+        }
+    }))
+else:
+    print("{}")
+""",
+        encoding="utf-8",
+    )
+    mapper.chmod(0o755)
     fake_operator = json.dumps({
         "execution_state": "dry_run",
         "returncode": 0,
@@ -57,24 +83,31 @@ def test_evidence_receipt_built_from_run_and_watcher_reads_it(tmp_path):
         "argv": ["simplicio-dev-cli", "task", "demo"]
     })
     fake_mapper_preflight = json.dumps({
-        "version_stdout": "simplicio-mapper 0.14.0",
+        "version_stdout": "simplicio-mapper 0.26.0",
         "help_stdout": " inspect handoff ask sync drift ",
         "version_returncode": 0,
         "help_returncode": 0,
     })
     fake_devcli_preflight = json.dumps({
-        "help_stdout": " task --dry-run-task --json ",
+        "version_stdout": "simplicio-dev-cli 0.18.0",
+        "help_stdout": " task --dry-run-task --json --bound-paths --target --task-spec --mode ",
+        "version_returncode": 0,
         "help_returncode": 0,
     })
     started = _run(CLI + ["run", "--repo", str(repo), "--task", str(task),
-                          "--delivery", "verified", "--max-iterations", "9"], REPO,
+                          "--delivery", "verified", "--max-iterations", "9",
+                          "--quality-provider", "simplicio_loop_quality"], REPO,
                    env={
                        "SIMPLICIO_LOOP_FAKE_OPERATOR_JSON": fake_operator,
                        "SIMPLICIO_LOOP_FAKE_MAPPER_PREFLIGHT_JSON": fake_mapper_preflight,
                        "SIMPLICIO_LOOP_FAKE_DEVCLI_PREFLIGHT_JSON": fake_devcli_preflight,
+                       # Do not inherit a host-installed operator: this test proves the
+                       # explicit dry-run boundary and must remain PARTIAL everywhere.
+                       "PATH": str(operator_bin) + os.pathsep + os.defpath,
                    })
-    assert started.returncode == 0, started.stdout + started.stderr
+    assert started.returncode == 22, started.stdout + started.stderr
     payload = json.loads(started.stdout)
+    assert payload["outcome"]["outcome"] == "PARTIAL"
     run_dir = payload["run_dir"]
     evidence_path = os.path.join(run_dir, "evidence-receipt.json")
     assert os.path.exists(evidence_path)
@@ -95,7 +128,11 @@ def test_evidence_receipt_built_from_run_and_watcher_reads_it(tmp_path):
                          encoding="utf-8")
     (loop_dir / "anchor.json").write_text(json.dumps({"criteria": [{"id": "AC1", "status": "done"}]}),
                                           encoding="utf-8")
-    r = _run([sys.executable, WATCHER, "verify"], str(repo), env={"SIMPLICIO_RUN_DIR": run_dir})
+    r = _run(
+        [sys.executable, WATCHER, "verify"],
+        str(repo),
+        env={"SIMPLICIO_RUN_DIR": run_dir, "SIMPLICIO_LOOP_REPO": str(repo)},
+    )
     assert r.returncode == 0
     state = json.loads((loop_dir / "watcher_state.json").read_text(encoding="utf-8"))
     assert state["status"] == "UNVERIFIED"
@@ -169,7 +206,11 @@ def test_watcher_rejects_uncovered_manual_diff_from_evidence(tmp_path):
                     "scenario_verified": 1, "rule_total": 0, "rule_verified": 0},
         "checks": [],
     }), encoding="utf-8")
-    r = _run([sys.executable, WATCHER, "verify"], str(repo), env={"SIMPLICIO_RUN_DIR": str(run_dir)})
+    r = _run(
+        [sys.executable, WATCHER, "verify"],
+        str(repo),
+        env={"SIMPLICIO_RUN_DIR": str(run_dir), "SIMPLICIO_LOOP_REPO": str(repo)},
+    )
     assert r.returncode == 0
     state = json.loads((loop_dir / "watcher_state.json").read_text(encoding="utf-8"))
     assert state["match"] is False
@@ -196,8 +237,11 @@ def test_watcher_rejects_verified_ac_without_proof_reference(tmp_path):
         "summary": {"criteria_total": 1, "criteria_verified": 1, "scenario_total": 1,
                     "scenario_verified": 1, "rule_total": 0, "rule_verified": 0}, "checks": [],
     }), encoding="utf-8")
-    r = _run([sys.executable, WATCHER, "verify"], str(repo),
-             env={"SIMPLICIO_RUN_DIR": str(run_dir)})
+    r = _run(
+        [sys.executable, WATCHER, "verify"],
+        str(repo),
+        env={"SIMPLICIO_RUN_DIR": str(run_dir), "SIMPLICIO_LOOP_REPO": str(repo)},
+    )
     assert r.returncode == 0
     state = json.loads((loop_dir / "watcher_state.json").read_text(encoding="utf-8"))
     assert state["match"] is False

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/tests/test_github_drain_admission_projection.py

@@ -112,6 +112,18 @@ def test_closed_external_dependency_evidence_is_preserved_and_bound(tmp_path):
         (lambda value: value["plan"]["waves"].reverse(), "checkpoint_plan_invalid"),
         (lambda value: value["source_observation"].update(path="/private/source"), "job_source_invalid"),
         (lambda value: value["items"]["1"].update(path="/private/worktree"), "job_items_invalid"),
+        (
+            lambda value: value["items"]["1"]["acceptance_criteria"][0].update(
+                text="tampered after planning"
+            ),
+            "job_items_invalid",
+        ),
+        (
+            lambda value: value["items"]["1"]["planning_receipt"].update(
+                receipt_hash="0" * 64
+            ),
+            "job_items_invalid",
+        ),
         (
             lambda value: value["items"]["1"].update(
                 dependencies=[99], external_dependencies_closed=[99],

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/tests/test_hooks_coverage_integration.py

@@ -110,7 +110,7 @@ def test_orient_rewrite_noop_outside_a_simplicio_loop_project(tmp_path):
 
 
 def test_orient_rewrite_wraps_allowed_readonly_command_inside_project(tmp_path):
-    (tmp_path / ".simplicio/orchestrator").mkdir()
+    (tmp_path / ".simplicio/orchestrator").mkdir(parents=True)
     out = _rewrite({"command": "git status"}, cwd=str(tmp_path))
     updated = out["hookSpecificOutput"].get("updatedInput", {}).get("command", "")
     assert "orient_clamp.py" in updated and "git status" in updated
@@ -123,21 +123,21 @@ def test_orient_rewrite_env_var_gate_without_orchestrator_dir(tmp_path):
 
 
 def test_orient_rewrite_leaves_compound_command_unchanged(tmp_path):
-    (tmp_path / ".simplicio/orchestrator").mkdir()
+    (tmp_path / ".simplicio/orchestrator").mkdir(parents=True)
     out = _rewrite({"command": "git status && rm -rf /tmp/x"}, cwd=str(tmp_path))
     assert "updatedInput" not in out["hookSpecificOutput"], \
         "a compound/unsafe-shaped command must never be rewritten"
 
 
 def test_orient_rewrite_leaves_non_allowlisted_command_unchanged(tmp_path):
-    (tmp_path / ".simplicio/orchestrator").mkdir()
+    (tmp_path / ".simplicio/orchestrator").mkdir(parents=True)
     out = _rewrite({"command": "npm install left-pad"}, cwd=str(tmp_path))
     assert "updatedInput" not in out["hookSpecificOutput"], \
         "a write command outside the read-only allowlist must never be rewritten"
 
 
 def test_orient_rewrite_leaves_already_wrapped_command_unchanged(tmp_path):
-    (tmp_path / ".simplicio/orchestrator").mkdir()
+    (tmp_path / ".simplicio/orchestrator").mkdir(parents=True)
     out = _rewrite({"command": 'python3 "hooks/orient_clamp.py" -- git status'}, cwd=str(tmp_path))
     assert "updatedInput" not in out["hookSpecificOutput"]
 

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/tests/test_hub_held_admission_queue.py

@@ -6,7 +6,11 @@ import threading
 import pytest
 
 from simplicio_loop.github_drain_admission import build_admission_request
-from simplicio_loop.github_drain_intake import _digest
+from simplicio_loop.github_drain_intake import (
+    PLANNER_REVISION,
+    _build_item_planning_receipt,
+    _digest,
+)
 from simplicio_loop.hub_governor import ResourceGovernor, ResourceLimits, ResourceRequest
 from simplicio_loop.hub_queue_retry import HubRetryQueue, QueueRetryError
 from simplicio_loop.hub_scheduler import FairScheduler, ScheduledJob
@@ -14,6 +18,23 @@ from simplicio_loop.hub_service import HubService
 
 
 def _job(run_digest: str = "a" * 64, *, title: str = "one"):
+    acceptance_criteria = [{
+        "id": "AC-TITLE",
+        "text": f"Implementar e verificar: {title}",
+        "origin": "source",
+        "state": "pending",
+    }, {
+        "id": "AC-EVIDENCE-GATE",
+        "text": "Concluir somente com evidência concreta e receipt de entrega.",
+        "origin": "derived",
+        "state": "pending",
+    }]
+    planning_receipt = _build_item_planning_receipt(
+        item_number=1,
+        source_revision="r1",
+        acceptance_criteria=acceptance_criteria,
+        planner_revision=PLANNER_REVISION,
+    )
     source = {
         "digest": _digest([1]), "open_issues": [1], "observed_at": "2026-07-19T00:00:00Z",
     }
@@ -44,6 +65,8 @@ def _job(run_digest: str = "a" * 64, *, title: str = "one"):
             "labels": [], "source_revision": "r1", "observed_at": "2026-07-19T00:00:00Z",
             "dependencies": [], "external_dependencies_closed": [], "risk": "low",
             "state": "planned",
+            "acceptance_criteria": acceptance_criteria,
+            "planning_receipt": planning_receipt,
         }},
         "external_dependencies": {},
         "plan": plan,

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/tests/test_hub_interactive_transport_system.py

@@ -22,7 +22,7 @@ def _stop(process):
     process.terminate(); process.wait(timeout=10)
 
 @pytest.mark.skipif(os.name == "nt", reason="POSIX external socket proof")
-def test_external_interactive_reconnect_replay_and_idempotent_submit():
+def test_external_interactive_reconnect_replay_and_idempotent_submit(require_af_unix):
     with tempfile.TemporaryDirectory() as directory:
         lock, endpoint = str(Path(directory)/"hub.lock"), str(Path(directory)/"hub.sock")
         process = _start(lock, endpoint)

{simplicio_loop-3.38.7 → simplicio_loop-3.38.8}/tests/test_hub_queue_agent_client.py

@@ -140,7 +140,7 @@ def _process_spec(*argv: str, timeout: float = 5.0) -> dict:
     }
 
 
-def test_real_hub_socket_lifecycle_stale_fence_and_cancel():
+def test_real_hub_socket_lifecycle_stale_fence_and_cancel(require_af_unix):
     with tempfile.TemporaryDirectory() as directory:
         daemon = HubDaemon(str(Path(directory) / "hub.lock"))
         daemon.start()
@@ -174,7 +174,7 @@ def test_real_hub_socket_lifecycle_stale_fence_and_cancel():
             daemon.stop()
 
 
-def test_real_hub_restart_marks_claimed_recovery_unknown_without_redispatch():
+def test_real_hub_restart_marks_claimed_recovery_unknown_without_redispatch(require_af_unix):
     with tempfile.TemporaryDirectory() as directory:
         lock_path = str(Path(directory) / "hub.lock")
         daemon = HubDaemon(lock_path)