agentic-dev-loop 1.0.0a43__tar.gz → 1.0.0a44__tar.gz

{agentic_dev_loop-1.0.0a43/src/agentic_dev_loop.egg-info → agentic_dev_loop-1.0.0a44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a43
+Version: 1.0.0a44
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -255,6 +255,7 @@ steps:
 | `custom_prompt:` | Planned (planning-docs/040). Optional agent-step value: literal text, or a path whose file contents are read at load time, appended verbatim to the agent prompt at context assembly (after the prompt, before the task/artifacts). A value that looks like a path but names no file is a validation error. Agent steps only. |
 | `on_pass:` / `on_fail:` | A step name, terminal `success`/`failure`, or `{goto: X, retry: true}`. No loops happen unless you write them. |
 | `env:` / `setup:` / `network:` | `env:` declares step vars (fixed safe base + declared vars only); `setup:` provisions the sandbox before the step runs (command or agent steps; network ON; stamp-cached, re-runs when the pipeline's lockfiles change); `network: true` lets a command/agent step reach the hosts its `egress:` allowlist names (default off) - see [Per-stage networking](#per-stage-networking). |
+| `setup_probe:` | Optional consumer-authored in-container probe run on a warm `setup:` stamp instead of the venv probe. Exit 0 trusts the stamp (skips); any nonzero re-provisions with network on (fail toward freshness). The probe text is NOT part of the stamp key, so a probe-only change needs `--refresh` or `--clean-stamps` to take effect. Example (asserting a warmed esbuild binary is Linux-shaped): `file frontend-editor/node_modules/esbuild/bin/esbuild | grep -q ELF`. |
 | `mounts:` / `egress:` | Per-step workspace isolation. `mounts:` lists `{path, mode}` entries (`rw`/`ro`, default `ro`) and is **strict-by-default** - empty/missing mounts nothing; only declared-rw paths sync back to the repo. `egress:` is `{class, presets, targets}` (`class: browser` = broad-but-logged; otherwise a strict allowlist). See [Per-stage networking](#per-stage-networking) and [docs/setup.md](docs/setup.md). |
 | `secrets:` (top-level) / step `secrets:` | Declares secret **refs only - never values**; each step opts in to the refs it needs. Resolved host-side and injected into that step's exec env only. See [Secrets](#secrets--refs-only-never-values). |
 | `isolation:` (optional) | Configures the sandbox - image override, resource caps, `allow_git_mutations`, `seccomp_profile`. It can never disable it. See [browser sandbox](docs/browser-sandbox.md). |

{agentic_dev_loop-1.0.0a43 → agentic_dev_loop-1.0.0a44}/README.md

@@ -211,6 +211,7 @@ steps:
 | `custom_prompt:` | Planned (planning-docs/040). Optional agent-step value: literal text, or a path whose file contents are read at load time, appended verbatim to the agent prompt at context assembly (after the prompt, before the task/artifacts). A value that looks like a path but names no file is a validation error. Agent steps only. |
 | `on_pass:` / `on_fail:` | A step name, terminal `success`/`failure`, or `{goto: X, retry: true}`. No loops happen unless you write them. |
 | `env:` / `setup:` / `network:` | `env:` declares step vars (fixed safe base + declared vars only); `setup:` provisions the sandbox before the step runs (command or agent steps; network ON; stamp-cached, re-runs when the pipeline's lockfiles change); `network: true` lets a command/agent step reach the hosts its `egress:` allowlist names (default off) - see [Per-stage networking](#per-stage-networking). |
+| `setup_probe:` | Optional consumer-authored in-container probe run on a warm `setup:` stamp instead of the venv probe. Exit 0 trusts the stamp (skips); any nonzero re-provisions with network on (fail toward freshness). The probe text is NOT part of the stamp key, so a probe-only change needs `--refresh` or `--clean-stamps` to take effect. Example (asserting a warmed esbuild binary is Linux-shaped): `file frontend-editor/node_modules/esbuild/bin/esbuild | grep -q ELF`. |
 | `mounts:` / `egress:` | Per-step workspace isolation. `mounts:` lists `{path, mode}` entries (`rw`/`ro`, default `ro`) and is **strict-by-default** - empty/missing mounts nothing; only declared-rw paths sync back to the repo. `egress:` is `{class, presets, targets}` (`class: browser` = broad-but-logged; otherwise a strict allowlist). See [Per-stage networking](#per-stage-networking) and [docs/setup.md](docs/setup.md). |
 | `secrets:` (top-level) / step `secrets:` | Declares secret **refs only - never values**; each step opts in to the refs it needs. Resolved host-side and injected into that step's exec env only. See [Secrets](#secrets--refs-only-never-values). |
 | `isolation:` (optional) | Configures the sandbox - image override, resource caps, `allow_git_mutations`, `seccomp_profile`. It can never disable it. See [browser sandbox](docs/browser-sandbox.md). |

{agentic_dev_loop-1.0.0a43 → agentic_dev_loop-1.0.0a44}/pyproject.toml

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

@@ -362,6 +362,7 @@ class StepConfig(BaseModel):
     custom_prompt: str | None = None  # agent steps only (040); file path resolved at load
     env: dict[str, str | None] | None = None  # NFR-1: null = inherit host value
     setup: str | None = None  # BR-13: command steps only
+    setup_probe: str | None = None  # 045: consumer probe replacing the venv probe on a warm stamp; requires `setup`; probe text is NOT part of the stamp key (a probe-only change needs --refresh/--clean-stamps)
     forbidden_commands: list[str] = []  # banned-command regex deny-list (036 D1)
     network: bool = False  # per-stage egress (command/agent + sandbox actions; host-side actions reject at registry time)
     # unit-5: per-step mount granularity + egress policy. Empty mounts =
@@ -420,6 +421,13 @@ class StepConfig(BaseModel):
             raise ValueError("custom_prompt must be a non-empty string")
         return v
 
+    @field_validator("setup_probe")
+    @classmethod
+    def _nonempty_setup_probe(cls, v: str | None) -> str | None:
+        if v is not None and not v.strip():
+            raise ValueError("setup_probe must be a non-empty string")
+        return v
+
     @model_validator(mode="after")
     def _check_shape(self) -> "StepConfig":
         for key in ("agent", "action", "command"):
@@ -494,6 +502,10 @@ class StepConfig(BaseModel):
             raise ValueError(
                 f"step {self.name!r}: 'setup' is only allowed on 'command' or 'agent' steps"
             )
+        if self.setup_probe is not None and self.setup is None:
+            raise ValueError(
+                f"step {self.name!r}: 'setup_probe' requires 'setup'"
+            )
         # `network` is NOT rejected here: the schema can't tell a host-side
         # built-in action (e.g. `commit`, which must never take egress) from
         # a sandbox-executed consumer action (which may, like a command step).

{agentic_dev_loop-1.0.0a43 → agentic_dev_loop-1.0.0a44}/src/agentic_dev_loop/engine/isolation.py

@@ -534,11 +534,19 @@ def venv_probe_command() -> str:
     )
 
 
+def probe_argv(probe_cmd: str, container: str, workspace: str) -> list[str]:
+    """``docker exec`` argv that runs an arbitrary in-container probe command
+    (045) inside the already-running execution container against the
+    bind-mounted workspace. ``probe_cmd`` is a consumer-authored shell command
+    string passed verbatim to ``/bin/sh -c``."""
+    return ["docker", "exec", "-w", workspace, container,
+            "/bin/sh", "-c", probe_cmd]
+
+
 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()]
+    return probe_argv(venv_probe_command(), container, workspace)
 
 
 def venv_probe_state(stdout: str, exit_code: int | None) -> str:
@@ -1133,7 +1141,7 @@ class DockerBackend(Sandbox):
                                        self._sync_excludes)
 
     def provision(self, setup_cmd: str, stamp_key: str, stamp_dir: str,
-                  force: bool) -> None:
+                  force: bool, setup_probe: str | None = None) -> None:
         """Run one ``setup:`` hook in the provision container (network ON),
         stamp-cached. Nonzero exit → AE-SBX-009, no stamp written.
 
@@ -1143,13 +1151,21 @@ class DockerBackend(Sandbox):
         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.
+
+        045: when ``setup_probe`` is set it replaces the venv probe for this
+        hook. Exit 0 trusts the stamp (skip); any nonzero - a broken artifact
+        or a failed probe run - falls through to re-provision (fail toward
+        freshness).
         """
         if not force and read_stamp(Path(stamp_dir), stamp_key):
-            if self._probe_venv() == "broken":
+            if setup_probe is not None:
+                if self._probe(setup_probe).exit_code == 0:
+                    return
+            else:
+                if self._probe_venv() != "broken":
+                    return
                 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, sandbox_venv_dir=self._sandbox_venv_dir,
@@ -1162,13 +1178,18 @@ class DockerBackend(Sandbox):
                 f"- stamp not written (docs/setup.md §5)")
         write_stamp(Path(stamp_dir), stamp_key)
 
+    def _probe(self, probe_cmd: str) -> CmdResult:
+        """Run an arbitrary in-container probe command (045). The workdir
+        follows the export root when one is materialised, else the workspace."""
+        workdir = self._export_root or self._workspace
+        return self._runner.run(
+            probe_argv(probe_cmd, self._container, workdir), timeout=30)
+
     def _probe_venv(self) -> str:
         """Run the in-container venv probe and classify it (016 self-heal).
         With an export the venv is mounted at ``{export}/.venv-sandbox``, so
         the probe workdir follows the export root."""
-        workdir = self._export_root or self._workspace
-        res = self._runner.run(
-            venv_probe_argv(self._container, workdir), timeout=30)
+        res = self._probe(venv_probe_command())
         return venv_probe_state(res.stdout, res.exit_code)
 
     # -- execution ----------------------------------------------------------
@@ -1903,7 +1924,8 @@ def _declared_setups(cfg: PipelineConfig, workspace: Path):
         if step.setup is not None and (
             step.command is not None or step.agent is not None
         ):
-            yield step.setup, setup_stamp_key(step.setup, hashes)
+            yield (step.setup, setup_stamp_key(step.setup, hashes),
+                   step.setup_probe)
 
 
 def isolation_state_dir(cfg: PipelineConfig) -> Path:
@@ -2017,10 +2039,11 @@ def startup_sandbox(cfg: PipelineConfig, *, workspace: Path,
         _announce("execution container started")
         if refresh is None:
             refresh = bool(cfg.isolation and cfg.isolation.refresh)
-        for setup_cmd, stamp_key in _declared_setups(cfg, workspace):
+        for setup_cmd, stamp_key, setup_probe in _declared_setups(cfg, workspace):
             _announce(f"provisioning setup (stamp {stamp_key[:8]})")
             backend.provision(setup_cmd, stamp_key,
-                              str(iso_state_dir / "stamps"), force=refresh)
+                              str(iso_state_dir / "stamps"), force=refresh,
+                              setup_probe=setup_probe)
         _announce("sandbox ready")
         return backend
     except BaseException:

{agentic_dev_loop-1.0.0a43 → agentic_dev_loop-1.0.0a44/src/agentic_dev_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a43
+Version: 1.0.0a44
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -255,6 +255,7 @@ steps:
 | `custom_prompt:` | Planned (planning-docs/040). Optional agent-step value: literal text, or a path whose file contents are read at load time, appended verbatim to the agent prompt at context assembly (after the prompt, before the task/artifacts). A value that looks like a path but names no file is a validation error. Agent steps only. |
 | `on_pass:` / `on_fail:` | A step name, terminal `success`/`failure`, or `{goto: X, retry: true}`. No loops happen unless you write them. |
 | `env:` / `setup:` / `network:` | `env:` declares step vars (fixed safe base + declared vars only); `setup:` provisions the sandbox before the step runs (command or agent steps; network ON; stamp-cached, re-runs when the pipeline's lockfiles change); `network: true` lets a command/agent step reach the hosts its `egress:` allowlist names (default off) - see [Per-stage networking](#per-stage-networking). |
+| `setup_probe:` | Optional consumer-authored in-container probe run on a warm `setup:` stamp instead of the venv probe. Exit 0 trusts the stamp (skips); any nonzero re-provisions with network on (fail toward freshness). The probe text is NOT part of the stamp key, so a probe-only change needs `--refresh` or `--clean-stamps` to take effect. Example (asserting a warmed esbuild binary is Linux-shaped): `file frontend-editor/node_modules/esbuild/bin/esbuild | grep -q ELF`. |
 | `mounts:` / `egress:` | Per-step workspace isolation. `mounts:` lists `{path, mode}` entries (`rw`/`ro`, default `ro`) and is **strict-by-default** - empty/missing mounts nothing; only declared-rw paths sync back to the repo. `egress:` is `{class, presets, targets}` (`class: browser` = broad-but-logged; otherwise a strict allowlist). See [Per-stage networking](#per-stage-networking) and [docs/setup.md](docs/setup.md). |
 | `secrets:` (top-level) / step `secrets:` | Declares secret **refs only - never values**; each step opts in to the refs it needs. Resolved host-side and injected into that step's exec env only. See [Secrets](#secrets--refs-only-never-values). |
 | `isolation:` (optional) | Configures the sandbox - image override, resource caps, `allow_git_mutations`, `seccomp_profile`. It can never disable it. See [browser sandbox](docs/browser-sandbox.md). |

{agentic_dev_loop-1.0.0a43 → agentic_dev_loop-1.0.0a44}/tests/test_config.py

@@ -596,6 +596,37 @@ class TestStepEnvAndSetup:
         assert rt.env == {"A": "x", "B": None}
 
 
+class TestSetupProbe:
+    def test_defaults_none(self, tmp_path):
+        assert _load(tmp_path, _base()).steps[0].setup_probe is None
+
+    def test_parses_with_setup(self, tmp_path):
+        data = _base()
+        data["steps"] = [{"name": "t", "command": "make",
+                          "setup": "make warm-cache",
+                          "setup_probe": "file node_modules/esbuild/bin/esbuild | grep -q ELF",
+                          "on_pass": "success"}]
+        step = _load(tmp_path, data).steps[0]
+        assert step.setup_probe == (
+            "file node_modules/esbuild/bin/esbuild | grep -q ELF")
+
+    def test_requires_setup(self, tmp_path):
+        data = _base()
+        data["steps"] = [{"name": "t", "command": "make",
+                          "setup_probe": "file node_modules/esbuild/bin/esbuild | grep -q ELF",
+                          "on_pass": "success"}]
+        with pytest.raises(ValidationError,
+                           match="'setup_probe' requires 'setup'"):
+            _load(tmp_path, data)
+
+    def test_empty_rejected(self, tmp_path):
+        data = _base()
+        data["steps"] = [{"name": "t", "command": "make", "setup": "make warm-cache",
+                          "setup_probe": "  ", "on_pass": "success"}]
+        with pytest.raises(ValidationError, match="non-empty"):
+            _load(tmp_path, data)
+
+
 class TestStepNetwork:
     def test_network_defaults_false(self, tmp_path):
         step = _load(tmp_path, _base()).steps[0]

{agentic_dev_loop-1.0.0a43 → agentic_dev_loop-1.0.0a44}/tests/test_isolation.py

@@ -33,7 +33,7 @@ from agentic_dev_loop.engine.isolation import (
     probe_docker, process_start, read_stamp, reap_orphaned_containers,
     remove_sandbox_venv, resolve_effective_profile, resolve_image_ref,
     resolve_sandbox_env, resolve_sandbox_venv_dir, select_backend,
-    setup_stamp_key, translate_mount_path, venv_probe_argv,
+    probe_argv, setup_stamp_key, translate_mount_path, venv_probe_argv,
     venv_probe_command, venv_probe_state, write_stamp,
 )
 
@@ -282,6 +282,16 @@ class TestVenvProbe:
         assert venv_probe_state(stdout, exit_code) == expected
 
 
+class TestProbeArgv:
+    def test_assembly(self):
+        argv = probe_argv("file .warmed | grep -q ELF", "c1", "/ws")
+        assert argv[1] == "exec"
+        assert argv[2] == "-w"
+        assert argv[3] == "/ws"
+        assert argv[4] == "c1"
+        assert argv[5:] == ["/bin/sh", "-c", "file .warmed | grep -q ELF"]
+
+
 class TestRemoveSandboxVenv:
     def test_removes_broken_symlink_dir(self, tmp_path):
         ws = tmp_path / "ws"
@@ -971,6 +981,39 @@ class TestProvisionStampsAudit:
         assert "x" * 8 in rolled
 
 
+class TestSetupProbeProvision:
+    def test_probe_exit_zero_skips(self, tmp_path):
+        runner = FakeRunner(ok(""))
+        backend = _backend(tmp_path, runner)
+        stamp_dir = tmp_path / "stamps"
+        write_stamp(stamp_dir, "key1")
+        backend.provision("make warm-cache", "key1", str(stamp_dir),
+                          force=False, setup_probe="file .warmed | grep -q ELF")
+        assert [c for c in runner.calls if c[1] == "exec"]
+        assert not [c for c in runner.calls if c[1] == "run"]
+
+    def test_probe_nonzero_reprovisions(self, tmp_path):
+        runner = FakeRunner(fail(1, "not ELF"), ok(""))
+        backend = _backend(tmp_path, runner)
+        stamp_dir = tmp_path / "stamps"
+        write_stamp(stamp_dir, "key1")
+        backend.provision("make warm-cache", "key1", str(stamp_dir),
+                          force=False, setup_probe="file .warmed | grep -q ELF")
+        assert [c for c in runner.calls if c[1] == "run"]
+        assert read_stamp(stamp_dir, "key1")
+
+    def test_probe_run_failure_reprovisions(self, tmp_path):
+        # A probe that cannot run (exec failure) is treated as a broken artifact.
+        runner = FakeRunner(fail(125, "no such container"), ok(""))
+        backend = _backend(tmp_path, runner)
+        stamp_dir = tmp_path / "stamps"
+        write_stamp(stamp_dir, "key1")
+        backend.provision("make warm-cache", "key1", str(stamp_dir),
+                          force=False, setup_probe="file .warmed | grep -q ELF")
+        assert [c for c in runner.calls if c[1] == "run"]
+        assert read_stamp(stamp_dir, "key1")
+
+
 class TestStartupSandbox:
     """Eager startup sequence (Q2): probe → image → create/start → provision
     all declared setups - with zero infra operations left for the run phase."""
@@ -2298,14 +2341,18 @@ def test_declared_setups_includes_agent_steps(tmp_path):
             {"name": "dev", "agent": "dev",
              "setup": "cd frontend-editor && npm ci", "on_pass": "success"},
             {"name": "t", "command": "make", "setup": "echo warm",
+             "setup_probe": "file .warmed | grep -q ELF",
              "on_pass": "success"},
         ],
     }
     p = tmp_path / "pipeline.yaml"
     p.write_text(yaml.safe_dump(data))
     cfg = load_config(p)
-    assert set(dict(_declared_setups(cfg, tmp_path))) == {
+    declared = list(_declared_setups(cfg, tmp_path))
+    assert {s for s, _k, _p in declared} == {
         "cd frontend-editor && npm ci", "echo warm"}
+    assert {p for _s, _k, p in declared} == {
+        None, "file .warmed | grep -q ELF"}
 
 
 def test_provision_payload_mounts_declared_caches():

{agentic_dev_loop-1.0.0a43 → agentic_dev_loop-1.0.0a44}/tests/test_isolation_integration.py

@@ -224,6 +224,25 @@ class TestVenvSelfHealE2E:
         assert read_stamp(stamp_dir, key)
 
 
+class TestSetupProbeE2E:
+    """045 repro: a warm stamp plus a consumer-authored probe that fails inside
+    the container must re-provision (remove-free - the setup hook re-warms)
+    instead of blind-skipping a poisoned artifact."""
+
+    def test_consumer_probe_failure_reprovisions(self, backend, tmp_path):
+        b, ws = backend
+        (ws / "warmed").write_text("poisoned")
+        stamp_dir = tmp_path / "stamps"
+        key = "warm-probe"
+        write_stamp(stamp_dir, key)
+
+        b.provision("printf fresh > warmed", key, str(stamp_dir),
+                    force=False, setup_probe="grep -q fresh warmed")
+
+        assert (ws / "warmed").read_text() == "fresh"
+        assert read_stamp(stamp_dir, key)
+
+
 class TestRelocatedVenvE2E:
     """022: `sandbox_venv_dir` relocates the sandbox venv outside the workspace.
     The outside dir is bind-mounted at `{ws}/.venv-sandbox` in BOTH containers,