agentic-dev-loop 1.0.0a39__tar.gz → 1.0.0a40__tar.gz

{agentic_dev_loop-1.0.0a39/src/agentic_dev_loop.egg-info → agentic_dev_loop-1.0.0a40}/PKG-INFO

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

{agentic_dev_loop-1.0.0a39 → agentic_dev_loop-1.0.0a40}/pyproject.toml

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

@@ -148,6 +148,7 @@ class VerdictSpec(BaseModel):
     pass_: str = Field(alias="pass")
     fail: str = Field(alias="fail")
     unverifiable: str | None = None
+    env: str | None = None
 
 
 class Route(BaseModel):
@@ -404,6 +405,7 @@ class StepConfig(BaseModel):
     on_pass: RouteTarget | None = None
     on_fail: RouteTarget | None = None
     on_unverifiable: RouteTarget | None = None
+    on_env: RouteTarget | None = None
 
     @property
     def kind(self) -> str:
@@ -794,7 +796,8 @@ class PipelineConfig(BaseModel):
                 raise ValueError(f"step name {n!r} collides with a reserved terminal")
         valid = set(names) | TERMINALS
         for step in self.steps:
-            for route in (step.on_pass, step.on_fail, step.on_unverifiable):
+            for route in (step.on_pass, step.on_fail, step.on_unverifiable,
+                          step.on_env):
                 target = route_target(route)
                 if target is not None and target not in valid:
                     raise ValueError(

{agentic_dev_loop-1.0.0a39 → agentic_dev_loop-1.0.0a40}/src/agentic_dev_loop/engine/stages.py

@@ -683,13 +683,13 @@ def _unclear_note(runtime: Runtime, step: StepConfig, attempt: int,
     captured response when it exists, so real findings are never swallowed."""
     expected = ""
     if step.verdicts is not None:
+        keywords = [f"`VERDICT: {step.verdicts.pass_}`",
+                    f"`VERDICT: {step.verdicts.fail}`"]
         if step.verdicts.unverifiable is not None:
-            expected = (f" (expected `VERDICT: {step.verdicts.pass_}`, "
-                        f"`VERDICT: {step.verdicts.fail}`, or "
-                        f"`VERDICT: {step.verdicts.unverifiable}` on its own line)")
-        else:
-            expected = (f" (expected `VERDICT: {step.verdicts.pass_}` or "
-                        f"`VERDICT: {step.verdicts.fail}` on its own line)")
+            keywords.append(f"`VERDICT: {step.verdicts.unverifiable}`")
+        if step.verdicts.env is not None:
+            keywords.append(f"`VERDICT: {step.verdicts.env}`")
+        expected = f" (expected {' or '.join(keywords)} on its own line)"
     if truncated:
         lead = (f"{step.name} agent was cut short on attempt {attempt} "
                 f"(hit the {max_iterations}-turn limit or was stopped "
@@ -718,6 +718,8 @@ def make_agent_node(runtime: Runtime, step: StepConfig):
         verdicts_map = {step.verdicts.pass_: "pass", step.verdicts.fail: "fail"}
         if step.verdicts.unverifiable is not None:
             verdicts_map[step.verdicts.unverifiable] = "unverifiable"
+        if step.verdicts.env is not None:
+            verdicts_map[step.verdicts.env] = "env"
     captures = step.artifact is not None or bool(step.produces)
 
     def node(state: dict) -> dict:
@@ -787,6 +789,21 @@ def make_agent_node(runtime: Runtime, step: StepConfig):
                 if captures and result.response is not None:
                     update["artifacts"] = {step.name: result.response}
                 return update
+            if verdict == "env":
+                print(f"[{subject}] {step.name} verdict: ENV "
+                      f"(environmental, halting).", flush=True)
+                if step.on_env is None:
+                    runtime.state_dir.mkdir(parents=True, exist_ok=True)
+                    (runtime.state_dir / LAST_ERROR).write_text(
+                        f"# Environmental failure (verdict: ENV)\n\n"
+                        f"{result.response or 'no captured response'}\n",
+                        encoding="utf-8")
+                    return {"step_verdicts": merged,
+                            "failed": True, "failed_step": step.name}
+                update = {"step_verdicts": merged, "failed": False}
+                if captures and result.response is not None:
+                    update["artifacts"] = {step.name: result.response}
+                return update
             print(f"[{subject}] {step.name} verdict: fail on attempt {attempt}.",
                   flush=True)
             update = {"step_verdicts": merged,
@@ -1115,6 +1132,8 @@ def make_router(runtime: Runtime, step: StepConfig):
             if step.on_unverifiable is not None:
                 return resolve(step.on_unverifiable)
             return resolve(step.on_pass)
+        if verdict == "env":
+            return resolve(step.on_env) if step.on_env is not None else END
         if verdict == "fail":
             if step.on_fail is None:
                 return END

{agentic_dev_loop-1.0.0a39 → agentic_dev_loop-1.0.0a40}/src/agentic_dev_loop/viz/server.py

@@ -546,6 +546,7 @@ PAGE = """<!doctype html>
   var verdictFail = new Set();
   var verdictPass = new Set();
   var verdictUnverifiable = new Set();
+  var verdictEnv = new Set();
   var fatalNodes = new Set();
   var maxAttempts = null;
   var attempt = null;
@@ -614,9 +615,15 @@ PAGE = """<!doctype html>
     if (verdictFail.has(n)) { return "fail"; }
     if (verdictPass.has(n)) { return "pass"; }
     if (verdictUnverifiable.has(n)) { return "unverifiable"; }
+    if (verdictEnv.has(n)) { return "env"; }
     return nodeStatus[n] || "pending";
   }
 
+  function renderStatusOf(n) {
+    var s = statusOf(n);
+    return s === "env" ? "fatal" : s;
+  }
+
   function updateBadges() {
     var box = el("verdicts");
     box.innerHTML = "";
@@ -627,6 +634,7 @@ PAGE = """<!doctype html>
       if (v === "pass") { b.className += " badge-pass"; }
       else if (v === "fail") { b.className += " badge-fail"; }
       else if (v === "unverifiable") { b.className += " badge-unverifiable"; }
+      else if (v === "env") { b.className += " badge-fail"; }
       else { b.className += " badge-unclear"; }
       b.textContent = step + ": " + (v === null || v === undefined ? "no verdict" : v);
       box.appendChild(b);
@@ -638,6 +646,7 @@ PAGE = """<!doctype html>
     verdictPass.clear();
     verdictFail.clear();
     verdictUnverifiable.clear();
+    verdictEnv.clear();
     currentVerdicts = {};
     nodeStatus = {};
     stageWord = {};
@@ -665,7 +674,7 @@ PAGE = """<!doctype html>
     var classLines = Object.keys(nodeStatus).filter(function (n) {
       return nodeIds.has(n);
     }).map(function (n) {
-      return "class " + n + " " + statusOf(n) + ";";
+      return "class " + n + " " + renderStatusOf(n) + ";";
     });
     var src = mermaidSource + "\\n" + classDefs.join("\\n") + "\\n" + classLines.join("\\n");
     mermaid.render("graph-" + (renderCount++), src).then(function (res) {
@@ -756,9 +765,10 @@ PAGE = """<!doctype html>
       if (v === "pass") { suffix = " (verdict: PASS)"; }
       else if (v === "fail") { suffix = " (verdict: FAIL)"; }
       else if (v === "unverifiable") { suffix = " (verdict: UNVERIFIABLE)"; }
+      else if (v === "env") { suffix = " (verdict: ENV)"; }
     }
     status.textContent = (word ? " " + word : "") + suffix;
-    header.className = "stage-header status-" + statusOf(node);
+    header.className = "stage-header status-" + renderStatusOf(node);
   }
 
   function setStageStatus(node, word) {
@@ -1072,10 +1082,11 @@ PAGE = """<!doctype html>
           Object.keys(ev.step_verdicts).forEach(function (k) {
             verdictSteps.add(k);
             var v = ev.step_verdicts[k];
-            if (v === "pass") { verdictPass.add(k); verdictFail.delete(k); verdictUnverifiable.delete(k); }
-            else if (v === "fail") { verdictFail.add(k); verdictPass.delete(k); verdictUnverifiable.delete(k); }
-            else if (v === "unverifiable") { verdictUnverifiable.add(k); verdictPass.delete(k); verdictFail.delete(k); }
-            else { verdictPass.delete(k); verdictFail.delete(k); verdictUnverifiable.delete(k); }
+            if (v === "pass") { verdictPass.add(k); verdictFail.delete(k); verdictUnverifiable.delete(k); verdictEnv.delete(k); }
+            else if (v === "fail") { verdictFail.add(k); verdictPass.delete(k); verdictUnverifiable.delete(k); verdictEnv.delete(k); }
+            else if (v === "unverifiable") { verdictUnverifiable.add(k); verdictPass.delete(k); verdictFail.delete(k); verdictEnv.delete(k); }
+            else if (v === "env") { verdictEnv.add(k); verdictPass.delete(k); verdictFail.delete(k); verdictUnverifiable.delete(k); }
+            else { verdictPass.delete(k); verdictFail.delete(k); verdictUnverifiable.delete(k); verdictEnv.delete(k); }
             currentVerdicts[k] = v;
           });
           updateBadges();

{agentic_dev_loop-1.0.0a39 → agentic_dev_loop-1.0.0a40/src/agentic_dev_loop.egg-info}/PKG-INFO

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

{agentic_dev_loop-1.0.0a39 → agentic_dev_loop-1.0.0a40}/tests/test_config.py

@@ -637,3 +637,40 @@ class TestDepsPolicy:
     def test_lockfiles_accepts_a_single_string(self, tmp_path):
         data = _base() | {"lockfiles": "uv.lock"}
         assert _load(tmp_path, data).lockfiles == ["uv.lock"]
+
+
+def test_four_keyword_verdict_and_on_env_load(tmp_path):
+    data = _base()
+    data["steps"][0] = {
+        "name": "qa", "agent": "qa", "artifact": "qa-report.md",
+        "verdicts": {"pass": "PASS", "fail": "FAIL",
+                     "unverifiable": "UNVERIFIABLE", "env": "ENV"},
+        "on_pass": "success", "on_unverifiable": "success",
+        "on_env": "failure",
+    }
+    step = _load(tmp_path, data).steps[0]
+    assert step.verdicts.pass_ == "PASS"
+    assert step.verdicts.fail == "FAIL"
+    assert step.verdicts.unverifiable == "UNVERIFIABLE"
+    assert step.verdicts.env == "ENV"
+    assert step.on_env == "failure"
+
+
+def test_dangling_on_env_rejected(tmp_path):
+    data = _base()
+    data["steps"][0]["on_env"] = "nope"
+    with pytest.raises(ValidationError, match="unknown route target 'nope'"):
+        _load(tmp_path, data)
+
+
+def test_env_keyword_optional_three_keyword_still_loads(tmp_path):
+    data = _base()
+    data["steps"][0] = {
+        "name": "qa", "agent": "qa", "artifact": "qa-report.md",
+        "verdicts": {"pass": "PASS", "fail": "FAIL",
+                     "unverifiable": "UNVERIFIABLE"},
+        "on_pass": "success", "on_unverifiable": "success",
+    }
+    step = _load(tmp_path, data).steps[0]
+    assert step.verdicts.env is None
+    assert step.on_env is None

{agentic_dev_loop-1.0.0a39 → agentic_dev_loop-1.0.0a40}/tests/test_qa_prompt.py

@@ -35,3 +35,19 @@ def test_probe_plan_rules_present():
     assert "**Outcome probes.**" in text
     assert "**Concurrency probes.**" in text
     assert "**Error messages are assertions.**" in text
+
+
+def test_env_verdict_rules_present():
+    text = _text()
+    assert "VERDICT: ENV" in text
+    assert "## ENV" in text
+    assert "environment" in text.lower()
+    assert "harness" in text
+    assert "2 attempts" in text
+
+
+def test_env_unverifiable_distinction_present():
+    text = _text()
+    assert "UNVERIFIABLE" in text
+    assert "verification environment" in text
+    assert "product code" in text

{agentic_dev_loop-1.0.0a39 → agentic_dev_loop-1.0.0a40}/tests/test_stages.py

@@ -362,6 +362,53 @@ class TestAgentNode:
         assert "VERDICT: FAIL" in note
         assert "VERDICT: UNVERIFIABLE" in note
 
+    def test_unclear_note_mentions_fourth_keyword(self, runtime, fake_agents):
+        step = make_cfg([
+            {"name": "qa", "agent": "qa", "artifact": "qa-report.md",
+             "verdicts": {"pass": "PASS", "fail": "FAIL",
+                          "unverifiable": "UNVERIFIABLE", "env": "ENV"},
+             "on_pass": "success"}]).steps[0]
+        fake_agents.set("qa", [("write", "qa-report.md", "undecided")])
+        update = make_agent_node(runtime, step)(make_state())
+        (note,) = update["notes"]
+        assert "VERDICT: PASS" in note
+        assert "VERDICT: FAIL" in note
+        assert "VERDICT: UNVERIFIABLE" in note
+        assert "VERDICT: ENV" in note
+
+    def test_env_verdict_hard_fails_and_writes_last_error(self, runtime,
+                                                          fake_agents):
+        step = make_cfg([
+            {"name": "qa", "agent": "qa", "artifact": "qa-report.md",
+             "verdicts": {"pass": "PASS", "fail": "FAIL",
+                          "unverifiable": "UNVERIFIABLE", "env": "ENV"},
+             "on_pass": "success"}]).steps[0]
+        fake_agents.set("qa", [("write", "qa-report.md",
+                                "probe timeout\nVERDICT: ENV")])
+        update = make_agent_node(runtime, step)(make_state())
+        assert update["step_verdicts"] == {"qa": "env"}
+        assert update["failed"] is True
+        assert update["failed_step"] == "qa"
+        assert "artifacts" not in update
+        err = (runtime.state_dir / "last-error.md").read_text()
+        assert "Environmental failure (verdict: ENV)" in err
+        assert "probe timeout" in err
+
+    def test_env_verdict_with_on_env_route_moves_without_hard_fail(
+            self, runtime, fake_agents):
+        step = make_cfg([
+            {"name": "qa", "agent": "qa", "artifact": "qa-report.md",
+             "verdicts": {"pass": "PASS", "fail": "FAIL",
+                          "unverifiable": "UNVERIFIABLE", "env": "ENV"},
+             "on_pass": "success", "on_env": "failure"}]).steps[0]
+        fake_agents.set("qa", [("write", "qa-report.md",
+                                "probe timeout\nVERDICT: ENV")])
+        update = make_agent_node(runtime, step)(make_state())
+        assert update["step_verdicts"] == {"qa": "env"}
+        assert update["failed"] is False
+        assert update["artifacts"] == {"qa": "probe timeout\nVERDICT: ENV"}
+        assert "failed_step" not in update
+
 
 class TestCommandNode:
     def _node(self, runtime, steps, idx=0):
@@ -640,6 +687,46 @@ class TestRouter:
         assert router(make_state(attempt=1,
                                  step_verdicts={"qa": "unverifiable"})) == "commit"
 
+    def test_env_routes_on_env(self, runtime):
+        cfg = make_cfg([
+            {"name": "dev", "agent": "dev", "on_pass": "qa"},
+            {"name": "qa", "agent": "qa", "artifact": "qa-report.md",
+             "verdicts": {"pass": "PASS", "fail": "FAIL",
+                          "unverifiable": "UNVERIFIABLE", "env": "ENV"},
+             "on_pass": "commit", "on_fail": {"goto": "dev", "retry": True},
+             "on_env": "dev"},
+            {"name": "commit", "action": "commit", "on_pass": "success"},
+        ])
+        runtime = dataclasses.replace(runtime, cfg=cfg)
+        router = make_router(runtime, cfg.steps[1])
+        assert router(make_state(step_verdicts={"qa": "env"})) == "dev"
+
+    def test_env_with_on_env_failure_ends(self, runtime):
+        cfg = make_cfg([
+            {"name": "dev", "agent": "dev", "on_pass": "qa"},
+            {"name": "qa", "agent": "qa", "artifact": "qa-report.md",
+             "verdicts": {"pass": "PASS", "fail": "FAIL",
+                          "unverifiable": "UNVERIFIABLE", "env": "ENV"},
+             "on_pass": "commit", "on_env": "failure"},
+            {"name": "commit", "action": "commit", "on_pass": "success"},
+        ])
+        runtime = dataclasses.replace(runtime, cfg=cfg)
+        router = make_router(runtime, cfg.steps[1])
+        assert router(make_state(step_verdicts={"qa": "env"})) == END
+
+    def test_env_without_on_env_is_defensive_end(self, runtime):
+        cfg = make_cfg([
+            {"name": "dev", "agent": "dev", "on_pass": "qa"},
+            {"name": "qa", "agent": "qa", "artifact": "qa-report.md",
+             "verdicts": {"pass": "PASS", "fail": "FAIL",
+                          "unverifiable": "UNVERIFIABLE", "env": "ENV"},
+             "on_pass": "commit"},
+            {"name": "commit", "action": "commit", "on_pass": "success"},
+        ])
+        runtime = dataclasses.replace(runtime, cfg=cfg)
+        router = make_router(runtime, cfg.steps[1])
+        assert router(make_state(step_verdicts={"qa": "env"})) == END
+
 
 class TestBumpNode:
     def test_consumes_attempt_resets_verdicts_rebuilds_cleans(self, runtime):

{agentic_dev_loop-1.0.0a39 → agentic_dev_loop-1.0.0a40}/tests/test_verdict.py

@@ -217,3 +217,27 @@ class TestVerdictShape:
         a = _parse("VERDICT: PASS", TEST_VERDICTS).value
         b = _parse("VERDICT: **PASS**", TEST_VERDICTS).value
         assert a == b
+
+
+QA_ENV_VERDICTS = {"PASS": "pass", "FAIL": "fail",
+                   "UNVERIFIABLE": "unverifiable", "ENV": "env"}
+
+
+class TestEnvVerdictParsing:
+    def test_parse_env(self):
+        _ok("VERDICT: ENV", QA_ENV_VERDICTS, "env")
+        _ok("VERDICT: ENV - sandbox network is dead",
+            QA_ENV_VERDICTS, "env")
+        _ok("verdict: env", QA_ENV_VERDICTS, "env")
+
+    def test_parse_verdict_env_returns_canonical_value(self):
+        assert parse_verdict("VERDICT: ENV", QA_ENV_VERDICTS) == "env"
+
+    def test_negated_env_stays_ambiguous_on_four_key_sets(self):
+        _err("VERDICT: NOT ENV", QA_ENV_VERDICTS, VerdictError.AMBIGUOUS)
+
+    def test_conflicting_pass_and_env_is_ambiguous(self):
+        _err("VERDICT: PASS\nVERDICT: ENV", QA_ENV_VERDICTS,
+             VerdictError.AMBIGUOUS)
+        assert parse_verdict("VERDICT: PASS\nVERDICT: ENV",
+                             QA_ENV_VERDICTS) == "retry"

{agentic_dev_loop-1.0.0a39 → agentic_dev_loop-1.0.0a40}/tests/test_viz.py

@@ -743,6 +743,13 @@ class TestServer:
         assert 'else if (v === "unverifiable")' in PAGE
         assert " (verdict: UNVERIFIABLE)" in PAGE
 
+    def test_page_constant_has_env_verdict_support(self):
+        assert "verdictEnv" in PAGE
+        # the new value maps to the fatal badge, never the unclear fallthrough
+        assert 'else if (v === "env")' in PAGE
+        assert " (verdict: ENV)" in PAGE
+        assert 'verdictEnv.has(n)' in PAGE
+
     def test_page_constant_color_palette(self):
         assert 'classDef running fill:#1976d2' in PAGE
         assert 'classDef fail fill:#ffb300' in PAGE
@@ -1119,6 +1126,19 @@ main();
         assert snaps[0]["badges"] == ["review: unverifiable"]
         assert snaps[0]["classes"]["review"] == "unverifiable"
 
+    def test_env_verdict_badge_and_fatal_class(self, node, tmp_path):
+        events = [
+            {"type": "run_started", "subject": "s", "max_attempts": 5,
+             "attempt": 1, "thread_id": "t"},
+            {"type": "node_finished", "node": "review", "ok": True},
+            {"type": "state", "attempt": 1,
+             "step_verdicts": {"review": "env"}, "failed": False},
+        ]
+        snaps = self._run_page(node, events, tmp_path)
+
+        assert snaps[0]["badges"] == ["review: env"]
+        assert snaps[0]["classes"]["review"] == "fatal"
+
     def test_copy_button_copies_console_text(self, node, tmp_path):
         events = [
             {"type": "run_started", "subject": "s", "max_attempts": 5,