agentic-dev-loop 1.0.0a11__tar.gz → 1.0.0a13__tar.gz

{agentic_dev_loop-1.0.0a11 → agentic_dev_loop-1.0.0a13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a11
+Version: 1.0.0a13
 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.0a11 → agentic_dev_loop-1.0.0a13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentic-dev-loop"
-version = "1.0.0a11"
+version = "1.0.0a13"
 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.0a11 → agentic_dev_loop-1.0.0a13}/src/agentic_dev_loop/core/config.py

@@ -79,6 +79,13 @@ class IsolationConfig(BaseModel):
     cpus: float | None = None           # override exec container cpus
     allow_git_mutations: bool = False   # BR-6 knob
     state_dir: str = "~/.agentic-dev-loop/state"  # stamps + audit (host-only)
+    # 022 relocation opt-in: an out-of-workspace host dir that is bind-mounted
+    # at ``{ws}/.venv-sandbox`` (rw) in both the exec and provision containers,
+    # keeping the workspace free of container venv artifacts. Unset keeps the
+    # legacy workspace-local ``.venv-sandbox`` unchanged. Must resolve outside
+    # the workspace — validated at startup, not load (the workspace is unknown
+    # here).
+    sandbox_venv_dir: str | None = None
 
     @field_validator("memory")
     @classmethod

{agentic_dev_loop-1.0.0a11 → agentic_dev_loop-1.0.0a13}/src/agentic_dev_loop/engine/cli.py

@@ -12,6 +12,7 @@ from pathlib import Path
 from agentic_dev_loop.core.config import PipelineConfig, load_config
 from .dryrun import dry_run
 from .isolation import clean_stamps, isolation_state_dir
+from .loaders import mark_plan_completed
 from .registry import Registry, default_registry, load_extensions
 
 
@@ -112,6 +113,10 @@ def main(argv: list[str] | None = None) -> int:
     # dry run, --clean-stamps, and --help stay side-effect free.
     from .graph import run_pipeline
     success, _attempts = run_pipeline(args.pipeline, args, registry=registry)
+    if success and args.plan is not None:
+        # Only a completed run earns the stamp — failed runs leave the plan
+        # as-is. AI-DLC runs never pass --plan, so aidlc docs stay untouched.
+        mark_plan_completed(args.plan)
     if not success:
         print("agentic-dev-loop: pipeline failed — exiting with code 1",
               file=sys.stderr)

{agentic_dev_loop-1.0.0a11 → agentic_dev_loop-1.0.0a13}/src/agentic_dev_loop/engine/isolation.py

@@ -7,10 +7,13 @@ concrete implementation (user directive 2026-10-19). Everything else here is
 either pure translation logic (the PBT-03 targets) or host-side audit/stamp
 helpers.
 
-Host-only vs sandboxed: the sandbox mount set is EXACTLY {workspace} (Q1).
-The isolation state dir (stamps + audit JSONL) and the pipeline run-state dir
-(checkpoint DB + last-error.md) are never mounted — sandboxed code cannot
-reach them.
+Host-only vs sandboxed: the sandbox mount set is {workspace} plus the
+host-only mask mounts (022): a read-only empty tmpfs at ``{ws}/.venv`` so the
+host's throwaway venv can never be written from inside the sandbox. When
+``isolation.sandbox_venv_dir`` relocates the sandbox venv, one extra rw bind
+mount at ``{ws}/.venv-sandbox`` is added (opt-in). The isolation state dir
+(stamps + audit JSONL) and the pipeline run-state dir (checkpoint DB +
+last-error.md) are never mounted — sandboxed code cannot reach them.
 """
 
 from __future__ import annotations
@@ -74,6 +77,10 @@ PROVISION_TIMEOUT_SECONDS = 3600
 # container, so it must be detected and re-provisioned there.
 SANDBOX_VENV_DIR = ".venv-sandbox"
 SANDBOX_VENV_PYTHON = ".venv-sandbox/bin/python"
+# Host-only dirs masked inside the sandbox (022): each gets a read-only empty
+# tmpfs submount at ``{ws}/<dir>`` so agents fail loudly on any write instead
+# of silently mutating a host-owned throwaway venv.
+HOST_ONLY_DIRS = (".venv",)
 
 
 class SandboxError(RuntimeError):
@@ -267,16 +274,58 @@ def is_git_mutation(argv: list[str]) -> bool:
     return True
 
 
+def _expand_home(path: str) -> str:
+    """Expand a leading ``~`` against ``$HOME``, falling back to
+    ``USERPROFILE`` (Windows).
+
+    The engine is driven from bash on every platform (Windows via Git Bash),
+    where HOME is the authoritative home. CPython's Windows expanduser ignores
+    HOME in favour of USERPROFILE, so a literal ``~`` in a config file would
+    resolve inconsistently on Windows. Only a leading tilde (``~``, ``~/``,
+    ``~\\``) is handled here; ``~user`` forms and the no-HOME/no-USERPROFILE
+    case fall through to the stdlib below.
+    """
+    if path != "~" and not path.startswith(("~/", "~\\")):
+        return path
+    home = os.environ.get("HOME") or os.environ.get("USERPROFILE")
+    if home:
+        return home + path[1:]
+    return path
+
+
 def translate_mount_path(path: str) -> str:
     """expanduser + absolute resolution without symlink chasing. Identity on
     macOS/Windows/WSL2-with-Docker-Desktop (verbatim passthrough — Docker
-    Desktop translates). Idempotent: translate(translate(p)) == translate(p)."""
-    p = Path(path).expanduser()
+    Desktop translates). Idempotent: translate(translate(p)) == translate(p).
+    A leading ``~`` resolves against $HOME first (USERPROFILE fallback), then
+    the stdlib handles anything left (pwd on POSIX)."""
+    p = Path(_expand_home(path)).expanduser()
     if not p.is_absolute():
         p = p.absolute()
     return str(p)
 
 
+def resolve_sandbox_venv_dir(sandbox_venv_dir: str | None,
+                             workspace: str | Path) -> str | None:
+    """Resolve the opt-in relocated sandbox venv (022).
+
+    ``None`` keeps the legacy workspace-local ``.venv-sandbox`` (bit-compatible
+    default — payloads are unchanged). A set value is expanduser + absolute and
+    must resolve OUTSIDE the workspace: an in-workspace value defeats the whole
+    relocation and fails loud (AE-SBX-015).
+    """
+    if sandbox_venv_dir is None:
+        return None
+    resolved = Path(translate_mount_path(sandbox_venv_dir))
+    ws = Path(translate_mount_path(os.fspath(workspace)))
+    if resolved == ws or ws in resolved.parents:
+        raise SandboxError(
+            f"AE-SBX-015: isolation.sandbox_venv_dir {resolved!r} must resolve "
+            "outside the workspace — an in-workspace value defeats the 022 "
+            "relocation (docs/setup.md §3)")
+    return str(resolved)
+
+
 def setup_stamp_key(setup_cmd: str, lockfile_hashes: dict[str, str]) -> str:
     """sha256 hex of canonical JSON {setup_cmd, lockfiles: sorted hashes}."""
     canonical = {
@@ -323,10 +372,44 @@ def venv_probe_state(stdout: str, exit_code: int | None) -> str:
     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."""
+def _clear_dir_contents(path: Path) -> None:
+    """Delete every entry under ``path``, keeping ``path`` itself. The 022
+    relocated venv is the bind-mount source for the still-running execution
+    container, so the source dir must survive removal (deleting it would leave
+    the container pointed at a stale inode)."""
+    if not path.exists():
+        return
+    for child in path.iterdir():
+        if child.is_symlink() or child.is_file():
+            child.unlink()
+        elif child.is_dir():
+            shutil.rmtree(child)
+
+
+def remove_sandbox_venv(workspace: str | Path, *,
+                        sandbox_venv_dir: str | None = None) -> None:
+    """Remove the 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.
+
+    With the 022 relocation opt-in (``sandbox_venv_dir``), the venv lives at
+    that host path and is the source of a live bind mount in the execution
+    container — so only its CONTENTS are removed (the mount source dir stays),
+    leaving the container's ``{ws}/.venv-sandbox`` mount valid for re-provision.
+    The default (unset) path removes the whole workspace-local dir as before.
+    """
+    if sandbox_venv_dir is not None:
+        venv = Path(sandbox_venv_dir)
+        try:
+            if venv.is_symlink() or venv.is_file():
+                venv.unlink()
+            elif venv.is_dir():
+                _clear_dir_contents(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
+        return
     venv = Path(workspace) / SANDBOX_VENV_DIR
     try:
         if venv.is_symlink() or venv.is_file():
@@ -360,15 +443,34 @@ def exec_container_name(run_id: str, network: bool = False) -> str:
     return f"{run_id}-exec-net" if network else f"{run_id}-exec"
 
 
+def _sandbox_mounts(workspace: str, sandbox_venv_dir: str | None) -> list[str]:
+    """The mount segment shared by the exec and provision payloads (022).
+
+    ``{workspace}`` rw is always first; each host-only dir is then shadowed by
+    a read-only empty tmpfs submount (Docker cannot exclude a subdirectory of a
+    bind — a submount is the only way to hide it, and ``ro`` makes any write
+    attempt fail loudly instead of silently succeeding against a decoy). When
+    ``sandbox_venv_dir`` relocates the sandbox venv, one rw bind mount maps it
+    to the unchanged container path ``{ws}/.venv-sandbox``.
+    """
+    mounts = ["-v", f"{workspace}:{workspace}"]
+    for host_only in HOST_ONLY_DIRS:
+        mounts += ["--tmpfs", f"{workspace}/{host_only}:ro"]
+    if sandbox_venv_dir is not None:
+        mounts += ["-v", f"{sandbox_venv_dir}:{workspace}/{SANDBOX_VENV_DIR}"]
+    return mounts
+
+
 def docker_create_payload(*, run_id: str, image: str, profile: EffectiveProfile,
-                          workspace: str, network: bool = False) -> list[str]:
+                          workspace: str, network: bool = False,
+                          sandbox_venv_dir: str | None = None) -> list[str]:
     """Exact ``docker run -d --rm`` argv for the execution container (§3.3, KD-8).
-    Single mount {workspace} (Q1); ``--network none`` (bridge when ``network``
-    is true — 014 per-stage networking), --read-only, --cap-drop ALL; --user
-    host uid:gid (host-owned bind mounts, AE-SBX-009 root cause) with
-    HOME=/tmp (the rootfs is read-only; /tmp is a 1777 tmpfs). ``--rm`` lets the
-    daemon auto-remove the container the instant it exits, however it exits
-    (D1) — a SIGKILLed CLI never reaches close()."""
+    Mount set {workspace} + host-only masks (022); ``--network none`` (bridge
+    when ``network`` is true — 014 per-stage networking), --read-only,
+    --cap-drop ALL; --user host uid:gid (host-owned bind mounts, AE-SBX-009
+    root cause) with HOME=/tmp (the rootfs is read-only; /tmp is a 1777 tmpfs).
+    ``--rm`` lets the daemon auto-remove the container the instant it exits,
+    however it exits (D1) — a SIGKILLed CLI never reaches close()."""
     payload = [
         "docker", "run", "--detach", "--rm", "--name",
         exec_container_name(run_id, network),
@@ -380,8 +482,8 @@ def docker_create_payload(*, run_id: str, image: str, profile: EffectiveProfile,
     user = host_user_flag()
     if user is not None:
         payload.extend(["--user", user, "--env", "HOME=/tmp"])
+    payload.extend(_sandbox_mounts(workspace, sandbox_venv_dir))
     payload.extend([
-        "-v", f"{workspace}:{workspace}",
         "--workdir", workspace,
         image, "sleep", "infinity",
     ])
@@ -389,10 +491,12 @@ def docker_create_payload(*, run_id: str, image: str, profile: EffectiveProfile,
 
 
 def docker_provision_payload(*, run_id: str, image: str, workspace: str,
-                             setup_cmd: str) -> list[str]:
+                             setup_cmd: str,
+                             sandbox_venv_dir: str | None = None) -> list[str]:
     """Exact ``docker run --rm`` argv for the provision container (§3.4).
-    Network ON (default bridge), rw rootfs, --cap-drop ALL, single mount
-    {workspace} (Q1); --user host uid:gid (AE-SBX-009) with HOME=/tmp."""
+    Network ON (default bridge), rw rootfs, --cap-drop ALL, mount set
+    {workspace} + host-only masks (022); --user host uid:gid (AE-SBX-009) with
+    HOME=/tmp."""
     payload = [
         "docker", "run", "--rm", "--name", f"{run_id}-provision",
         "--network", "bridge", "--cap-drop", "ALL",
@@ -401,8 +505,8 @@ def docker_provision_payload(*, run_id: str, image: str, workspace: str,
     user = host_user_flag()
     if user is not None:
         payload.extend(["--user", user, "--env", "HOME=/tmp"])
+    payload.extend(_sandbox_mounts(workspace, sandbox_venv_dir))
     payload.extend([
-        "-v", f"{workspace}:{workspace}",
         "--workdir", workspace,
         image, "sh", "-c", setup_cmd,
     ])
@@ -502,7 +606,7 @@ class DockerBackend(Sandbox):
 
     def __init__(self, *, image: str, workspace: str, iso_state_dir: str,
                  profile: EffectiveProfile, runner: CommandRunner | None = None,
-                 network: bool = False):
+                 network: bool = False, sandbox_venv_dir: str | None = None):
         self._image = image
         self._workspace = workspace
         self._iso_state_dir = Path(iso_state_dir)  # host-only (audit)
@@ -512,6 +616,13 @@ class DockerBackend(Sandbox):
         self._container = exec_container_name(self._run_id, network=False)
         self._network_container = exec_container_name(self._run_id, network=True)
         self._network_enabled = network
+        self._sandbox_venv_dir = sandbox_venv_dir  # 022 relocated venv (opt-in)
+        if sandbox_venv_dir is not None:
+            # 022: the relocated venv dir is a bind-mount source. On native
+            # Linux, Docker auto-creates a missing source as root, which the
+            # --user uid:gid containers then cannot write (the AE-SBX-009
+            # ownership class). Pre-create it host-side so it is uid-owned.
+            Path(sandbox_venv_dir).mkdir(parents=True, exist_ok=True)
         self._started = False
         self._network_started = False
 
@@ -551,7 +662,8 @@ class DockerBackend(Sandbox):
         infrastructure work happens mid-run (014 per-stage networking)."""
         payload = docker_create_payload(
             run_id=self._run_id, image=self._image, profile=self._profile,
-            workspace=self._workspace, network=False)
+            workspace=self._workspace, network=False,
+            sandbox_venv_dir=self._sandbox_venv_dir)
         res = self._runner.run(payload, timeout=60)
         if res.exit_code != 0:
             raise SandboxError(
@@ -562,7 +674,8 @@ class DockerBackend(Sandbox):
             return
         net_payload = docker_create_payload(
             run_id=self._run_id, image=self._image, profile=self._profile,
-            workspace=self._workspace, network=True)
+            workspace=self._workspace, network=True,
+            sandbox_venv_dir=self._sandbox_venv_dir)
         net_res = self._runner.run(net_payload, timeout=60)
         if net_res.exit_code != 0:
             # reclaim the already-started network-none container — never leak it.
@@ -587,12 +700,13 @@ class DockerBackend(Sandbox):
         """
         if not force and read_stamp(Path(stamp_dir), stamp_key):
             if self._probe_venv() == "broken":
-                remove_sandbox_venv(self._workspace)
+                remove_sandbox_venv(self._workspace,
+                                    sandbox_venv_dir=self._sandbox_venv_dir)
             else:
                 return
         payload = docker_provision_payload(
             run_id=self._run_id, image=self._image, workspace=self._workspace,
-            setup_cmd=setup_cmd)
+            setup_cmd=setup_cmd, sandbox_venv_dir=self._sandbox_venv_dir)
         res = self._runner.run(payload, timeout=PROVISION_TIMEOUT_SECONDS)
         if res.exit_code != 0:
             tail = (res.stdout or res.stderr or "")[-4000:]
@@ -846,9 +960,12 @@ def startup_sandbox(cfg: PipelineConfig, *, workspace: Path,
     image = resolve_image_ref(profile.image)
     iso_state_dir = isolation_state_dir(cfg)
     needs_network = any(step.network for step in cfg.steps)
+    sandbox_venv_dir = resolve_sandbox_venv_dir(
+        cfg.isolation.sandbox_venv_dir if cfg.isolation else None, workspace)
     backend = DockerBackend(
         image=image, workspace=str(workspace), iso_state_dir=str(iso_state_dir),
-        profile=profile, runner=runner, network=needs_network)
+        profile=profile, runner=runner, network=needs_network,
+        sandbox_venv_dir=sandbox_venv_dir)
     backend.ensure_image()
     backend.create_execution_container()
     if refresh is None:

{agentic_dev_loop-1.0.0a11 → agentic_dev_loop-1.0.0a13}/src/agentic_dev_loop/engine/loaders.py

@@ -1,6 +1,7 @@
 """Built-in `plan` document loader + the loader-selection flow."""
 
 import argparse
+import re
 from pathlib import Path
 
 from agentic_dev_loop.core.config import PipelineConfig
@@ -18,6 +19,46 @@ def resolve_plan_docs(plan_path: Path | str) -> dict[str, str]:
     return {path.name: path.read_text()}
 
 
+# A status line at the top of a planning doc, in any recorded form:
+# `> **Status: COMPLETED** (date)`, `**Status:** ...`, `- **Status**: ...`,
+# or bare `Status: ...`.
+_STATUS_LINE = re.compile(r"^\s*(?:>\s*)?(?:[-*]\s+)?\*{0,2}Status\*{0,2}\s*:")
+# The status only counts as "recorded at the top" when it appears early —
+# buried history (e.g. `## Status history` or a later `Status: ...` line)
+# is not the doc's current status.
+_STATUS_SCAN_LINES = 10
+_STAMP = "> **Status: COMPLETED**"
+
+
+def mark_plan_completed(plan_path: Path | str) -> None:
+    """Stamp the plan doc as COMPLETED after a successful run.
+
+    Replaces the first status line found within the top of the doc, or
+    inserts the stamp right after the `# ` title (blank separators around
+    it) — or at the very top when there is no title. Trailing-newline
+    presence is preserved."""
+    path = Path(plan_path)
+    text = path.read_text(encoding="utf-8")
+    lines = text.splitlines()
+    trailing = "\n" if text.endswith("\n") else ""
+
+    for idx in range(min(len(lines), _STATUS_SCAN_LINES)):
+        if _STATUS_LINE.match(lines[idx]):
+            lines[idx] = _STAMP
+            break
+    else:
+        title_idx = next((i for i, line in enumerate(lines)
+                          if line.startswith("# ")), None)
+        insert_at = 0 if title_idx is None else title_idx + 1
+        stamp_block = [_STAMP]
+        if insert_at > 0 and lines[insert_at - 1] != "":
+            stamp_block.insert(0, "")   # blank separator above the stamp
+        if insert_at < len(lines) and lines[insert_at] != "":
+            stamp_block.append("")      # blank separator below the stamp
+        lines[insert_at:insert_at] = stamp_block
+    path.write_text("\n".join(lines) + trailing, encoding="utf-8")
+
+
 class PlanDocumentLoader:
     name = "plan"
     defaultable = False  # needs a path — never autodetects

{agentic_dev_loop-1.0.0a11 → agentic_dev_loop-1.0.0a13}/src/agentic_dev_loop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a11
+Version: 1.0.0a13
 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.0a11 → agentic_dev_loop-1.0.0a13}/src/agentic_dev_loop.egg-info/SOURCES.txt

@@ -63,5 +63,6 @@ tests/test_secrets_integration.py
 tests/test_secrets_pipeline.py
 tests/test_source_resolution.py
 tests/test_stages.py
+tests/test_trigger_script.py
 tests/test_verdict.py
 tests/test_viz.py

{agentic_dev_loop-1.0.0a11 → agentic_dev_loop-1.0.0a13}/tests/test_cli.py

@@ -202,6 +202,54 @@ class TestRun:
         # dev completed before the crash — only test re-ran on resume
         assert fake_agents.agents_called() == ["dev", "check", "check"]
 
+    def test_success_stamps_plan_completed(self, repo, fake_agents):
+        fake_agents.set("dev", [("write", "implementation-summary.md", "done")])
+
+        assert main(["pipeline.yaml", "--plan", "plan.md", "--no-viz"]) == 0
+
+        assert (repo / "plan.md").read_text() == (
+            "> **Status: COMPLETED**\n\nTHE PLAN")
+
+    def test_success_replaces_existing_status(self, repo, fake_agents):
+        (repo / "plan.md").write_text(
+            "# Plan\n\n> **Status: DONE**\n\nTHE PLAN\n")
+        git(repo, "add", "-A")
+        git(repo, "commit", "-m", "record status")
+        fake_agents.set("dev", [("write", "implementation-summary.md", "done")])
+
+        assert main(["pipeline.yaml", "--plan", "plan.md", "--no-viz"]) == 0
+
+        assert (repo / "plan.md").read_text() == (
+            "# Plan\n\n> **Status: COMPLETED**\n\nTHE PLAN\n")
+
+    def test_failed_run_does_not_stamp(self, repo, fake_agents):
+        write_pipeline(repo, "retry.yaml", RETRY_YAML)
+        fake_agents.set("dev", [("write", "implementation-summary.md", "done")])
+        fake_agents.set("check", [("write", "ci-fix.md", "VERDICT: FAIL")])
+
+        assert main(["retry.yaml", "--plan", "plan.md", "--no-viz"]) == 1
+
+        assert (repo / "plan.md").read_text() == "THE PLAN"
+
+    def test_aidlc_run_leaves_docs_untouched(self, repo, fake_agents):
+        write_pipeline(repo, "aidlc.yaml", with_extensions(
+            PLAIN_YAML, "agentic_dev_loop.engine.extensions.aidlc:AidlcExtension"))
+        unit_dir = repo / "aidlc-docs" / "construction" / "unit-3"
+        unit_dir.mkdir(parents=True)
+        (unit_dir / "design.md").write_text("# Design")
+        (repo / "aidlc-docs" / "aidlc-state.md").write_text(
+            "# State\n\n- **Current Stage**: CONSTRUCTION — Unit unit-3 (SCAN).\n")
+        git(repo, "add", "-A")
+        git(repo, "commit", "-m", "aidlc fixture")
+        fake_agents.set("dev", [("write", "implementation-summary.md", "done")])
+        state_before = (repo / "aidlc-docs" / "aidlc-state.md").read_text()
+
+        assert main(["aidlc.yaml", "--aidlc-unit", "unit-3", "--no-viz"]) == 0
+
+        assert (repo / "aidlc-docs" / "aidlc-state.md").read_text() == state_before
+        assert (repo / "aidlc-docs" / "construction" / "unit-3" / "design.md").read_text() == "# Design"
+        assert (repo / "plan.md").read_text() == "THE PLAN"
+
 
 class TestViz:
     def test_no_viz_flags_parse(self, repo):

{agentic_dev_loop-1.0.0a11 → agentic_dev_loop-1.0.0a13}/tests/test_config.py

@@ -402,6 +402,17 @@ class TestIsolationConfig:
         data = _base() | {"isolation": {"memory": memory}}
         assert _load(tmp_path, data).isolation.memory == memory
 
+    def test_sandbox_venv_dir_accepts_and_round_trips(self, tmp_path):
+        """022: `sandbox_venv_dir` is an optional relocation opt-in. It loads
+        verbatim here; the outside-workspace validation happens at startup
+        (where the workspace is known), not at config load."""
+        data = _base() | {"isolation": {"sandbox_venv_dir":
+                                        "~/.agentic-dev-loop/venvs/engine"}}
+        iso = _load(tmp_path, data).isolation
+        assert iso.sandbox_venv_dir == "~/.agentic-dev-loop/venvs/engine"
+        roundtripped = type(iso).model_validate(iso.model_dump())
+        assert roundtripped.sandbox_venv_dir == iso.sandbox_venv_dir
+
     @pytest.mark.parametrize("memory", ["8", "g", "8G", "8 g", ""])
     def test_invalid_memory_rejected(self, tmp_path, memory):
         data = _base() | {"isolation": {"memory": memory}}

{agentic_dev_loop-1.0.0a11 → agentic_dev_loop-1.0.0a13}/tests/test_e2e_fixtures.py

@@ -27,10 +27,11 @@ EXAMPLE = Path(__file__).resolve().parent.parent / "agentic-dev-loop"
 
 
 # Scripted stand-in for the shipped example's mechanical test command. The
-# example runs `.venv/bin/python -m pytest tests/ -q`, which cannot run inside
-# the consumer-repo copy (no .venv, no tests/) — so this fixture scripts the
-# seam locally. The real subprocess path stays covered by test_stages.py and
-# test_graph.py. Behaviors: ("pass",) → (0, "", False); ("fail", output) →
+# example runs `.venv-sandbox/bin/python -m pytest tests/ -q -m "not docker"`,
+# which cannot run inside the consumer-repo copy (no .venv-sandbox, no tests/)
+# — so this fixture scripts the seam locally. The real subprocess path stays
+# covered by test_stages.py and test_graph.py. Behaviors: ("pass",) →
+# (0, "", False); ("fail", output) →
 # (1, output, False); ("timeout", output) → (None, output, True); the last
 # behavior repeats; empty queue → default pass.
 _COMMAND_QUEUE: list[tuple] = []