agentic-dev-loop 1.0.0a6__tar.gz → 1.0.0a7__tar.gz

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a6
+Version: 1.0.0a7
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentic-dev-loop"
-version = "1.0.0a6"
+version = "1.0.0a7"
 description = "Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase."
 readme = "README.md"
 requires-python = ">=3.12"

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a7}/src/agentic_dev_loop/engine/isolation.py

@@ -20,6 +20,7 @@ import json
 import math
 import os
 import re
+import shlex
 import shutil
 import subprocess
 import time
@@ -66,6 +67,14 @@ AUDIT_MAX_BYTES = 5 * 1024 * 1024
 # hung `setup:` hook can never wedge startup (BR-8 fail fast, not a hang).
 PROVISION_TIMEOUT_SECONDS = 3600
 
+# The sandbox venv the shipped pipeline relies on (016 sandbox-venv
+# hardening). The engine probes this path INSIDE the exec container
+# before trusting a warm provision stamp — a host-built (darwin) venv
+# symlinks to a host interpreter that does not exist in the Linux
+# container, so it must be detected and re-provisioned there.
+SANDBOX_VENV_DIR = ".venv-sandbox"
+SANDBOX_VENV_PYTHON = ".venv-sandbox/bin/python"
+
 
 class SandboxError(RuntimeError):
     """A loud fail-fast sandbox failure; the message names the problem and
@@ -270,6 +279,58 @@ def setup_stamp_key(setup_cmd: str, lockfile_hashes: dict[str, str]) -> str:
         json.dumps(canonical, sort_keys=True).encode("utf-8")).hexdigest()
 
 
+def venv_probe_command() -> str:
+    """In-container probe classifying the sandbox venv (016 self-heal).
+
+    Returns a shell command that prints exactly one of ``valid`` /
+    ``missing`` / ``broken`` and exits 0. ``broken`` is the host-tampered
+    class: the python entry exists as a path (including a dangling symlink —
+    the host-darwin venv case) but is not executable/importable in the
+    container. ``missing`` means no such entry at all (the setup hook may
+    legitimately not create a venv), so it is treated as a stamp hit, never a
+    self-heal trigger.
+    """
+    py = shlex.quote(SANDBOX_VENV_PYTHON)
+    return (
+        f"if [ -L {py} ] && [ ! -x {py} ]; then echo broken; "
+        f"elif [ ! -e {py} ]; then echo missing; "
+        f"elif {py} -c 'import sys' >/dev/null 2>&1; then echo valid; "
+        f"else echo broken; fi"
+    )
+
+
+def venv_probe_argv(container: str, workspace: str) -> list[str]:
+    """``docker exec`` argv that runs the venv probe inside the (already
+    running) execution container against the bind-mounted workspace."""
+    return ["docker", "exec", "-w", workspace, container,
+            "/bin/sh", "-c", venv_probe_command()]
+
+
+def venv_probe_state(stdout: str, exit_code: int | None) -> str:
+    """Classify a probe result. A nonzero exit (docker exec failed) is
+    ``unknown`` — the caller leaves the stamp alone rather than guessing."""
+    if exit_code != 0:
+        return "unknown"
+    line = stdout.strip().splitlines()[-1] if stdout.strip() else ""
+    return line if line in ("valid", "missing", "broken") else "unknown"
+
+
+def remove_sandbox_venv(workspace: str | Path) -> None:
+    """Remove the workspace's sandbox venv before re-provision (016 self-heal).
+    Fails loud when the venv exists but cannot be removed — a silent skip
+    would re-create the ENOENT failure the next run."""
+    venv = Path(workspace) / SANDBOX_VENV_DIR
+    try:
+        if venv.is_symlink() or venv.is_file():
+            venv.unlink()
+        elif venv.is_dir():
+            shutil.rmtree(venv)
+    except OSError as e:
+        raise SandboxError(
+            f"AE-SBX-014: cannot remove invalid sandbox venv at {venv}: {e} "
+            f"— remove it manually and re-run (docs/setup.md §5)") from e
+
+
 def host_user_flag() -> str | None:
     """The ``docker --user`` value binding the sandbox to the host user.
 
@@ -507,9 +568,20 @@ class DockerBackend(Sandbox):
     def provision(self, setup_cmd: str, stamp_key: str, stamp_dir: str,
                   force: bool) -> None:
         """Run one ``setup:`` hook in the provision container (network ON),
-        stamp-cached. Nonzero exit → AE-SBX-009, no stamp written."""
+        stamp-cached. Nonzero exit → AE-SBX-009, no stamp written.
+
+        016 self-heal: a warm stamp no longer blind-skips. Before trusting it,
+        probe the sandbox venv inside the exec container — a host-built venv
+        (darwin symlinks to a host interpreter) looks valid on the host but is
+        broken in the Linux container. A ``broken`` probe removes the venv
+        (fail loud if removal is impossible) and falls through to re-provision;
+        ``valid``/``missing``/``unknown`` keep the stamp skip.
+        """
         if not force and read_stamp(Path(stamp_dir), stamp_key):
-            return
+            if self._probe_venv() == "broken":
+                remove_sandbox_venv(self._workspace)
+            else:
+                return
         payload = docker_provision_payload(
             run_id=self._run_id, image=self._image, workspace=self._workspace,
             setup_cmd=setup_cmd)
@@ -521,6 +593,12 @@ class DockerBackend(Sandbox):
                 f"— stamp not written (docs/setup.md §5)")
         write_stamp(Path(stamp_dir), stamp_key)
 
+    def _probe_venv(self) -> str:
+        """Run the in-container venv probe and classify it (016 self-heal)."""
+        res = self._runner.run(
+            venv_probe_argv(self._container, self._workspace), timeout=30)
+        return venv_probe_state(res.stdout, res.exit_code)
+
     # -- execution ----------------------------------------------------------
 
     def run(self, request: SandboxExecutionRequest) -> SandboxExecutionResult:

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a7}/src/agentic_dev_loop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a6
+Version: 1.0.0a7
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a7}/tests/test_isolation.py

@@ -20,8 +20,9 @@ from agentic_dev_loop.engine.isolation import (
     SandboxExecutionRequest, SandboxExecutionResult, append_audit_record,
     clean_stamps, docker_create_payload, docker_provision_payload,
     exec_container_name, is_git_mutation, probe_docker, read_stamp,
-    resolve_effective_profile, resolve_image_ref, resolve_sandbox_env,
-    select_backend, setup_stamp_key, translate_mount_path, write_stamp,
+    remove_sandbox_venv, resolve_effective_profile, resolve_image_ref,
+    resolve_sandbox_env, select_backend, setup_stamp_key, translate_mount_path,
+    venv_probe_argv, venv_probe_command, venv_probe_state, write_stamp,
 )
 
 
@@ -243,6 +244,66 @@ class TestSetupStampKey:
         assert a == b
 
 
+class TestVenvProbe:
+    def test_command_classifies_broken_symlink_first(self):
+        cmd = venv_probe_command()
+        # the dangling-symlink (host-darwin) case is caught before -e, which
+        # would otherwise report "missing"
+        assert "echo broken" in cmd and "echo missing" in cmd and "echo valid" in cmd
+        assert "-L .venv-sandbox/bin/python" in cmd
+        assert "import sys" in cmd
+
+    def test_argv_assembly(self):
+        argv = venv_probe_argv("c1", "/ws")
+        assert argv[:5] == ["docker", "exec", "-w", "/ws", "c1"]
+        assert argv[5:] == ["/bin/sh", "-c", venv_probe_command()]
+
+    @pytest.mark.parametrize("stdout,exit_code,expected", [
+        ("valid\n", 0, "valid"),
+        ("missing\n", 0, "missing"),
+        ("broken\n", 0, "broken"),
+        ("", 0, "unknown"),
+        ("garbage", 0, "unknown"),
+        ("valid", 1, "unknown"),
+    ])
+    def test_state_classification(self, stdout, exit_code, expected):
+        assert venv_probe_state(stdout, exit_code) == expected
+
+
+class TestRemoveSandboxVenv:
+    def test_removes_broken_symlink_dir(self, tmp_path):
+        ws = tmp_path / "ws"
+        venv = ws / ".venv-sandbox"
+        (venv / "bin").mkdir(parents=True)
+        (venv / "bin" / "python").symlink_to("/opt/homebrew/opt/python/bin/python3.14")
+        remove_sandbox_venv(ws)
+        assert not venv.exists()
+
+    def test_removes_regular_dir(self, tmp_path):
+        ws = tmp_path / "ws"
+        venv = ws / ".venv-sandbox"
+        (venv / "lib").mkdir(parents=True)
+        (venv / "lib" / "x.txt").write_text("x")
+        remove_sandbox_venv(ws)
+        assert not venv.exists()
+
+    def test_missing_is_noop(self, tmp_path):
+        ws = tmp_path / "ws"
+        ws.mkdir()
+        remove_sandbox_venv(ws)  # must not raise
+
+    def test_fails_loud_when_removal_impossible(self, tmp_path, monkeypatch):
+        ws = tmp_path / "ws"
+        (ws / ".venv-sandbox").mkdir(parents=True)
+
+        def boom(*args, **kwargs):
+            raise OSError("permission denied")
+
+        monkeypatch.setattr("agentic_dev_loop.engine.isolation.shutil.rmtree", boom)
+        with pytest.raises(SandboxError, match="AE-SBX-014"):
+            remove_sandbox_venv(ws)
+
+
 class TestPayloads:
     def _profile(self):
         return EffectiveProfile(True, True, True, True, True, "img", "4g", 2.0)
@@ -650,12 +711,36 @@ class TestProvisionStampsAudit:
         assert runner.calls
 
     def test_provision_skips_on_stamp(self, tmp_path):
-        runner = FakeRunner(ok(""))
+        """A warm stamp still skips, but only after the in-container venv
+        probe reports ``valid`` (016 self-heal) — no blind skip."""
+        runner = FakeRunner(ok("valid"))
         backend = _backend(tmp_path, runner)
         stamp_dir = tmp_path / "stamps"
         write_stamp(stamp_dir, "key1")
         backend.provision("make build", "key1", str(stamp_dir), force=False)
-        assert runner.calls == []
+        # the probe ran (docker exec); no provision container ran
+        assert [c for c in runner.calls if c[:2] == ["docker", "exec"]]
+        assert not [c for c in runner.calls if c[:2] == ["docker", "run"]]
+
+    def test_provision_self_heals_broken_venv_on_stamp(self, tmp_path):
+        """016 repro (unit): stamp hit + broken venv → probe reports broken →
+        the venv is removed and the setup re-runs instead of blind-skipping."""
+        runner = FakeRunner(ok("broken"), ok(""))
+        backend = _backend(tmp_path, runner)
+        stamp_dir = tmp_path / "stamps"
+        write_stamp(stamp_dir, "key1")
+        ws = tmp_path / "ws"
+        venv_bin = ws / ".venv-sandbox" / "bin"
+        venv_bin.mkdir(parents=True)
+        # host-darwin venv: a python symlink whose target doesn't exist in the
+        # Linux container.
+        (venv_bin / "python").symlink_to("/opt/homebrew/opt/python/bin/python3.14")
+        backend.provision("python -m venv .venv-sandbox", "key1",
+                          str(stamp_dir), force=False)
+        # broken venv removed, then provision re-ran
+        assert not (ws / ".venv-sandbox").exists()
+        assert [c for c in runner.calls if c[:2] == ["docker", "run"]]
+        assert read_stamp(stamp_dir, "key1")
 
     def test_provision_refresh_forces(self, tmp_path):
         runner = FakeRunner(ok(""))

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a7}/tests/test_isolation_integration.py

@@ -180,3 +180,38 @@ class TestProvisionE2E:
         b.provision("printf refreshed > stamp-probe", "k1", str(stamp_dir),
                     force=True)
         assert (ws / "stamp-probe").read_text() == "refreshed"
+
+
+class TestVenvSelfHealE2E:
+    """016 exact repro: a warm stamp plus a host-built (darwin) venv that is
+    broken inside the Linux container must self-heal — remove + re-provision —
+    instead of blind-skipping into a later ENOENT."""
+
+    def test_stamp_hit_with_host_venv_reprovisions(self, backend, tmp_path):
+        b, ws = backend
+        # Simulate a host-rebuilt venv: `bin/python` is a symlink to a host
+        # interpreter path that does not exist inside the Linux container.
+        venv_bin = ws / ".venv-sandbox" / "bin"
+        venv_bin.mkdir(parents=True)
+        (venv_bin / "python").symlink_to(
+            "/opt/homebrew/opt/python@3.14/bin/python3.14")
+        (venv_bin / "pip").symlink_to(
+            "/opt/homebrew/opt/python@3.14/bin/pip3.14")
+
+        stamp_dir = tmp_path / "stamps"
+        key = "warm-stamp"
+        write_stamp(stamp_dir, key)
+
+        b.provision("python -m venv .venv-sandbox", key, str(stamp_dir),
+                    force=False)
+
+        # The broken venv was removed and re-provisioned: the sandbox python
+        # is now executable and importable, and the warm stamp still stands.
+        req = SandboxExecutionRequest(
+            argv=[".venv-sandbox/bin/python", "-c", "import sys; print('ok')"],
+            cwd=ws,
+            env={"PATH": "/usr/local/bin:/usr/bin:/bin", "HOME": "/tmp"})
+        result = b.run(req)
+        assert result.exit_code == 0, result.stderr
+        assert "ok" in result.stdout
+        assert read_stamp(stamp_dir, key)