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

{agentic_dev_loop-1.0.0a42/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.0a42
+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
@@ -33,6 +33,8 @@ Requires-Dist: agent-client-protocol<1.0.0
 Requires-Dist: langgraph>=1.2
 Requires-Dist: langgraph-checkpoint-sqlite>=3.0
 Requires-Dist: filelock>=4.2.1
+Requires-Dist: pyasn1>=0.6.5
+Requires-Dist: pypdf>=6.21.4
 Provides-Extra: dev
 Requires-Dist: hypothesis>=6.0; extra == "dev"
 Requires-Dist: pytest>=8.0; extra == "dev"
@@ -213,7 +215,6 @@ steps:
     agent: dev
     produces: implementation-summary.md
     terminal_timeout: 900
-    stop_when: { green_command: ".venv-sandbox/bin/python -m pytest tests/ -q", post_green_turns: 2 }
     on_pass: test
 
   - name: test
@@ -249,12 +250,12 @@ steps:
 | `agent:` / `command:` / `action:` | Exactly one per step. Agents live in `agents_dir` as `<name>.agent.md`; commands run sandboxed (mechanical, never an LLM call). `commit` is the sole host-side built-in action; consumer actions are sandbox-executed, command-shaped scripts (see [Host boundary](#host-boundary-security-model)). |
 | `produces:` / `artifact:` + `verdicts:` | Hygiene-tracked outputs vs verdict-parsed routing. The **last** `VERDICT:` line wins; stale artifacts are deleted at each attempt start. |
 | `brief_inputs:` | Optional agent-step input spec: `{ include: [<paths/globs>], env_facts: [<strings>] }`. The engine resolves the include list against the workspace, passes the resolved docs + include contents + env facts as that step's task message, and regenerates the step only when those inputs change. A produces-only agent step such as `brief` is the documented pattern for per-run context digestion. |
-| `stop_when:` | Optional agent-step termination: `{ green_command: <argv regex>, post_green_turns: <int, default 2> }`. When the agent's most recent terminal observation matching `green_command` exits 0 and no workspace writes have happened since, the engine injects one nudge turn, allows `post_green_turns` further turns, then closes the conversation. Absent = run to finish. |
 | `terminal_timeout:` | Optional agent-step per-action timeout in seconds (gt 0). `SandboxTerminalExecutor` uses it when the agent leaves the terminal action timeout unset, overriding the SDK tool's default. `None` = current behavior. |
 | `finalize_nudge_turns:` | Optional agent-step final-response nudge (gt 0). Requires `max_iterations:` and must be less than it. At `max_iterations - finalize_nudge_turns` completed turns the engine injects one advisory turn ("`N turns remain: produce your final response now`"), exactly once; the agent may still exhaust its turns and existing stuck/unclear handling applies unchanged. Absent = current behavior. Provisional pending one consumer run (revert if noisy or the raised cap inflates cost). |
 | `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.0a42 → agentic_dev_loop-1.0.0a44}/README.md

@@ -171,7 +171,6 @@ steps:
     agent: dev
     produces: implementation-summary.md
     terminal_timeout: 900
-    stop_when: { green_command: ".venv-sandbox/bin/python -m pytest tests/ -q", post_green_turns: 2 }
     on_pass: test
 
   - name: test
@@ -207,12 +206,12 @@ steps:
 | `agent:` / `command:` / `action:` | Exactly one per step. Agents live in `agents_dir` as `<name>.agent.md`; commands run sandboxed (mechanical, never an LLM call). `commit` is the sole host-side built-in action; consumer actions are sandbox-executed, command-shaped scripts (see [Host boundary](#host-boundary-security-model)). |
 | `produces:` / `artifact:` + `verdicts:` | Hygiene-tracked outputs vs verdict-parsed routing. The **last** `VERDICT:` line wins; stale artifacts are deleted at each attempt start. |
 | `brief_inputs:` | Optional agent-step input spec: `{ include: [<paths/globs>], env_facts: [<strings>] }`. The engine resolves the include list against the workspace, passes the resolved docs + include contents + env facts as that step's task message, and regenerates the step only when those inputs change. A produces-only agent step such as `brief` is the documented pattern for per-run context digestion. |
-| `stop_when:` | Optional agent-step termination: `{ green_command: <argv regex>, post_green_turns: <int, default 2> }`. When the agent's most recent terminal observation matching `green_command` exits 0 and no workspace writes have happened since, the engine injects one nudge turn, allows `post_green_turns` further turns, then closes the conversation. Absent = run to finish. |
 | `terminal_timeout:` | Optional agent-step per-action timeout in seconds (gt 0). `SandboxTerminalExecutor` uses it when the agent leaves the terminal action timeout unset, overriding the SDK tool's default. `None` = current behavior. |
 | `finalize_nudge_turns:` | Optional agent-step final-response nudge (gt 0). Requires `max_iterations:` and must be less than it. At `max_iterations - finalize_nudge_turns` completed turns the engine injects one advisory turn ("`N turns remain: produce your final response now`"), exactly once; the agent may still exhaust its turns and existing stuck/unclear handling applies unchanged. Absent = current behavior. Provisional pending one consumer run (revert if noisy or the raised cap inflates cost). |
 | `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.0a42 → 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.0a42"
+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"
@@ -47,6 +47,14 @@ dependencies = [
     # 3.32.7 carries CVE-2026-112907/-112913/-112940 (fixed in 4.2.1); pin a
     # floor so the restore step's pip-audit stays green.
     "filelock>=4.2.1",
+    # pyasn1 is a transitive dep (openhands-sdk, rsa, google-auth). 0.6.4
+    # carries CVE-2026-119194/-119195/-119196/-119197 (fixed in 0.6.5); pin a
+    # floor so the restore step's pip-audit stays green.
+    "pyasn1>=0.6.5",
+    # pypdf is a transitive dep (openhands-tools document loaders). 6.21.2
+    # carries CVE-2026-119203/-119204/-119205/-119206/-119207/-119208/-119209
+    # (fixed in 6.21.4); pin a floor so the restore step's pip-audit stays green.
+    "pypdf>=6.21.4",
 ]
 
 [project.urls]

{agentic_dev_loop-1.0.0a42 → agentic_dev_loop-1.0.0a44}/src/agentic_dev_loop/core/__init__.py

@@ -6,8 +6,7 @@ test fails if this package imports engine/viz or heavy deps.
 
 from .config import (PipelineConfig, StepConfig, LlmConfig, IsolationConfig,
                      VerdictSpec, Route, route_target, load_config,
-                     default_state_dir, TERMINALS, MountSpec, EgressSpec,
-                     StopWhenSpec)
+                     default_state_dir, TERMINALS, MountSpec, EgressSpec)
 from .results import Result
 from .verdict import Verdict, VerdictError, parse_verdict, RETRY
 
@@ -15,6 +14,5 @@ __all__ = [
     "PipelineConfig", "StepConfig", "LlmConfig", "IsolationConfig",
     "VerdictSpec", "Route", "route_target", "load_config",
     "default_state_dir", "TERMINALS", "MountSpec", "EgressSpec",
-    "StopWhenSpec",
     "Result", "Verdict", "VerdictError", "parse_verdict", "RETRY",
 ]

{agentic_dev_loop-1.0.0a42 → agentic_dev_loop-1.0.0a44}/src/agentic_dev_loop/core/config.py

@@ -306,36 +306,6 @@ class EgressSpec(BaseModel):
         return [_validate_egress_target(t) for t in v]
 
 
-class StopWhenSpec(BaseModel):
-    """Optional ``stop_when:`` termination signal on an agent step (032).
-
-    ``green_command`` is a regex matched against the agent's terminal
-    observation command; a matching observation that exits 0 - and no
-    workspace writes since - triggers one nudge turn, then
-    ``post_green_turns`` further turns before the engine closes the
-    conversation. Absent ``stop_when`` keeps the current run-to-finish
-    behaviour unchanged.
-    """
-
-    model_config = ConfigDict(extra="forbid")
-
-    green_command: str
-    post_green_turns: int = Field(default=2, ge=0)
-
-    @field_validator("green_command")
-    @classmethod
-    def _valid_regex(cls, v: str) -> str:
-        if not isinstance(v, str) or not v.strip():
-            raise ValueError(
-                "stop_when.green_command must be a non-empty string")
-        try:
-            re.compile(v)
-        except re.error as e:
-            raise ValueError(
-                f"stop_when.green_command is not a valid regex: {e}") from e
-        return v
-
-
 class BriefInputsSpec(BaseModel):
     """Optional ``brief_inputs:`` on an agent step (033): the closed input
     list a brief agent digests once per run. ``include`` is repo-relative
@@ -387,12 +357,12 @@ class StepConfig(BaseModel):
     max_iterations: int | None = None
     timeout: float | None = Field(default=None, gt=0)  # seconds, command steps only
     terminal_timeout: float | None = Field(default=None, gt=0)  # seconds, agent steps only (032)
-    stop_when: StopWhenSpec | None = None  # agent steps only (032)
     finalize_nudge_turns: int | None = Field(default=None, gt=0)  # agent steps only (035)
     brief_inputs: BriefInputsSpec | None = None  # agent steps only (033)
     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 =
@@ -451,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"):
@@ -488,10 +465,6 @@ class StepConfig(BaseModel):
             raise ValueError(
                 f"step {self.name!r}: 'terminal_timeout' requires 'agent'"
             )
-        if self.stop_when is not None and self.agent is None:
-            raise ValueError(
-                f"step {self.name!r}: 'stop_when' requires 'agent'"
-            )
         if self.finalize_nudge_turns is not None and self.agent is None:
             raise ValueError(
                 f"step {self.name!r}: 'finalize_nudge_turns' requires 'agent'"
@@ -529,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.0a42 → 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.0a42 → agentic_dev_loop-1.0.0a44}/src/agentic_dev_loop/engine/stages.py

@@ -21,7 +21,6 @@ from __future__ import annotations
 
 import hashlib
 import os
-import re
 import subprocess
 import sys
 import traceback
@@ -70,9 +69,9 @@ def custom_prompt_section(text: str) -> str:
 
 
 class _TurnPauseController:
-    """Turn-level pause callback (032): pause the SDK run loop after every
+    """Turn-level pause callback: pause the SDK run loop after every
     agent-sourced event so the caller can drive one turn at a time. The
-    finalize nudge (035) reuses this hook without any stop-when state."""
+    finalize nudge (035) reuses this hook."""
 
     def __init__(self) -> None:
         self.conversation = None
@@ -108,65 +107,6 @@ class _FinalizeNudgeController(_TurnPauseController):
         return self._TEMPLATE.format(n=self.turns)
 
 
-class _StopWhenController(_TurnPauseController):
-    """Turn-level stop-when-green observation (032).
-
-    Pure per-event state machine - no knowledge of how the conversation is
-    driven. ``on_event`` is a SDK conversation callback: it records the most
-    recent matching terminal observation and any subsequent file-editor
-    write, and (via the base pause) pauses the conversation after every
-    agent-sourced event so the caller can drive one turn at a time.
-    """
-
-    NUDGE = "Step complete: produce your final response now"
-    _WRITE_COMMANDS = frozenset({"create", "str_replace", "insert", "undo_edit"})
-
-    def __init__(self, spec) -> None:
-        super().__init__()
-        self._pattern = re.compile(spec.green_command)
-        self.post_green_turns = spec.post_green_turns
-        self.green_hit = False
-        self.writes_since_green = False
-        self.nudged = False
-        self.post_nudge_turns = 0
-
-    @property
-    def green_signal(self) -> bool:
-        return self.green_hit and not self.writes_since_green
-
-    def on_event(self, event) -> None:
-        super().on_event(event)
-        if self.conversation is None:
-            return
-        from openhands.sdk.event import ObservationEvent
-
-        if isinstance(event, ObservationEvent):
-            self._record_observation(event)
-
-    def on_terminal_result(self, command: str | None, exit_code: int | None,
-                           wrote_workspace: bool) -> None:
-        """Feed the sandbox terminal result channel (032): a matching green
-        command is the signal; any other terminal write resets it."""
-        if command is not None and self._pattern.search(command):
-            self.green_hit = exit_code == 0
-            self.writes_since_green = False
-        elif wrote_workspace:
-            self.writes_since_green = True
-
-    def _record_observation(self, event) -> None:
-        observation = event.observation
-        tool_name = event.tool_name
-        if tool_name == "terminal":
-            command = getattr(observation, "command", None)
-            if command is not None and self._pattern.search(command):
-                self.green_hit = getattr(observation, "exit_code", None) == 0
-                self.writes_since_green = False
-        elif tool_name == "file_editor":
-            command = getattr(observation, "command", None)
-            if command in self._WRITE_COMMANDS and not observation.is_error:
-                self.writes_since_green = True
-
-
 @dataclass
 class Runtime:
     """Everything stage nodes need that isn't in LoopState: pipeline config,
@@ -201,9 +141,6 @@ class Runtime:
         try:
             from openhands.sdk.conversation.state import ConversationExecutionStatus
 
-            controller = None
-            if step is not None and step.stop_when is not None:
-                controller = _StopWhenController(step.stop_when)
             finalize_controller = None
             if step is not None and step.finalize_nudge_turns is not None:
                 finalize_controller = _FinalizeNudgeController(
@@ -232,29 +169,23 @@ class Runtime:
                     egress_policy=egress_policy,
                     terminal_timeout=(step.terminal_timeout
                                       if step is not None else None),
-                    on_terminal_result=(controller.on_terminal_result
-                                        if controller is not None else None),
                     secrets=(step_secret_env(self.cfg, step, self.secrets)
                              if step is not None else None),
                     forbidden_commands=forbidden_commands,
                     allowlist=allowlist)
             agent = load_agent(self.agents_dir, agent_name, self.llm)
             callbacks = []
-            if controller is not None:
-                callbacks.append(controller.on_event)
             if finalize_controller is not None:
                 callbacks.append(finalize_controller.on_event)
             conv = Conversation(agent=agent, workspace=str(self.workspace),
                                 max_iteration_per_run=max_iterations,
                                 callbacks=callbacks or None)
-            if controller is not None:
-                controller.attach(conv)
             if finalize_controller is not None:
                 finalize_controller.attach(conv)
             conv.send_message(message)
-            if controller is not None or finalize_controller is not None:
-                self._run_stop_when_loop(conv, controller, max_iterations,
-                                         finalize_controller)
+            if finalize_controller is not None:
+                self._run_finalize_loop(conv, max_iterations,
+                                        finalize_controller)
             else:
                 conv.run()
 
@@ -295,10 +226,9 @@ class Runtime:
             if conv is not None:
                 conv.close()
 
-    def _run_stop_when_loop(self, conv,
-                            controller: _StopWhenController | None,
-                            max_iterations: int,
-                            finalize_controller: _FinalizeNudgeController | None = None) -> None:
+    def _run_finalize_loop(self, conv,
+                           max_iterations: int,
+                           finalize_controller: _FinalizeNudgeController | None = None) -> None:
         """Drive one turn at a time so turn-level hooks can inject their
         nudges and enforce budgets. A controller's callback pauses the SDK
         run loop after every agent-sourced event, so each ``conv.run()`` here
@@ -327,19 +257,6 @@ class Runtime:
                 finalize_controller.nudged = True
                 continue
 
-            if controller is not None:
-                if not controller.nudged and controller.green_signal:
-                    conv.send_message(controller.NUDGE)
-                    controller.nudged = True
-                    if controller.post_green_turns == 0:
-                        break
-                    continue
-
-                if controller.nudged:
-                    controller.post_nudge_turns += 1
-                    if controller.post_nudge_turns >= controller.post_green_turns:
-                        break
-
 
 def prompt_dir(runtime: Runtime) -> str:
     """state_dir as agents must address it. Agents resolve prompt paths

{agentic_dev_loop-1.0.0a42 → 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.0a42
+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
@@ -33,6 +33,8 @@ Requires-Dist: agent-client-protocol<1.0.0
 Requires-Dist: langgraph>=1.2
 Requires-Dist: langgraph-checkpoint-sqlite>=3.0
 Requires-Dist: filelock>=4.2.1
+Requires-Dist: pyasn1>=0.6.5
+Requires-Dist: pypdf>=6.21.4
 Provides-Extra: dev
 Requires-Dist: hypothesis>=6.0; extra == "dev"
 Requires-Dist: pytest>=8.0; extra == "dev"
@@ -213,7 +215,6 @@ steps:
     agent: dev
     produces: implementation-summary.md
     terminal_timeout: 900
-    stop_when: { green_command: ".venv-sandbox/bin/python -m pytest tests/ -q", post_green_turns: 2 }
     on_pass: test
 
   - name: test
@@ -249,12 +250,12 @@ steps:
 | `agent:` / `command:` / `action:` | Exactly one per step. Agents live in `agents_dir` as `<name>.agent.md`; commands run sandboxed (mechanical, never an LLM call). `commit` is the sole host-side built-in action; consumer actions are sandbox-executed, command-shaped scripts (see [Host boundary](#host-boundary-security-model)). |
 | `produces:` / `artifact:` + `verdicts:` | Hygiene-tracked outputs vs verdict-parsed routing. The **last** `VERDICT:` line wins; stale artifacts are deleted at each attempt start. |
 | `brief_inputs:` | Optional agent-step input spec: `{ include: [<paths/globs>], env_facts: [<strings>] }`. The engine resolves the include list against the workspace, passes the resolved docs + include contents + env facts as that step's task message, and regenerates the step only when those inputs change. A produces-only agent step such as `brief` is the documented pattern for per-run context digestion. |
-| `stop_when:` | Optional agent-step termination: `{ green_command: <argv regex>, post_green_turns: <int, default 2> }`. When the agent's most recent terminal observation matching `green_command` exits 0 and no workspace writes have happened since, the engine injects one nudge turn, allows `post_green_turns` further turns, then closes the conversation. Absent = run to finish. |
 | `terminal_timeout:` | Optional agent-step per-action timeout in seconds (gt 0). `SandboxTerminalExecutor` uses it when the agent leaves the terminal action timeout unset, overriding the SDK tool's default. `None` = current behavior. |
 | `finalize_nudge_turns:` | Optional agent-step final-response nudge (gt 0). Requires `max_iterations:` and must be less than it. At `max_iterations - finalize_nudge_turns` completed turns the engine injects one advisory turn ("`N turns remain: produce your final response now`"), exactly once; the agent may still exhaust its turns and existing stuck/unclear handling applies unchanged. Absent = current behavior. Provisional pending one consumer run (revert if noisy or the raised cap inflates cost). |
 | `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.0a42 → agentic_dev_loop-1.0.0a44}/src/agentic_dev_loop.egg-info/SOURCES.txt

@@ -51,7 +51,6 @@ src/agentic_dev_loop/viz/__main__.py
 src/agentic_dev_loop/viz/server.py
 tests/test_028_declared_caches.py
 tests/test_029_merge_on_conflict.py
-tests/test_032_stop_when_green.py
 tests/test_033_brief_step.py
 tests/test_035_finalize_nudge.py
 tests/test_036_banned_commands_and_lane_boundary.py

{agentic_dev_loop-1.0.0a42 → agentic_dev_loop-1.0.0a44}/src/agentic_dev_loop.egg-info/requires.txt

@@ -6,6 +6,8 @@ agent-client-protocol<1.0.0
 langgraph>=1.2
 langgraph-checkpoint-sqlite>=3.0
 filelock>=4.2.1
+pyasn1>=0.6.5
+pypdf>=6.21.4
 
 [dev]
 hypothesis>=6.0

{agentic_dev_loop-1.0.0a42 → agentic_dev_loop-1.0.0a44}/tests/test_035_finalize_nudge.py

@@ -1,5 +1,5 @@
 """Finalize nudge (035): config surface, the turn-index injection, and the
-exactly-once guard on the shared 032 turn loop."""
+exactly-once guard on the shared turn loop."""
 
 from pathlib import Path
 from types import SimpleNamespace
@@ -90,6 +90,13 @@ class TestFinalizeNudgeConfig:
         with pytest.raises(ValidationError, match="requires 'agent'"):
             _load(tmp_path, data)
 
+    def test_stop_when_key_rejected(self, tmp_path):
+        data = _base()
+        data["steps"] = [{"name": "dev", "agent": "dev",
+                          "stop_when": {"green_command": "pytest"}}]
+        with pytest.raises(ValidationError, match="stop_when"):
+            _load(tmp_path, data)
+
 
 class TestFinalizeNudgeLoop:
     def _conv(self, finish_after):
@@ -114,7 +121,7 @@ class TestFinalizeNudgeLoop:
     def test_nudge_at_configured_turn_and_only_once(self):
         conv = self._conv(finish_after=9)
         controller = _FinalizeNudgeController(3)
-        Runtime._run_stop_when_loop(None, conv, None, max_iterations=10,
+        Runtime._run_finalize_loop(None, conv, max_iterations=10,
                                     finalize_controller=controller)
         assert controller.nudged is True
         assert conv.sent == [(7, NUDGE)]
@@ -122,7 +129,7 @@ class TestFinalizeNudgeLoop:
     def test_no_nudge_when_finished_before_threshold(self):
         conv = self._conv(finish_after=3)
         controller = _FinalizeNudgeController(3)
-        Runtime._run_stop_when_loop(None, conv, None, max_iterations=10,
+        Runtime._run_finalize_loop(None, conv, max_iterations=10,
                                     finalize_controller=controller)
         assert controller.nudged is False
         assert conv.sent == []
@@ -130,7 +137,7 @@ class TestFinalizeNudgeLoop:
     def test_turn_cap_still_applies_when_nudge_ignored(self):
         conv = self._conv(finish_after=999)
         controller = _FinalizeNudgeController(3)
-        Runtime._run_stop_when_loop(None, conv, None, max_iterations=5,
+        Runtime._run_finalize_loop(None, conv, max_iterations=5,
                                     finalize_controller=controller)
         assert controller.nudged is True
         assert conv.state.execution_status == ConversationExecutionStatus.ERROR

{agentic_dev_loop-1.0.0a42 → agentic_dev_loop-1.0.0a44}/tests/test_agents.py

@@ -188,6 +188,37 @@ class TestSandboxTerminalExecutor:
         assert fake_sandbox.requests[0].network is False
 
 
+class TestTerminalTimeoutOverride:
+    def test_defaults_to_terminal_timeout(self, fake_sandbox, tmp_path):
+        from openhands.tools.terminal import TerminalAction
+
+        from agentic_dev_loop.engine.agents import SandboxTerminalExecutor
+        ex = SandboxTerminalExecutor(
+            fake_sandbox, workspace=str(tmp_path), env={"PATH": "/bin"},
+            terminal_timeout=900)
+        ex(TerminalAction(command="echo hi"), None)
+        assert fake_sandbox.requests[0].timeout == 900
+
+    def test_action_timeout_wins(self, fake_sandbox, tmp_path):
+        from openhands.tools.terminal import TerminalAction
+
+        from agentic_dev_loop.engine.agents import SandboxTerminalExecutor
+        ex = SandboxTerminalExecutor(
+            fake_sandbox, workspace=str(tmp_path), env={"PATH": "/bin"},
+            terminal_timeout=900)
+        ex(TerminalAction(command="echo hi", timeout=30), None)
+        assert fake_sandbox.requests[0].timeout == 30
+
+    def test_unset_keeps_none(self, fake_sandbox, tmp_path):
+        from openhands.tools.terminal import TerminalAction
+
+        from agentic_dev_loop.engine.agents import SandboxTerminalExecutor
+        ex = SandboxTerminalExecutor(
+            fake_sandbox, workspace=str(tmp_path), env={"PATH": "/bin"})
+        ex(TerminalAction(command="echo hi"), None)
+        assert fake_sandbox.requests[0].timeout is None
+
+
 class TestRegisterSandboxTerminal:
     def test_resolves_to_sandbox_executor(self, fake_sandbox, tmp_path):
         from openhands.sdk.tool.registry import resolve_tool