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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a42
+Version: 1.0.0a43
 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,7 +250,6 @@ 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. |

{agentic_dev_loop-1.0.0a42 → agentic_dev_loop-1.0.0a43}/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,7 +206,6 @@ 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. |

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentic-dev-loop"
-version = "1.0.0a42"
+version = "1.0.0a43"
 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.0a43}/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.0a43}/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,7 +357,6 @@ 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
@@ -488,10 +457,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'"

{agentic_dev_loop-1.0.0a42 → agentic_dev_loop-1.0.0a43}/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.0a43/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.0a43
 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,7 +250,6 @@ 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. |

{agentic_dev_loop-1.0.0a42 → agentic_dev_loop-1.0.0a43}/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.0a43}/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.0a43}/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.0a43}/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

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

@@ -331,6 +331,30 @@ def test_timeout_without_command_rejected(tmp_path):
         _load(tmp_path, data)
 
 
+def test_terminal_timeout_round_trip(tmp_path):
+    data = _base()
+    data["steps"][0]["terminal_timeout"] = 900
+    assert _load(tmp_path, data).steps[0].terminal_timeout == 900
+
+
+@pytest.mark.parametrize("step", [
+    {"name": "x", "command": "true", "terminal_timeout": 900},
+    {"name": "x", "action": "commit", "terminal_timeout": 900},
+])
+def test_terminal_timeout_requires_agent(tmp_path, step):
+    data = _base()
+    data["steps"] = [step]
+    with pytest.raises(ValidationError, match="'terminal_timeout' requires 'agent'"):
+        _load(tmp_path, data)
+
+
+def test_negative_terminal_timeout_rejected(tmp_path):
+    data = _base()
+    data["steps"][0]["terminal_timeout"] = -1
+    with pytest.raises(ValidationError):
+        _load(tmp_path, data)
+
+
 class TestCustomPrompt:
     def test_defaults_none(self, tmp_path):
         assert _load(tmp_path, _base()).steps[0].custom_prompt is None

{agentic_dev_loop-1.0.0a42 → agentic_dev_loop-1.0.0a43}/tests/test_sdk_compat.py

@@ -91,29 +91,29 @@ def test_canary_sdk_terminal_seam_still_present():
 
 
 def test_canary_sdk_turn_level_pause_seam_still_present():
-    """Canary for the 032 turn-level stop-when-green seam (COMPAT-SHIMS.md):
+    """Canary for the 035 finalize-nudge turn loop seam (COMPAT-SHIMS.md):
     passes while the SDK still accepts ``callbacks`` on LocalConversation,
     passes agent-sourced events to them via ``agent.step(on_event=...)``, and
     breaks its run loop on PAUSED; fails once any of those disappear - the
-    _StopWhenController pause loop is then dead and must be replaced with the
+    _TurnPauseController pause loop is then dead and must be replaced with the
     SDK's supported turn-level pause mechanism."""
     import inspect
 
     from openhands.sdk.conversation.impl.local_conversation import LocalConversation
 
     assert "callbacks" in inspect.signature(LocalConversation.__init__).parameters, (
-        "The SDK's LocalConversation no longer accepts `callbacks=` - the 032 "
-        "turn-level stop-when-green seam in src/agentic_dev_loop/engine/stages.py "
+        "The SDK's LocalConversation no longer accepts `callbacks=` - the 035 "
+        "finalize-nudge turn loop seam in src/agentic_dev_loop/engine/stages.py "
         "is dead. Adopt the SDK's supported pause mechanism and update "
         "COMPAT-SHIMS.md.")
     run_src = inspect.getsource(LocalConversation.run)
     assert "on_event=self._on_event" in run_src, (
         "The SDK's LocalConversation.run no longer passes its composed callback "
-        "to agent.step - the 032 callback seam no longer receives agent-sourced "
+        "to agent.step - the 035 callback seam no longer receives agent-sourced "
         "events. Update COMPAT-SHIMS.md.")
     assert "ConversationExecutionStatus.PAUSED" in run_src, (
-        "The SDK's LocalConversation.run no longer breaks on PAUSED - the 032 "
-        "one-turn run loop in src/agentic_dev_loop/engine/stages.py is dead. "
+        "The SDK's LocalConversation.run no longer breaks on PAUSED - the 035 "
+        "finalize-nudge turn loop in src/agentic_dev_loop/engine/stages.py is dead. "
         "Adopt the SDK's supported pause mechanism and update COMPAT-SHIMS.md.")
 
 

agentic_dev_loop-1.0.0a42/tests/test_032_stop_when_green.py

@@ -1,363 +0,0 @@
-"""Stop-when-green (032): config surface, the per-event signal state machine,
-the one-turn run-loop budget, and the terminal timeout override."""
-
-from pathlib import Path
-from types import SimpleNamespace
-
-import pytest
-import yaml
-from pydantic import ValidationError
-
-from openhands.sdk import LLM
-from openhands.sdk.conversation.state import ConversationExecutionStatus
-from openhands.sdk.event import ActionEvent, MessageEvent, ObservationEvent
-from openhands.sdk.llm.message import Message, MessageToolCall, TextContent
-from openhands.tools.file_editor import FileEditorObservation
-from openhands.tools.terminal import TerminalAction, TerminalObservation
-from openhands.tools.terminal.metadata import CmdOutputMetadata
-
-from agentic_dev_loop.core.config import PipelineConfig, StopWhenSpec, load_config
-from agentic_dev_loop.engine.agents import SandboxTerminalExecutor
-from agentic_dev_loop.engine.registry import default_registry
-from agentic_dev_loop.engine.stages import Runtime, _StopWhenController
-
-
-def _base() -> dict:
-    return {
-        "name": "t",
-        "llm": {"model": "m", "api_key_env": "K"},
-        "agents_dir": "agents",
-        "lockfiles": ["uv.lock"],
-        "steps": [{"name": "dev", "agent": "dev", "on_pass": "success"}],
-    }
-
-
-def _load(tmp_path, data):
-    p = tmp_path / "pipeline.yaml"
-    p.write_text(yaml.safe_dump(data))
-    return load_config(p)
-
-
-def _terminal_obs(command, exit_code):
-    return TerminalObservation.from_text(
-        "output", command=command, exit_code=exit_code,
-        metadata=CmdOutputMetadata(exit_code=exit_code))
-
-
-def _terminal_event(command, exit_code, idx=0):
-    return ObservationEvent(
-        tool_name="terminal",
-        tool_call_id=f"tc-{idx}",
-        action_id=f"a-{idx}",
-        observation=_terminal_obs(command, exit_code))
-
-
-def _file_write_event(command="create", idx=0, is_error=False):
-    obs = FileEditorObservation(
-        command=command, path="src/x.py", prev_exist=False,
-        old_content=None, new_content="x")
-    obs = obs.model_copy(update={"is_error": is_error})
-    return ObservationEvent(
-        tool_name="file_editor",
-        tool_call_id=f"fc-{idx}",
-        action_id=f"fa-{idx}",
-        observation=obs)
-
-
-def _agent_event(idx=0):
-    return ActionEvent(
-        thought=[TextContent(type="text", text="working")],
-        tool_name="terminal",
-        tool_call_id=f"ag-{idx}",
-        tool_call=MessageToolCall(
-            id=f"ag-{idx}", name="terminal", arguments="{}",
-            origin="completion"),
-        llm_response_id=f"r-{idx}",
-        action=TerminalAction(command="echo hi"))
-
-
-def _controller(green_command="pytest"):
-    return _StopWhenController(StopWhenSpec(green_command=green_command))
-
-
-class TestStopWhenConfig:
-    def test_valid_agent_step_round_trip(self, tmp_path):
-        data = _base()
-        data["steps"] = [{"name": "dev", "agent": "dev", "on_pass": "success",
-                          "stop_when": {"green_command": "pytest tests/"},
-                          "terminal_timeout": 900}]
-        step = _load(tmp_path, data).steps[0]
-        assert step.stop_when == StopWhenSpec(green_command="pytest tests/")
-        assert step.stop_when.post_green_turns == 2
-        assert step.terminal_timeout == 900
-
-    def test_post_green_turns_custom(self, tmp_path):
-        data = _base()
-        data["steps"] = [{"name": "dev", "agent": "dev", "on_pass": "success",
-                          "stop_when": {"green_command": "pytest",
-                                        "post_green_turns": 0}}]
-        assert _load(tmp_path, data).steps[0].stop_when.post_green_turns == 0
-
-    @pytest.mark.parametrize("bad", ["[", ""])
-    def test_invalid_regex_rejected(self, tmp_path, bad):
-        data = _base()
-        data["steps"] = [{"name": "dev", "agent": "dev",
-                          "stop_when": {"green_command": bad}}]
-        with pytest.raises(ValidationError, match="green_command"):
-            _load(tmp_path, data)
-
-    def test_negative_post_green_turns_rejected(self, tmp_path):
-        data = _base()
-        data["steps"] = [{"name": "dev", "agent": "dev",
-                          "stop_when": {"green_command": "pytest",
-                                        "post_green_turns": -1}}]
-        with pytest.raises(ValidationError):
-            _load(tmp_path, data)
-
-    @pytest.mark.parametrize("step", [
-        {"name": "test", "command": "true", "stop_when": {"green_command": "pytest"}},
-        {"name": "commit", "action": "commit", "stop_when": {"green_command": "pytest"}},
-        {"name": "test", "command": "true", "terminal_timeout": 900},
-        {"name": "commit", "action": "commit", "terminal_timeout": 900},
-    ])
-    def test_agent_only_fields_rejected_on_non_agent(self, tmp_path, step):
-        data = _base()
-        data["steps"] = [step]
-        with pytest.raises(ValidationError, match="requires 'agent'"):
-            _load(tmp_path, data)
-
-    def test_negative_terminal_timeout_rejected(self, tmp_path):
-        data = _base()
-        data["steps"] = [{"name": "dev", "agent": "dev",
-                          "terminal_timeout": -1}]
-        with pytest.raises(ValidationError):
-            _load(tmp_path, data)
-
-
-class TestStopWhenController:
-    def test_matching_green_terminal_sets_signal(self):
-        c = _controller()
-        c.attach(SimpleNamespace(state=SimpleNamespace(execution_status=None)))
-        c.on_event(_agent_event(0))
-        c.on_event(_terminal_event("pytest tests/ -q", 0))
-        assert c.green_signal is True
-
-    def test_matching_failure_clears_signal(self):
-        c = _controller()
-        c.attach(SimpleNamespace(state=SimpleNamespace(execution_status=None)))
-        c.on_event(_agent_event(0))
-        c.on_event(_terminal_event("pytest tests/ -q", 1))
-        assert c.green_signal is False
-
-    def test_file_write_after_green_resets_signal(self):
-        c = _controller()
-        c.attach(SimpleNamespace(state=SimpleNamespace(execution_status=None)))
-        c.on_event(_agent_event(0))
-        c.on_event(_terminal_event("pytest tests/ -q", 0))
-        c.on_event(_file_write_event("create"))
-        assert c.green_signal is False
-
-    def test_file_view_does_not_reset_signal(self):
-        c = _controller()
-        c.attach(SimpleNamespace(state=SimpleNamespace(execution_status=None)))
-        c.on_event(_agent_event(0))
-        c.on_event(_terminal_event("pytest tests/ -q", 0))
-        c.on_event(_file_write_event("view"))
-        assert c.green_signal is True
-
-    def test_later_nonmatching_terminal_keeps_signal(self):
-        c = _controller()
-        c.attach(SimpleNamespace(state=SimpleNamespace(execution_status=None)))
-        c.on_event(_agent_event(0))
-        c.on_event(_terminal_event("pytest tests/ -q", 0))
-        c.on_event(_terminal_event("git status", 0))
-        assert c.green_signal is True
-
-    def test_later_matching_failure_replaces_signal(self):
-        c = _controller()
-        c.attach(SimpleNamespace(state=SimpleNamespace(execution_status=None)))
-        c.on_event(_agent_event(0))
-        c.on_event(_terminal_event("pytest tests/ -q", 0))
-        c.on_event(_terminal_event("pytest tests/ -q", 2))
-        assert c.green_signal is False
-
-    def test_agent_event_pauses_conversation(self):
-        c = _controller()
-        conv = SimpleNamespace(state=SimpleNamespace(execution_status=None))
-        c.attach(conv)
-        c.on_event(_agent_event(0))
-        assert conv.state.execution_status is not None
-        assert conv.state.execution_status.name == "PAUSED"
-
-
-class TestTerminalWriteChannel:
-    def test_terminal_result_green_then_write_resets(self):
-        c = _controller()
-        c.on_terminal_result("pytest tests/ -q", 0, False)
-        assert c.green_signal is True
-        c.on_terminal_result("git diff", 0, True)
-        assert c.green_signal is False
-
-    def test_terminal_result_matching_failure_clears(self):
-        c = _controller()
-        c.on_terminal_result("pytest tests/ -q", 0, False)
-        c.on_terminal_result("pytest tests/ -q", 1, False)
-        assert c.green_signal is False
-
-    def test_executor_reports_writes(self, fake_sandbox, tmp_path):
-        seen = []
-        ex = SandboxTerminalExecutor(
-            fake_sandbox, workspace=str(tmp_path), env={"PATH": "/bin"},
-            on_terminal_result=lambda command, exit_code, wrote: seen.append(
-                (command, exit_code, wrote)))
-        fake_sandbox.script(lambda req: (0, "ok", False, True))
-        ex(TerminalAction(command="echo hi"), None)
-        assert seen == [("echo hi", 0, True)]
-
-
-class TestStopWhenRunLoop:
-    def _conv(self, controller):
-        class Fake:
-            def __init__(self):
-                self.state = SimpleNamespace(execution_status=None)
-                self.messages = []
-                self.run_calls = 0
-
-            def run(self):
-                self.run_calls += 1
-                # The controller callback normally pauses after the turn.
-                self.state.execution_status = SimpleNamespace(name="PAUSED")
-
-            def send_message(self, message):
-                self.messages.append(message)
-
-        return Fake()
-
-    def test_nudge_then_budget_close(self):
-        controller = _controller()
-        controller.green_hit = True
-        controller.writes_since_green = False
-        conv = self._conv(controller)
-        Runtime._run_stop_when_loop(None, conv, controller, max_iterations=10)
-        assert controller.nudged is True
-        assert conv.messages == [controller.NUDGE]
-        assert conv.run_calls == 1 + controller.post_green_turns
-        assert controller.post_nudge_turns == controller.post_green_turns
-
-    def test_post_green_turns_zero_closes_after_nudge(self):
-        controller = _StopWhenController(
-            StopWhenSpec(green_command="pytest", post_green_turns=0))
-        controller.green_hit = True
-        conv = self._conv(controller)
-        Runtime._run_stop_when_loop(None, conv, controller, max_iterations=10)
-        assert controller.nudged is True
-        assert conv.messages == [controller.NUDGE]
-        assert conv.run_calls == 1
-
-
-class TestRunAgentStopWhen:
-    def _runtime(self, tmp_path):
-        cfg = PipelineConfig.model_validate({
-            "name": "t",
-            "llm": {"model": "m", "api_key_env": "K"},
-            "agents_dir": "agents",
-            "lockfiles": ["uv.lock"],
-            "steps": [{
-                "name": "dev",
-                "agent": "dev",
-                "produces": ["implementation-summary.md"],
-                "stop_when": {"green_command": "pytest", "post_green_turns": 2},
-                "on_pass": "success",
-            }],
-        })
-        state_dir = tmp_path / ".pr"
-        state_dir.mkdir()
-        agents_dir = tmp_path / "agents"
-        agents_dir.mkdir()
-        (agents_dir / "dev.agent.md").write_text(
-            "---\nname: dev\ntools: [terminal]\n---\nDo the work.")
-        return Runtime(
-            cfg=cfg, registry=default_registry(),
-            llm=LLM(model="openai/test-model", api_key="sk-test"),
-            agents_dir=agents_dir, state_dir=state_dir,
-            workspace=tmp_path, sandbox=None)
-
-    def _fake_conv(self, script):
-        class Fake:
-            def __init__(self, script):
-                self.state = SimpleNamespace(events=[], execution_status=None)
-                self.callbacks = []
-                self.messages = []
-                self.closed = False
-                self.script = list(script)
-                self.run_calls = 0
-
-            def send_message(self, message):
-                self.messages.append(message)
-
-            def run(self):
-                self.run_calls += 1
-                events, status = self.script.pop(0)
-                for event in events:
-                    self.state.events.append(event)
-                    for cb in self.callbacks:
-                        cb(event)
-                self.state.execution_status = status
-
-            def close(self):
-                self.closed = True
-
-        return Fake(script)
-
-    def test_green_signal_nudges_closes_and_captures(self, tmp_path, monkeypatch):
-        runtime = self._runtime(tmp_path)
-        final = MessageEvent(
-            source="agent",
-            llm_message=Message(
-                role="assistant",
-                content=[TextContent(type="text", text="final summary")]))
-        script = [
-            ([_agent_event(0), _terminal_event("pytest tests/ -q", 0)],
-             ConversationExecutionStatus.PAUSED),
-            ([final], ConversationExecutionStatus.FINISHED),
-        ]
-        conv = self._fake_conv(script)
-
-        def factory(**kw):
-            conv.callbacks = kw.get("callbacks") or []
-            return conv
-
-        monkeypatch.setattr(
-            "agentic_dev_loop.engine.stages.Conversation", factory)
-
-        result = runtime.run_agent("dev", "the task", max_iterations=10,
-                                   step=runtime.cfg.steps[0])
-
-        assert result.ok is True
-        assert result.response == "final summary"
-        assert result.truncated is False
-        assert conv.messages == ["the task", _StopWhenController.NUDGE]
-        assert conv.run_calls == 2
-        assert conv.closed is True
-
-
-class TestTerminalTimeoutOverride:
-    def test_defaults_to_terminal_timeout(self, fake_sandbox, tmp_path):
-        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):
-        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):
-        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