agentic-dev-loop 1.0.0a45__tar.gz → 1.0.0a46__tar.gz

{agentic_dev_loop-1.0.0a45/src/agentic_dev_loop.egg-info → agentic_dev_loop-1.0.0a46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a45
+Version: 1.0.0a46
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -199,6 +199,7 @@ llm:
   model: openai/deepseek-v4-pro
   base_url: https://api.deepseek.com
   api_key_env: OPENAI_API_KEY
+  # reasoning_effort: medium                        # optional: low | medium | high | xhigh | none
 
 max_attempts: 10                                        # CLI --max-attempts overrides
 agents_dir: sdk_agents                                  # your <name>.agent.md files
@@ -228,6 +229,7 @@ steps:
     agent: review
     artifact: review-findings.md
     verdicts: { pass: APPROVED, fail: NEEDS CHANGES }
+    # reasoning_effort: xhigh                        # per-step override; falls back to the llm block, then SDK default
     on_pass: qa
     on_fail: { goto: dev, retry: true }
 
@@ -253,6 +255,7 @@ steps:
 | `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. |
+| `reasoning_effort:` | Optional `low` / `medium` / `high` / `xhigh` / `none`. Set on the `llm` block (pipeline-global) or per-step (overrides the block). Unset anywhere = the field is not passed and the SDK default (`high`) applies, so today's behavior is unchanged. Forwarded only for models the SDK/LiteLLM mark as supporting it; an unsupported value fails at the first LLM call. See [Reasoning effort](#reasoning-effort-opt-in). |
 | `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`. |
@@ -266,6 +269,30 @@ steps:
 | `caches:` / `sync_excludes:` | Top-level run-wide lists. `caches:` names repo-relative toolchain cache dirs bind-mounted rw from the real workspace (auto-created if missing); a `setup:` hook can warm them (the provision container carries the same cache mounts); `sync_excludes:` names scratch paths skipped from both the export copy and sync-back (wildcard `*` spans separators, so `**/bin/**` matches a `/bin/` segment at any depth). Both default to `[]`. See [docs/setup.md](docs/setup.md). |
 | `merge_on_conflict:` | Top-level run-wide list of append-style logs (same path vocabulary as `sync_excludes:`, default `[]`). A concurrent host edit to a listed path is union-merged instead of raising: the host file wins and the sandbox's export-only lines are appended in order; both sides converge and the run continues. See [docs/setup.md](docs/setup.md). |
 
+### Reasoning effort (opt-in)
+
+`reasoning_effort` is an opt-in latency dial on the pipeline `llm` block and
+on individual agent steps. It takes one of `low`, `medium`, `high`, `xhigh`,
+or `none`; unset means the field is never passed and the SDK default
+(`high`) applies, so a pipeline that omits it behaves exactly as before. A
+step's value overrides the `llm` block's value, so the review lane can hold
+a higher effort than the rest.
+
+The value is forwarded only for models the SDK/LiteLLM mark as supporting
+it; an unsupported value fails at the first LLM call (the schema rejects
+unknown names at load time, but cannot know provider capability). No
+pipeline ships a value: adopt one only after an observed run proves lower
+per-turn latency with a green suite and no provider 400s.
+
+Recommended lane defaults (guidance only, not enforced):
+
+| Lane | reasoning_effort | Why |
+| --- | --- | --- |
+| brief | medium | digest and classify, no design work |
+| dev | high | hold the line: dev caught a real plan bug and a real sandbox triage this unit |
+| qa | medium | classification discipline must stay reliable |
+| review | xhigh | shortest lane, highest stakes: a missed detection sails past the last gate into commit |
+
 A `brief_inputs:` step is the per-run context-digestion pattern: it runs once at
 run start (or when its inputs change), its `produces:` artifact survives attempt
 starts, and the dev/review agents read that digest instead of re-deriving repo

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a46}/README.md

@@ -155,6 +155,7 @@ llm:
   model: openai/deepseek-v4-pro
   base_url: https://api.deepseek.com
   api_key_env: OPENAI_API_KEY
+  # reasoning_effort: medium                        # optional: low | medium | high | xhigh | none
 
 max_attempts: 10                                        # CLI --max-attempts overrides
 agents_dir: sdk_agents                                  # your <name>.agent.md files
@@ -184,6 +185,7 @@ steps:
     agent: review
     artifact: review-findings.md
     verdicts: { pass: APPROVED, fail: NEEDS CHANGES }
+    # reasoning_effort: xhigh                        # per-step override; falls back to the llm block, then SDK default
     on_pass: qa
     on_fail: { goto: dev, retry: true }
 
@@ -209,6 +211,7 @@ steps:
 | `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. |
+| `reasoning_effort:` | Optional `low` / `medium` / `high` / `xhigh` / `none`. Set on the `llm` block (pipeline-global) or per-step (overrides the block). Unset anywhere = the field is not passed and the SDK default (`high`) applies, so today's behavior is unchanged. Forwarded only for models the SDK/LiteLLM mark as supporting it; an unsupported value fails at the first LLM call. See [Reasoning effort](#reasoning-effort-opt-in). |
 | `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`. |
@@ -222,6 +225,30 @@ steps:
 | `caches:` / `sync_excludes:` | Top-level run-wide lists. `caches:` names repo-relative toolchain cache dirs bind-mounted rw from the real workspace (auto-created if missing); a `setup:` hook can warm them (the provision container carries the same cache mounts); `sync_excludes:` names scratch paths skipped from both the export copy and sync-back (wildcard `*` spans separators, so `**/bin/**` matches a `/bin/` segment at any depth). Both default to `[]`. See [docs/setup.md](docs/setup.md). |
 | `merge_on_conflict:` | Top-level run-wide list of append-style logs (same path vocabulary as `sync_excludes:`, default `[]`). A concurrent host edit to a listed path is union-merged instead of raising: the host file wins and the sandbox's export-only lines are appended in order; both sides converge and the run continues. See [docs/setup.md](docs/setup.md). |
 
+### Reasoning effort (opt-in)
+
+`reasoning_effort` is an opt-in latency dial on the pipeline `llm` block and
+on individual agent steps. It takes one of `low`, `medium`, `high`, `xhigh`,
+or `none`; unset means the field is never passed and the SDK default
+(`high`) applies, so a pipeline that omits it behaves exactly as before. A
+step's value overrides the `llm` block's value, so the review lane can hold
+a higher effort than the rest.
+
+The value is forwarded only for models the SDK/LiteLLM mark as supporting
+it; an unsupported value fails at the first LLM call (the schema rejects
+unknown names at load time, but cannot know provider capability). No
+pipeline ships a value: adopt one only after an observed run proves lower
+per-turn latency with a green suite and no provider 400s.
+
+Recommended lane defaults (guidance only, not enforced):
+
+| Lane | reasoning_effort | Why |
+| --- | --- | --- |
+| brief | medium | digest and classify, no design work |
+| dev | high | hold the line: dev caught a real plan bug and a real sandbox triage this unit |
+| qa | medium | classification discipline must stay reliable |
+| review | xhigh | shortest lane, highest stakes: a missed detection sails past the last gate into commit |
+
 A `brief_inputs:` step is the per-run context-digestion pattern: it runs once at
 run start (or when its inputs change), its `produces:` artifact survives attempt
 starts, and the dev/review agents read that digest instead of re-deriving repo

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a46}/pyproject.toml

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

@@ -6,7 +6,7 @@ import hashlib
 import re
 import warnings
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 import yaml
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
@@ -35,6 +35,11 @@ DEFAULT_BRIEF_SECTIONS = [
     "Open risks",
 ]
 
+# 047: the full SDK reasoning_effort literal, passed through verbatim. The
+# engine is provider-generic, so it validates shape only - whether a given
+# provider accepts every value (notably "none") is operator risk (D3).
+ReasoningEffort = Literal["low", "medium", "high", "xhigh", "none"]
+
 
 def _validate_mount_path(path: str) -> str:
     """Validate one repo-relative mount path (BR-1.3).
@@ -385,6 +390,9 @@ class StepConfig(BaseModel):
     terminal_timeout: float | None = Field(default=None, gt=0)  # seconds, 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)
+    # 047 (D7): per-step opt-in override; unset falls back to the llm block,
+    # then the SDK default. Full SDK literal, passthrough semantics.
+    reasoning_effort: ReasoningEffort | None = None
     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
@@ -552,6 +560,10 @@ class LlmConfig(BaseModel):
     base_url: str | None = None
     api_key_env: str
     timeout: float | None = None  # omitted → opinionated no-timeout default
+    # 047 (D1): opt-in passthrough; unset means the field is not passed at
+    # all, so the SDK default ("high") applies and today's behavior is
+    # byte-identical. No default may move without an observed run (D6).
+    reasoning_effort: ReasoningEffort | None = None
 
 
 class PipelineConfig(BaseModel):

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a46}/src/agentic_dev_loop/engine/llm.py

@@ -48,13 +48,20 @@ if not getattr(_ORIGINAL_FORMAT_MESSAGES, "_agentic_dev_loop_reasoning_repair",
     LLM.format_messages_for_llm = _repair_reasoning_passback
 
 
-def build_llm(cfg: LlmConfig) -> LLM:
+def build_llm(cfg: LlmConfig, reasoning_effort: str | None = None) -> LLM:
     api_key = os.environ.get(cfg.api_key_env)
     if not api_key:
         raise RuntimeError(f"{cfg.api_key_env} environment variable is required")
-    return LLM(
-        model=cfg.model,
-        api_key=api_key,
-        base_url=cfg.base_url,
-        timeout=cfg.timeout,  # policy: no LLM timeout unless explicitly set
-    )
+    # 047 (D2/D7): an explicit per-step override wins, else the llm block's
+    # value applies, else the field is omitted entirely and the SDK default
+    # ("high") is in force. The reasoning_content shims above stay untouched.
+    effort = reasoning_effort if reasoning_effort is not None else cfg.reasoning_effort
+    kwargs = {
+        "model": cfg.model,
+        "api_key": api_key,
+        "base_url": cfg.base_url,
+        "timeout": cfg.timeout,  # policy: no LLM timeout unless explicitly set
+    }
+    if effort is not None:
+        kwargs["reasoning_effort"] = effort
+    return LLM(**kwargs)

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a46}/src/agentic_dev_loop/engine/stages.py

@@ -42,6 +42,7 @@ from .egress_policy import assemble_egress_policy
 from .forbidden import resolve_forbidden_rules
 from .isolation import (SandboxError, SandboxExecutionRequest, command_argv,
                         resolve_sandbox_env)
+from .llm import build_llm
 from .mounts import resolve_mount_set
 from .outputs import CapturedOutput
 from .secrets import redact_values, step_secret_env
@@ -174,11 +175,18 @@ class Runtime:
                              if step is not None else None),
                     forbidden_commands=forbidden_commands,
                     allowlist=allowlist)
+            # 047 (D7): a step's reasoning_effort overrides the llm block's;
+            # self.llm already carries the block value (or the SDK default),
+            # so only build a fresh LLM when the step overrides it.
+            llm = self.llm
+            if step is not None and step.reasoning_effort is not None:
+                llm = build_llm(self.cfg.llm,
+                                reasoning_effort=step.reasoning_effort)
             if step is not None and step.brief_inputs is not None:
                 agent = load_brief_agent(
-                    agent_name, step.brief_inputs.sections, self.llm)
+                    agent_name, step.brief_inputs.sections, llm)
             else:
-                agent = load_agent(self.agents_dir, agent_name, self.llm)
+                agent = load_agent(self.agents_dir, agent_name, llm)
             callbacks = []
             if finalize_controller is not None:
                 callbacks.append(finalize_controller.on_event)

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a46/src/agentic_dev_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a45
+Version: 1.0.0a46
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -199,6 +199,7 @@ llm:
   model: openai/deepseek-v4-pro
   base_url: https://api.deepseek.com
   api_key_env: OPENAI_API_KEY
+  # reasoning_effort: medium                        # optional: low | medium | high | xhigh | none
 
 max_attempts: 10                                        # CLI --max-attempts overrides
 agents_dir: sdk_agents                                  # your <name>.agent.md files
@@ -228,6 +229,7 @@ steps:
     agent: review
     artifact: review-findings.md
     verdicts: { pass: APPROVED, fail: NEEDS CHANGES }
+    # reasoning_effort: xhigh                        # per-step override; falls back to the llm block, then SDK default
     on_pass: qa
     on_fail: { goto: dev, retry: true }
 
@@ -253,6 +255,7 @@ steps:
 | `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. |
+| `reasoning_effort:` | Optional `low` / `medium` / `high` / `xhigh` / `none`. Set on the `llm` block (pipeline-global) or per-step (overrides the block). Unset anywhere = the field is not passed and the SDK default (`high`) applies, so today's behavior is unchanged. Forwarded only for models the SDK/LiteLLM mark as supporting it; an unsupported value fails at the first LLM call. See [Reasoning effort](#reasoning-effort-opt-in). |
 | `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`. |
@@ -266,6 +269,30 @@ steps:
 | `caches:` / `sync_excludes:` | Top-level run-wide lists. `caches:` names repo-relative toolchain cache dirs bind-mounted rw from the real workspace (auto-created if missing); a `setup:` hook can warm them (the provision container carries the same cache mounts); `sync_excludes:` names scratch paths skipped from both the export copy and sync-back (wildcard `*` spans separators, so `**/bin/**` matches a `/bin/` segment at any depth). Both default to `[]`. See [docs/setup.md](docs/setup.md). |
 | `merge_on_conflict:` | Top-level run-wide list of append-style logs (same path vocabulary as `sync_excludes:`, default `[]`). A concurrent host edit to a listed path is union-merged instead of raising: the host file wins and the sandbox's export-only lines are appended in order; both sides converge and the run continues. See [docs/setup.md](docs/setup.md). |
 
+### Reasoning effort (opt-in)
+
+`reasoning_effort` is an opt-in latency dial on the pipeline `llm` block and
+on individual agent steps. It takes one of `low`, `medium`, `high`, `xhigh`,
+or `none`; unset means the field is never passed and the SDK default
+(`high`) applies, so a pipeline that omits it behaves exactly as before. A
+step's value overrides the `llm` block's value, so the review lane can hold
+a higher effort than the rest.
+
+The value is forwarded only for models the SDK/LiteLLM mark as supporting
+it; an unsupported value fails at the first LLM call (the schema rejects
+unknown names at load time, but cannot know provider capability). No
+pipeline ships a value: adopt one only after an observed run proves lower
+per-turn latency with a green suite and no provider 400s.
+
+Recommended lane defaults (guidance only, not enforced):
+
+| Lane | reasoning_effort | Why |
+| --- | --- | --- |
+| brief | medium | digest and classify, no design work |
+| dev | high | hold the line: dev caught a real plan bug and a real sandbox triage this unit |
+| qa | medium | classification discipline must stay reliable |
+| review | xhigh | shortest lane, highest stakes: a missed detection sails past the last gate into commit |
+
 A `brief_inputs:` step is the per-run context-digestion pattern: it runs once at
 run start (or when its inputs change), its `produces:` artifact survives attempt
 starts, and the dev/review agents read that digest instead of re-deriving repo

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a46}/tests/test_config.py

@@ -180,6 +180,40 @@ def test_extra_body_llm_key_rejected(tmp_path):
         _load(tmp_path, data)
 
 
+def test_llm_reasoning_effort_round_trips(tmp_path):
+    data = _base()
+    data["llm"]["reasoning_effort"] = "medium"
+    assert _load(tmp_path, data).llm.reasoning_effort == "medium"
+
+
+def test_llm_reasoning_effort_defaults_none(tmp_path):
+    assert _load(tmp_path, _base()).llm.reasoning_effort is None
+
+
+def test_llm_reasoning_effort_unknown_value_rejected(tmp_path):
+    data = _base()
+    data["llm"]["reasoning_effort"] = "maximum"
+    with pytest.raises(ValidationError):
+        _load(tmp_path, data)
+
+
+def test_step_reasoning_effort_round_trips(tmp_path):
+    data = _base()
+    data["steps"][0]["reasoning_effort"] = "xhigh"
+    assert _load(tmp_path, data).steps[0].reasoning_effort == "xhigh"
+
+
+def test_step_reasoning_effort_defaults_none(tmp_path):
+    assert _load(tmp_path, _base()).steps[0].reasoning_effort is None
+
+
+def test_step_reasoning_effort_unknown_value_rejected(tmp_path):
+    data = _base()
+    data["steps"][0]["reasoning_effort"] = "banana"
+    with pytest.raises(ValidationError):
+        _load(tmp_path, data)
+
+
 def test_unknown_route_key_rejected(tmp_path):
     data = _base()
     data["steps"][0]["on_pass"] = {"goto": "success", "bogus": 1}

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a46}/tests/test_llm.py

@@ -43,6 +43,46 @@ class TestBuildLlm:
 
         assert mock_cls.call_args.kwargs["timeout"] == 30
 
+    def test_reasoning_effort_omitted_when_unset(self, monkeypatch):
+        monkeypatch.setenv(KEY, "sk-test")
+        with patch("agentic_dev_loop.engine.llm.LLM") as mock_cls:
+            build_llm(_cfg())
+
+        assert "reasoning_effort" not in mock_cls.call_args.kwargs
+
+    def test_reasoning_effort_passed_through_when_set(self, monkeypatch):
+        monkeypatch.setenv(KEY, "sk-test")
+        with patch("agentic_dev_loop.engine.llm.LLM") as mock_cls:
+            build_llm(_cfg(reasoning_effort="medium"))
+
+        assert mock_cls.call_args.kwargs["reasoning_effort"] == "medium"
+
+
+class TestReasoningEffortResolution:
+    """D7: the step's value wins, else the llm block's value, else unset
+    (the SDK default "high" applies)."""
+
+    def test_step_override_wins_over_block(self, monkeypatch):
+        monkeypatch.setenv(KEY, "sk-test")
+        with patch("agentic_dev_loop.engine.llm.LLM") as mock_cls:
+            build_llm(_cfg(reasoning_effort="low"), reasoning_effort="xhigh")
+
+        assert mock_cls.call_args.kwargs["reasoning_effort"] == "xhigh"
+
+    def test_block_value_applies_without_step_override(self, monkeypatch):
+        monkeypatch.setenv(KEY, "sk-test")
+        with patch("agentic_dev_loop.engine.llm.LLM") as mock_cls:
+            build_llm(_cfg(reasoning_effort="medium"))
+
+        assert mock_cls.call_args.kwargs["reasoning_effort"] == "medium"
+
+    def test_unset_everywhere_omits_the_field(self, monkeypatch):
+        monkeypatch.setenv(KEY, "sk-test")
+        with patch("agentic_dev_loop.engine.llm.LLM") as mock_cls:
+            build_llm(_cfg())
+
+        assert "reasoning_effort" not in mock_cls.call_args.kwargs
+
 
 class TestReasoningContentShim:
     """DeepSeek thinking mode 400s on multi-turn requests unless prior

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a46}/tests/test_publish.py

@@ -226,6 +226,45 @@ class TestChangelog:
         assert read_version(repo) == "0.2.0"
 
 
+class TestConsumerAdoption:
+    def test_marker_without_adoption_section_fails(self, tmp_path):
+        repo, _ = make_repo(
+            tmp_path,
+            unreleased=(
+                "### Changed\n\n"
+                "- feat: construct plan 031-qa-environmental-verdict.md\n"
+            ),
+        )
+        proc = run_publish(repo, "--patch")
+        assert proc.returncode != 0
+        assert "Consumer adoption" in proc.stderr
+        assert read_version(repo) == "0.2.0"
+        assert tags(repo) == []
+
+    def test_marker_with_adoption_section_passes(self, tmp_path):
+        repo, _ = make_repo(
+            tmp_path,
+            unreleased=(
+                "### Changed\n\n"
+                "- feat: construct plan 031-qa-environmental-verdict.md\n\n"
+                "### Consumer adoption\n\n"
+                "- qa verdict steps must add `env: ENV` to their verdicts map\n"
+            ),
+        )
+        proc = run_publish(repo, "--patch")
+        assert proc.returncode == 0, proc.stderr
+        assert read_version(repo) == "0.2.1"
+
+    def test_no_marker_passes_without_section(self, tmp_path):
+        repo, _ = make_repo(
+            tmp_path,
+            unreleased="### Changed\n\n- feat: add kernel sandbox\n",
+        )
+        proc = run_publish(repo, "--patch")
+        assert proc.returncode == 0, proc.stderr
+        assert read_version(repo) == "0.2.1"
+
+
 class TestGitOps:
     def test_commit_tag_and_push(self, tmp_path):
         repo, bare = make_repo(tmp_path)

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a46}/tests/test_trigger_script.py

@@ -109,8 +109,8 @@ def test_trigger_rejects_both_flags(tmp_path):
                          env=_env_with(bin_dir))
 
     assert result.returncode != 0
-    assert ("pass exactly one of --plan <path> or --aidlc-unit <slug>, "
-            "not both") in result.stderr
+    assert ("pass exactly one of --plan <path>, --aidlc-unit <slug>, or "
+            "--resume <thread-id>") in result.stderr
     assert "cli-ran:" not in result.stdout
 
 
@@ -120,8 +120,8 @@ def test_trigger_requires_exactly_one_flag(tmp_path):
     result = _run_script(env=_env_with(bin_dir))
 
     assert result.returncode != 0
-    assert ("pass exactly one of --plan <path> or --aidlc-unit <slug>"
-            in result.stderr)
+    assert ("pass exactly one of --plan <path>, --aidlc-unit <slug>, or "
+            "--resume <thread-id>") in result.stderr
     assert "cli-ran:" not in result.stdout
 
 
@@ -135,6 +135,51 @@ def test_trigger_forwards_aidlc_unit(tmp_path):
     assert "--aidlc-unit unit-3" in result.stdout
 
 
+def test_trigger_forwards_resume(tmp_path):
+    bin_dir = _stub_env(tmp_path)
+
+    result = _run_script("--resume", "07a767a50de64529ac442759b3685a78",
+                         env=_env_with(bin_dir))
+
+    assert result.returncode == 0, result.stderr
+    assert "cli-ran:" in result.stdout
+    assert "--resume 07a767a50de64529ac442759b3685a78" in result.stdout
+    assert "--plan" not in result.stdout
+    assert "--aidlc-unit" not in result.stdout
+
+
+def test_trigger_resume_equals_form(tmp_path):
+    bin_dir = _stub_env(tmp_path)
+
+    result = _run_script("--resume=07a767a50de64529ac442759b3685a78",
+                         env=_env_with(bin_dir))
+
+    assert result.returncode == 0, result.stderr
+    assert "--resume 07a767a50de64529ac442759b3685a78" in result.stdout
+
+
+def test_trigger_resume_missing_value_is_usage_error(tmp_path):
+    bin_dir = _stub_env(tmp_path)
+
+    result = _run_script("--resume", env=_env_with(bin_dir))
+
+    assert result.returncode != 0
+    assert "--resume requires a thread id" in result.stderr
+    assert "cli-ran:" not in result.stdout
+
+
+def test_trigger_rejects_resume_with_plan(tmp_path):
+    bin_dir = _stub_env(tmp_path)
+
+    result = _run_script("--resume", "abc123", "--plan", "plan.md",
+                         env=_env_with(bin_dir))
+
+    assert result.returncode != 0
+    assert ("pass exactly one of --plan <path>, --aidlc-unit <slug>, or "
+            "--resume <thread-id>") in result.stderr
+    assert "cli-ran:" not in result.stdout
+
+
 def test_trigger_unit_positional_is_aidlc_shorthand(tmp_path):
     bin_dir = _stub_env(tmp_path)